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