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

   1 /*
   2  * XML test
   3  *
   4  * Copyright 2005 Mike McCormack for CodeWeavers
   5  * Copyright 2007-2008 Alistair Leslie-Hughes
   6  *
   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     SysFreeString( str );
 532     if(nodetext)
 533     {
 534         IXMLDOMNamedNodeMap *pAttribs;
 535
 536         /* Text Last Child Checks */
 537         r = IXMLDOMText_get_lastChild(nodetext, NULL);
 538         ok(r == E_INVALIDARG, "ret %08x\n", r );
 539
 540         nodeChild = (IXMLDOMNode*)0x1;
 541         r = IXMLDOMText_get_lastChild(nodetext, &nodeChild);
 542         ok(r == S_FALSE, "ret %08x\n", r );
 543         ok(nodeChild == NULL, "nodeChild not NULL\n");
 544
 545         /* test get_attributes */
 546         r = IXMLDOMText_get_attributes( nodetext, NULL );
 547         ok( r == E_INVALIDARG, "get_attributes returned wrong code\n");
 548
 549         pAttribs = (IXMLDOMNamedNodeMap*)0x1;
 550         r = IXMLDOMText_get_attributes( nodetext, &pAttribs);
 551         ok(r == S_FALSE, "ret %08x\n", r );
 552         ok( pAttribs == NULL, "pAttribs not NULL\n");
 553
 554         /* test get_dataType */
 555         r = IXMLDOMText_get_dataType(nodetext, &var);
 556         ok(r == S_FALSE, "ret %08x\n", r );
 557         ok( V_VT(&var) == VT_NULL, "incorrect dataType type\n");
 558         VariantClear(&var);
 559
 560         /* test length property */
 561         r = IXMLDOMText_get_length(nodetext, NULL);
 562         ok(r == E_INVALIDARG, "ret %08x\n", r );
 563
 564         r = IXMLDOMText_get_length(nodetext, &nLength);
 565         ok(r == S_OK, "ret %08x\n", r );
 566         ok(nLength == 4, "expected 4 got %ld\n", nLength);
 567
 568         /* test nodeTypeString */
 569         r = IXMLDOMText_get_nodeTypeString(nodetext, &str);
 570         ok(r == S_OK, "ret %08x\n", r );
 571         ok( !lstrcmpW( str, _bstr_("text") ), "incorrect nodeTypeString string\n");
 572         SysFreeString(str);
 573
 574         /* put data Tests */
 575         r = IXMLDOMText_put_data(nodetext, _bstr_("This &is a ; test <>\\"));
 576         ok(r == S_OK, "ret %08x\n", r );
 577
 578         /* get data Tests */
 579         r = IXMLDOMText_get_data(nodetext, &str);
 580         ok(r == S_OK, "ret %08x\n", r );
 581         ok( !lstrcmpW( str, _bstr_("This &is a ; test <>\\") ), "incorrect put_data string\n");
 582         SysFreeString(str);
 583
 584         /* Confirm XML text is good */
 585         r = IXMLDOMText_get_xml(nodetext, &str);
 586         ok(r == S_OK, "ret %08x\n", r );
 587         ok( !lstrcmpW( str, _bstr_("This &amp;is a ; test &lt;&gt;\\") ), "incorrect xml string\n");
 588         SysFreeString(str);
 589
 590         /* Confirm we get the put_data Text back */
 591         r = IXMLDOMText_get_text(nodetext, &str);
 592         ok(r == S_OK, "ret %08x\n", r );
 593         ok( !lstrcmpW( str, _bstr_("This &is a ; test <>\\") ), "incorrect xml string\n");
 594         SysFreeString(str);
 595
 596         /* test substringData */
 597         r = IXMLDOMText_substringData(nodetext, 0, 4, NULL);
 598         ok(r == E_INVALIDARG, "ret %08x\n", r );
 599
 600         /* test substringData - Invalid offset */
 601         str = (BSTR)&szElement;
 602         r = IXMLDOMText_substringData(nodetext, -1, 4, &str);
 603         ok(r == E_INVALIDARG, "ret %08x\n", r );
 604         ok( str == NULL, "incorrect string\n");
 605
 606         /* test substringData - Invalid offset */
 607         str = (BSTR)&szElement;
 608         r = IXMLDOMText_substringData(nodetext, 30, 0, &str);
 609         ok(r == S_FALSE, "ret %08x\n", r );
 610         ok( str == NULL, "incorrect string\n");
 611
 612         /* test substringData - Invalid size */
 613         str = (BSTR)&szElement;
 614         r = IXMLDOMText_substringData(nodetext, 0, -1, &str);
 615         ok(r == E_INVALIDARG, "ret %08x\n", r );
 616         ok( str == NULL, "incorrect string\n");
 617
 618         /* test substringData - Invalid size */
 619         str = (BSTR)&szElement;
 620         r = IXMLDOMText_substringData(nodetext, 2, 0, &str);
 621         ok(r == S_FALSE, "ret %08x\n", r );
 622         ok( str == NULL, "incorrect string\n");
 623
 624         /* test substringData - Start of string */
 625         r = IXMLDOMText_substringData(nodetext, 0, 4, &str);
 626         ok(r == S_OK, "ret %08x\n", r );
 627         ok( !lstrcmpW( str, _bstr_("This") ), "incorrect substringData string\n");
 628         SysFreeString(str);
 629
 630         /* test substringData - Middle of string */
 631         r = IXMLDOMText_substringData(nodetext, 13, 4, &str);
 632         ok(r == S_OK, "ret %08x\n", r );
 633         ok( !lstrcmpW( str, _bstr_("test") ), "incorrect substringData string\n");
 634         SysFreeString(str);
 635
 636         /* test substringData - End of string */
 637         r = IXMLDOMText_substringData(nodetext, 20, 4, &str);
 638         ok(r == S_OK, "ret %08x\n", r );
 639         ok( !lstrcmpW( str, _bstr_("\\") ), "incorrect substringData string\n");
 640         SysFreeString(str);
 641
 642         /* test appendData */
 643         r = IXMLDOMText_appendData(nodetext, NULL);
 644         ok(r == S_OK, "ret %08x\n", r );
 645
 646         r = IXMLDOMText_appendData(nodetext, _bstr_(""));
 647         ok(r == S_OK, "ret %08x\n", r );
 648
 649         r = IXMLDOMText_appendData(nodetext, _bstr_("Append"));
 650         ok(r == S_OK, "ret %08x\n", r );
 651
 652         r = IXMLDOMText_get_text(nodetext, &str);
 653         ok(r == S_OK, "ret %08x\n", r );
 654         ok( !lstrcmpW( str, _bstr_("This &is a ; test <>\\Append") ), "incorrect get_text string\n");
 655         SysFreeString(str);
 656
 657         /* test insertData */
 658         str = SysAllocStringLen(NULL, 0);
 659         r = IXMLDOMText_insertData(nodetext, -1, str);
 660         ok(r == S_OK, "ret %08x\n", r );
 661
 662         r = IXMLDOMText_insertData(nodetext, -1, NULL);
 663         ok(r == S_OK, "ret %08x\n", r );
 664
 665         r = IXMLDOMText_insertData(nodetext, 1000, str);
 666         ok(r == S_OK, "ret %08x\n", r );
 667
 668         r = IXMLDOMText_insertData(nodetext, 1000, NULL);
 669         ok(r == S_OK, "ret %08x\n", r );
 670
 671         r = IXMLDOMText_insertData(nodetext, 0, NULL);
 672         ok(r == S_OK, "ret %08x\n", r );
 673
 674         r = IXMLDOMText_insertData(nodetext, 0, str);
 675         ok(r == S_OK, "ret %08x\n", r );
 676         SysFreeString(str);
 677
 678         r = IXMLDOMText_insertData(nodetext, -1, _bstr_("Inserting"));
 679         ok(r == E_INVALIDARG, "ret %08x\n", r );
 680
 681         r = IXMLDOMText_insertData(nodetext, 1000, _bstr_("Inserting"));
 682         ok(r == E_INVALIDARG, "ret %08x\n", r );
 683
 684         r = IXMLDOMText_insertData(nodetext, 0, _bstr_("Begin "));
 685         ok(r == S_OK, "ret %08x\n", r );
 686
 687         r = IXMLDOMText_insertData(nodetext, 17, _bstr_("Middle"));
 688         ok(r == S_OK, "ret %08x\n", r );
 689
 690         r = IXMLDOMText_insertData(nodetext, 39, _bstr_(" End"));
 691         ok(r == S_OK, "ret %08x\n", r );
 692
 693         r = IXMLDOMText_get_text(nodetext, &str);
 694         ok(r == S_OK, "ret %08x\n", r );
 695         ok( !lstrcmpW( str, _bstr_("Begin This &is a Middle; test <>\\Append End") ), "incorrect get_text string\n");
 696         SysFreeString(str);
 697
 698         IXMLDOMText_Release( nodetext );
 699     }
 700
 701     /* test Create Comment */
 702     r = IXMLDOMDocument_createComment(doc, NULL, NULL);
 703     ok( r == E_INVALIDARG, "returns %08x\n", r );
 704     r = IXMLDOMDocument_createComment(doc, szComment, &node_comment);
 705     ok( r == S_OK, "returns %08x\n", r );
 706     if(node_comment)
 707     {
 708         /* Last Child Checks */
 709         r = IXMLDOMComment_get_lastChild(node_comment, NULL);
 710         ok(r == E_INVALIDARG, "ret %08x\n", r );
 711
 712         nodeChild = (IXMLDOMNode*)0x1;
 713         r = IXMLDOMComment_get_lastChild(node_comment, &nodeChild);
 714         ok(r == S_FALSE, "ret %08x\n", r );
 715         ok(nodeChild == NULL, "pLastChild not NULL\n");
 716
 717         IXMLDOMComment_Release( node_comment );
 718     }
 719
 720     /* test Create Attribute */
 721     r = IXMLDOMDocument_createAttribute(doc, NULL, NULL);
 722     ok( r == E_INVALIDARG, "returns %08x\n", r );
 723     r = IXMLDOMDocument_createAttribute(doc, szAttribute, &node_attr);
 724     ok( r == S_OK, "returns %08x\n", r );
 725     IXMLDOMText_Release( node_attr);
 726
 727     /* test Processing Instruction */
 728     str = SysAllocStringLen(NULL, 0);
 729     r = IXMLDOMDocument_createProcessingInstruction(doc, str, str, NULL);
 730     ok( r == E_INVALIDARG, "returns %08x\n", r );
 731     r = IXMLDOMDocument_createProcessingInstruction(doc, NULL, str, &nodePI);
 732     ok( r == E_FAIL, "returns %08x\n", r );
 733     r = IXMLDOMDocument_createProcessingInstruction(doc, str, str, &nodePI);
 734     ok( r == E_FAIL, "returns %08x\n", r );
 735     SysFreeString(str);
 736
 737     r = IXMLDOMDocument_createProcessingInstruction(doc, _bstr_("xml"), _bstr_("version=\"1.0\""), &nodePI);
 738     ok( r == S_OK, "returns %08x\n", r );
 739     if(nodePI)
 740     {
 741         /* Last Child Checks */
 742         r = IXMLDOMProcessingInstruction_get_lastChild(nodePI, NULL);
 743         ok(r == E_INVALIDARG, "ret %08x\n", r );
 744
 745         nodeChild = (IXMLDOMNode*)0x1;
 746         r = IXMLDOMProcessingInstruction_get_lastChild(nodePI, &nodeChild);
 747         ok(r == S_FALSE, "ret %08x\n", r );
 748         ok(nodeChild == NULL, "nodeChild not NULL\n");
 749
 750         r = IXMLDOMProcessingInstruction_get_dataType(nodePI, &var);
 751         ok(r == S_FALSE, "ret %08x\n", r );
 752         ok( V_VT(&var) == VT_NULL, "incorrect dataType type\n");
 753         VariantClear(&var);
 754
 755         /* test nodeName */
 756         r = IXMLDOMProcessingInstruction_get_nodeName(nodePI, &str);
 757         ok(r == S_OK, "ret %08x\n", r );
 758         ok( !lstrcmpW( str, _bstr_("xml") ), "incorrect nodeName string\n");
 759         SysFreeString(str);
 760
 761         /* test Target */
 762         r = IXMLDOMProcessingInstruction_get_target(nodePI, &str);
 763         ok(r == S_OK, "ret %08x\n", r );
 764         ok( !lstrcmpW( str, _bstr_("xml") ), "incorrect target string\n");
 765         SysFreeString(str);
 766
 767         /* test nodeTypeString */
 768         r = IXMLDOMProcessingInstruction_get_nodeTypeString(nodePI, &str);
 769         ok(r == S_OK, "ret %08x\n", r );
 770         ok( !lstrcmpW( str, _bstr_("processinginstruction") ), "incorrect nodeTypeString string\n");
 771         SysFreeString(str);
 772
 773         /* test get_nodeValue */
 774         r = IXMLDOMProcessingInstruction_get_nodeValue(nodePI, &var);
 775         ok(r == S_OK, "ret %08x\n", r );
 776         ok( !lstrcmpW( V_BSTR(&var), _bstr_("version=\"1.0\"") ), "incorrect data string\n");
 777         VariantClear(&var);
 778
 779         /* test get_data */
 780         r = IXMLDOMProcessingInstruction_get_data(nodePI, &str);
 781         ok(r == S_OK, "ret %08x\n", r );
 782         ok( !lstrcmpW( str, _bstr_("version=\"1.0\"") ), "incorrect data string\n");
 783         SysFreeString(str);
 784
 785         /* test put_data */
 786         r = IXMLDOMProcessingInstruction_put_data(nodePI, _bstr_("version=\"1.0\" encoding=\"UTF-8\""));
 787         ok(r == E_FAIL, "ret %08x\n", r );
 788
 789         /* test put_data */
 790         V_VT(&var) = VT_BSTR;
 791         V_BSTR(&var) = SysAllocString(szOpen);  /* Doesn't matter what the string is, cannot set an xml node. */
 792         r = IXMLDOMProcessingInstruction_put_nodeValue(nodePI, var);
 793         ok(r == E_FAIL, "ret %08x\n", r );
 794         VariantClear(&var);
 795
 796         /* test get nodeName */
 797         r = IXMLDOMProcessingInstruction_get_nodeName(nodePI, &str);
 798         ok( !lstrcmpW( str, _bstr_("xml") ), "incorrect nodeName string\n");
 799         ok(r == S_OK, "ret %08x\n", r );
 800         SysFreeString(str);
 801
 802         IXMLDOMProcessingInstruction_Release(nodePI);
 803     }
 804
 805     r = IXMLDOMDocument_Release( doc );
 806     ok( r == 0, "document ref count incorrect\n");
 807
 808     free_bstrs();
 809 }
 810
 811 static void test_domnode( void )
 812 {
 813     HRESULT r;
 814     IXMLDOMDocument *doc = NULL, *owner = NULL;
 815     IXMLDOMElement *element = NULL;
 816     IXMLDOMNamedNodeMap *map = NULL;
 817     IXMLDOMNode *node = NULL, *next = NULL;
 818     IXMLDOMNodeList *list = NULL;
 819     DOMNodeType type = NODE_INVALID;
 820     VARIANT_BOOL b;
 821     BSTR str;
 822     VARIANT var;
 823     long count;
 824
 825     r = CoCreateInstance( &CLSID_DOMDocument, NULL,
 826         CLSCTX_INPROC_SERVER, &IID_IXMLDOMDocument, (LPVOID*)&doc );
 827     if( r != S_OK )
 828         return;
 829
 830     b = FALSE;
 831     str = SysAllocString( szComplete4 );
 832     r = IXMLDOMDocument_loadXML( doc, str, &b );
 833     ok( r == S_OK, "loadXML failed\n");
 834     ok( b == VARIANT_TRUE, "failed to load XML string\n");
 835     SysFreeString( str );
 836
 837     if (doc)
 838     {
 839         b = 1;
 840         r = IXMLDOMNode_hasChildNodes( doc, &b );
 841         ok( r == S_OK, "hasChildNoes bad return\n");
 842         ok( b == VARIANT_TRUE, "hasChildNoes wrong result\n");
 843
 844         r = IXMLDOMDocument_get_documentElement( doc, &element );
 845         ok( r == S_OK, "should be a document element\n");
 846         ok( element != NULL, "should be an element\n");
 847     }
 848     else
 849         ok( FALSE, "no document\n");
 850
 851     VariantInit(&var);
 852     ok( V_VT(&var) == VT_EMPTY, "variant init failed\n");
 853
 854     r = IXMLDOMNode_get_nodeValue( doc, NULL );
 855     ok(r == E_INVALIDARG, "get_nodeValue ret %08x\n", r );
 856
 857     r = IXMLDOMNode_get_nodeValue( doc, &var );
 858     ok( r == S_FALSE, "nextNode returned wrong code\n");
 859     ok( V_VT(&var) == VT_NULL, "variant wasn't empty\n");
 860     ok( V_BSTR(&var) == NULL, "variant value wasn't null\n");
 861
 862     if (element)
 863     {
 864         owner = NULL;
 865         r = IXMLDOMNode_get_ownerDocument( element, &owner );
 866         todo_wine {
 867         ok( r == S_OK, "get_ownerDocument return code\n");
 868         }
 869         ok( owner != doc, "get_ownerDocument return\n");
 870
 871         type = NODE_INVALID;
 872         r = IXMLDOMNode_get_nodeType( element, &type);
 873         ok( r == S_OK, "getNamedItem returned wrong code\n");
 874         ok( type == NODE_ELEMENT, "node not an element\n");
 875
 876         str = NULL;
 877         r = IXMLDOMNode_get_baseName( element, &str );
 878         ok( r == S_OK, "get_baseName returned wrong code\n");
 879         ok( lstrcmpW(str,szlc) == 0, "basename was wrong\n");
 880         SysFreeString(str);
 881
 882         /* check if nodename is correct */
 883         r = IXMLDOMElement_get_nodeName( element, NULL );
 884         ok ( r == E_INVALIDARG, "get_nodeName (NULL) wrong code\n");
 885
 886         /* content doesn't matter here */
 887         str = NULL;
 888         r = IXMLDOMElement_get_nodeName( element, &str );
 889         ok ( r == S_OK, "get_nodeName wrong code\n");
 890         ok ( str != NULL, "str is null\n");
 891         ok( !lstrcmpW( str, szlc ), "incorrect nodeName\n");
 892         SysFreeString( str );
 893
 894         str = SysAllocString( szNonExistentFile );
 895         V_VT(&var) = VT_I4;
 896         V_I4(&var) = 0x1234;
 897         r = IXMLDOMElement_getAttribute( element, str, &var );
 898         ok( r == E_FAIL, "getAttribute ret %08x\n", r );
 899         ok( V_VT(&var) == VT_NULL, "vt = %x\n", V_VT(&var));
 900         VariantClear(&var);
 901         SysFreeString( str );
 902
 903         str = SysAllocString( szdl );
 904         V_VT(&var) = VT_I4;
 905         V_I4(&var) = 0x1234;
 906         r = IXMLDOMElement_getAttribute( element, str, &var );
 907         ok( r == S_OK, "getAttribute ret %08x\n", r );
 908         ok( V_VT(&var) == VT_BSTR, "vt = %x\n", V_VT(&var));
 909         ok( !lstrcmpW(V_BSTR(&var), szstr1), "wrong attr value\n");
 910         VariantClear( &var );
 911
 912         r = IXMLDOMElement_getAttribute( element, NULL, &var );
 913         ok( r == E_INVALIDARG, "getAttribute ret %08x\n", r );
 914
 915         r = IXMLDOMElement_getAttribute( element, str, NULL );
 916         ok( r == E_INVALIDARG, "getAttribute ret %08x\n", r );
 917
 918         SysFreeString( str );
 919
 920         r = IXMLDOMElement_get_attributes( element, &map );
 921         ok( r == S_OK, "get_attributes returned wrong code\n");
 922         ok( map != NULL, "should be attributes\n");
 923
 924         b = 1;
 925         r = IXMLDOMNode_hasChildNodes( element, &b );
 926         ok( r == S_OK, "hasChildNoes bad return\n");
 927         ok( b == VARIANT_TRUE, "hasChildNoes wrong result\n");
 928     }
 929     else
 930         ok( FALSE, "no element\n");
 931
 932     if (map)
 933     {
 934         ISupportErrorInfo *support_error;
 935         r = IXMLDOMNamedNodeMap_QueryInterface( map, &IID_ISupportErrorInfo, (LPVOID*)&support_error );
 936         ok( r == S_OK, "ret %08x\n", r );
 937
 938         r = ISupportErrorInfo_InterfaceSupportsErrorInfo( support_error, &IID_IXMLDOMNamedNodeMap );
 939 todo_wine
 940 {
 941         ok( r == S_OK, "ret %08x\n", r );
 942 }
 943         ISupportErrorInfo_Release( support_error );
 944
 945         str = SysAllocString( szdl );
 946         r = IXMLDOMNamedNodeMap_getNamedItem( map, str, &node );
 947         ok( r == S_OK, "getNamedItem returned wrong code\n");
 948         ok( node != NULL, "should be attributes\n");
 949         IXMLDOMNode_Release(node);
 950         SysFreeString( str );
 951
 952         str = SysAllocString( szdl );
 953         r = IXMLDOMNamedNodeMap_getNamedItem( map, str, NULL );
 954         ok( r == E_INVALIDARG, "getNamedItem should return E_INVALIDARG\n");
 955         SysFreeString( str );
 956
 957         /* something that isn't in szComplete4 */
 958         str = SysAllocString( szOpen );
 959         node = (IXMLDOMNode *) 1;
 960         r = IXMLDOMNamedNodeMap_getNamedItem( map, str, &node );
 961         ok( r = S_FALSE, "getNamedItem found a node that wasn't there\n");
 962         ok( node == NULL, "getNamedItem should have returned NULL\n");
 963         SysFreeString( str );
 964
 965         /* test indexed access of attributes */
 966         r = IXMLDOMNamedNodeMap_get_length( map, &count );
 967         ok ( r == S_OK, "get_length wrong code\n");
 968         ok ( count == 1, "get_length != 1\n");
 969
 970         node = NULL;
 971         r = IXMLDOMNamedNodeMap_get_item( map, -1, &node);
 972         ok ( r == S_FALSE, "get_item (-1) wrong code\n");
 973         ok ( node == NULL, "there is no node\n");
 974
 975         node = NULL;
 976         r = IXMLDOMNamedNodeMap_get_item( map, 1, &node);
 977         ok ( r == S_FALSE, "get_item (1) wrong code\n");
 978         ok ( node == NULL, "there is no attribute\n");
 979
 980         node = NULL;
 981         r = IXMLDOMNamedNodeMap_get_item( map, 0, &node);
 982         ok ( r == S_OK, "get_item (0) wrong code\n");
 983         ok ( node != NULL, "should be attribute\n");
 984
 985         r = IXMLDOMNode_get_nodeName( node, NULL );
 986         ok ( r == E_INVALIDARG, "get_nodeName (NULL) wrong code\n");
 987
 988         /* content doesn't matter here */
 989         str = NULL;
 990         r = IXMLDOMNode_get_nodeName( node, &str );
 991         ok ( r == S_OK, "get_nodeName wrong code\n");
 992         ok ( str != NULL, "str is null\n");
 993         ok( !lstrcmpW( str, szdl ), "incorrect node name\n");
 994         SysFreeString( str );
 995
 996         /* test sequential access of attributes */
 997         node = NULL;
 998         r = IXMLDOMNamedNodeMap_nextNode( map, &node );
 999         ok ( r == S_OK, "nextNode (first time) wrong code\n");
1000         ok ( node != NULL, "nextNode, should be attribute\n");
1001
1002         r = IXMLDOMNamedNodeMap_nextNode( map, &node );
1003         ok ( r != S_OK, "nextNode (second time) wrong code\n");
1004         ok ( node == NULL, "nextNode, there is no attribute\n");
1005
1006         r = IXMLDOMNamedNodeMap_reset( map );
1007         ok ( r == S_OK, "reset should return S_OK\n");
1008
1009         r = IXMLDOMNamedNodeMap_nextNode( map, &node );
1010         ok ( r == S_OK, "nextNode (third time) wrong code\n");
1011         ok ( node != NULL, "nextNode, should be attribute\n");
1012     }
1013     else
1014         ok( FALSE, "no map\n");
1015
1016     if (node)
1017     {
1018         type = NODE_INVALID;
1019         r = IXMLDOMNode_get_nodeType( node, &type);
1020         ok( r == S_OK, "getNamedItem returned wrong code\n");
1021         ok( type == NODE_ATTRIBUTE, "node not an attribute\n");
1022
1023         str = NULL;
1024         r = IXMLDOMNode_get_baseName( node, NULL );
1025         ok( r == E_INVALIDARG, "get_baseName returned wrong code\n");
1026
1027         str = NULL;
1028         r = IXMLDOMNode_get_baseName( node, &str );
1029         ok( r == S_OK, "get_baseName returned wrong code\n");
1030         ok( lstrcmpW(str,szdl) == 0, "basename was wrong\n");
1031         SysFreeString( str );
1032
1033         r = IXMLDOMNode_get_nodeValue( node, &var );
1034         ok( r == S_OK, "returns %08x\n", r );
1035         ok( V_VT(&var) == VT_BSTR, "vt %x\n", V_VT(&var));
1036         ok( !lstrcmpW(V_BSTR(&var), szstr1), "nodeValue incorrect\n");
1037         VariantClear(&var);
1038
1039         r = IXMLDOMNode_get_childNodes( node, NULL );
1040         ok( r == E_INVALIDARG, "get_childNodes returned wrong code\n");
1041
1042         r = IXMLDOMNode_get_childNodes( node, &list );
1043         ok( r == S_OK, "get_childNodes returned wrong code\n");
1044
1045         if (list)
1046         {
1047             r = IXMLDOMNodeList_nextNode( list, &next );
1048             ok( r == S_OK, "nextNode returned wrong code\n");
1049         }
1050         else
1051             ok( FALSE, "no childlist\n");
1052
1053         if (next)
1054         {
1055             b = 1;
1056             r = IXMLDOMNode_hasChildNodes( next, &b );
1057             ok( r == S_FALSE, "hasChildNoes bad return\n");
1058             ok( b == VARIANT_FALSE, "hasChildNoes wrong result\n");
1059
1060             type = NODE_INVALID;
1061             r = IXMLDOMNode_get_nodeType( next, &type);
1062             ok( r == S_OK, "getNamedItem returned wrong code\n");
1063             ok( type == NODE_TEXT, "node not text\n");
1064
1065             str = (BSTR) 1;
1066             r = IXMLDOMNode_get_baseName( next, &str );
1067             ok( r == S_FALSE, "get_baseName returned wrong code\n");
1068             ok( str == NULL, "basename was wrong\n");
1069             SysFreeString(str);
1070         }
1071         else
1072             ok( FALSE, "no next\n");
1073
1074         if (next)
1075             IXMLDOMNode_Release( next );
1076         next = NULL;
1077         if (list)
1078             IXMLDOMNodeList_Release( list );
1079         list = NULL;
1080         if (node)
1081             IXMLDOMNode_Release( node );
1082     }
1083     else
1084         ok( FALSE, "no node\n");
1085     node = NULL;
1086
1087     if (map)
1088         IXMLDOMNamedNodeMap_Release( map );
1089
1090     /* now traverse the tree from the root element */
1091     if (element)
1092     {
1093         IXMLDOMNode *node;
1094         r = IXMLDOMNode_get_childNodes( element, &list );
1095         ok( r == S_OK, "get_childNodes returned wrong code\n");
1096
1097         /* using get_item for child list doesn't advance the position */
1098         ole_check(IXMLDOMNodeList_get_item(list, 1, &node));
1099         expect_node(node, "E2.E2.D1");
1100         IXMLDOMNode_Release(node);
1101         ole_check(IXMLDOMNodeList_nextNode(list, &node));
1102         expect_node(node, "E1.E2.D1");
1103         IXMLDOMNode_Release(node);
1104         ole_check(IXMLDOMNodeList_reset(list));
1105
1106         IXMLDOMNodeList_AddRef(list);
1107         expect_list_and_release(list, "E1.E2.D1 E2.E2.D1 E3.E2.D1 E4.E2.D1");
1108         ole_check(IXMLDOMNodeList_reset(list));
1109     }
1110     else
1111         ok( FALSE, "no element\n");
1112
1113     node = (void*)0xdeadbeef;
1114     r = IXMLDOMNode_selectSingleNode( element, szdl, &node );
1115     ok( r == S_FALSE, "ret %08x\n", r );
1116     ok( node == NULL, "node %p\n", node );
1117     r = IXMLDOMNode_selectSingleNode( element, szbs, &node );
1118     ok( r == S_OK, "ret %08x\n", r );
1119     r = IXMLDOMNode_Release( node );
1120     ok( r == 0, "ret %08x\n", r );
1121
1122     if (list)
1123     {
1124         r = IXMLDOMNodeList_get_length( list, &count );
1125         ok( r == S_OK, "get_length returns %08x\n", r );
1126         ok( count == 4, "get_length got %ld\n", count );
1127
1128         r = IXMLDOMNodeList_nextNode( list, &node );
1129         ok( r == S_OK, "nextNode returned wrong code\n");
1130     }
1131     else
1132         ok( FALSE, "no list\n");
1133
1134     if (node)
1135     {
1136         type = NODE_INVALID;
1137         r = IXMLDOMNode_get_nodeType( node, &type);
1138         ok( r == S_OK, "getNamedItem returned wrong code\n");
1139         ok( type == NODE_ELEMENT, "node not text\n");
1140
1141         VariantInit(&var);
1142         ok( V_VT(&var) == VT_EMPTY, "variant init failed\n");
1143         r = IXMLDOMNode_get_nodeValue( node, &var );
1144         ok( r == S_FALSE, "nextNode returned wrong code\n");
1145         ok( V_VT(&var) == VT_NULL, "variant wasn't empty\n");
1146         ok( V_BSTR(&var) == NULL, "variant value wasn't null\n");
1147
1148         r = IXMLDOMNode_hasChildNodes( node, NULL );
1149         ok( r == E_INVALIDARG, "hasChildNoes bad return\n");
1150
1151         b = 1;
1152         r = IXMLDOMNode_hasChildNodes( node, &b );
1153         ok( r == S_OK, "hasChildNoes bad return\n");
1154         ok( b == VARIANT_TRUE, "hasChildNoes wrong result\n");
1155
1156         str = NULL;
1157         r = IXMLDOMNode_get_baseName( node, &str );
1158         ok( r == S_OK, "get_baseName returned wrong code\n");
1159         ok( lstrcmpW(str,szbs) == 0, "basename was wrong\n");
1160         SysFreeString(str);
1161     }
1162     else
1163         ok( FALSE, "no node\n");
1164
1165     if (node)
1166         IXMLDOMNode_Release( node );
1167     if (list)
1168         IXMLDOMNodeList_Release( list );
1169     if (element)
1170         IXMLDOMElement_Release( element );
1171
1172     b = FALSE;
1173     str = SysAllocString( szComplete5 );
1174     r = IXMLDOMDocument_loadXML( doc, str, &b );
1175     ok( r == S_OK, "loadXML failed\n");
1176     ok( b == VARIANT_TRUE, "failed to load XML string\n");
1177     SysFreeString( str );
1178
1179     b = 1;
1180     r = IXMLDOMNode_hasChildNodes( doc, &b );
1181     ok( r == S_OK, "hasChildNoes bad return\n");
1182     ok( b == VARIANT_TRUE, "hasChildNoes wrong result\n");
1183
1184     r = IXMLDOMDocument_get_documentElement( doc, &element );
1185     ok( r == S_OK, "should be a document element\n");
1186     ok( element != NULL, "should be an element\n");
1187
1188     if (element)
1189     {
1190         static const WCHAR szSSearch[] = {'S',':','s','e','a','r','c','h',0};
1191         BSTR tag = NULL;
1192
1193         /* check if the tag is correct */
1194         r = IXMLDOMElement_get_tagName( element, &tag );
1195         ok( r == S_OK, "couldn't get tag name\n");
1196         ok( tag != NULL, "tag was null\n");
1197         ok( !lstrcmpW( tag, szSSearch ), "incorrect tag name\n");
1198         SysFreeString( tag );
1199     }
1200
1201     if (element)
1202         IXMLDOMElement_Release( element );
1203     if (doc)
1204         IXMLDOMDocument_Release( doc );
1205 }
1206
1207 static void test_refs(void)
1208 {
1209     HRESULT r;
1210     BSTR str;
1211     VARIANT_BOOL b;
1212     IXMLDOMDocument *doc = NULL;
1213     IXMLDOMElement *element = NULL;
1214     IXMLDOMNode *node = NULL, *node2;
1215     IXMLDOMNodeList *node_list = NULL;
1216     LONG ref;
1217     IUnknown *unk, *unk2;
1218
1219     r = CoCreateInstance( &CLSID_DOMDocument, NULL,
1220         CLSCTX_INPROC_SERVER, &IID_IXMLDOMDocument, (LPVOID*)&doc );
1221     if( r != S_OK )
1222         return;
1223     ref = IXMLDOMDocument_Release(doc);
1224     ok( ref == 0, "ref %d\n", ref);
1225
1226     r = CoCreateInstance( &CLSID_DOMDocument, NULL,
1227         CLSCTX_INPROC_SERVER, &IID_IXMLDOMDocument, (LPVOID*)&doc );
1228     if( r != S_OK )
1229         return;
1230
1231     str = SysAllocString( szComplete4 );
1232     r = IXMLDOMDocument_loadXML( doc, str, &b );
1233     ok( r == S_OK, "loadXML failed\n");
1234     ok( b == VARIANT_TRUE, "failed to load XML string\n");
1235     SysFreeString( str );
1236
1237     ref = IXMLDOMDocument_AddRef( doc );
1238     ok( ref == 2, "ref %d\n", ref );
1239     ref = IXMLDOMDocument_AddRef( doc );
1240     ok( ref == 3, "ref %d\n", ref );
1241     IXMLDOMDocument_Release( doc );
1242     IXMLDOMDocument_Release( doc );
1243
1244     r = IXMLDOMDocument_get_documentElement( doc, &element );
1245     ok( r == S_OK, "should be a document element\n");
1246     ok( element != NULL, "should be an element\n");
1247
1248     ref = IXMLDOMDocument_AddRef( doc );
1249     ok( ref == 2, "ref %d\n", ref );
1250     IXMLDOMDocument_Release( doc );
1251
1252     r = IXMLDOMElement_get_childNodes( element, &node_list );
1253     ok( r == S_OK, "rets %08x\n", r);
1254     ref = IXMLDOMNodeList_AddRef( node_list );
1255     ok( ref == 2, "ref %d\n", ref );
1256     IXMLDOMNodeList_Release( node_list );
1257
1258     IXMLDOMNodeList_get_item( node_list, 0, &node );
1259     ok( r == S_OK, "rets %08x\n", r);
1260
1261     IXMLDOMNodeList_get_item( node_list, 0, &node2 );
1262     ok( r == S_OK, "rets %08x\n", r);
1263
1264     ref = IXMLDOMNode_AddRef( node );
1265     ok( ref == 2, "ref %d\n", ref );
1266     IXMLDOMNode_Release( node );
1267
1268     ref = IXMLDOMNode_Release( node );
1269     ok( ref == 0, "ref %d\n", ref );
1270     ref = IXMLDOMNode_Release( node2 );
1271     ok( ref == 0, "ref %d\n", ref );
1272
1273     ref = IXMLDOMNodeList_Release( node_list );
1274     ok( ref == 0, "ref %d\n", ref );
1275
1276     ok( node != node2, "node %p node2 %p\n", node, node2 );
1277
1278     ref = IXMLDOMDocument_Release( doc );
1279     ok( ref == 0, "ref %d\n", ref );
1280
1281     ref = IXMLDOMElement_AddRef( element );
1282     todo_wine {
1283     ok( ref == 3, "ref %d\n", ref );
1284     }
1285     IXMLDOMElement_Release( element );
1286
1287     /* IUnknown must be unique however we obtain it */
1288     r = IXMLDOMElement_QueryInterface( element, &IID_IUnknown, (LPVOID*)&unk );
1289     ok( r == S_OK, "rets %08x\n", r );
1290     r = IXMLDOMElement_QueryInterface( element, &IID_IXMLDOMNode, (LPVOID*)&node );
1291     ok( r == S_OK, "rets %08x\n", r );
1292     r = IXMLDOMNode_QueryInterface( node, &IID_IUnknown, (LPVOID*)&unk2 );
1293     ok( r == S_OK, "rets %08x\n", r );
1294     ok( unk == unk2, "unk %p unk2 %p\n", unk, unk2 );
1295
1296     IUnknown_Release( unk2 );
1297     IUnknown_Release( unk );
1298     IXMLDOMNode_Release( node );
1299
1300     IXMLDOMElement_Release( element );
1301
1302 }
1303
1304 static void test_create(void)
1305 {
1306     HRESULT r;
1307     VARIANT var;
1308     BSTR str, name;
1309     IXMLDOMDocument *doc;
1310     IXMLDOMElement *element;
1311     IXMLDOMNode *root, *node, *child;
1312     IXMLDOMNamedNodeMap *attr_map;
1313     IUnknown *unk;
1314     LONG ref;
1315     long num;
1316
1317     r = CoCreateInstance( &CLSID_DOMDocument, NULL,
1318         CLSCTX_INPROC_SERVER, &IID_IXMLDOMDocument, (LPVOID*)&doc );
1319     if( r != S_OK )
1320         return;
1321
1322     V_VT(&var) = VT_I4;
1323     V_I4(&var) = NODE_ELEMENT;
1324     str = SysAllocString( szlc );
1325     r = IXMLDOMDocument_createNode( doc, var, str, NULL, &node );
1326     ok( r == S_OK, "returns %08x\n", r );
1327     r = IXMLDOMDocument_appendChild( doc, node, &root );
1328     ok( r == S_OK, "returns %08x\n", r );
1329     ok( node == root, "%p %p\n", node, root );
1330
1331     ref = IXMLDOMNode_AddRef( node );
1332     ok(ref == 3, "ref %d\n", ref);
1333     IXMLDOMNode_Release( node );
1334
1335     ref = IXMLDOMNode_Release( node );
1336     ok(ref == 1, "ref %d\n", ref);
1337     SysFreeString( str );
1338
1339     V_VT(&var) = VT_I4;
1340     V_I4(&var) = NODE_ELEMENT;
1341     str = SysAllocString( szbs );
1342     r = IXMLDOMDocument_createNode( doc, var, str, NULL, &node );
1343     ok( r == S_OK, "returns %08x\n", r );
1344
1345     ref = IXMLDOMNode_AddRef( node );
1346     ok(ref == 2, "ref = %d\n", ref);
1347     IXMLDOMNode_Release( node );
1348
1349     r = IXMLDOMNode_QueryInterface( node, &IID_IUnknown, (LPVOID*)&unk );
1350     ok( r == S_OK, "returns %08x\n", r );
1351
1352     ref = IXMLDOMNode_AddRef( unk );
1353     ok(ref == 3, "ref = %d\n", ref);
1354     IXMLDOMNode_Release( unk );
1355
1356     V_VT(&var) = VT_EMPTY;
1357     r = IXMLDOMNode_insertBefore( root, (IXMLDOMNode*)unk, var, &child );
1358     ok( r == S_OK, "returns %08x\n", r );
1359     ok( unk == (IUnknown*)child, "%p %p\n", unk, child );
1360     IXMLDOMNode_Release( child );
1361     IUnknown_Release( unk );
1362
1363
1364     V_VT(&var) = VT_NULL;
1365     V_DISPATCH(&var) = (IDispatch*)node;
1366     r = IXMLDOMNode_insertBefore( root, node, var, &child );
1367     ok( r == S_OK, "returns %08x\n", r );
1368     ok( node == child, "%p %p\n", node, child );
1369     IXMLDOMNode_Release( child );
1370
1371
1372     V_VT(&var) = VT_NULL;
1373     V_DISPATCH(&var) = (IDispatch*)node;
1374     r = IXMLDOMNode_insertBefore( root, node, var, NULL );
1375     ok( r == S_OK, "returns %08x\n", r );
1376     IXMLDOMNode_Release( node );
1377
1378     r = IXMLDOMNode_QueryInterface( root, &IID_IXMLDOMElement, (LPVOID*)&element );
1379     ok( r == S_OK, "returns %08x\n", r );
1380
1381     r = IXMLDOMElement_get_attributes( element, &attr_map );
1382     ok( r == S_OK, "returns %08x\n", r );
1383     r = IXMLDOMNamedNodeMap_get_length( attr_map, &num );
1384     ok( r == S_OK, "returns %08x\n", r );
1385     ok( num == 0, "num %ld\n", num );
1386     IXMLDOMNamedNodeMap_Release( attr_map );
1387
1388     V_VT(&var) = VT_BSTR;
1389     V_BSTR(&var) = SysAllocString( szstr1 );
1390     name = SysAllocString( szdl );
1391     r = IXMLDOMElement_setAttribute( element, name, var );
1392     ok( r == S_OK, "returns %08x\n", r );
1393     r = IXMLDOMElement_get_attributes( element, &attr_map );
1394     ok( r == S_OK, "returns %08x\n", r );
1395     r = IXMLDOMNamedNodeMap_get_length( attr_map, &num );
1396     ok( r == S_OK, "returns %08x\n", r );
1397     ok( num == 1, "num %ld\n", num );
1398     IXMLDOMNamedNodeMap_Release( attr_map );
1399     VariantClear(&var);
1400
1401     V_VT(&var) = VT_BSTR;
1402     V_BSTR(&var) = SysAllocString( szstr2 );
1403     r = IXMLDOMElement_setAttribute( element, name, var );
1404     ok( r == S_OK, "returns %08x\n", r );
1405     r = IXMLDOMElement_get_attributes( element, &attr_map );
1406     ok( r == S_OK, "returns %08x\n", r );
1407     r = IXMLDOMNamedNodeMap_get_length( attr_map, &num );
1408     ok( r == S_OK, "returns %08x\n", r );
1409     ok( num == 1, "num %ld\n", num );
1410     IXMLDOMNamedNodeMap_Release( attr_map );
1411     VariantClear(&var);
1412     r = IXMLDOMElement_getAttribute( element, name, &var );
1413     ok( r == S_OK, "returns %08x\n", r );
1414     ok( !lstrcmpW(V_BSTR(&var), szstr2), "wrong attr value\n");
1415     VariantClear(&var);
1416     SysFreeString(name);
1417
1418     V_VT(&var) = VT_BSTR;
1419     V_BSTR(&var) = SysAllocString( szstr1 );
1420     name = SysAllocString( szlc );
1421     r = IXMLDOMElement_setAttribute( element, name, var );
1422     ok( r == S_OK, "returns %08x\n", r );
1423     r = IXMLDOMElement_get_attributes( element, &attr_map );
1424     ok( r == S_OK, "returns %08x\n", r );
1425     r = IXMLDOMNamedNodeMap_get_length( attr_map, &num );
1426     ok( r == S_OK, "returns %08x\n", r );
1427     ok( num == 2, "num %ld\n", num );
1428     IXMLDOMNamedNodeMap_Release( attr_map );
1429     VariantClear(&var);
1430     SysFreeString(name);
1431
1432     V_VT(&var) = VT_I4;
1433     V_I4(&var) = 10;
1434     name = SysAllocString( szbs );
1435     r = IXMLDOMElement_setAttribute( element, name, var );
1436     ok( r == S_OK, "returns %08x\n", r );
1437     VariantClear(&var);
1438     r = IXMLDOMElement_getAttribute( element, name, &var );
1439     ok( r == S_OK, "returns %08x\n", r );
1440     ok( V_VT(&var) == VT_BSTR, "variant type %x\n", V_VT(&var));
1441     VariantClear(&var);
1442     SysFreeString(name);
1443
1444     IXMLDOMElement_Release( element );
1445     IXMLDOMNode_Release( root );
1446     IXMLDOMDocument_Release( doc );
1447 }
1448
1449 static void test_getElementsByTagName(void)
1450 {
1451     HRESULT r;
1452     BSTR str;
1453     VARIANT_BOOL b;
1454     IXMLDOMDocument *doc;
1455     IXMLDOMNodeList *node_list;
1456     long len;
1457
1458     r = CoCreateInstance( &CLSID_DOMDocument, NULL,
1459         CLSCTX_INPROC_SERVER, &IID_IXMLDOMDocument, (LPVOID*)&doc );
1460     if( r != S_OK )
1461         return;
1462
1463     str = SysAllocString( szComplete4 );
1464     r = IXMLDOMDocument_loadXML( doc, str, &b );
1465     ok( r == S_OK, "loadXML failed\n");
1466     ok( b == VARIANT_TRUE, "failed to load XML string\n");
1467     SysFreeString( str );
1468
1469     str = SysAllocString( szstar );
1470     r = IXMLDOMDocument_getElementsByTagName(doc, str, &node_list);
1471     ok( r == S_OK, "ret %08x\n", r );
1472     r = IXMLDOMNodeList_get_length( node_list, &len );
1473     ok( r == S_OK, "ret %08x\n", r );
1474     ok( len == 6, "len %ld\n", len );
1475     IXMLDOMNodeList_Release( node_list );
1476     SysFreeString( str );
1477
1478     str = SysAllocString( szbs );
1479     r = IXMLDOMDocument_getElementsByTagName(doc, str, &node_list);
1480     ok( r == S_OK, "ret %08x\n", r );
1481     r = IXMLDOMNodeList_get_length( node_list, &len );
1482     ok( r == S_OK, "ret %08x\n", r );
1483     ok( len == 1, "len %ld\n", len );
1484     IXMLDOMNodeList_Release( node_list );
1485     SysFreeString( str );
1486
1487     str = SysAllocString( szdl );
1488     r = IXMLDOMDocument_getElementsByTagName(doc, str, &node_list);
1489     ok( r == S_OK, "ret %08x\n", r );
1490     r = IXMLDOMNodeList_get_length( node_list, &len );
1491     ok( r == S_OK, "ret %08x\n", r );
1492     ok( len == 0, "len %ld\n", len );
1493     IXMLDOMNodeList_Release( node_list );
1494     SysFreeString( str );
1495
1496     str = SysAllocString( szstr1 );
1497     r = IXMLDOMDocument_getElementsByTagName(doc, str, &node_list);
1498     ok( r == S_OK, "ret %08x\n", r );
1499     r = IXMLDOMNodeList_get_length( node_list, &len );
1500     ok( r == S_OK, "ret %08x\n", r );
1501     ok( len == 0, "len %ld\n", len );
1502     IXMLDOMNodeList_Release( node_list );
1503     SysFreeString( str );
1504
1505     IXMLDOMDocument_Release( doc );
1506 }
1507
1508 static void test_get_text(void)
1509 {
1510     HRESULT r;
1511     BSTR str;
1512     VARIANT_BOOL b;
1513     IXMLDOMDocument *doc;
1514     IXMLDOMNode *node, *node2, *node3;
1515     IXMLDOMNodeList *node_list;
1516     IXMLDOMNamedNodeMap *node_map;
1517
1518     r = CoCreateInstance( &CLSID_DOMDocument, NULL,
1519         CLSCTX_INPROC_SERVER, &IID_IXMLDOMDocument, (LPVOID*)&doc );
1520     if( r != S_OK )
1521         return;
1522
1523     str = SysAllocString( szComplete4 );
1524     r = IXMLDOMDocument_loadXML( doc, str, &b );
1525     ok( r == S_OK, "loadXML failed\n");
1526     ok( b == VARIANT_TRUE, "failed to load XML string\n");
1527     SysFreeString( str );
1528
1529     str = SysAllocString( szbs );
1530     r = IXMLDOMDocument_getElementsByTagName( doc, str, &node_list );
1531     ok( r == S_OK, "ret %08x\n", r );
1532     SysFreeString(str);
1533
1534     r = IXMLDOMNodeList_get_item( node_list, 0, &node );
1535     ok( r == S_OK, "ret %08x\n", r );
1536     IXMLDOMNodeList_Release( node_list );
1537
1538     /* Invalid output parameter*/
1539     r = IXMLDOMNode_get_text( node, NULL );
1540     ok( r == E_INVALIDARG, "ret %08x\n", r );
1541
1542     r = IXMLDOMNode_get_text( node, &str );
1543     ok( r == S_OK, "ret %08x\n", r );
1544 todo_wine {
1545     ok( !memcmp(str, szfn1_txt, sizeof(szfn1_txt)), "wrong string\n" );
1546  }
1547     ok( !memcmp(str, szfn1_txt, sizeof(szfn1_txt)-4), "wrong string\n" );
1548     SysFreeString(str);
1549
1550     r = IXMLDOMNode_get_attributes( node, &node_map );
1551     ok( r == S_OK, "ret %08x\n", r );
1552
1553     str = SysAllocString( szvr );
1554     r = IXMLDOMNamedNodeMap_getNamedItem( node_map, str, &node2 );
1555     ok( r == S_OK, "ret %08x\n", r );
1556     SysFreeString(str);
1557
1558     r = IXMLDOMNode_get_text( node2, &str );
1559     ok( r == S_OK, "ret %08x\n", r );
1560     ok( !memcmp(str, szstr2, sizeof(szstr2)), "wrong string\n" );
1561     SysFreeString(str);
1562
1563     r = IXMLDOMNode_get_firstChild( node2, &node3 );
1564     ok( r == S_OK, "ret %08x\n", r );
1565
1566     r = IXMLDOMNode_get_text( node3, &str );
1567     ok( r == S_OK, "ret %08x\n", r );
1568     ok( !memcmp(str, szstr2, sizeof(szstr2)), "wrong string\n" );
1569     SysFreeString(str);
1570
1571
1572     IXMLDOMNode_Release( node3 );
1573     IXMLDOMNode_Release( node2 );
1574     IXMLDOMNamedNodeMap_Release( node_map );
1575     IXMLDOMNode_Release( node );
1576     IXMLDOMDocument_Release( doc );
1577 }
1578
1579 static void test_get_childNodes(void)
1580 {
1581     HRESULT r;
1582     BSTR str;
1583     VARIANT_BOOL b;
1584     IXMLDOMDocument *doc;
1585     IXMLDOMElement *element;
1586     IXMLDOMNode *node, *node2;
1587     IXMLDOMNodeList *node_list, *node_list2;
1588     long len;
1589
1590     r = CoCreateInstance( &CLSID_DOMDocument, NULL,
1591         CLSCTX_INPROC_SERVER, &IID_IXMLDOMDocument, (LPVOID*)&doc );
1592     if( r != S_OK )
1593         return;
1594
1595     str = SysAllocString( szComplete4 );
1596     r = IXMLDOMDocument_loadXML( doc, str, &b );
1597     ok( r == S_OK, "loadXML failed\n");
1598     ok( b == VARIANT_TRUE, "failed to load XML string\n");
1599     SysFreeString( str );
1600
1601     r = IXMLDOMDocument_get_documentElement( doc, &element );
1602     ok( r == S_OK, "ret %08x\n", r);
1603
1604     r = IXMLDOMElement_get_childNodes( element, &node_list );
1605     ok( r == S_OK, "ret %08x\n", r);
1606
1607     r = IXMLDOMNodeList_get_length( node_list, &len );
1608     ok( r == S_OK, "ret %08x\n", r);
1609     ok( len == 4, "len %ld\n", len);
1610
1611     r = IXMLDOMNodeList_get_item( node_list, 2, &node );
1612     ok( r == S_OK, "ret %08x\n", r);
1613
1614     r = IXMLDOMNode_get_childNodes( node, &node_list2 );
1615     ok( r == S_OK, "ret %08x\n", r);
1616
1617     r = IXMLDOMNodeList_get_length( node_list2, &len );
1618     ok( r == S_OK, "ret %08x\n", r);
1619     ok( len == 0, "len %ld\n", len);
1620
1621     r = IXMLDOMNodeList_get_item( node_list2, 0, &node2);
1622     ok( r == S_FALSE, "ret %08x\n", r);
1623
1624     IXMLDOMNodeList_Release( node_list2 );
1625     IXMLDOMNode_Release( node );
1626     IXMLDOMNodeList_Release( node_list );
1627     IXMLDOMElement_Release( element );
1628     IXMLDOMDocument_Release( doc );
1629 }
1630
1631 static void test_removeChild(void)
1632 {
1633     HRESULT r;
1634     BSTR str;
1635     VARIANT_BOOL b;
1636     IXMLDOMDocument *doc;
1637     IXMLDOMElement *element;
1638     IXMLDOMNode *node, *node2, *node3, *node4;
1639     IXMLDOMNodeList *node_list, *node_list2;
1640
1641     r = CoCreateInstance( &CLSID_DOMDocument, NULL,
1642         CLSCTX_INPROC_SERVER, &IID_IXMLDOMDocument, (LPVOID*)&doc );
1643     if( r != S_OK )
1644         return;
1645
1646     str = SysAllocString( szComplete4 );
1647     r = IXMLDOMDocument_loadXML( doc, str, &b );
1648     ok( r == S_OK, "loadXML failed\n");
1649     ok( b == VARIANT_TRUE, "failed to load XML string\n");
1650     SysFreeString( str );
1651
1652     r = IXMLDOMDocument_get_documentElement( doc, &element );
1653     ok( r == S_OK, "ret %08x\n", r);
1654
1655     r = IXMLDOMElement_get_childNodes( element, &node_list );
1656     ok( r == S_OK, "ret %08x\n", r);
1657
1658     r = IXMLDOMNodeList_get_item( node_list, 3, &node );
1659     ok( r == S_OK, "ret %08x\n", r);
1660
1661     r = IXMLDOMNode_get_childNodes( node, &node_list2 );
1662     ok( r == S_OK, "ret %08x\n", r);
1663
1664     r = IXMLDOMNodeList_get_item( node_list, 0, &node4 );
1665     ok( r == S_OK, "ret %08x\n", r);
1666
1667     r = IXMLDOMElement_removeChild( element, NULL, &node2 );
1668     ok( r == E_INVALIDARG, "ret %08x\n", r );
1669
1670     r = IXMLDOMElement_removeChild( element, node4, &node2 );
1671     ok( r == S_OK, "ret %08x\n", r);
1672     ok( node4 == node2, "node %p node2 %p\n", node4, node2 );
1673
1674     r = IXMLDOMNode_get_parentNode( node4, &node3 );
1675     ok( r == S_FALSE, "ret %08x\n", r);
1676     ok( node3 == NULL, "%p\n", node3 );
1677
1678     IXMLDOMNode_Release( node2 );
1679     IXMLDOMNode_Release( node4 );
1680     IXMLDOMNodeList_Release( node_list2 );
1681     IXMLDOMNode_Release( node );
1682     IXMLDOMNodeList_Release( node_list );
1683     IXMLDOMElement_Release( element );
1684     IXMLDOMDocument_Release( doc );
1685 }
1686
1687 static void test_XMLHTTP(void)
1688 {
1689     static const WCHAR wszBody[] = {'m','o','d','e','=','T','e','s','t',0};
1690     static WCHAR wszPOST[] = {'P','O','S','T',0};
1691     static WCHAR wszUrl[] = {'h','t','t','p',':','/','/',
1692         'c','r','o','s','s','o','v','e','r','.','c','o','d','e','w','e','a','v','e','r','s','.','c','o','m','/',
1693         'p','o','s','t','t','e','s','t','.','p','h','p',0};
1694     static const WCHAR wszExpectedResponse[] = {'F','A','I','L','E','D',0};
1695     IXMLHttpRequest *pXMLHttpRequest;
1696     BSTR bstrResponse;
1697     VARIANT dummy;
1698     VARIANT varfalse;
1699     VARIANT varbody;
1700     HRESULT hr = CoCreateInstance(&CLSID_XMLHTTPRequest, NULL,
1701                                   CLSCTX_INPROC_SERVER, &IID_IXMLHttpRequest,
1702                                   (void **)&pXMLHttpRequest);
1703     todo_wine {
1704     ok(hr == S_OK, "CoCreateInstance(CLSID_XMLHTTPRequest) should have succeeded instead of failing with 0x%08x\n", hr);
1705     }
1706     if (hr != S_OK)
1707         return;
1708
1709     VariantInit(&dummy);
1710     V_VT(&dummy) = VT_ERROR;
1711     V_ERROR(&dummy) = DISP_E_MEMBERNOTFOUND;
1712     VariantInit(&varfalse);
1713     V_VT(&varfalse) = VT_BOOL;
1714     V_BOOL(&varfalse) = VARIANT_FALSE;
1715     V_VT(&varbody) = VT_BSTR;
1716     V_BSTR(&varbody) = SysAllocString(wszBody);
1717
1718     hr = IXMLHttpRequest_open(pXMLHttpRequest, wszPOST, wszUrl, varfalse, dummy, dummy);
1719     ok(hr == S_OK, "IXMLHttpRequest_open should have succeeded instead of failing with 0x%08x\n", hr);
1720
1721     hr = IXMLHttpRequest_send(pXMLHttpRequest, varbody);
1722     ok(hr == S_OK, "IXMLHttpRequest_send should have succeeded instead of failing with 0x%08x\n", hr);
1723     VariantClear(&varbody);
1724
1725     hr = IXMLHttpRequest_get_responseText(pXMLHttpRequest, &bstrResponse);
1726     ok(hr == S_OK, "IXMLHttpRequest_get_responseText should have succeeded instead of failing with 0x%08x\n", hr);
1727     /* the server currently returns "FAILED" because the Content-Type header is
1728      * not what the server expects */
1729     ok(!memcmp(bstrResponse, wszExpectedResponse, sizeof(wszExpectedResponse)), "bstrResponse differs from what was expected\n");
1730     SysFreeString(bstrResponse);
1731 }
1732
1733 static void test_IXMLDOMDocument2(void)
1734 {
1735     HRESULT r;
1736     VARIANT_BOOL b;
1737     BSTR str;
1738     IXMLDOMDocument *doc;
1739     IXMLDOMDocument2 *doc2;
1740     VARIANT var;
1741     int ref;
1742
1743     r = CoCreateInstance( &CLSID_DOMDocument, NULL,
1744         CLSCTX_INPROC_SERVER, &IID_IXMLDOMDocument, (LPVOID*)&doc );
1745     if( r != S_OK )
1746         return;
1747
1748     str = SysAllocString( szComplete4 );
1749     r = IXMLDOMDocument_loadXML( doc, str, &b );
1750     ok( r == S_OK, "loadXML failed\n");
1751     ok( b == VARIANT_TRUE, "failed to load XML string\n");
1752     SysFreeString( str );
1753
1754     r = IXMLDOMDocument_QueryInterface( doc, &IID_IXMLDOMDocument2, (void**)&doc2 );
1755     ok( r == S_OK, "ret %08x\n", r );
1756     ok( doc == (IXMLDOMDocument*)doc2, "interfaces differ\n");
1757
1758     /* we will check if the variant got cleared */
1759     ref = IXMLDOMDocument2_AddRef(doc2);
1760     expect_eq(ref, 3, int, "%d");  /* doc, doc2, AddRef*/
1761     V_VT(&var) = VT_UNKNOWN;
1762     V_UNKNOWN(&var) = (IUnknown *)doc2;
1763
1764     /* invalid calls */
1765     ole_expect(IXMLDOMDocument2_getProperty(doc2, _bstr_("askldhfaklsdf"), &var), E_FAIL);
1766     expect_eq(V_VT(&var), VT_UNKNOWN, int, "%x");
1767     ole_expect(IXMLDOMDocument2_getProperty(doc2, _bstr_("SelectionLanguage"), NULL), E_INVALIDARG);
1768
1769     /* valid call */
1770     ole_check(IXMLDOMDocument2_getProperty(doc2, _bstr_("SelectionLanguage"), &var));
1771     expect_eq(V_VT(&var), VT_BSTR, int, "%x");
1772     expect_bstr_eq_and_free(V_BSTR(&var), "XSLPattern");
1773     V_VT(&var) = VT_R4;
1774
1775     /* the variant didn't get cleared*/
1776     expect_eq(IXMLDOMDocument2_Release(doc2), 2, int, "%d");
1777
1778     /* setProperty tests */
1779     ole_expect(IXMLDOMDocument2_setProperty(doc2, _bstr_("askldhfaklsdf"), var), E_FAIL);
1780     ole_expect(IXMLDOMDocument2_setProperty(doc2, _bstr_("SelectionLanguage"), var), E_FAIL);
1781     ole_expect(IXMLDOMDocument2_setProperty(doc2, _bstr_("SelectionLanguage"), _variantbstr_("alskjdh faklsjd hfk")), E_FAIL);
1782     ole_check(IXMLDOMDocument2_setProperty(doc2, _bstr_("SelectionLanguage"), _variantbstr_("XSLPattern")));
1783     ole_check(IXMLDOMDocument2_setProperty(doc2, _bstr_("SelectionLanguage"), _variantbstr_("XPath")));
1784     ole_check(IXMLDOMDocument2_setProperty(doc2, _bstr_("SelectionLanguage"), _variantbstr_("XSLPattern")));
1785
1786     /* contrary to what MSDN claims you can switch back from XPath to XSLPattern */
1787     ole_check(IXMLDOMDocument2_getProperty(doc2, _bstr_("SelectionLanguage"), &var));
1788     expect_eq(V_VT(&var), VT_BSTR, int, "%x");
1789     expect_bstr_eq_and_free(V_BSTR(&var), "XSLPattern");
1790
1791     IXMLDOMDocument2_Release( doc2 );
1792     IXMLDOMDocument_Release( doc );
1793     free_bstrs();
1794 }
1795
1796 static void test_XPath(void)
1797 {
1798     HRESULT r;
1799     VARIANT var;
1800     VARIANT_BOOL b;
1801     IXMLDOMDocument2 *doc;
1802     IXMLDOMNode *rootNode;
1803     IXMLDOMNode *elem1Node;
1804     IXMLDOMNode *node;
1805     IXMLDOMNodeList *list;
1806
1807     r = CoCreateInstance( &CLSID_DOMDocument, NULL,
1808         CLSCTX_INPROC_SERVER, &IID_IXMLDOMDocument2, (LPVOID*)&doc );
1809     if( r != S_OK )
1810         return;
1811
1812     ole_check(IXMLDOMDocument_loadXML(doc, _bstr_(szExampleXML), &b));
1813     ok(b == VARIANT_TRUE, "failed to load XML string\n");
1814
1815     /* switch to XPath */
1816     ole_check(IXMLDOMDocument2_setProperty(doc, _bstr_("SelectionLanguage"), _variantbstr_("XPath")));
1817
1818     /* some simple queries*/
1819     ole_check(IXMLDOMDocument_selectNodes(doc, _bstr_("root"), &list));
1820     ole_check(IXMLDOMNodeList_get_item(list, 0, &rootNode));
1821     ole_check(IXMLDOMNodeList_reset(list));
1822     expect_list_and_release(list, "E2.D1");
1823     if (rootNode == NULL)
1824         return;
1825
1826     ole_check(IXMLDOMDocument_selectNodes(doc, _bstr_("root//c"), &list));
1827     expect_list_and_release(list, "E3.E1.E2.D1 E3.E2.E2.D1");
1828
1829     ole_check(IXMLDOMDocument_selectNodes(doc, _bstr_("//c[@type]"), &list));
1830     expect_list_and_release(list, "E3.E2.E2.D1");
1831
1832     ole_check(IXMLDOMNode_selectNodes(rootNode, _bstr_("elem"), &list));
1833     /* using get_item for query results advances the position */
1834     ole_check(IXMLDOMNodeList_get_item(list, 1, &node));
1835     expect_node(node, "E2.E2.D1");
1836     IXMLDOMNode_Release(node);
1837     ole_check(IXMLDOMNodeList_nextNode(list, &node));
1838     expect_node(node, "E4.E2.D1");
1839     IXMLDOMNode_Release(node);
1840     ole_check(IXMLDOMNodeList_reset(list));
1841     expect_list_and_release(list, "E1.E2.D1 E2.E2.D1 E4.E2.D1");
1842
1843     ole_check(IXMLDOMNode_selectNodes(rootNode, _bstr_("."), &list));
1844     expect_list_and_release(list, "E2.D1");
1845
1846     ole_check(IXMLDOMNode_selectNodes(rootNode, _bstr_("elem[3]/preceding-sibling::*"), &list));
1847     ole_check(IXMLDOMNodeList_get_item(list, 0, &elem1Node));
1848     ole_check(IXMLDOMNodeList_reset(list));
1849     expect_list_and_release(list, "E1.E2.D1 E2.E2.D1 E3.E2.D1");
1850
1851     /* select an attribute */
1852     ole_check(IXMLDOMNode_selectNodes(rootNode, _bstr_(".//@type"), &list));
1853     expect_list_and_release(list, "A'type'.E3.E2.E2.D1");
1854
1855     /* would evaluate to a number */
1856     ole_expect(IXMLDOMNode_selectNodes(rootNode, _bstr_("count(*)"), &list), E_FAIL);
1857     /* would evaluate to a boolean */
1858     ole_expect(IXMLDOMNode_selectNodes(rootNode, _bstr_("position()>0"), &list), E_FAIL);
1859     /* would evaluate to a string */
1860     ole_expect(IXMLDOMNode_selectNodes(rootNode, _bstr_("name()"), &list), E_FAIL);
1861
1862     /* no results */
1863     ole_check(IXMLDOMNode_selectNodes(rootNode, _bstr_("c"), &list));
1864     expect_list_and_release(list, "");
1865     ole_check(IXMLDOMDocument_selectNodes(doc, _bstr_("elem//c"), &list));
1866     expect_list_and_release(list, "");
1867     ole_check(IXMLDOMDocument_selectNodes(doc, _bstr_("//elem[4]"), &list));
1868     expect_list_and_release(list, "");
1869
1870     /* foo undeclared in document node */
1871     ole_expect(IXMLDOMDocument_selectNodes(doc, _bstr_("root//foo:c"), &list), E_FAIL);
1872     /* undeclared in <root> node */
1873     ole_expect(IXMLDOMNode_selectNodes(rootNode, _bstr_(".//foo:c"), &list), E_FAIL);
1874     /* undeclared in <elem> node */
1875     ole_expect(IXMLDOMNode_selectNodes(elem1Node, _bstr_("//foo:c"), &list), E_FAIL);
1876     /* but this trick can be used */
1877     ole_check(IXMLDOMNode_selectNodes(elem1Node, _bstr_("//*[name()='foo:c']"), &list));
1878     expect_list_and_release(list, "E3.E4.E2.D1");
1879
1880     /* it has to be declared in SelectionNamespaces */
1881     todo_wine ole_check(IXMLDOMDocument2_setProperty(doc, _bstr_("SelectionNamespaces"),
1882         _variantbstr_("xmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29'")));
1883
1884     /* now the namespace can be used */
1885     todo_wine ole_check(IXMLDOMDocument_selectNodes(doc, _bstr_("root//test:c"), &list));
1886     todo_wine expect_list_and_release(list, "E3.E3.E2.D1 E3.E4.E2.D1");
1887     todo_wine ole_check(IXMLDOMNode_selectNodes(rootNode, _bstr_(".//test:c"), &list));
1888     todo_wine expect_list_and_release(list, "E3.E3.E2.D1 E3.E4.E2.D1");
1889     todo_wine ole_check(IXMLDOMNode_selectNodes(elem1Node, _bstr_("//test:c"), &list));
1890     todo_wine expect_list_and_release(list, "E3.E3.E2.D1 E3.E4.E2.D1");
1891     todo_wine ole_check(IXMLDOMNode_selectNodes(elem1Node, _bstr_(".//test:x"), &list));
1892     todo_wine expect_list_and_release(list, "E5.E1.E4.E1.E2.D1");
1893
1894     /* SelectionNamespaces syntax error - the namespaces doesn't work anymore but the value is stored */
1895     ole_expect(IXMLDOMDocument2_setProperty(doc, _bstr_("SelectionNamespaces"),
1896         _variantbstr_("xmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29' xmlns:foo=###")), E_FAIL);
1897
1898     ole_expect(IXMLDOMDocument_selectNodes(doc, _bstr_("root//foo:c"), &list), E_FAIL);
1899
1900     VariantClear(&var);
1901     todo_wine ole_check(IXMLDOMDocument2_getProperty(doc, _bstr_("SelectionNamespaces"), &var));
1902     todo_wine expect_eq(V_VT(&var), VT_BSTR, int, "%x");
1903     if (V_VT(&var) == VT_BSTR)
1904         expect_bstr_eq_and_free(V_BSTR(&var), "xmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29' xmlns:foo=###");
1905
1906     /* extra attributes - same thing*/
1907     ole_expect(IXMLDOMDocument2_setProperty(doc, _bstr_("SelectionNamespaces"),
1908         _variantbstr_("xmlns:test='urn:uuid:86B2F87F-ACB6-45cd-8B77-9BDB92A01A29' param='test'")), E_FAIL);
1909     ole_expect(IXMLDOMDocument_selectNodes(doc, _bstr_("root//foo:c"), &list), E_FAIL);
1910
1911     IXMLDOMNode_Release(rootNode);
1912     IXMLDOMNode_Release(elem1Node);
1913     IXMLDOMDocument_Release(doc);
1914     free_bstrs();
1915 }
1916
1917 static void test_cloneNode(void )
1918 {
1919     IXMLDOMDocument *doc = NULL;
1920     VARIANT_BOOL b;
1921     IXMLDOMNodeList *pList;
1922     IXMLDOMNamedNodeMap *mapAttr;
1923     long nLength = 0, nLength1 = 0;
1924     long nAttrCnt = 0, nAttrCnt1 = 0;
1925     IXMLDOMNode *node;
1926     IXMLDOMNode *node_clone;
1927     HRESULT r;
1928     BSTR str;
1929     static const WCHAR szSearch[] = { 'l', 'c', '/', 'p', 'r', 0 };
1930
1931     r = CoCreateInstance( &CLSID_DOMDocument, NULL, CLSCTX_INPROC_SERVER, &IID_IXMLDOMDocument2, (LPVOID*)&doc );
1932     if( r != S_OK )
1933         return;
1934
1935     str = SysAllocString( szComplete4 );
1936     ole_check(IXMLDOMDocument_loadXML(doc, str, &b));
1937     ok(b == VARIANT_TRUE, "failed to load XML string\n");
1938     SysFreeString(str);
1939
1940     if(!b)
1941         return;
1942
1943     str = SysAllocString( szSearch);
1944     r = IXMLDOMNode_selectSingleNode(doc, str, &node);
1945     ok( r == S_OK, "ret %08x\n", r );
1946     ok( node != NULL, "node %p\n", node );
1947     SysFreeString(str);
1948
1949     if(!node)
1950     {
1951         IXMLDOMDocument_Release(doc);
1952         return;
1953     }
1954
1955     /* Check invalid parameter */
1956     r = IXMLDOMNode_cloneNode(node, VARIANT_TRUE, NULL);
1957     ok( r == E_INVALIDARG, "ret %08x\n", r );
1958
1959     /* All Children */
1960     r = IXMLDOMNode_cloneNode(node, VARIANT_TRUE, &node_clone);
1961     ok( r == S_OK, "ret %08x\n", r );
1962     ok( node_clone != NULL, "node %p\n", node );
1963
1964     if(!node_clone)
1965     {
1966         IXMLDOMDocument_Release(doc);
1967         IXMLDOMNode_Release(node);
1968         return;
1969     }
1970
1971     r = IXMLDOMNode_get_childNodes(node, &pList);
1972     ok( r == S_OK, "ret %08x\n", r );
1973     if (pList)
1974         {
1975                 IXMLDOMNodeList_get_length(pList, &nLength);
1976                 IXMLDOMNodeList_Release(pList);
1977         }
1978
1979     r = IXMLDOMNode_get_attributes(node, &mapAttr);
1980     ok( r == S_OK, "ret %08x\n", r );
1981     if(mapAttr)
1982     {
1983         IXMLDOMNamedNodeMap_get_length(mapAttr, &nAttrCnt);
1984         IXMLDOMNamedNodeMap_Release(mapAttr);
1985     }
1986
1987     r = IXMLDOMNode_get_childNodes(node_clone, &pList);
1988     ok( r == S_OK, "ret %08x\n", r );
1989     if (pList)
1990         {
1991                 IXMLDOMNodeList_get_length(pList, &nLength1);
1992                 IXMLDOMNodeList_Release(pList);
1993         }
1994
1995     r = IXMLDOMNode_get_attributes(node_clone, &mapAttr);
1996     ok( r == S_OK, "ret %08x\n", r );
1997     if(mapAttr)
1998     {
1999         IXMLDOMNamedNodeMap_get_length(mapAttr, &nAttrCnt1);
2000         IXMLDOMNamedNodeMap_Release(mapAttr);
2001     }
2002
2003     ok(nLength == nLength1, "wrong Child count (%ld, %ld)\n", nLength, nLength1);
2004     ok(nAttrCnt == nAttrCnt1, "wrong Attribute count (%ld, %ld)\n", nAttrCnt, nAttrCnt1);
2005     IXMLDOMNode_Release(node_clone);
2006
2007     /* No Children */
2008     r = IXMLDOMNode_cloneNode(node, VARIANT_FALSE, &node_clone);
2009     ok( r == S_OK, "ret %08x\n", r );
2010     ok( node_clone != NULL, "node %p\n", node );
2011
2012     if(!node_clone)
2013     {
2014         IXMLDOMDocument_Release(doc);
2015         IXMLDOMNode_Release(node);
2016         return;
2017     }
2018
2019     r = IXMLDOMNode_get_childNodes(node_clone, &pList);
2020     ok( r == S_OK, "ret %08x\n", r );
2021     if (pList)
2022         {
2023                 IXMLDOMNodeList_get_length(pList, &nLength1);
2024         ok( nLength1 == 0, "Length should be 0 (%ld)\n", nLength1);
2025                 IXMLDOMNodeList_Release(pList);
2026         }
2027
2028     r = IXMLDOMNode_get_attributes(node_clone, &mapAttr);
2029     ok( r == S_OK, "ret %08x\n", r );
2030     if(mapAttr)
2031     {
2032         IXMLDOMNamedNodeMap_get_length(mapAttr, &nAttrCnt1);
2033         ok( nAttrCnt1 == 3, "Attribute count should be 3 (%ld)\n", nAttrCnt1);
2034         IXMLDOMNamedNodeMap_Release(mapAttr);
2035     }
2036
2037     ok(nLength != nLength1, "wrong Child count (%ld, %ld)\n", nLength, nLength1);
2038     ok(nAttrCnt == nAttrCnt1, "wrong Attribute count (%ld, %ld)\n", nAttrCnt, nAttrCnt1);
2039     IXMLDOMNode_Release(node_clone);
2040
2041
2042     IXMLDOMNode_Release(node);
2043     IXMLDOMDocument_Release(doc);
2044 }
2045
2046 static void test_xmlTypes(void)
2047 {
2048     IXMLDOMDocument *doc = NULL;
2049     IXMLDOMElement *pRoot;
2050     HRESULT hr;
2051     IXMLDOMComment *pComment;
2052     IXMLDOMElement *pElement;
2053     IXMLDOMAttribute *pAttrubute;
2054     IXMLDOMNamedNodeMap *pAttribs;
2055     IXMLDOMCDATASection *pCDataSec;
2056     IXMLDOMImplementation *pIXMLDOMImplementation = NULL;
2057     IXMLDOMDocumentFragment *pDocFrag = NULL;
2058     IXMLDOMEntityReference *pEntityRef = NULL;
2059     BSTR str;
2060     IXMLDOMNode *pNextChild = (IXMLDOMNode *)0x1;   /* Used for testing Siblings */
2061     VARIANT v;
2062     long len = 0;
2063
2064     hr = CoCreateInstance( &CLSID_DOMDocument, NULL, CLSCTX_INPROC_SERVER, &IID_IXMLDOMDocument2, (LPVOID*)&doc );
2065     if( hr != S_OK )
2066         return;
2067
2068     hr = IXMLDOMDocument_get_nextSibling(doc, NULL);
2069     ok(hr == E_INVALIDARG, "ret %08x\n", hr );
2070
2071     hr = IXMLDOMDocument_get_nextSibling(doc, &pNextChild);
2072     ok(hr == S_FALSE, "ret %08x\n", hr );
2073     ok(pNextChild == NULL, "pDocChild not NULL\n");
2074
2075     /* test previous Sibling */
2076     hr = IXMLDOMDocument_get_previousSibling(doc, NULL);
2077     ok(hr == E_INVALIDARG, "ret %08x\n", hr );
2078
2079     pNextChild = (IXMLDOMNode *)0x1;
2080     hr = IXMLDOMDocument_get_previousSibling(doc, &pNextChild);
2081     ok(hr == S_FALSE, "ret %08x\n", hr );
2082     ok(pNextChild == NULL, "pNextChild not NULL\n");
2083
2084     /* test get_attributes */
2085     hr = IXMLDOMDocument_get_attributes( doc, NULL );
2086     ok( hr == E_INVALIDARG, "get_attributes returned wrong code\n");
2087
2088     pAttribs = (IXMLDOMNamedNodeMap*)0x1;
2089     hr = IXMLDOMDocument_get_attributes( doc, &pAttribs);
2090     ok(hr == S_FALSE, "ret %08x\n", hr );
2091     ok( pAttribs == NULL, "pAttribs not NULL\n");
2092
2093     /* test get_dataType */
2094     hr = IXMLDOMDocument_get_dataType(doc, &v);
2095     ok(hr == S_FALSE, "ret %08x\n", hr );
2096     ok( V_VT(&v) == VT_NULL, "incorrect dataType type\n");
2097     VariantClear(&v);
2098
2099     /* test nodeTypeString */
2100     hr = IXMLDOMDocument_get_nodeTypeString(doc, &str);
2101     ok(hr == S_OK, "ret %08x\n", hr );
2102     ok( !lstrcmpW( str, _bstr_("document") ), "incorrect nodeTypeString string\n");
2103     SysFreeString(str);
2104
2105     /* test implementation */
2106     hr = IXMLDOMDocument_get_implementation(doc, NULL);
2107     ok(hr == E_INVALIDARG, "ret %08x\n", hr );
2108
2109     hr = IXMLDOMDocument_get_implementation(doc, &pIXMLDOMImplementation);
2110     ok(hr == S_OK, "ret %08x\n", hr );
2111     if(hr == S_OK)
2112     {
2113         VARIANT_BOOL hasFeature = VARIANT_TRUE;
2114         BSTR sEmpty = SysAllocStringLen(NULL, 0);
2115
2116         hr = IXMLDOMImplementation_hasFeature(pIXMLDOMImplementation, NULL, sEmpty, &hasFeature);
2117         ok(hr == E_INVALIDARG, "ret %08x\n", hr );
2118
2119         hr = IXMLDOMImplementation_hasFeature(pIXMLDOMImplementation, sEmpty, sEmpty, NULL);
2120         ok(hr == E_INVALIDARG, "ret %08x\n", hr );
2121
2122         hr = IXMLDOMImplementation_hasFeature(pIXMLDOMImplementation, _bstr_("DOM"), sEmpty, &hasFeature);
2123         ok(hr == S_OK, "ret %08x\n", hr );
2124         ok(hasFeature == VARIANT_FALSE, "hasFeature returned false\n");
2125
2126         hr = IXMLDOMImplementation_hasFeature(pIXMLDOMImplementation, sEmpty, sEmpty, &hasFeature);
2127         ok(hr == S_OK, "ret %08x\n", hr );
2128         ok(hasFeature == VARIANT_FALSE, "hasFeature returned true\n");
2129
2130         hr = IXMLDOMImplementation_hasFeature(pIXMLDOMImplementation, _bstr_("DOM"), NULL, &hasFeature);
2131         ok(hr == S_OK, "ret %08x\n", hr );
2132         ok(hasFeature == VARIANT_TRUE, "hasFeature returned false\n");
2133
2134         hr = IXMLDOMImplementation_hasFeature(pIXMLDOMImplementation, _bstr_("DOM"), sEmpty, &hasFeature);
2135         ok(hr == S_OK, "ret %08x\n", hr );
2136         ok(hasFeature == VARIANT_FALSE, "hasFeature returned false\n");
2137
2138         hr = IXMLDOMImplementation_hasFeature(pIXMLDOMImplementation, _bstr_("DOM"), _bstr_("1.0"), &hasFeature);
2139         ok(hr == S_OK, "ret %08x\n", hr );
2140         ok(hasFeature == VARIANT_TRUE, "hasFeature returned true\n");
2141
2142         hr = IXMLDOMImplementation_hasFeature(pIXMLDOMImplementation, _bstr_("XML"), _bstr_("1.0"), &hasFeature);
2143         ok(hr == S_OK, "ret %08x\n", hr );
2144         ok(hasFeature == VARIANT_TRUE, "hasFeature returned true\n");
2145
2146         hr = IXMLDOMImplementation_hasFeature(pIXMLDOMImplementation, _bstr_("MS-DOM"), _bstr_("1.0"), &hasFeature);
2147         ok(hr == S_OK, "ret %08x\n", hr );
2148         ok(hasFeature == VARIANT_TRUE, "hasFeature returned true\n");
2149
2150         hr = IXMLDOMImplementation_hasFeature(pIXMLDOMImplementation, _bstr_("SSS"), NULL, &hasFeature);
2151         ok(hr == S_OK, "ret %08x\n", hr );
2152         ok(hasFeature == VARIANT_FALSE, "hasFeature returned false\n");
2153
2154         SysFreeString(sEmpty);
2155         IXMLDOMImplementation_Release(pIXMLDOMImplementation);
2156     }
2157
2158
2159
2160     hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing"), &pRoot);
2161     ok(hr == S_OK, "ret %08x\n", hr );
2162     if(hr == S_OK)
2163     {
2164         hr = IXMLDOMDocument_appendChild(doc, (IXMLDOMNode*)pRoot, NULL);
2165         ok(hr == S_OK, "ret %08x\n", hr );
2166         if(hr == S_OK)
2167         {
2168             /* Comment */
2169             hr = IXMLDOMDocument_createComment(doc, szComment, &pComment);
2170             ok(hr == S_OK, "ret %08x\n", hr );
2171             if(hr == S_OK)
2172             {
2173                 /* test get_attributes */
2174                 hr = IXMLDOMComment_get_attributes( pComment, NULL );
2175                 ok( hr == E_INVALIDARG, "get_attributes returned wrong code\n");
2176
2177                 pAttribs = (IXMLDOMNamedNodeMap*)0x1;
2178                 hr = IXMLDOMComment_get_attributes( pComment, &pAttribs);
2179                 ok(hr == S_FALSE, "ret %08x\n", hr );
2180                 ok( pAttribs == NULL, "pAttribs not NULL\n");
2181
2182                 /* test nodeTypeString */
2183                 hr = IXMLDOMComment_get_nodeTypeString(pComment, &str);
2184                 ok(hr == S_OK, "ret %08x\n", hr );
2185                 ok( !lstrcmpW( str, _bstr_("comment") ), "incorrect nodeTypeString string\n");
2186                 SysFreeString(str);
2187
2188                 hr = IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pComment, NULL);
2189                 ok(hr == S_OK, "ret %08x\n", hr );
2190
2191                 hr = IXMLDOMComment_get_nodeName(pComment, &str);
2192                 ok(hr == S_OK, "ret %08x\n", hr );
2193                 ok( !lstrcmpW( str, szCommentNodeText ), "incorrect comment node Name\n");
2194                 SysFreeString(str);
2195
2196                 hr = IXMLDOMComment_get_xml(pComment, &str);
2197                 ok(hr == S_OK, "ret %08x\n", hr );
2198                 ok( !lstrcmpW( str, szCommentXML ), "incorrect comment xml\n");
2199                 SysFreeString(str);
2200
2201                 hr = IXMLDOMComment_get_dataType(pComment, &v);
2202                 ok(hr == S_FALSE, "ret %08x\n", hr );
2203                 ok( V_VT(&v) == VT_NULL, "incorrect dataType type\n");
2204                 VariantClear(&v);
2205
2206                 /* put data Tests */
2207                 hr = IXMLDOMComment_put_data(pComment, _bstr_("This &is a ; test <>\\"));
2208                 ok(hr == S_OK, "ret %08x\n", hr );
2209
2210                 /* get data Tests */
2211                 hr = IXMLDOMComment_get_data(pComment, &str);
2212                 ok(hr == S_OK, "ret %08x\n", hr );
2213                 ok( !lstrcmpW( str, _bstr_("This &is a ; test <>\\") ), "incorrect get_data string\n");
2214                 SysFreeString(str);
2215
2216                 /* get data Tests */
2217                 hr = IXMLDOMComment_get_nodeValue(pComment, &v);
2218                 ok(hr == S_OK, "ret %08x\n", hr );
2219                 ok( V_VT(&v) == VT_BSTR, "incorrect dataType type\n");
2220                 ok( !lstrcmpW( V_BSTR(&v), _bstr_("This &is a ; test <>\\") ), "incorrect get_nodeValue string\n");
2221                 VariantClear(&v);
2222
2223                 /* Confirm XML text is good */
2224                 hr = IXMLDOMComment_get_xml(pComment, &str);
2225                 ok(hr == S_OK, "ret %08x\n", hr );
2226                 ok( !lstrcmpW( str, _bstr_("<!--This &is a ; test <>\\-->") ), "incorrect xml string\n");
2227                 SysFreeString(str);
2228
2229                 /* Confirm we get the put_data Text back */
2230                 hr = IXMLDOMComment_get_text(pComment, &str);
2231                 ok(hr == S_OK, "ret %08x\n", hr );
2232                 ok( !lstrcmpW( str, _bstr_("This &is a ; test <>\\") ), "incorrect xml string\n");
2233                 SysFreeString(str);
2234
2235                 /* test length property */
2236                 hr = IXMLDOMComment_get_length(pComment, &len);
2237                 ok(hr == S_OK, "ret %08x\n", hr );
2238                 ok(len == 21, "expected 21 got %ld\n", len);
2239
2240                 /* test substringData */
2241                 hr = IXMLDOMComment_substringData(pComment, 0, 4, NULL);
2242                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
2243
2244                 /* test substringData - Invalid offset */
2245                 str = (BSTR)&szElement;
2246                 hr = IXMLDOMComment_substringData(pComment, -1, 4, &str);
2247                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
2248                 ok( str == NULL, "incorrect string\n");
2249
2250                 /* test substringData - Invalid offset */
2251                 str = (BSTR)&szElement;
2252                 hr = IXMLDOMComment_substringData(pComment, 30, 0, &str);
2253                 ok(hr == S_FALSE, "ret %08x\n", hr );
2254                 ok( str == NULL, "incorrect string\n");
2255
2256                 /* test substringData - Invalid size */
2257                 str = (BSTR)&szElement;
2258                 hr = IXMLDOMComment_substringData(pComment, 0, -1, &str);
2259                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
2260                 ok( str == NULL, "incorrect string\n");
2261
2262                 /* test substringData - Invalid size */
2263                 str = (BSTR)&szElement;
2264                 hr = IXMLDOMComment_substringData(pComment, 2, 0, &str);
2265                 ok(hr == S_FALSE, "ret %08x\n", hr );
2266                 ok( str == NULL, "incorrect string\n");
2267
2268                 /* test substringData - Start of string */
2269                 hr = IXMLDOMComment_substringData(pComment, 0, 4, &str);
2270                 ok(hr == S_OK, "ret %08x\n", hr );
2271                 ok( !lstrcmpW( str, _bstr_("This") ), "incorrect substringData string\n");
2272                 SysFreeString(str);
2273
2274                 /* test substringData - Middle of string */
2275                 hr = IXMLDOMComment_substringData(pComment, 13, 4, &str);
2276                 ok(hr == S_OK, "ret %08x\n", hr );
2277                 ok( !lstrcmpW( str, _bstr_("test") ), "incorrect substringData string\n");
2278                 SysFreeString(str);
2279
2280                 /* test substringData - End of string */
2281                 hr = IXMLDOMComment_substringData(pComment, 20, 4, &str);
2282                 ok(hr == S_OK, "ret %08x\n", hr );
2283                 ok( !lstrcmpW( str, _bstr_("\\") ), "incorrect substringData string\n");
2284                 SysFreeString(str);
2285
2286                 /* test appendData */
2287                 hr = IXMLDOMComment_appendData(pComment, NULL);
2288                 ok(hr == S_OK, "ret %08x\n", hr );
2289
2290                 hr = IXMLDOMComment_appendData(pComment, _bstr_(""));
2291                 ok(hr == S_OK, "ret %08x\n", hr );
2292
2293                 hr = IXMLDOMComment_appendData(pComment, _bstr_("Append"));
2294                 ok(hr == S_OK, "ret %08x\n", hr );
2295
2296                 hr = IXMLDOMComment_get_text(pComment, &str);
2297                 ok(hr == S_OK, "ret %08x\n", hr );
2298                 ok( !lstrcmpW( str, _bstr_("This &is a ; test <>\\Append") ), "incorrect get_text string\n");
2299                 SysFreeString(str);
2300
2301                 IXMLDOMComment_Release(pComment);
2302             }
2303
2304             /* Element */
2305             hr = IXMLDOMDocument_createElement(doc, szElement, &pElement);
2306             ok(hr == S_OK, "ret %08x\n", hr );
2307             if(hr == S_OK)
2308             {
2309                 hr = IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pElement, NULL);
2310                 ok(hr == S_OK, "ret %08x\n", hr );
2311
2312                 /* test nodeTypeString */
2313                 hr = IXMLDOMDocument_get_nodeTypeString(pElement, &str);
2314                 ok(hr == S_OK, "ret %08x\n", hr );
2315                 ok( !lstrcmpW( str, _bstr_("element") ), "incorrect nodeTypeString string\n");
2316                 SysFreeString(str);
2317
2318                 hr = IXMLDOMElement_get_nodeName(pElement, &str);
2319                 ok(hr == S_OK, "ret %08x\n", hr );
2320                 ok( !lstrcmpW( str, szElement ), "incorrect element node Name\n");
2321                 SysFreeString(str);
2322
2323                 hr = IXMLDOMElement_get_xml(pElement, &str);
2324                 ok(hr == S_OK, "ret %08x\n", hr );
2325                 ok( !lstrcmpW( str, szElementXML ), "incorrect element xml\n");
2326                 SysFreeString(str);
2327
2328                 hr = IXMLDOMElement_get_dataType(pElement, &v);
2329                 ok(hr == S_FALSE, "ret %08x\n", hr );
2330                 ok( V_VT(&v) == VT_NULL, "incorrect dataType type\n");
2331                 VariantClear(&v);
2332
2333                  /* Attribute */
2334                 hr = IXMLDOMDocument_createAttribute(doc, szAttribute, &pAttrubute);
2335                 ok(hr == S_OK, "ret %08x\n", hr );
2336                 if(hr == S_OK)
2337                 {
2338                     IXMLDOMNode *pNewChild = (IXMLDOMNode *)0x1;
2339
2340                     hr = IXMLDOMAttribute_get_nextSibling(pAttrubute, NULL);
2341                     ok(hr == E_INVALIDARG, "ret %08x\n", hr );
2342
2343                     pNextChild = (IXMLDOMNode *)0x1;
2344                     hr = IXMLDOMAttribute_get_nextSibling(pAttrubute, &pNextChild);
2345                     ok(hr == S_FALSE, "ret %08x\n", hr );
2346                     ok(pNextChild == NULL, "pNextChild not NULL\n");
2347
2348                     /* test Previous Sibling*/
2349                     hr = IXMLDOMAttribute_get_previousSibling(pAttrubute, NULL);
2350                     ok(hr == E_INVALIDARG, "ret %08x\n", hr );
2351
2352                     pNextChild = (IXMLDOMNode *)0x1;
2353                     hr = IXMLDOMAttribute_get_previousSibling(pAttrubute, &pNextChild);
2354                     ok(hr == S_FALSE, "ret %08x\n", hr );
2355                     ok(pNextChild == NULL, "pNextChild not NULL\n");
2356
2357                     /* test get_attributes */
2358                     hr = IXMLDOMAttribute_get_attributes( pAttrubute, NULL );
2359                     ok( hr == E_INVALIDARG, "get_attributes returned wrong code\n");
2360
2361                     pAttribs = (IXMLDOMNamedNodeMap*)0x1;
2362                     hr = IXMLDOMAttribute_get_attributes( pAttrubute, &pAttribs);
2363                     ok(hr == S_FALSE, "ret %08x\n", hr );
2364                     ok( pAttribs == NULL, "pAttribs not NULL\n");
2365
2366                     hr = IXMLDOMElement_appendChild(pElement, (IXMLDOMNode*)pAttrubute, &pNewChild);
2367                     ok(hr == E_FAIL, "ret %08x\n", hr );
2368                     ok(pNewChild == NULL, "pNewChild not NULL\n");
2369
2370                     hr = IXMLDOMElement_get_attributes(pElement, &pAttribs);
2371                     ok(hr == S_OK, "ret %08x\n", hr );
2372                     if ( hr == S_OK )
2373                     {
2374                         hr = IXMLDOMNamedNodeMap_setNamedItem(pAttribs, (IXMLDOMNode*)pAttrubute, NULL );
2375                         ok(hr == S_OK, "ret %08x\n", hr );
2376
2377                         IXMLDOMNamedNodeMap_Release(pAttribs);
2378                     }
2379
2380                     hr = IXMLDOMAttribute_get_nodeName(pAttrubute, &str);
2381                     ok(hr == S_OK, "ret %08x\n", hr );
2382                     ok( !lstrcmpW( str, szAttribute ), "incorrect attribute node Name\n");
2383                     SysFreeString(str);
2384
2385                     /* test nodeTypeString */
2386                     hr = IXMLDOMAttribute_get_nodeTypeString(pAttrubute, &str);
2387                     ok(hr == S_OK, "ret %08x\n", hr );
2388                     ok( !lstrcmpW( str, _bstr_("attribute") ), "incorrect nodeTypeString string\n");
2389                     SysFreeString(str);
2390
2391                     /* test nodeName */
2392                     hr = IXMLDOMAttribute_get_nodeName(pAttrubute, &str);
2393                     ok(hr == S_OK, "ret %08x\n", hr );
2394                     ok( !lstrcmpW( str, szAttribute ), "incorrect nodeName string\n");
2395                     SysFreeString(str);
2396
2397                     /* test name property */
2398                     hr = IXMLDOMAttribute_get_name(pAttrubute, &str);
2399                     ok(hr == S_OK, "ret %08x\n", hr );
2400                     ok( !lstrcmpW( str, szAttribute ), "incorrect name string\n");
2401                     SysFreeString(str);
2402
2403                     hr = IXMLDOMAttribute_get_xml(pAttrubute, &str);
2404                     ok(hr == S_OK, "ret %08x\n", hr );
2405                     ok( !lstrcmpW( str, szAttributeXML ), "incorrect attribute xml\n");
2406                     SysFreeString(str);
2407
2408                     hr = IXMLDOMAttribute_get_dataType(pAttrubute, &v);
2409                     ok(hr == S_FALSE, "ret %08x\n", hr );
2410                     ok( V_VT(&v) == VT_NULL, "incorrect dataType type\n");
2411                     VariantClear(&v);
2412
2413                     IXMLDOMAttribute_Release(pAttrubute);
2414
2415                     /* Check Element again with the Add Attribute*/
2416                     hr = IXMLDOMElement_get_xml(pElement, &str);
2417                     ok(hr == S_OK, "ret %08x\n", hr );
2418                     ok( !lstrcmpW( str, szElementXML2 ), "incorrect element xml\n");
2419                     SysFreeString(str);
2420                 }
2421
2422                 hr = IXMLDOMElement_put_text(pElement, _bstr_("TestingNode"));
2423                 ok(hr == S_OK, "ret %08x\n", hr );
2424
2425                 hr = IXMLDOMElement_get_xml(pElement, &str);
2426                 ok(hr == S_OK, "ret %08x\n", hr );
2427                 ok( !lstrcmpW( str, szElementXML3 ), "incorrect element xml\n");
2428                 SysFreeString(str);
2429
2430                 IXMLDOMElement_Release(pElement);
2431             }
2432
2433             /* CData Section */
2434             hr = IXMLDOMDocument_createCDATASection(doc, szCData, NULL);
2435             ok(hr == E_INVALIDARG, "ret %08x\n", hr );
2436
2437             hr = IXMLDOMDocument_createCDATASection(doc, szCData, &pCDataSec);
2438             ok(hr == S_OK, "ret %08x\n", hr );
2439             if(hr == S_OK)
2440             {
2441                 IXMLDOMNode *pNextChild = (IXMLDOMNode *)0x1;
2442                 VARIANT var;
2443
2444                 hr = IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pCDataSec, NULL);
2445                 ok(hr == S_OK, "ret %08x\n", hr );
2446
2447                 /* get Attribute Tests */
2448                 hr = IXMLDOMCDATASection_get_attributes(pCDataSec, NULL);
2449                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
2450
2451                 pAttribs = (IXMLDOMNamedNodeMap*)0x1;
2452                 hr = IXMLDOMCDATASection_get_attributes(pCDataSec, &pAttribs);
2453                 ok(hr == S_FALSE, "ret %08x\n", hr );
2454                 ok(pAttribs == NULL, "pAttribs != NULL\n");
2455
2456                 hr = IXMLDOMCDATASection_get_nodeName(pCDataSec, &str);
2457                 ok(hr == S_OK, "ret %08x\n", hr );
2458                 ok( !lstrcmpW( str, szCDataNodeText ), "incorrect cdata node Name\n");
2459                 SysFreeString(str);
2460
2461                 hr = IXMLDOMCDATASection_get_xml(pCDataSec, &str);
2462                 ok(hr == S_OK, "ret %08x\n", hr );
2463                 ok( !lstrcmpW( str, szCDataXML ), "incorrect cdata xml\n");
2464                 SysFreeString(str);
2465
2466                 /* test lastChild */
2467                 pNextChild = (IXMLDOMNode*)0x1;
2468                 hr = IXMLDOMCDATASection_get_lastChild(pCDataSec, &pNextChild);
2469                 ok(hr == S_FALSE, "ret %08x\n", hr );
2470                 ok(pNextChild == NULL, "pNextChild not NULL\n");
2471
2472                 /* test get_dataType */
2473                 hr = IXMLDOMCDATASection_get_dataType(pCDataSec, NULL);
2474                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
2475
2476                 hr = IXMLDOMCDATASection_get_dataType(pCDataSec, &v);
2477                 ok(hr == S_FALSE, "ret %08x\n", hr );
2478                 ok( V_VT(&v) == VT_NULL, "incorrect dataType type\n");
2479                 VariantClear(&v);
2480
2481                 /* test nodeTypeString */
2482                 hr = IXMLDOMCDATASection_get_nodeTypeString(pCDataSec, &str);
2483                 ok(hr == S_OK, "ret %08x\n", hr );
2484                 ok( !lstrcmpW( str, _bstr_("cdatasection") ), "incorrect nodeTypeString string\n");
2485                 SysFreeString(str);
2486
2487                 /* put data Tests */
2488                 hr = IXMLDOMCDATASection_put_data(pCDataSec, _bstr_("This &is a ; test <>\\"));
2489                 ok(hr == S_OK, "ret %08x\n", hr );
2490
2491                 /* Confirm XML text is good */
2492                 hr = IXMLDOMCDATASection_get_xml(pCDataSec, &str);
2493                 ok(hr == S_OK, "ret %08x\n", hr );
2494                 ok( !lstrcmpW( str, _bstr_("<![CDATA[This &is a ; test <>\\]]>") ), "incorrect xml string\n");
2495                 SysFreeString(str);
2496
2497                 /* Confirm we get the put_data Text back */
2498                 hr = IXMLDOMCDATASection_get_text(pCDataSec, &str);
2499                 ok(hr == S_OK, "ret %08x\n", hr );
2500                 ok( !lstrcmpW( str, _bstr_("This &is a ; test <>\\") ), "incorrect text string\n");
2501                 SysFreeString(str);
2502
2503                 /* test length property */
2504                 hr = IXMLDOMCDATASection_get_length(pCDataSec, &len);
2505                 ok(hr == S_OK, "ret %08x\n", hr );
2506                 ok(len == 21, "expected 21 got %ld\n", len);
2507
2508                 /* test get nodeValue */
2509                 hr = IXMLDOMCDATASection_get_nodeValue(pCDataSec, &var);
2510                 ok(hr == S_OK, "ret %08x\n", hr );
2511                 ok( !lstrcmpW( str, _bstr_("This &is a ; test <>\\") ), "incorrect text string\n");
2512                 VariantClear(&var);
2513
2514                 /* test get data */
2515                 hr = IXMLDOMCDATASection_get_data(pCDataSec, &str);
2516                 ok(hr == S_OK, "ret %08x\n", hr );
2517                 ok( !lstrcmpW( str, _bstr_("This &is a ; test <>\\") ), "incorrect text string\n");
2518                 SysFreeString(str);
2519
2520                 /* test substringData */
2521                 hr = IXMLDOMCDATASection_substringData(pCDataSec, 0, 4, NULL);
2522                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
2523
2524                 /* test substringData - Invalid offset */
2525                 str = (BSTR)&szElement;
2526                 hr = IXMLDOMCDATASection_substringData(pCDataSec, -1, 4, &str);
2527                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
2528                 ok( str == NULL, "incorrect string\n");
2529
2530                 /* test substringData - Invalid offset */
2531                 str = (BSTR)&szElement;
2532                 hr = IXMLDOMCDATASection_substringData(pCDataSec, 30, 0, &str);
2533                 ok(hr == S_FALSE, "ret %08x\n", hr );
2534                 ok( str == NULL, "incorrect string\n");
2535
2536                 /* test substringData - Invalid size */
2537                 str = (BSTR)&szElement;
2538                 hr = IXMLDOMCDATASection_substringData(pCDataSec, 0, -1, &str);
2539                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
2540                 ok( str == NULL, "incorrect string\n");
2541
2542                 /* test substringData - Invalid size */
2543                 str = (BSTR)&szElement;
2544                 hr = IXMLDOMCDATASection_substringData(pCDataSec, 2, 0, &str);
2545                 ok(hr == S_FALSE, "ret %08x\n", hr );
2546                 ok( str == NULL, "incorrect string\n");
2547
2548                 /* test substringData - Start of string */
2549                 hr = IXMLDOMCDATASection_substringData(pCDataSec, 0, 4, &str);
2550                 ok(hr == S_OK, "ret %08x\n", hr );
2551                 ok( !lstrcmpW( str, _bstr_("This") ), "incorrect substringData string\n");
2552                 SysFreeString(str);
2553
2554                 /* test substringData - Middle of string */
2555                 hr = IXMLDOMCDATASection_substringData(pCDataSec, 13, 4, &str);
2556                 ok(hr == S_OK, "ret %08x\n", hr );
2557                 ok( !lstrcmpW( str, _bstr_("test") ), "incorrect substringData string\n");
2558                 SysFreeString(str);
2559
2560                 /* test substringData - End of string */
2561                 hr = IXMLDOMCDATASection_substringData(pCDataSec, 20, 4, &str);
2562                 ok(hr == S_OK, "ret %08x\n", hr );
2563                 ok( !lstrcmpW( str, _bstr_("\\") ), "incorrect substringData string\n");
2564                 SysFreeString(str);
2565
2566                 /* test appendData */
2567                 hr = IXMLDOMCDATASection_appendData(pCDataSec, NULL);
2568                 ok(hr == S_OK, "ret %08x\n", hr );
2569
2570                 hr = IXMLDOMCDATASection_appendData(pCDataSec, _bstr_(""));
2571                 ok(hr == S_OK, "ret %08x\n", hr );
2572
2573                 hr = IXMLDOMCDATASection_appendData(pCDataSec, _bstr_("Append"));
2574                 ok(hr == S_OK, "ret %08x\n", hr );
2575
2576                 hr = IXMLDOMCDATASection_get_text(pCDataSec, &str);
2577                 ok(hr == S_OK, "ret %08x\n", hr );
2578                 ok( !lstrcmpW( str, _bstr_("This &is a ; test <>\\Append") ), "incorrect get_text string\n");
2579                 SysFreeString(str);
2580
2581                 /* test insertData */
2582                 str = SysAllocStringLen(NULL, 0);
2583                 hr = IXMLDOMCDATASection_insertData(pCDataSec, -1, str);
2584                 ok(hr == S_OK, "ret %08x\n", hr );
2585
2586                 hr = IXMLDOMCDATASection_insertData(pCDataSec, -1, NULL);
2587                 ok(hr == S_OK, "ret %08x\n", hr );
2588
2589                 hr = IXMLDOMCDATASection_insertData(pCDataSec, 1000, str);
2590                 ok(hr == S_OK, "ret %08x\n", hr );
2591
2592                 hr = IXMLDOMCDATASection_insertData(pCDataSec, 1000, NULL);
2593                 ok(hr == S_OK, "ret %08x\n", hr );
2594
2595                 hr = IXMLDOMCDATASection_insertData(pCDataSec, 0, NULL);
2596                 ok(hr == S_OK, "ret %08x\n", hr );
2597
2598                 hr = IXMLDOMCDATASection_insertData(pCDataSec, 0, str);
2599                 ok(hr == S_OK, "ret %08x\n", hr );
2600                 SysFreeString(str);
2601
2602                 hr = IXMLDOMCDATASection_insertData(pCDataSec, -1, _bstr_("Inserting"));
2603                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
2604
2605                 hr = IXMLDOMCDATASection_insertData(pCDataSec, 1000, _bstr_("Inserting"));
2606                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
2607
2608                 hr = IXMLDOMCDATASection_insertData(pCDataSec, 0, _bstr_("Begin "));
2609                 ok(hr == S_OK, "ret %08x\n", hr );
2610
2611                 hr = IXMLDOMCDATASection_insertData(pCDataSec, 17, _bstr_("Middle"));
2612                 ok(hr == S_OK, "ret %08x\n", hr );
2613
2614                 hr = IXMLDOMCDATASection_insertData(pCDataSec, 39, _bstr_(" End"));
2615                 ok(hr == S_OK, "ret %08x\n", hr );
2616
2617                 hr = IXMLDOMCDATASection_get_text(pCDataSec, &str);
2618                 ok(hr == S_OK, "ret %08x\n", hr );
2619                 ok( !lstrcmpW( str, _bstr_("Begin This &is a Middle; test <>\\Append End") ), "incorrect get_text string\n");
2620                 SysFreeString(str);
2621
2622                 IXMLDOMCDATASection_Release(pCDataSec);
2623             }
2624
2625             /* Document Fragments */
2626             hr = IXMLDOMDocument_createDocumentFragment(doc, NULL);
2627             ok(hr == E_INVALIDARG, "ret %08x\n", hr );
2628
2629             hr = IXMLDOMDocument_createDocumentFragment(doc, &pDocFrag);
2630             ok(hr == S_OK, "ret %08x\n", hr );
2631             if(hr == S_OK)
2632             {
2633                 IXMLDOMNode *pNextChild = (IXMLDOMNode *)0x1;
2634
2635                 hr = IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pDocFrag, NULL);
2636                 ok(hr == S_OK, "ret %08x\n", hr );
2637
2638                 /* get Attribute Tests */
2639                 hr = IXMLDOMDocumentFragment_get_attributes(pDocFrag, NULL);
2640                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
2641
2642                 pAttribs = (IXMLDOMNamedNodeMap*)0x1;
2643                 hr = IXMLDOMDocumentFragment_get_attributes(pDocFrag, &pAttribs);
2644                 ok(hr == S_FALSE, "ret %08x\n", hr );
2645                 ok(pAttribs == NULL, "pAttribs != NULL\n");
2646
2647                 hr = IXMLDOMDocumentFragment_get_nodeName(pDocFrag, &str);
2648                 ok(hr == S_OK, "ret %08x\n", hr );
2649                 ok( !lstrcmpW( str, szDocFragmentText ), "incorrect docfragment node Name\n");
2650                 SysFreeString(str);
2651
2652                 /* test next Sibling*/
2653                 hr = IXMLDOMDocumentFragment_get_nextSibling(pDocFrag, NULL);
2654                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
2655
2656                 pNextChild = (IXMLDOMNode *)0x1;
2657                 hr = IXMLDOMDocumentFragment_get_nextSibling(pDocFrag, &pNextChild);
2658                 ok(hr == S_FALSE, "ret %08x\n", hr );
2659                 ok(pNextChild == NULL, "pNextChild not NULL\n");
2660
2661                 /* test Previous Sibling*/
2662                 hr = IXMLDOMDocumentFragment_get_previousSibling(pDocFrag, NULL);
2663                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
2664
2665                 pNextChild = (IXMLDOMNode *)0x1;
2666                 hr = IXMLDOMDocumentFragment_get_previousSibling(pDocFrag, &pNextChild);
2667                 ok(hr == S_FALSE, "ret %08x\n", hr );
2668                 ok(pNextChild == NULL, "pNextChild not NULL\n");
2669
2670                 /* test get_dataType */
2671                 hr = IXMLDOMDocumentFragment_get_dataType(pDocFrag, NULL);
2672                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
2673
2674                 hr = IXMLDOMDocumentFragment_get_dataType(pDocFrag, &v);
2675                 ok(hr == S_FALSE, "ret %08x\n", hr );
2676                 ok( V_VT(&v) == VT_NULL, "incorrect dataType type\n");
2677                 VariantClear(&v);
2678
2679                 /* test nodeTypeString */
2680                 hr = IXMLDOMDocumentFragment_get_nodeTypeString(pDocFrag, &str);
2681                 ok(hr == S_OK, "ret %08x\n", hr );
2682                 ok( !lstrcmpW( str, _bstr_("documentfragment") ), "incorrect nodeTypeString string\n");
2683                 SysFreeString(str);
2684
2685                 IXMLDOMDocumentFragment_Release(pDocFrag);
2686             }
2687
2688             /* Entity References */
2689             hr = IXMLDOMDocument_createEntityReference(doc, szEntityRef, NULL);
2690             ok(hr == E_INVALIDARG, "ret %08x\n", hr );
2691
2692             hr = IXMLDOMDocument_createEntityReference(doc, szEntityRef, &pEntityRef);
2693             ok(hr == S_OK, "ret %08x\n", hr );
2694             if(hr == S_OK)
2695             {
2696                 hr = IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pEntityRef, NULL);
2697                 ok(hr == S_OK, "ret %08x\n", hr );
2698
2699                 /* get Attribute Tests */
2700                 hr = IXMLDOMEntityReference_get_attributes(pEntityRef, NULL);
2701                 ok(hr == E_INVALIDARG, "ret %08x\n", hr );
2702
2703                 pAttribs = (IXMLDOMNamedNodeMap*)0x1;
2704                 hr = IXMLDOMEntityReference_get_attributes(pEntityRef, &pAttribs);
2705                 ok(hr == S_FALSE, "ret %08x\n", hr );
2706                 ok(pAttribs == NULL, "pAttribs != NULL\n");
2707
2708                 /* test dataType */
2709                 hr = IXMLDOMEntityReference_get_dataType(pEntityRef, &v);
2710                 ok(hr == S_FALSE, "ret %08x\n", hr );
2711                 ok( V_VT(&v) == VT_NULL, "incorrect dataType type\n");
2712                 VariantClear(&v);
2713
2714                 /* test nodeTypeString */
2715                 hr = IXMLDOMEntityReference_get_nodeTypeString(pEntityRef, &str);
2716                 ok(hr == S_OK, "ret %08x\n", hr );
2717                 ok( !lstrcmpW( str, _bstr_("entityreference") ), "incorrect nodeTypeString string\n");
2718                 SysFreeString(str);
2719
2720                 /* test get_xml*/
2721                 hr = IXMLDOMEntityReference_get_xml(pEntityRef, &str);
2722                 ok(hr == S_OK, "ret %08x\n", hr );
2723                 ok( !lstrcmpW( str, szEntityRefXML ), "incorrect xml string\n");
2724                 SysFreeString(str);
2725
2726                 IXMLDOMEntityReference_Release(pEntityRef);
2727             }
2728
2729             IXMLDOMElement_Release( pRoot );
2730         }
2731     }
2732
2733     IXMLDOMDocument_Release(doc);
2734
2735     free_bstrs();
2736 }
2737
2738 static void test_nodeTypeTests( void )
2739 {
2740     IXMLDOMDocument *doc = NULL;
2741     IXMLDOMElement *pRoot;
2742     IXMLDOMElement *pElement;
2743     HRESULT hr;
2744
2745     hr = CoCreateInstance( &CLSID_DOMDocument, NULL, CLSCTX_INPROC_SERVER, &IID_IXMLDOMDocument2, (LPVOID*)&doc );
2746     if( hr != S_OK )
2747         return;
2748
2749     hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing"), &pRoot);
2750     ok(hr == S_OK, "ret %08x\n", hr );
2751     if(hr == S_OK)
2752     {
2753         hr = IXMLDOMDocument_appendChild(doc, (IXMLDOMNode*)pRoot, NULL);
2754         ok(hr == S_OK, "ret %08x\n", hr );
2755         if(hr == S_OK)
2756         {
2757             hr = IXMLDOMElement_put_dataType(pRoot, NULL);
2758             ok(hr == E_INVALIDARG, "ret %08x\n", hr );
2759
2760             /* Invalid Value */
2761             hr = IXMLDOMElement_put_dataType(pRoot, _bstr_("abcdefg") );
2762             ok(hr == E_FAIL, "ret %08x\n", hr );
2763
2764             /* NOTE:
2765              *   The name passed into put_dataType is case-insensitive. So many of the names
2766              *     have been changed to reflect this.
2767              */
2768             /* Boolean */
2769             hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing_Boolean"), &pElement);
2770             ok(hr == S_OK, "ret %08x\n", hr );
2771             if(hr == S_OK)
2772             {
2773                 IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pElement, NULL);
2774
2775                 hr = IXMLDOMElement_put_dataType(pElement, _bstr_("Boolean") );
2776                 ok(hr == S_OK, "ret %08x\n", hr );
2777
2778                 IXMLDOMElement_Release(pElement);
2779             }
2780
2781             /* String */
2782             hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing_String"), &pElement);
2783             ok(hr == S_OK, "ret %08x\n", hr );
2784             if(hr == S_OK)
2785             {
2786                 IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pElement, NULL);
2787
2788                 hr = IXMLDOMElement_put_dataType(pElement, _bstr_("String") );
2789                 ok(hr == S_OK, "ret %08x\n", hr );
2790
2791                 IXMLDOMElement_Release(pElement);
2792             }
2793
2794             /* Number */
2795             hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing_Number"), &pElement);
2796             ok(hr == S_OK, "ret %08x\n", hr );
2797             if(hr == S_OK)
2798             {
2799                 IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pElement, NULL);
2800
2801                 hr = IXMLDOMElement_put_dataType(pElement, _bstr_("number") );
2802                 ok(hr == S_OK, "ret %08x\n", hr );
2803
2804                 IXMLDOMElement_Release(pElement);
2805             }
2806
2807             /* Int */
2808             hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing_Int"), &pElement);
2809             ok(hr == S_OK, "ret %08x\n", hr );
2810             if(hr == S_OK)
2811             {
2812                 IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pElement, NULL);
2813
2814                 hr = IXMLDOMElement_put_dataType(pElement, _bstr_("InT") );
2815                 ok(hr == S_OK, "ret %08x\n", hr );
2816
2817                 IXMLDOMElement_Release(pElement);
2818             }
2819
2820             /* Fixed */
2821             hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing_Fixed"), &pElement);
2822             ok(hr == S_OK, "ret %08x\n", hr );
2823             if(hr == S_OK)
2824             {
2825                 IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pElement, NULL);
2826
2827                 hr = IXMLDOMElement_put_dataType(pElement, _bstr_("fixed.14.4") );
2828                 ok(hr == S_OK, "ret %08x\n", hr );
2829
2830                 IXMLDOMElement_Release(pElement);
2831             }
2832
2833             /* DateTime */
2834             hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing_DateTime"), &pElement);
2835             ok(hr == S_OK, "ret %08x\n", hr );
2836             if(hr == S_OK)
2837             {
2838                 IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pElement, NULL);
2839
2840                 hr = IXMLDOMElement_put_dataType(pElement, _bstr_("DateTime") );
2841                 ok(hr == S_OK, "ret %08x\n", hr );
2842
2843                 IXMLDOMElement_Release(pElement);
2844             }
2845
2846             /* DateTime TZ */
2847             hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing_DateTime_tz"), &pElement);
2848             ok(hr == S_OK, "ret %08x\n", hr );
2849             if(hr == S_OK)
2850             {
2851                 IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pElement, NULL);
2852
2853                 hr = IXMLDOMElement_put_dataType(pElement, _bstr_("DateTime.tz") );
2854                 ok(hr == S_OK, "ret %08x\n", hr );
2855
2856                 IXMLDOMElement_Release(pElement);
2857             }
2858
2859             /* Date */
2860             hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing_Date"), &pElement);
2861             ok(hr == S_OK, "ret %08x\n", hr );
2862             if(hr == S_OK)
2863             {
2864                 IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pElement, NULL);
2865
2866                 hr = IXMLDOMElement_put_dataType(pElement, _bstr_("Date") );
2867                 ok(hr == S_OK, "ret %08x\n", hr );
2868
2869                 IXMLDOMElement_Release(pElement);
2870             }
2871
2872             /* Time */
2873             hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing_Time"), &pElement);
2874             ok(hr == S_OK, "ret %08x\n", hr );
2875             if(hr == S_OK)
2876             {
2877                 IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pElement, NULL);
2878
2879                 hr = IXMLDOMElement_put_dataType(pElement, _bstr_("Time") );
2880                 ok(hr == S_OK, "ret %08x\n", hr );
2881
2882                 IXMLDOMElement_Release(pElement);
2883             }
2884
2885             /* Time.tz */
2886             hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing_Time_TZ"), &pElement);
2887             ok(hr == S_OK, "ret %08x\n", hr );
2888             if(hr == S_OK)
2889             {
2890                 IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pElement, NULL);
2891
2892                 hr = IXMLDOMElement_put_dataType(pElement, _bstr_("Time.tz") );
2893                 ok(hr == S_OK, "ret %08x\n", hr );
2894
2895                 IXMLDOMElement_Release(pElement);
2896             }
2897
2898             /* I1 */
2899             hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing_I1"), &pElement);
2900             ok(hr == S_OK, "ret %08x\n", hr );
2901             if(hr == S_OK)
2902             {
2903                 IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pElement, NULL);
2904
2905                 hr = IXMLDOMElement_put_dataType(pElement, _bstr_("I1") );
2906                 ok(hr == S_OK, "ret %08x\n", hr );
2907
2908                 IXMLDOMElement_Release(pElement);
2909             }
2910
2911             /* I2 */
2912             hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing_I2"), &pElement);
2913             ok(hr == S_OK, "ret %08x\n", hr );
2914             if(hr == S_OK)
2915             {
2916                 IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pElement, NULL);
2917
2918                 hr = IXMLDOMElement_put_dataType(pElement, _bstr_("I2") );
2919                 ok(hr == S_OK, "ret %08x\n", hr );
2920
2921                 IXMLDOMElement_Release(pElement);
2922             }
2923
2924             /* I4 */
2925             hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing_I4"), &pElement);
2926             ok(hr == S_OK, "ret %08x\n", hr );
2927             if(hr == S_OK)
2928             {
2929                 IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pElement, NULL);
2930
2931                 hr = IXMLDOMElement_put_dataType(pElement, _bstr_("I4") );
2932                 ok(hr == S_OK, "ret %08x\n", hr );
2933
2934                 IXMLDOMElement_Release(pElement);
2935             }
2936
2937             /* UI1 */
2938             hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing_UI1"), &pElement);
2939             ok(hr == S_OK, "ret %08x\n", hr );
2940             if(hr == S_OK)
2941             {
2942                 IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pElement, NULL);
2943
2944                 hr = IXMLDOMElement_put_dataType(pElement, _bstr_("UI1") );
2945                 ok(hr == S_OK, "ret %08x\n", hr );
2946
2947                 IXMLDOMElement_Release(pElement);
2948             }
2949
2950             /* UI2 */
2951             hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing_UI2"), &pElement);
2952             ok(hr == S_OK, "ret %08x\n", hr );
2953             if(hr == S_OK)
2954             {
2955                 IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pElement, NULL);
2956
2957                 hr = IXMLDOMElement_put_dataType(pElement, _bstr_("UI2") );
2958                 ok(hr == S_OK, "ret %08x\n", hr );
2959
2960                 IXMLDOMElement_Release(pElement);
2961             }
2962
2963             /* UI4 */
2964             hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing_UI4"), &pElement);
2965             ok(hr == S_OK, "ret %08x\n", hr );
2966             if(hr == S_OK)
2967             {
2968                 IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pElement, NULL);
2969
2970                 hr = IXMLDOMElement_put_dataType(pElement, _bstr_("UI4") );
2971                 ok(hr == S_OK, "ret %08x\n", hr );
2972
2973                 IXMLDOMElement_Release(pElement);
2974             }
2975
2976             /* r4 */
2977             hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing_r4"), &pElement);
2978             ok(hr == S_OK, "ret %08x\n", hr );
2979             if(hr == S_OK)
2980             {
2981                 IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pElement, NULL);
2982
2983                 hr = IXMLDOMElement_put_dataType(pElement, _bstr_("r4") );
2984                 ok(hr == S_OK, "ret %08x\n", hr );
2985
2986                 IXMLDOMElement_Release(pElement);
2987             }
2988
2989             /* r8 */
2990             hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing_r8"), &pElement);
2991             ok(hr == S_OK, "ret %08x\n", hr );
2992             if(hr == S_OK)
2993             {
2994                 IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pElement, NULL);
2995
2996                 hr = IXMLDOMElement_put_dataType(pElement, _bstr_("r8") );
2997                 ok(hr == S_OK, "ret %08x\n", hr );
2998
2999                 IXMLDOMElement_Release(pElement);
3000             }
3001
3002             /* float */
3003             hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing_float"), &pElement);
3004             ok(hr == S_OK, "ret %08x\n", hr );
3005             if(hr == S_OK)
3006             {
3007                 IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pElement, NULL);
3008
3009                 hr = IXMLDOMElement_put_dataType(pElement, _bstr_("float") );
3010                 ok(hr == S_OK, "ret %08x\n", hr );
3011
3012                 IXMLDOMElement_Release(pElement);
3013             }
3014
3015             /* uuid */
3016             hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing_uuid"), &pElement);
3017             ok(hr == S_OK, "ret %08x\n", hr );
3018             if(hr == S_OK)
3019             {
3020                 IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pElement, NULL);
3021
3022                 hr = IXMLDOMElement_put_dataType(pElement, _bstr_("UuId") );
3023                 ok(hr == S_OK, "ret %08x\n", hr );
3024
3025                 IXMLDOMElement_Release(pElement);
3026             }
3027
3028             /* bin.hex */
3029             hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing_bin_hex"), &pElement);
3030             ok(hr == S_OK, "ret %08x\n", hr );
3031             if(hr == S_OK)
3032             {
3033                 IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pElement, NULL);
3034
3035                 hr = IXMLDOMElement_put_dataType(pElement, _bstr_("bin.hex") );
3036                 ok(hr == S_OK, "ret %08x\n", hr );
3037
3038                 IXMLDOMElement_Release(pElement);
3039             }
3040
3041             /* bin.base64 */
3042             hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing_bin_base64"), &pElement);
3043             ok(hr == S_OK, "ret %08x\n", hr );
3044             if(hr == S_OK)
3045             {
3046                 IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pElement, NULL);
3047
3048                 hr = IXMLDOMElement_put_dataType(pElement, _bstr_("bin.base64") );
3049                 ok(hr == S_OK, "ret %08x\n", hr );
3050
3051                 IXMLDOMElement_Release(pElement);
3052             }
3053
3054             /* Check changing types */
3055             hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing_Change"), &pElement);
3056             ok(hr == S_OK, "ret %08x\n", hr );
3057             if(hr == S_OK)
3058             {
3059                 IXMLDOMElement_appendChild(pRoot, (IXMLDOMNode*)pElement, NULL);
3060
3061                 hr = IXMLDOMElement_put_dataType(pElement, _bstr_("DateTime.tz") );
3062                 ok(hr == S_OK, "ret %08x\n", hr );
3063
3064                 hr = IXMLDOMElement_put_dataType(pElement, _bstr_("string") );
3065                 ok(hr == S_OK, "ret %08x\n", hr );
3066
3067                 IXMLDOMElement_Release(pElement);
3068             }
3069
3070             IXMLDOMElement_Release(pRoot);
3071         }
3072     }
3073
3074     IXMLDOMDocument_Release(doc);
3075
3076     free_bstrs();
3077 }
3078
3079 static void test_DocumentSaveToDocument(void)
3080 {
3081     IXMLDOMDocument *doc = NULL;
3082     IXMLDOMDocument *doc2 = NULL;
3083     IXMLDOMElement *pRoot;
3084
3085     HRESULT hr;
3086
3087     hr = CoCreateInstance( &CLSID_DOMDocument, NULL, CLSCTX_INPROC_SERVER, &IID_IXMLDOMDocument2, (LPVOID*)&doc );
3088     if( hr != S_OK )
3089         return;
3090
3091     hr = CoCreateInstance( &CLSID_DOMDocument, NULL, CLSCTX_INPROC_SERVER, &IID_IXMLDOMDocument2, (LPVOID*)&doc2 );
3092     if( hr != S_OK )
3093     {
3094         IXMLDOMDocument_Release(doc);
3095         return;
3096     }
3097
3098     hr = IXMLDOMDocument_createElement(doc, _bstr_("Testing"), &pRoot);
3099     ok(hr == S_OK, "ret %08x\n", hr );
3100     if(hr == S_OK)
3101     {
3102         hr = IXMLDOMDocument_appendChild(doc, (IXMLDOMNode*)pRoot, NULL);
3103         ok(hr == S_OK, "ret %08x\n", hr );
3104         if(hr == S_OK)
3105         {
3106             VARIANT vDoc;
3107             BSTR sOrig;
3108             BSTR sNew;
3109
3110             V_VT(&vDoc) = VT_UNKNOWN;
3111             V_UNKNOWN(&vDoc) = (IUnknown*)doc2;
3112
3113             hr = IXMLDOMDocument_save(doc, vDoc);
3114             ok(hr == S_OK, "ret %08x\n", hr );
3115
3116             hr = IXMLDOMDocument_get_xml(doc, &sOrig);
3117             ok(hr == S_OK, "ret %08x\n", hr );
3118
3119             hr = IXMLDOMDocument_get_xml(doc2, &sNew);
3120             ok(hr == S_OK, "ret %08x\n", hr );
3121
3122             ok( !lstrcmpW( sOrig, sNew ), "New document is not the same as origial\n");
3123
3124             SysFreeString(sOrig);
3125             SysFreeString(sNew);
3126         }
3127     }
3128
3129     IXMLDOMDocument_Release(doc2);
3130     IXMLDOMDocument_Release(doc);
3131 }
3132
3133 START_TEST(domdoc)
3134 {
3135     HRESULT r;
3136
3137     r = CoInitialize( NULL );
3138     ok( r == S_OK, "failed to init com\n");
3139
3140     test_domdoc();
3141     test_domnode();
3142     test_refs();
3143     test_create();
3144     test_getElementsByTagName();
3145     test_get_text();
3146     test_get_childNodes();
3147     test_removeChild();
3148     test_XMLHTTP();
3149     test_IXMLDOMDocument2();
3150     test_XPath();
3151     test_cloneNode();
3152     test_xmlTypes();
3153     test_nodeTypeTests();
3154     test_DocumentSaveToDocument();
3155
3156     CoUninitialize();
3157 }