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