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