dlls/msxml3/tests/domdoc.c

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