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

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