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

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