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

   1 /*
   2  * XML test
   3  *
   4  * Copyright 2008 Piotr Caban
   5  * Copyright 2011 Thomas Mullaly
   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 #define COBJMACROS
  23 #define CONST_VTABLE
  24
  25 #include <stdio.h>
  26 #include <assert.h>
  27
  28 #include "windows.h"
  29 #include "ole2.h"
  30 #include "msxml2.h"
  31 #include "ocidl.h"
  32
  33 #include "wine/test.h"
  34
  35 #define EXPECT_HR(hr,hr_exp) \
  36     ok(hr == hr_exp, "got 0x%08x, expected 0x%08x\n", hr, hr_exp)
  37
  38 #define EXPECT_REF(obj,ref) _expect_ref((IUnknown*)obj, ref, __LINE__)
  39 static void _expect_ref(IUnknown* obj, ULONG ref, int line)
  40 {
  41     ULONG rc = IUnknown_AddRef(obj);
  42     IUnknown_Release(obj);
  43     ok_(__FILE__,line)(rc-1 == ref, "expected refcount %d, got %d\n", ref, rc-1);
  44 }
  45
  46 static BSTR alloc_str_from_narrow(const char *str)
  47 {
  48     int len = MultiByteToWideChar(CP_ACP, 0, str, -1, NULL, 0);
  49     BSTR ret = SysAllocStringLen(NULL, len - 1);  /* NUL character added automatically */
  50     MultiByteToWideChar(CP_ACP, 0, str, -1, ret, len);
  51     return ret;
  52 }
  53
  54 static BSTR alloced_bstrs[512];
  55 static int alloced_bstrs_count;
  56
  57 static BSTR _bstr_(const char *str)
  58 {
  59     assert(alloced_bstrs_count < sizeof(alloced_bstrs)/sizeof(alloced_bstrs[0]));
  60     alloced_bstrs[alloced_bstrs_count] = alloc_str_from_narrow(str);
  61     return alloced_bstrs[alloced_bstrs_count++];
  62 }
  63
  64 static void free_bstrs(void)
  65 {
  66     int i;
  67     for (i = 0; i < alloced_bstrs_count; i++)
  68         SysFreeString(alloced_bstrs[i]);
  69     alloced_bstrs_count = 0;
  70 }
  71
  72 typedef enum _CH {
  73     CH_ENDTEST,
  74     CH_PUTDOCUMENTLOCATOR,
  75     CH_STARTDOCUMENT,
  76     CH_ENDDOCUMENT,
  77     CH_STARTPREFIXMAPPING,
  78     CH_ENDPREFIXMAPPING,
  79     CH_STARTELEMENT,
  80     CH_ENDELEMENT,
  81     CH_CHARACTERS,
  82     CH_IGNORABLEWHITESPACE,
  83     CH_PROCESSINGINSTRUCTION,
  84     CH_SKIPPEDENTITY,
  85     EH_ERROR,
  86     EH_FATALERROR,
  87     EG_IGNORABLEWARNING
  88 } CH;
  89
  90 static const WCHAR szSimpleXML[] = {
  91 '<','?','x','m','l',' ','v','e','r','s','i','o','n','=','\"','1','.','0','\"',' ','?','>','\n',
  92 '<','B','a','n','k','A','c','c','o','u','n','t','>','\n',
  93 ' ',' ',' ','<','N','u','m','b','e','r','>','1','2','3','4','<','/','N','u','m','b','e','r','>','\n',
  94 ' ',' ',' ','<','N','a','m','e','>','C','a','p','t','a','i','n',' ','A','h','a','b','<','/','N','a','m','e','>','\n',
  95 '<','/','B','a','n','k','A','c','c','o','u','n','t','>','\n','\0'
  96 };
  97
  98 static const WCHAR szCarriageRetTest[] = {
  99 '<','?','x','m','l',' ','v','e','r','s','i','o','n','=','"','1','.','0','"','?','>','\r','\n',
 100 '<','B','a','n','k','A','c','c','o','u','n','t','>','\r','\n',
 101 '\t','<','N','u','m','b','e','r','>','1','2','3','4','<','/','N','u','m','b','e','r','>','\r','\n',
 102 '\t','<','N','a','m','e','>','C','a','p','t','a','i','n',' ','A','h','a','b','<','/','N','a','m','e','>','\r','\n',
 103 '<','/','B','a','n','k','A','c','c','o','u','n','t','>','\r','\n','\0'
 104 };
 105
 106 static const WCHAR szUtf16XML[] = {
 107 '<','?','x','m','l',' ','v','e','r','s','i','o','n','=','"','1','.','0','"',' ',
 108 'e','n','c','o','d','i','n','g','=','"','U','T','F','-','1','6','"',' ',
 109 's','t','a','n','d','a','l','o','n','e','=','"','n','o','"','?','>','\r','\n'
 110 };
 111
 112 static const CHAR szUtf16BOM[] = {0xff, 0xfe};
 113
 114 static const CHAR szUtf8XML[] =
 115 "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?>\r\n";
 116
 117 static const CHAR szTestXML[] =
 118 "<?xml version=\"1.0\" ?>\n"
 119 "<BankAccount>\n"
 120 "   <Number>1234</Number>\n"
 121 "   <Name>Captain Ahab</Name>\n"
 122 "</BankAccount>\n";
 123
 124 static const CHAR szTestAttributes[] =
 125 "<?xml version=\"1.0\" ?>\n"
 126 "<document xmlns:test=\"prefix_test\" xmlns=\"prefix\" test:arg1=\"arg1\" arg2=\"arg2\">\n"
 127 "<node1 xmlns:p=\"test\" />"
 128 "</document>\n";
 129
 130 typedef struct _contenthandlercheck {
 131     CH id;
 132     int line;
 133     int column;
 134     int line_v6;
 135     int column_v6;
 136     const char *arg1;
 137     const char *arg2;
 138     const char *arg3;
 139     HRESULT ret;
 140 } content_handler_test;
 141
 142 static content_handler_test contentHandlerTest1[] = {
 143     { CH_PUTDOCUMENTLOCATOR, 0, 0, 1, 0 },
 144     { CH_STARTDOCUMENT, 0, 0, 1, 22 },
 145     { CH_STARTELEMENT, 2, 14, 2, 13, "", "BankAccount", "BankAccount" },
 146     { CH_CHARACTERS, 2, 14, 3, 4, "\n   " },
 147     { CH_STARTELEMENT, 3, 12, 3, 11, "", "Number", "Number" },
 148     { CH_CHARACTERS, 3, 12, 3, 16, "1234" },
 149     { CH_ENDELEMENT, 3, 18, 3, 24, "", "Number", "Number" },
 150     { CH_CHARACTERS, 3, 25, 4, 4, "\n   " },
 151     { CH_STARTELEMENT, 4, 10, 4, 9, "", "Name", "Name" },
 152     { CH_CHARACTERS, 4, 10, 4, 22, "Captain Ahab" },
 153     { CH_ENDELEMENT, 4, 24, 4, 28, "", "Name", "Name" },
 154     { CH_CHARACTERS, 4, 29, 5, 1, "\n" },
 155     { CH_ENDELEMENT, 5, 3, 5, 14, "", "BankAccount", "BankAccount" },
 156     { CH_ENDDOCUMENT, 0, 0, 6, 0 },
 157     { CH_ENDTEST }
 158 };
 159
 160 static content_handler_test contentHandlerTest2[] = {
 161     { CH_PUTDOCUMENTLOCATOR, 0, 0, 1, 0 },
 162     { CH_STARTDOCUMENT, 0, 0, 1, 21 },
 163     { CH_STARTELEMENT, 2, 14, 2, 13, "", "BankAccount", "BankAccount" },
 164     { CH_CHARACTERS, 2, 14, 3, 0, "\n" },
 165     { CH_CHARACTERS, 2, 16, 3, 2, "\t" },
 166     { CH_STARTELEMENT, 3, 10, 3, 9, "", "Number", "Number" },
 167     { CH_CHARACTERS, 3, 10, 3, 14, "1234" },
 168     { CH_ENDELEMENT, 3, 16, 3, 22, "", "Number", "Number" },
 169     { CH_CHARACTERS, 3, 23, 4, 0, "\n" },
 170     { CH_CHARACTERS, 3, 25, 4, 2, "\t" },
 171     { CH_STARTELEMENT, 4, 8, 4, 7, "", "Name", "Name" },
 172     { CH_CHARACTERS, 4, 8, 4, 20, "Captain Ahab" },
 173     { CH_ENDELEMENT, 4, 22, 4, 26, "", "Name", "Name" },
 174     { CH_CHARACTERS, 4, 27, 5, 0, "\n" },
 175     { CH_ENDELEMENT, 5, 3, 5, 14, "", "BankAccount", "BankAccount" },
 176     { CH_ENDDOCUMENT, 0, 0, 6, 0 },
 177     { CH_ENDTEST }
 178 };
 179
 180 static content_handler_test contentHandlerTestError[] = {
 181     { CH_PUTDOCUMENTLOCATOR, 0, 0, 1, 0, NULL, NULL, NULL, E_FAIL },
 182     { EH_FATALERROR, 0, 0, 0, 0, NULL, NULL, NULL, E_FAIL },
 183     { CH_ENDTEST }
 184 };
 185
 186 static content_handler_test contentHandlerTestCallbackResults[] = {
 187     { CH_PUTDOCUMENTLOCATOR, 0, 0, 1, 0, NULL, NULL, NULL, S_FALSE },
 188     { CH_STARTDOCUMENT, 0, 0, 1, 22, NULL, NULL, NULL, S_FALSE },
 189     { EH_FATALERROR, 0, 0, 0, 0, NULL, NULL, NULL, S_FALSE },
 190     { CH_ENDTEST }
 191 };
 192
 193 static content_handler_test contentHandlerTestCallbackResult6[] = {
 194     { CH_PUTDOCUMENTLOCATOR, 0, 0, 1, 0, NULL, NULL, NULL, S_FALSE },
 195     { CH_STARTDOCUMENT, 0, 0, 1, 22, NULL, NULL, NULL, S_FALSE },
 196     { CH_STARTELEMENT, 2, 14, 2, 13, "", "BankAccount", "BankAccount", S_FALSE },
 197     { CH_CHARACTERS, 2, 14, 3, 4, "\n   ", NULL, NULL, S_FALSE },
 198     { CH_STARTELEMENT, 3, 12, 3, 11, "", "Number", "Number", S_FALSE },
 199     { CH_CHARACTERS, 3, 12, 3, 16, "1234", NULL, NULL, S_FALSE },
 200     { CH_ENDELEMENT, 3, 18, 3, 24, "", "Number", "Number", S_FALSE },
 201     { CH_CHARACTERS, 3, 25, 4, 4, "\n   ", NULL, NULL, S_FALSE },
 202     { CH_STARTELEMENT, 4, 10, 4, 9, "", "Name", "Name", S_FALSE },
 203     { CH_CHARACTERS, 4, 10, 4, 22, "Captain Ahab", NULL, NULL, S_FALSE },
 204     { CH_ENDELEMENT, 4, 24, 4, 28, "", "Name", "Name", S_FALSE },
 205     { CH_CHARACTERS, 4, 29, 5, 1, "\n", NULL, NULL, S_FALSE },
 206     { CH_ENDELEMENT, 5, 3, 5, 14, "", "BankAccount", "BankAccount", S_FALSE },
 207     { CH_ENDDOCUMENT, 0, 0, 6, 0, NULL, NULL, NULL, S_FALSE },
 208     { CH_ENDTEST }
 209 };
 210
 211 static content_handler_test contentHandlerTestAttributes[] = {
 212     { CH_PUTDOCUMENTLOCATOR, 0, 0, 1, 0 },
 213     { CH_STARTDOCUMENT, 0, 0, 1, 22 },
 214     { CH_STARTPREFIXMAPPING, 2, 80, 2, 79, "test", "prefix_test" },
 215     { CH_STARTPREFIXMAPPING, 2, 80, 2, 79, "", "prefix" },
 216     { CH_STARTELEMENT, 2, 80, 2, 79, "prefix", "document", "document" },
 217     { CH_CHARACTERS, 2, 80, 3, 1, "\n" },
 218     { CH_STARTPREFIXMAPPING, 3, 25, 3, 24, "p", "test" },
 219     { CH_STARTELEMENT, 3, 25, 3, 24, "prefix", "node1", "node1" },
 220     { CH_ENDELEMENT, 3, 25, 3, 24, "prefix", "node1", "node1" },
 221     { CH_ENDPREFIXMAPPING, 3, 25, 3, 24, "p" },
 222     { CH_ENDELEMENT, 3, 27, 3, 35, "prefix", "document", "document" },
 223     { CH_ENDPREFIXMAPPING, 3, 27, 3, 35, "" },
 224     { CH_ENDPREFIXMAPPING, 3, 27, 3, 35, "test" },
 225     { CH_ENDDOCUMENT, 0, 0, 4, 0 },
 226     { CH_ENDTEST }
 227 };
 228
 229 static content_handler_test contentHandlerTestAttributes6[] = {
 230     { CH_PUTDOCUMENTLOCATOR, 0, 0, 1, 0 },
 231     { CH_STARTDOCUMENT, 0, 0, 1, 22 },
 232     { CH_STARTPREFIXMAPPING, 2, 80, 2, 79, "test", "prefix_test" },
 233     { CH_STARTPREFIXMAPPING, 2, 80, 2, 79, "", "prefix" },
 234     { CH_STARTELEMENT, 2, 80, 2, 79, "prefix", "document", "document" },
 235     { CH_CHARACTERS, 2, 80, 3, 1, "\n" },
 236     { CH_STARTPREFIXMAPPING, 3, 25, 3, 24, "p", "test" },
 237     { CH_STARTELEMENT, 3, 25, 3, 24, "prefix", "node1", "node1" },
 238     { CH_ENDELEMENT, 3, 25, 3, 24, "prefix", "node1", "node1" },
 239     { CH_ENDPREFIXMAPPING, 3, 25, 3, 24, "p" },
 240     { CH_ENDELEMENT, 3, 27, 3, 35, "prefix", "document", "document" },
 241     { CH_ENDPREFIXMAPPING, 3, 27, 3, 35, "test" },
 242     { CH_ENDPREFIXMAPPING, 3, 27, 3, 35, "" },
 243     { CH_ENDDOCUMENT, 0, 0, 4, 0 },
 244     { CH_ENDTEST }
 245 };
 246
 247 static content_handler_test *expectCall;
 248 static ISAXLocator *locator;
 249 int msxml_version;
 250
 251 static void test_saxstr(unsigned line, const WCHAR *szStr, int nStr, const char *szTest)
 252 {
 253     WCHAR buf[1024];
 254     int len;
 255
 256     if(!szTest) {
 257         ok_(__FILE__,line) (szStr == NULL, "szStr != NULL\n");
 258         ok_(__FILE__,line) (nStr == 0, "nStr = %d, expected 0\n", nStr);
 259         return;
 260     }
 261
 262     len = strlen(szTest);
 263     ok_(__FILE__,line) (len == nStr, "nStr = %d, expected %d (%s)\n", nStr, len, szTest);
 264     if(len != nStr)
 265         return;
 266
 267     MultiByteToWideChar(CP_ACP, 0, szTest, -1, buf, sizeof(buf)/sizeof(WCHAR));
 268     ok_(__FILE__,line) (!memcmp(szStr, buf, len*sizeof(WCHAR)), "unexpected szStr %s, expected %s\n",
 269                         wine_dbgstr_wn(szStr, nStr), szTest);
 270 }
 271
 272 static BOOL test_expect_call(CH id)
 273 {
 274     ok(expectCall->id == id, "unexpected call %d, expected %d\n", id, expectCall->id);
 275     return expectCall->id == id;
 276 }
 277
 278 static void test_locator(unsigned line, int loc_line, int loc_column)
 279 {
 280     int rcolumn, rline;
 281     ISAXLocator_getLineNumber(locator, &rline);
 282     ISAXLocator_getColumnNumber(locator, &rcolumn);
 283
 284     ok_(__FILE__,line) (rline == loc_line,
 285             "unexpected line %d, expected %d\n", rline, loc_line);
 286     ok_(__FILE__,line) (rcolumn == loc_column,
 287             "unexpected column %d, expected %d\n", rcolumn, loc_column);
 288 }
 289
 290 static HRESULT WINAPI contentHandler_QueryInterface(
 291         ISAXContentHandler* iface,
 292         REFIID riid,
 293         void **ppvObject)
 294 {
 295     *ppvObject = NULL;
 296
 297     if(IsEqualGUID(riid, &IID_IUnknown) || IsEqualGUID(riid, &IID_ISAXContentHandler))
 298     {
 299         *ppvObject = iface;
 300     }
 301     else
 302     {
 303         return E_NOINTERFACE;
 304     }
 305
 306     return S_OK;
 307 }
 308
 309 static ULONG WINAPI contentHandler_AddRef(
 310         ISAXContentHandler* iface)
 311 {
 312     return 2;
 313 }
 314
 315 static ULONG WINAPI contentHandler_Release(
 316         ISAXContentHandler* iface)
 317 {
 318     return 1;
 319 }
 320
 321 static HRESULT WINAPI contentHandler_putDocumentLocator(
 322         ISAXContentHandler* iface,
 323         ISAXLocator *pLocator)
 324 {
 325     ISAXAttributes *attr;
 326     HRESULT hres;
 327
 328     if(!test_expect_call(CH_PUTDOCUMENTLOCATOR))
 329         return E_FAIL;
 330
 331     locator = pLocator;
 332     test_locator(__LINE__, msxml_version>=6 ? expectCall->line_v6 : expectCall->line,
 333             msxml_version>=6 ? expectCall->column_v6 : expectCall->column);
 334
 335     if(msxml_version >= 6) {
 336         hres = ISAXLocator_QueryInterface(pLocator, &IID_ISAXAttributes, (void**)&attr);
 337         ok(hres == S_OK, "QueryInterface failed: %x\n", hres);
 338         ISAXAttributes_Release(attr);
 339     }
 340
 341     return (expectCall++)->ret;
 342 }
 343
 344 static ISAXAttributes *test_attr_ptr;
 345 static HRESULT WINAPI contentHandler_startDocument(
 346         ISAXContentHandler* iface)
 347 {
 348     if(!test_expect_call(CH_STARTDOCUMENT))
 349         return E_FAIL;
 350
 351     test_attr_ptr = NULL;
 352     test_locator(__LINE__, msxml_version>=6 ? expectCall->line_v6 : expectCall->line,
 353             msxml_version>=6 ? expectCall->column_v6 : expectCall->column);
 354
 355     return (expectCall++)->ret;
 356 }
 357
 358 static HRESULT WINAPI contentHandler_endDocument(
 359         ISAXContentHandler* iface)
 360 {
 361     if(!test_expect_call(CH_ENDDOCUMENT))
 362         return E_FAIL;
 363
 364     test_locator(__LINE__, msxml_version>=6 ? expectCall->line_v6 : expectCall->line,
 365             msxml_version>=6 ? expectCall->column_v6 : expectCall->column);
 366
 367     return (expectCall++)->ret;
 368 }
 369
 370 static HRESULT WINAPI contentHandler_startPrefixMapping(
 371         ISAXContentHandler* iface,
 372         const WCHAR *pPrefix,
 373         int nPrefix,
 374         const WCHAR *pUri,
 375         int nUri)
 376 {
 377     if(!test_expect_call(CH_STARTPREFIXMAPPING))
 378         return E_FAIL;
 379
 380     test_saxstr(__LINE__, pPrefix, nPrefix, expectCall->arg1);
 381     test_saxstr(__LINE__, pUri, nUri, expectCall->arg2);
 382     test_locator(__LINE__, msxml_version>=6 ? expectCall->line_v6 : expectCall->line,
 383             msxml_version>=6 ? expectCall->column_v6 : expectCall->column);
 384
 385     return (expectCall++)->ret;
 386 }
 387
 388 static HRESULT WINAPI contentHandler_endPrefixMapping(
 389         ISAXContentHandler* iface,
 390         const WCHAR *pPrefix,
 391         int nPrefix)
 392 {
 393     if(!test_expect_call(CH_ENDPREFIXMAPPING))
 394         return E_FAIL;
 395
 396     test_saxstr(__LINE__, pPrefix, nPrefix, expectCall->arg1);
 397     test_locator(__LINE__, msxml_version>=6 ? expectCall->line_v6 : expectCall->line,
 398             msxml_version>=6 ? expectCall->column_v6 : expectCall->column);
 399
 400     return (expectCall++)->ret;
 401 }
 402
 403 static HRESULT WINAPI contentHandler_startElement(
 404         ISAXContentHandler* iface,
 405         const WCHAR *pNamespaceUri,
 406         int nNamespaceUri,
 407         const WCHAR *pLocalName,
 408         int nLocalName,
 409         const WCHAR *pQName,
 410         int nQName,
 411         ISAXAttributes *pAttr)
 412 {
 413     int len;
 414     HRESULT hres;
 415
 416     if(!test_expect_call(CH_STARTELEMENT))
 417         return E_FAIL;
 418
 419     test_saxstr(__LINE__, pNamespaceUri, nNamespaceUri, expectCall->arg1);
 420     test_saxstr(__LINE__, pLocalName, nLocalName, expectCall->arg2);
 421     test_saxstr(__LINE__, pQName, nQName, expectCall->arg3);
 422     test_locator(__LINE__, msxml_version>=6 ? expectCall->line_v6 : expectCall->line,
 423             msxml_version>=6 ? expectCall->column_v6 : expectCall->column);
 424
 425     if(!test_attr_ptr)
 426         test_attr_ptr = pAttr;
 427     ok(test_attr_ptr == pAttr, "Multiple ISAXAttributes instances are used (%p %p)\n", test_attr_ptr, pAttr);
 428
 429     if(expectCall == contentHandlerTestAttributes+4) {
 430         int i;
 431         /* msxml3 returns attributes and namespaces in the input order */
 432         hres = ISAXAttributes_getLength(pAttr, &len);
 433         ok(hres == S_OK, "getLength returned %x\n", hres);
 434         ok(len == 4, "Incorrect number of attributes: %d\n", len);
 435         ok(msxml_version < 6, "wrong msxml_version: %d\n", msxml_version);
 436
 437         for(i=0; i<len; i++) {
 438             hres = ISAXAttributes_getName(pAttr, i, &pNamespaceUri, &nNamespaceUri,
 439                     &pLocalName, &nLocalName, &pQName, &nQName);
 440             ok(hres == S_OK, "getName returned %x\n", hres);
 441
 442             if(nQName == 4) {
 443                 todo_wine ok(i==3, "Incorrect attributes order\n");
 444                 test_saxstr(__LINE__, pNamespaceUri, nNamespaceUri, "");
 445                 test_saxstr(__LINE__, pLocalName, nLocalName, "arg2");
 446                 test_saxstr(__LINE__, pQName, nQName, "arg2");
 447             } else if(nQName == 5) {
 448                 todo_wine ok(i==1, "Incorrect attributes order\n");
 449                 test_saxstr(__LINE__, pNamespaceUri, nNamespaceUri, "");
 450                 test_saxstr(__LINE__, pLocalName, nLocalName, "");
 451                 test_saxstr(__LINE__, pQName, nQName, "xmlns");
 452             } else if(nQName == 9) {
 453                 todo_wine ok(i==2, "Incorrect attributes order\n");
 454                 test_saxstr(__LINE__, pNamespaceUri, nNamespaceUri, "prefix_test");
 455                 test_saxstr(__LINE__, pLocalName, nLocalName, "arg1");
 456                 test_saxstr(__LINE__, pQName, nQName, "test:arg1");
 457             } else if(nQName == 10) {
 458                 todo_wine ok(i==0, "Incorrect attributes order\n");
 459                 test_saxstr(__LINE__, pNamespaceUri, nNamespaceUri, "");
 460                 test_saxstr(__LINE__, pLocalName, nLocalName, "");
 461                 test_saxstr(__LINE__, pQName, nQName, "xmlns:test");
 462             } else {
 463                 ok(0, "Unexpected attribute\n");
 464             }
 465         }
 466     } else if(expectCall == contentHandlerTestAttributes6+4) {
 467         /* msxml6 returns attributes first and then namespaces */
 468         hres = ISAXAttributes_getLength(pAttr, &len);
 469         ok(hres == S_OK, "getLength returned %x\n", hres);
 470         ok(len == 4, "Incorrect number of attributes: %d\n", len);
 471         ok(msxml_version >= 6, "wrong msxml_version: %d\n", msxml_version);
 472
 473         hres = ISAXAttributes_getName(pAttr, 0, &pNamespaceUri, &nNamespaceUri,
 474                 &pLocalName, &nLocalName, &pQName, &nQName);
 475         ok(hres == S_OK, "getName returned %x\n", hres);
 476         test_saxstr(__LINE__, pNamespaceUri, nNamespaceUri, "prefix_test");
 477         test_saxstr(__LINE__, pLocalName, nLocalName, "arg1");
 478         test_saxstr(__LINE__, pQName, nQName, "test:arg1");
 479
 480         hres = ISAXAttributes_getName(pAttr, 1, &pNamespaceUri, &nNamespaceUri,
 481                 &pLocalName, &nLocalName, &pQName, &nQName);
 482         ok(hres == S_OK, "getName returned %x\n", hres);
 483         test_saxstr(__LINE__, pNamespaceUri, nNamespaceUri, "");
 484         test_saxstr(__LINE__, pLocalName, nLocalName, "arg2");
 485         test_saxstr(__LINE__, pQName, nQName, "arg2");
 486
 487         hres = ISAXAttributes_getName(pAttr, 2, &pNamespaceUri, &nNamespaceUri,
 488                 &pLocalName, &nLocalName, &pQName, &nQName);
 489         ok(hres == S_OK, "getName returned %x\n", hres);
 490         test_saxstr(__LINE__, pNamespaceUri, nNamespaceUri, "http://www.w3.org/2000/xmlns/");
 491         test_saxstr(__LINE__, pLocalName, nLocalName, "");
 492         test_saxstr(__LINE__, pQName, nQName, "xmlns:test");
 493
 494         hres = ISAXAttributes_getName(pAttr, 3, &pNamespaceUri, &nNamespaceUri,
 495                 &pLocalName, &nLocalName, &pQName, &nQName);
 496         ok(hres == S_OK, "getName returned %x\n", hres);
 497         test_saxstr(__LINE__, pNamespaceUri, nNamespaceUri, "http://www.w3.org/2000/xmlns/");
 498         test_saxstr(__LINE__, pLocalName, nLocalName, "");
 499         test_saxstr(__LINE__, pQName, nQName, "xmlns");
 500     }
 501
 502     return (expectCall++)->ret;
 503 }
 504
 505 static HRESULT WINAPI contentHandler_endElement(
 506         ISAXContentHandler* iface,
 507         const WCHAR *pNamespaceUri,
 508         int nNamespaceUri,
 509         const WCHAR *pLocalName,
 510         int nLocalName,
 511         const WCHAR *pQName,
 512         int nQName)
 513 {
 514     if(!test_expect_call(CH_ENDELEMENT))
 515         return E_FAIL;
 516
 517     test_saxstr(__LINE__, pNamespaceUri, nNamespaceUri, expectCall->arg1);
 518     test_saxstr(__LINE__, pLocalName, nLocalName, expectCall->arg2);
 519     test_saxstr(__LINE__, pQName, nQName, expectCall->arg3);
 520     test_locator(__LINE__, msxml_version>=6 ? expectCall->line_v6 : expectCall->line,
 521             msxml_version>=6 ? expectCall->column_v6 : expectCall->column);
 522
 523     return (expectCall++)->ret;
 524 }
 525
 526 static HRESULT WINAPI contentHandler_characters(
 527         ISAXContentHandler* iface,
 528         const WCHAR *pChars,
 529         int nChars)
 530 {
 531     if(!test_expect_call(CH_CHARACTERS))
 532         return E_FAIL;
 533
 534     test_saxstr(__LINE__, pChars, nChars, expectCall->arg1);
 535     test_locator(__LINE__, msxml_version>=6 ? expectCall->line_v6 : expectCall->line,
 536             msxml_version>=6 ? expectCall->column_v6 : expectCall->column);
 537
 538     return (expectCall++)->ret;
 539 }
 540
 541 static HRESULT WINAPI contentHandler_ignorableWhitespace(
 542         ISAXContentHandler* iface,
 543         const WCHAR *pChars,
 544         int nChars)
 545 {
 546     if(!test_expect_call(CH_IGNORABLEWHITESPACE))
 547         return E_FAIL;
 548
 549     test_saxstr(__LINE__, pChars, nChars, expectCall->arg1);
 550     test_locator(__LINE__, msxml_version>=6 ? expectCall->line_v6 : expectCall->line,
 551             msxml_version>=6 ? expectCall->column_v6 : expectCall->column);
 552
 553     return (expectCall++)->ret;
 554 }
 555
 556 static HRESULT WINAPI contentHandler_processingInstruction(
 557         ISAXContentHandler* iface,
 558         const WCHAR *pTarget,
 559         int nTarget,
 560         const WCHAR *pData,
 561         int nData)
 562 {
 563     if(!test_expect_call(CH_PROCESSINGINSTRUCTION))
 564         return E_FAIL;
 565
 566     test_saxstr(__LINE__, pTarget, nTarget, expectCall->arg1);
 567     test_saxstr(__LINE__, pData, nData, expectCall->arg2);
 568     test_locator(__LINE__, msxml_version>=6 ? expectCall->line_v6 : expectCall->line,
 569             msxml_version>=6 ? expectCall->column_v6 : expectCall->column);
 570
 571     return (expectCall++)->ret;
 572 }
 573
 574 static HRESULT WINAPI contentHandler_skippedEntity(
 575         ISAXContentHandler* iface,
 576         const WCHAR *pName,
 577         int nName)
 578 {
 579     if(!test_expect_call(CH_SKIPPEDENTITY))
 580         return E_FAIL;
 581
 582     test_saxstr(__LINE__, pName, nName, expectCall->arg1);
 583     test_locator(__LINE__, msxml_version>=6 ? expectCall->line_v6 : expectCall->line,
 584             msxml_version>=6 ? expectCall->column_v6 : expectCall->column);
 585
 586     return (expectCall++)->ret;
 587 }
 588
 589
 590 static const ISAXContentHandlerVtbl contentHandlerVtbl =
 591 {
 592     contentHandler_QueryInterface,
 593     contentHandler_AddRef,
 594     contentHandler_Release,
 595     contentHandler_putDocumentLocator,
 596     contentHandler_startDocument,
 597     contentHandler_endDocument,
 598     contentHandler_startPrefixMapping,
 599     contentHandler_endPrefixMapping,
 600     contentHandler_startElement,
 601     contentHandler_endElement,
 602     contentHandler_characters,
 603     contentHandler_ignorableWhitespace,
 604     contentHandler_processingInstruction,
 605     contentHandler_skippedEntity
 606 };
 607
 608 static ISAXContentHandler contentHandler = { &contentHandlerVtbl };
 609
 610 static HRESULT WINAPI isaxerrorHandler_QueryInterface(
 611         ISAXErrorHandler* iface,
 612         REFIID riid,
 613         void **ppvObject)
 614 {
 615     *ppvObject = NULL;
 616
 617     if(IsEqualGUID(riid, &IID_IUnknown) || IsEqualGUID(riid, &IID_ISAXErrorHandler))
 618     {
 619         *ppvObject = iface;
 620     }
 621     else
 622     {
 623         return E_NOINTERFACE;
 624     }
 625
 626     return S_OK;
 627 }
 628
 629 static ULONG WINAPI isaxerrorHandler_AddRef(
 630         ISAXErrorHandler* iface)
 631 {
 632     return 2;
 633 }
 634
 635 static ULONG WINAPI isaxerrorHandler_Release(
 636         ISAXErrorHandler* iface)
 637 {
 638     return 1;
 639 }
 640
 641 static HRESULT WINAPI isaxerrorHandler_error(
 642         ISAXErrorHandler* iface,
 643         ISAXLocator *pLocator,
 644         const WCHAR *pErrorMessage,
 645         HRESULT hrErrorCode)
 646 {
 647     ok(0, "unexpected call\n");
 648     return S_OK;
 649 }
 650
 651 static HRESULT WINAPI isaxerrorHandler_fatalError(
 652         ISAXErrorHandler* iface,
 653         ISAXLocator *pLocator,
 654         const WCHAR *pErrorMessage,
 655         HRESULT hrErrorCode)
 656 {
 657     if(!test_expect_call(EH_FATALERROR))
 658         return E_FAIL;
 659
 660     ok(hrErrorCode == expectCall->ret, "hrErrorCode = %x, expected %x\n", hrErrorCode, expectCall->ret);
 661
 662     expectCall++;
 663     return S_OK;
 664 }
 665
 666 static HRESULT WINAPI isaxerrorHanddler_ignorableWarning(
 667         ISAXErrorHandler* iface,
 668         ISAXLocator *pLocator,
 669         const WCHAR *pErrorMessage,
 670         HRESULT hrErrorCode)
 671 {
 672     ok(0, "unexpected call\n");
 673     return S_OK;
 674 }
 675
 676 static const ISAXErrorHandlerVtbl errorHandlerVtbl =
 677 {
 678     isaxerrorHandler_QueryInterface,
 679     isaxerrorHandler_AddRef,
 680     isaxerrorHandler_Release,
 681     isaxerrorHandler_error,
 682     isaxerrorHandler_fatalError,
 683     isaxerrorHanddler_ignorableWarning
 684 };
 685
 686 static ISAXErrorHandler errorHandler = { &errorHandlerVtbl };
 687
 688 static HRESULT WINAPI isaxattributes_QueryInterface(
 689         ISAXAttributes* iface,
 690         REFIID riid,
 691         void **ppvObject)
 692 {
 693     *ppvObject = NULL;
 694
 695     if(IsEqualGUID(riid, &IID_IUnknown) || IsEqualGUID(riid, &IID_ISAXAttributes))
 696     {
 697         *ppvObject = iface;
 698     }
 699     else
 700     {
 701         return E_NOINTERFACE;
 702     }
 703
 704     return S_OK;
 705 }
 706
 707 static ULONG WINAPI isaxattributes_AddRef(ISAXAttributes* iface)
 708 {
 709     return 2;
 710 }
 711
 712 static ULONG WINAPI isaxattributes_Release(ISAXAttributes* iface)
 713 {
 714     return 1;
 715 }
 716
 717 static HRESULT WINAPI isaxattributes_getLength(ISAXAttributes* iface, int *length)
 718 {
 719     *length = 2;
 720     return S_OK;
 721 }
 722
 723 static HRESULT WINAPI isaxattributes_getURI(
 724     ISAXAttributes* iface,
 725     int nIndex,
 726     const WCHAR **pUrl,
 727     int *pUriSize)
 728 {
 729     ok(0, "unexpected call\n");
 730     return E_NOTIMPL;
 731 }
 732
 733 static HRESULT WINAPI isaxattributes_getLocalName(
 734     ISAXAttributes* iface,
 735     int nIndex,
 736     const WCHAR **pLocalName,
 737     int *pLocalNameLength)
 738 {
 739     ok(0, "unexpected call\n");
 740     return E_NOTIMPL;
 741 }
 742
 743 static HRESULT WINAPI isaxattributes_getQName(
 744     ISAXAttributes* iface,
 745     int nIndex,
 746     const WCHAR **pQName,
 747     int *pQNameLength)
 748 {
 749     static const WCHAR attr1W[] = {'a',':','a','t','t','r','1','j','u','n','k',0};
 750     static const WCHAR attr2W[] = {'a','t','t','r','2','j','u','n','k',0};
 751
 752     ok(nIndex == 0 || nIndex == 1, "invalid index received %d\n", nIndex);
 753
 754     *pQName = (nIndex == 0) ? attr1W : attr2W;
 755     *pQNameLength = (nIndex == 0) ? 7 : 5;
 756
 757     return S_OK;
 758 }
 759
 760 static HRESULT WINAPI isaxattributes_getName(
 761     ISAXAttributes* iface,
 762     int nIndex,
 763     const WCHAR **pUri,
 764     int * pUriLength,
 765     const WCHAR ** pLocalName,
 766     int * pLocalNameSize,
 767     const WCHAR ** pQName,
 768     int * pQNameLength)
 769 {
 770     ok(0, "unexpected call\n");
 771     return E_NOTIMPL;
 772 }
 773
 774 static HRESULT WINAPI isaxattributes_getIndexFromName(
 775     ISAXAttributes* iface,
 776     const WCHAR * pUri,
 777     int cUriLength,
 778     const WCHAR * pLocalName,
 779     int cocalNameLength,
 780     int * index)
 781 {
 782     ok(0, "unexpected call\n");
 783     return E_NOTIMPL;
 784 }
 785
 786 static HRESULT WINAPI isaxattributes_getIndexFromQName(
 787     ISAXAttributes* iface,
 788     const WCHAR * pQName,
 789     int nQNameLength,
 790     int * index)
 791 {
 792     ok(0, "unexpected call\n");
 793     return E_NOTIMPL;
 794 }
 795
 796 static HRESULT WINAPI isaxattributes_getType(
 797     ISAXAttributes* iface,
 798     int nIndex,
 799     const WCHAR ** pType,
 800     int * pTypeLength)
 801 {
 802     ok(0, "unexpected call\n");
 803     return E_NOTIMPL;
 804 }
 805
 806 static HRESULT WINAPI isaxattributes_getTypeFromName(
 807     ISAXAttributes* iface,
 808     const WCHAR * pUri,
 809     int nUri,
 810     const WCHAR * pLocalName,
 811     int nLocalName,
 812     const WCHAR ** pType,
 813     int * nType)
 814 {
 815     ok(0, "unexpected call\n");
 816     return E_NOTIMPL;
 817 }
 818
 819 static HRESULT WINAPI isaxattributes_getTypeFromQName(
 820     ISAXAttributes* iface,
 821     const WCHAR * pQName,
 822     int nQName,
 823     const WCHAR ** pType,
 824     int * nType)
 825 {
 826     ok(0, "unexpected call\n");
 827     return E_NOTIMPL;
 828 }
 829
 830 static HRESULT WINAPI isaxattributes_getValue(
 831     ISAXAttributes* iface,
 832     int nIndex,
 833     const WCHAR ** pValue,
 834     int * nValue)
 835 {
 836     static const WCHAR attrval1W[] = {'a','1','j','u','n','k',0};
 837     static const WCHAR attrval2W[] = {'a','2','j','u','n','k',0};
 838
 839     ok(nIndex == 0 || nIndex == 1, "invalid index received %d\n", nIndex);
 840
 841     *pValue = (nIndex == 0) ? attrval1W : attrval2W;
 842     *nValue = 2;
 843
 844     return S_OK;
 845 }
 846
 847 static HRESULT WINAPI isaxattributes_getValueFromName(
 848     ISAXAttributes* iface,
 849     const WCHAR * pUri,
 850     int nUri,
 851     const WCHAR * pLocalName,
 852     int nLocalName,
 853     const WCHAR ** pValue,
 854     int * nValue)
 855 {
 856     ok(0, "unexpected call\n");
 857     return E_NOTIMPL;
 858 }
 859
 860 static HRESULT WINAPI isaxattributes_getValueFromQName(
 861     ISAXAttributes* iface,
 862     const WCHAR * pQName,
 863     int nQName,
 864     const WCHAR ** pValue,
 865     int * nValue)
 866 {
 867     ok(0, "unexpected call\n");
 868     return E_NOTIMPL;
 869 }
 870
 871 static const ISAXAttributesVtbl SAXAttributesVtbl =
 872 {
 873     isaxattributes_QueryInterface,
 874     isaxattributes_AddRef,
 875     isaxattributes_Release,
 876     isaxattributes_getLength,
 877     isaxattributes_getURI,
 878     isaxattributes_getLocalName,
 879     isaxattributes_getQName,
 880     isaxattributes_getName,
 881     isaxattributes_getIndexFromName,
 882     isaxattributes_getIndexFromQName,
 883     isaxattributes_getType,
 884     isaxattributes_getTypeFromName,
 885     isaxattributes_getTypeFromQName,
 886     isaxattributes_getValue,
 887     isaxattributes_getValueFromName,
 888     isaxattributes_getValueFromQName
 889 };
 890
 891 static ISAXAttributes saxattributes = { &SAXAttributesVtbl };
 892
 893 static int handler_addrefcalled;
 894
 895 static HRESULT WINAPI isaxlexical_QueryInterface(ISAXLexicalHandler* iface, REFIID riid, void **ppvObject)
 896 {
 897     *ppvObject = NULL;
 898
 899     if(IsEqualGUID(riid, &IID_IUnknown) ||
 900        IsEqualGUID(riid, &IID_ISAXLexicalHandler))
 901     {
 902         *ppvObject = iface;
 903     }
 904     else
 905     {
 906         return E_NOINTERFACE;
 907     }
 908
 909     return S_OK;
 910 }
 911
 912 static ULONG WINAPI isaxlexical_AddRef(ISAXLexicalHandler* iface)
 913 {
 914     handler_addrefcalled++;
 915     return 2;
 916 }
 917
 918 static ULONG WINAPI isaxlexical_Release(ISAXLexicalHandler* iface)
 919 {
 920     return 1;
 921 }
 922
 923 static HRESULT WINAPI isaxlexical_startDTD(ISAXLexicalHandler* iface,
 924     const WCHAR * pName, int nName, const WCHAR * pPublicId,
 925     int nPublicId, const WCHAR * pSystemId, int nSystemId)
 926 {
 927     ok(0, "call not expected\n");
 928     return E_NOTIMPL;
 929 }
 930
 931 static HRESULT WINAPI isaxlexical_endDTD(ISAXLexicalHandler* iface)
 932 {
 933     ok(0, "call not expected\n");
 934     return E_NOTIMPL;
 935 }
 936
 937 static HRESULT WINAPI isaxlexical_startEntity(ISAXLexicalHandler *iface,
 938     const WCHAR * pName, int nName)
 939 {
 940     ok(0, "call not expected\n");
 941     return E_NOTIMPL;
 942 }
 943
 944 static HRESULT WINAPI isaxlexical_endEntity(ISAXLexicalHandler *iface,
 945     const WCHAR * pName, int nName)
 946 {
 947     ok(0, "call not expected\n");
 948     return E_NOTIMPL;
 949 }
 950
 951 static HRESULT WINAPI isaxlexical_startCDATA(ISAXLexicalHandler *iface)
 952 {
 953     ok(0, "call not expected\n");
 954     return E_NOTIMPL;
 955 }
 956
 957 static HRESULT WINAPI isaxlexical_endCDATA(ISAXLexicalHandler *iface)
 958 {
 959     ok(0, "call not expected\n");
 960     return E_NOTIMPL;
 961 }
 962
 963 static HRESULT WINAPI isaxlexical_comment(ISAXLexicalHandler *iface,
 964     const WCHAR * pChars, int nChars)
 965 {
 966     ok(0, "call not expected\n");
 967     return E_NOTIMPL;
 968 }
 969
 970 static const ISAXLexicalHandlerVtbl SAXLexicalHandlerVtbl =
 971 {
 972    isaxlexical_QueryInterface,
 973    isaxlexical_AddRef,
 974    isaxlexical_Release,
 975    isaxlexical_startDTD,
 976    isaxlexical_endDTD,
 977    isaxlexical_startEntity,
 978    isaxlexical_endEntity,
 979    isaxlexical_startCDATA,
 980    isaxlexical_endCDATA,
 981    isaxlexical_comment
 982 };
 983
 984 static ISAXLexicalHandler saxlexicalhandler = { &SAXLexicalHandlerVtbl };
 985
 986 static HRESULT WINAPI isaxdecl_QueryInterface(ISAXDeclHandler* iface, REFIID riid, void **ppvObject)
 987 {
 988     *ppvObject = NULL;
 989
 990     if(IsEqualGUID(riid, &IID_IUnknown) ||
 991        IsEqualGUID(riid, &IID_ISAXDeclHandler))
 992     {
 993         *ppvObject = iface;
 994     }
 995     else
 996     {
 997         return E_NOINTERFACE;
 998     }
 999
1000     return S_OK;
1001 }
1002
1003 static ULONG WINAPI isaxdecl_AddRef(ISAXDeclHandler* iface)
1004 {
1005     handler_addrefcalled++;
1006     return 2;
1007 }
1008
1009 static ULONG WINAPI isaxdecl_Release(ISAXDeclHandler* iface)
1010 {
1011     return 1;
1012 }
1013
1014 static HRESULT WINAPI isaxdecl_elementDecl(ISAXDeclHandler* iface,
1015     const WCHAR * pName, int nName, const WCHAR * pModel, int nModel)
1016 {
1017     ok(0, "call not expected\n");
1018     return E_NOTIMPL;
1019 }
1020
1021 static HRESULT WINAPI isaxdecl_attributeDecl(ISAXDeclHandler* iface,
1022     const WCHAR * pElementName, int nElementName, const WCHAR * pAttributeName,
1023     int nAttributeName, const WCHAR * pType, int nType, const WCHAR * pValueDefault,
1024     int nValueDefault, const WCHAR * pValue, int nValue)
1025 {
1026     ok(0, "call not expected\n");
1027     return E_NOTIMPL;
1028 }
1029
1030 static HRESULT WINAPI isaxdecl_internalEntityDecl(ISAXDeclHandler* iface,
1031     const WCHAR * pName, int nName, const WCHAR * pValue, int nValue)
1032 {
1033     ok(0, "call not expected\n");
1034     return E_NOTIMPL;
1035 }
1036
1037 static HRESULT WINAPI isaxdecl_externalEntityDecl(ISAXDeclHandler* iface,
1038     const WCHAR * pName, int nName, const WCHAR * pPublicId, int nPublicId,
1039     const WCHAR * pSystemId, int nSystemId)
1040 {
1041     ok(0, "call not expected\n");
1042     return E_NOTIMPL;
1043 }
1044
1045 static const ISAXDeclHandlerVtbl SAXDeclHandlerVtbl =
1046 {
1047    isaxdecl_QueryInterface,
1048    isaxdecl_AddRef,
1049    isaxdecl_Release,
1050    isaxdecl_elementDecl,
1051    isaxdecl_attributeDecl,
1052    isaxdecl_internalEntityDecl,
1053    isaxdecl_externalEntityDecl
1054 };
1055
1056 static ISAXDeclHandler saxdeclhandler = { &SAXDeclHandlerVtbl };
1057
1058 typedef struct mxwriter_write_test_t {
1059     BOOL        last;
1060     const BYTE  *data;
1061     DWORD       cb;
1062     BOOL        null_written;
1063     BOOL        fail_write;
1064 } mxwriter_write_test;
1065
1066 typedef struct mxwriter_stream_test_t {
1067     VARIANT_BOOL        bom;
1068     const char          *encoding;
1069     mxwriter_write_test expected_writes[4];
1070 } mxwriter_stream_test;
1071
1072 static const mxwriter_write_test *current_write_test;
1073 static DWORD current_stream_test_index;
1074
1075 static HRESULT WINAPI istream_QueryInterface(IStream *iface, REFIID riid, void **ppvObject)
1076 {
1077     *ppvObject = NULL;
1078
1079     if(IsEqualGUID(riid, &IID_IStream) || IsEqualGUID(riid, &IID_IUnknown))
1080         *ppvObject = iface;
1081     else
1082         return E_NOINTERFACE;
1083
1084     return S_OK;
1085 }
1086
1087 static ULONG WINAPI istream_AddRef(IStream *iface)
1088 {
1089     return 2;
1090 }
1091
1092 static ULONG WINAPI istream_Release(IStream *iface)
1093 {
1094     return 1;
1095 }
1096
1097 static HRESULT WINAPI istream_Read(IStream *iface, void *pv, ULONG cb, ULONG *pcbRead)
1098 {
1099     ok(0, "unexpected call\n");
1100     return E_NOTIMPL;
1101 }
1102
1103 static HRESULT WINAPI istream_Write(IStream *iface, const void *pv, ULONG cb, ULONG *pcbWritten)
1104 {
1105     BOOL fail = FALSE;
1106
1107     ok(pv != NULL, "pv == NULL\n");
1108
1109     if(current_write_test->last) {
1110         ok(0, "Too many Write calls made on test %d\n", current_stream_test_index);
1111         return E_FAIL;
1112     }
1113
1114     fail = current_write_test->fail_write;
1115
1116     ok(current_write_test->cb == cb, "Expected %d, but got %d on test %d\n",
1117         current_write_test->cb, cb, current_stream_test_index);
1118
1119     if(!pcbWritten)
1120         ok(current_write_test->null_written, "pcbWritten was NULL on test %d\n", current_stream_test_index);
1121     else
1122         ok(!memcmp(current_write_test->data, pv, cb), "Unexpected data on test %d\n", current_stream_test_index);
1123
1124     ++current_write_test;
1125
1126     if(pcbWritten)
1127         *pcbWritten = cb;
1128
1129     return fail ? E_FAIL : S_OK;
1130 }
1131
1132 static HRESULT WINAPI istream_Seek(IStream *iface, LARGE_INTEGER dlibMove, DWORD dwOrigin,
1133         ULARGE_INTEGER *plibNewPosition)
1134 {
1135     ok(0, "unexpected call\n");
1136     return E_NOTIMPL;
1137 }
1138
1139 static HRESULT WINAPI istream_SetSize(IStream *iface, ULARGE_INTEGER libNewSize)
1140 {
1141     ok(0, "unexpected call\n");
1142     return E_NOTIMPL;
1143 }
1144
1145 static HRESULT WINAPI istream_CopyTo(IStream *iface, IStream *pstm, ULARGE_INTEGER cb,
1146         ULARGE_INTEGER *pcbRead, ULARGE_INTEGER *plibWritten)
1147 {
1148     ok(0, "unexpected call\n");
1149     return E_NOTIMPL;
1150 }
1151
1152 static HRESULT WINAPI istream_Commit(IStream *iface, DWORD grfCommitFlags)
1153 {
1154     ok(0, "unexpected call\n");
1155     return E_NOTIMPL;
1156 }
1157
1158 static HRESULT WINAPI istream_Revert(IStream *iface)
1159 {
1160     ok(0, "unexpected call\n");
1161     return E_NOTIMPL;
1162 }
1163
1164 static HRESULT WINAPI istream_LockRegion(IStream *iface, ULARGE_INTEGER libOffset,
1165         ULARGE_INTEGER cb, DWORD dwLockType)
1166 {
1167     ok(0, "unexpected call\n");
1168     return E_NOTIMPL;
1169 }
1170
1171 static HRESULT WINAPI istream_UnlockRegion(IStream *iface, ULARGE_INTEGER libOffset,
1172         ULARGE_INTEGER cb, DWORD dwLockType)
1173 {
1174     ok(0, "unexpected call\n");
1175     return E_NOTIMPL;
1176 }
1177
1178 static HRESULT WINAPI istream_Stat(IStream *iface, STATSTG *pstatstg, DWORD grfStatFlag)
1179 {
1180     ok(0, "unexpected call\n");
1181     return E_NOTIMPL;
1182 }
1183
1184 static HRESULT WINAPI istream_Clone(IStream *iface, IStream **ppstm)
1185 {
1186     ok(0, "unexpected call\n");
1187     return E_NOTIMPL;
1188 }
1189
1190 static const IStreamVtbl StreamVtbl = {
1191     istream_QueryInterface,
1192     istream_AddRef,
1193     istream_Release,
1194     istream_Read,
1195     istream_Write,
1196     istream_Seek,
1197     istream_SetSize,
1198     istream_CopyTo,
1199     istream_Commit,
1200     istream_Revert,
1201     istream_LockRegion,
1202     istream_UnlockRegion,
1203     istream_Stat,
1204     istream_Clone
1205 };
1206
1207 static IStream mxstream = { &StreamVtbl };
1208
1209 static void test_saxreader(int version)
1210 {
1211     HRESULT hr;
1212     ISAXXMLReader *reader = NULL;
1213     VARIANT var;
1214     ISAXContentHandler *lpContentHandler;
1215     ISAXErrorHandler *lpErrorHandler;
1216     SAFEARRAY *pSA;
1217     SAFEARRAYBOUND SADim[1];
1218     char *pSAData = NULL;
1219     IStream *iStream;
1220     ULARGE_INTEGER liSize;
1221     LARGE_INTEGER liPos;
1222     ULONG bytesWritten;
1223     HANDLE file;
1224     static const CHAR testXmlA[] = "test.xml";
1225     static const WCHAR testXmlW[] = {'t','e','s','t','.','x','m','l',0};
1226     IXMLDOMDocument *domDocument;
1227     BSTR bstrData;
1228     VARIANT_BOOL vBool;
1229
1230     msxml_version = version;
1231     if(version == 3) {
1232         hr = CoCreateInstance(&CLSID_SAXXMLReader30, NULL, CLSCTX_INPROC_SERVER,
1233                 &IID_ISAXXMLReader, (LPVOID*)&reader);
1234     } else if(version == 6) {
1235         hr = CoCreateInstance(&CLSID_SAXXMLReader60, NULL, CLSCTX_INPROC_SERVER,
1236                 &IID_ISAXXMLReader, (LPVOID*)&reader);
1237         if(hr == REGDB_E_CLASSNOTREG) {
1238             win_skip("SAXXMLReader6 not registered\n");
1239             return;
1240         }
1241     } else {
1242         hr = CoCreateInstance(&CLSID_SAXXMLReader, NULL, CLSCTX_INPROC_SERVER,
1243                 &IID_ISAXXMLReader, (LPVOID*)&reader);
1244     }
1245     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
1246
1247     if(version != 6) {
1248         hr = ISAXXMLReader_getContentHandler(reader, NULL);
1249         ok(hr == E_POINTER, "Expected E_POINTER, got %08x\n", hr);
1250
1251         hr = ISAXXMLReader_getErrorHandler(reader, NULL);
1252         ok(hr == E_POINTER, "Expected E_POINTER, got %08x\n", hr);
1253     }
1254
1255     hr = ISAXXMLReader_getContentHandler(reader, &lpContentHandler);
1256     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
1257     ok(lpContentHandler == NULL, "Expected %p, got %p\n", NULL, lpContentHandler);
1258
1259     hr = ISAXXMLReader_getErrorHandler(reader, &lpErrorHandler);
1260     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
1261     ok(lpErrorHandler == NULL, "Expected %p, got %p\n", NULL, lpErrorHandler);
1262
1263     hr = ISAXXMLReader_putContentHandler(reader, NULL);
1264     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
1265
1266     hr = ISAXXMLReader_putContentHandler(reader, &contentHandler);
1267     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
1268
1269     hr = ISAXXMLReader_putErrorHandler(reader, &errorHandler);
1270     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
1271
1272     hr = ISAXXMLReader_getContentHandler(reader, &lpContentHandler);
1273     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
1274     ok(lpContentHandler == &contentHandler, "Expected %p, got %p\n", &contentHandler, lpContentHandler);
1275
1276     V_VT(&var) = VT_BSTR;
1277     V_BSTR(&var) = SysAllocString(szSimpleXML);
1278
1279     expectCall = contentHandlerTest1;
1280     hr = ISAXXMLReader_parse(reader, var);
1281     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
1282     test_expect_call(CH_ENDTEST);
1283
1284     VariantClear(&var);
1285
1286     SADim[0].lLbound= 0;
1287     SADim[0].cElements= sizeof(szTestXML)-1;
1288     pSA = SafeArrayCreate(VT_UI1, 1, SADim);
1289     SafeArrayAccessData(pSA, (void**)&pSAData);
1290     memcpy(pSAData, szTestXML, sizeof(szTestXML)-1);
1291     SafeArrayUnaccessData(pSA);
1292     V_VT(&var) = VT_ARRAY|VT_UI1;
1293     V_ARRAY(&var) = pSA;
1294
1295     expectCall = contentHandlerTest1;
1296     hr = ISAXXMLReader_parse(reader, var);
1297     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
1298     test_expect_call(CH_ENDTEST);
1299
1300     SafeArrayDestroy(pSA);
1301
1302     CreateStreamOnHGlobal(NULL, TRUE, &iStream);
1303     liSize.QuadPart = strlen(szTestXML);
1304     IStream_SetSize(iStream, liSize);
1305     IStream_Write(iStream, szTestXML, strlen(szTestXML), &bytesWritten);
1306     liPos.QuadPart = 0;
1307     IStream_Seek(iStream, liPos, STREAM_SEEK_SET, NULL);
1308     V_VT(&var) = VT_UNKNOWN|VT_DISPATCH;
1309     V_UNKNOWN(&var) = (IUnknown*)iStream;
1310
1311     expectCall = contentHandlerTest1;
1312     hr = ISAXXMLReader_parse(reader, var);
1313     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
1314     test_expect_call(CH_ENDTEST);
1315
1316     IStream_Release(iStream);
1317
1318     CreateStreamOnHGlobal(NULL, TRUE, &iStream);
1319     liSize.QuadPart = strlen(szTestAttributes);
1320     IStream_SetSize(iStream, liSize);
1321     IStream_Write(iStream, szTestAttributes, strlen(szTestAttributes), &bytesWritten);
1322     liPos.QuadPart = 0;
1323     IStream_Seek(iStream, liPos, STREAM_SEEK_SET, NULL);
1324     V_VT(&var) = VT_UNKNOWN|VT_DISPATCH;
1325     V_UNKNOWN(&var) = (IUnknown*)iStream;
1326
1327     if(version >= 6)
1328         expectCall = contentHandlerTestAttributes6;
1329     else
1330         expectCall = contentHandlerTestAttributes;
1331     hr = ISAXXMLReader_parse(reader, var);
1332     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
1333     test_expect_call(CH_ENDTEST);
1334
1335     IStream_Release(iStream);
1336
1337     V_VT(&var) = VT_BSTR;
1338     V_BSTR(&var) = SysAllocString(szCarriageRetTest);
1339
1340     expectCall = contentHandlerTest2;
1341     hr = ISAXXMLReader_parse(reader, var);
1342     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
1343     test_expect_call(CH_ENDTEST);
1344
1345     VariantClear(&var);
1346
1347     file = CreateFileA(testXmlA, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
1348     ok(file != INVALID_HANDLE_VALUE, "Could not create file: %u\n", GetLastError());
1349     WriteFile(file, szTestXML, sizeof(szTestXML)-1, &bytesWritten, NULL);
1350     CloseHandle(file);
1351
1352     expectCall = contentHandlerTest1;
1353     hr = ISAXXMLReader_parseURL(reader, testXmlW);
1354     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
1355     test_expect_call(CH_ENDTEST);
1356
1357     expectCall = contentHandlerTestError;
1358     hr = ISAXXMLReader_parseURL(reader, testXmlW);
1359     ok(hr == E_FAIL, "Expected E_FAIL, got %08x\n", hr);
1360     test_expect_call(CH_ENDTEST);
1361
1362     if(version >= 6)
1363         expectCall = contentHandlerTestCallbackResult6;
1364     else
1365         expectCall = contentHandlerTestCallbackResults;
1366     hr = ISAXXMLReader_parseURL(reader, testXmlW);
1367     ok(hr == (version>=6 ? S_OK : S_FALSE), "Expected S_FALSE, got %08x\n", hr);
1368     test_expect_call(CH_ENDTEST);
1369
1370     DeleteFileA(testXmlA);
1371
1372     hr = CoCreateInstance(&CLSID_DOMDocument, NULL, CLSCTX_INPROC_SERVER,
1373             &IID_IXMLDOMDocument, (LPVOID*)&domDocument);
1374     if(FAILED(hr))
1375     {
1376         skip("Failed to create DOMDocument instance\n");
1377         return;
1378     }
1379     bstrData = SysAllocString(szSimpleXML);
1380     hr = IXMLDOMDocument_loadXML(domDocument, bstrData, &vBool);
1381     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
1382     V_VT(&var) = VT_UNKNOWN;
1383     V_UNKNOWN(&var) = (IUnknown*)domDocument;
1384
1385     expectCall = contentHandlerTest2;
1386     hr = ISAXXMLReader_parse(reader, var);
1387     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
1388     test_expect_call(CH_ENDTEST);
1389     IXMLDOMDocument_Release(domDocument);
1390
1391     ISAXXMLReader_Release(reader);
1392     SysFreeString(bstrData);
1393 }
1394
1395 struct saxreader_props_test_t
1396 {
1397     const char *prop_name;
1398     IUnknown   *iface;
1399 };
1400
1401 static const struct saxreader_props_test_t props_test_data[] = {
1402     { "http://xml.org/sax/properties/lexical-handler", (IUnknown*)&saxlexicalhandler },
1403     { "http://xml.org/sax/properties/declaration-handler", (IUnknown*)&saxdeclhandler },
1404     { 0 }
1405 };
1406
1407 static void test_saxreader_properties(void)
1408 {
1409     const struct saxreader_props_test_t *ptr = props_test_data;
1410     ISAXXMLReader *reader;
1411     HRESULT hr;
1412
1413     hr = CoCreateInstance(&CLSID_SAXXMLReader, NULL, CLSCTX_INPROC_SERVER,
1414             &IID_ISAXXMLReader, (void**)&reader);
1415     EXPECT_HR(hr, S_OK);
1416
1417     hr = ISAXXMLReader_getProperty(reader, _bstr_("http://xml.org/sax/properties/lexical-handler"), NULL);
1418     EXPECT_HR(hr, E_POINTER);
1419
1420     while (ptr->prop_name)
1421     {
1422         VARIANT v;
1423
1424         V_VT(&v) = VT_EMPTY;
1425         V_UNKNOWN(&v) = (IUnknown*)0xdeadbeef;
1426         hr = ISAXXMLReader_getProperty(reader, _bstr_(ptr->prop_name), &v);
1427         EXPECT_HR(hr, S_OK);
1428         ok(V_VT(&v) == VT_UNKNOWN, "got %d\n", V_VT(&v));
1429         ok(V_UNKNOWN(&v) == NULL, "got %p\n", V_UNKNOWN(&v));
1430
1431         V_VT(&v) = VT_UNKNOWN;
1432         V_UNKNOWN(&v) = ptr->iface;
1433         hr = ISAXXMLReader_putProperty(reader, _bstr_(ptr->prop_name), v);
1434         EXPECT_HR(hr, S_OK);
1435
1436         V_VT(&v) = VT_EMPTY;
1437         V_UNKNOWN(&v) = (IUnknown*)0xdeadbeef;
1438         handler_addrefcalled = 0;
1439         hr = ISAXXMLReader_getProperty(reader, _bstr_(ptr->prop_name), &v);
1440         EXPECT_HR(hr, S_OK);
1441         ok(V_VT(&v) == VT_UNKNOWN, "got %d\n", V_VT(&v));
1442         ok(V_UNKNOWN(&v) == ptr->iface, "got %p\n", V_UNKNOWN(&v));
1443         ok(handler_addrefcalled == 1, "AddRef called %d times\n", handler_addrefcalled);
1444         VariantClear(&v);
1445
1446         V_VT(&v) = VT_EMPTY;
1447         V_UNKNOWN(&v) = (IUnknown*)0xdeadbeef;
1448         hr = ISAXXMLReader_putProperty(reader, _bstr_(ptr->prop_name), v);
1449         EXPECT_HR(hr, S_OK);
1450
1451         V_VT(&v) = VT_EMPTY;
1452         V_UNKNOWN(&v) = (IUnknown*)0xdeadbeef;
1453         hr = ISAXXMLReader_getProperty(reader, _bstr_(ptr->prop_name), &v);
1454         EXPECT_HR(hr, S_OK);
1455         ok(V_VT(&v) == VT_UNKNOWN, "got %d\n", V_VT(&v));
1456         ok(V_UNKNOWN(&v) == NULL, "got %p\n", V_UNKNOWN(&v));
1457
1458         V_VT(&v) = VT_UNKNOWN;
1459         V_UNKNOWN(&v) = ptr->iface;
1460         hr = ISAXXMLReader_putProperty(reader, _bstr_(ptr->prop_name), v);
1461         EXPECT_HR(hr, S_OK);
1462
1463         /* only VT_EMPTY seems to be valid to reset property */
1464         V_VT(&v) = VT_I4;
1465         V_UNKNOWN(&v) = (IUnknown*)0xdeadbeef;
1466         hr = ISAXXMLReader_putProperty(reader, _bstr_(ptr->prop_name), v);
1467         EXPECT_HR(hr, E_INVALIDARG);
1468
1469         V_VT(&v) = VT_EMPTY;
1470         V_UNKNOWN(&v) = (IUnknown*)0xdeadbeef;
1471         hr = ISAXXMLReader_getProperty(reader, _bstr_(ptr->prop_name), &v);
1472         EXPECT_HR(hr, S_OK);
1473         ok(V_VT(&v) == VT_UNKNOWN, "got %d\n", V_VT(&v));
1474         ok(V_UNKNOWN(&v) == ptr->iface, "got %p\n", V_UNKNOWN(&v));
1475         VariantClear(&v);
1476
1477         V_VT(&v) = VT_UNKNOWN;
1478         V_UNKNOWN(&v) = NULL;
1479         hr = ISAXXMLReader_putProperty(reader, _bstr_(ptr->prop_name), v);
1480         EXPECT_HR(hr, S_OK);
1481
1482         V_VT(&v) = VT_EMPTY;
1483         V_UNKNOWN(&v) = (IUnknown*)0xdeadbeef;
1484         hr = ISAXXMLReader_getProperty(reader, _bstr_(ptr->prop_name), &v);
1485         EXPECT_HR(hr, S_OK);
1486         ok(V_VT(&v) == VT_UNKNOWN, "got %d\n", V_VT(&v));
1487         ok(V_UNKNOWN(&v) == NULL, "got %p\n", V_UNKNOWN(&v));
1488
1489         ptr++;
1490     }
1491
1492     ISAXXMLReader_Release(reader);
1493     free_bstrs();
1494 }
1495
1496 struct feature_ns_entry_t {
1497     const GUID *guid;
1498     const char *clsid;
1499     VARIANT_BOOL value;
1500 };
1501
1502 static const struct feature_ns_entry_t feature_ns_entry_data[] = {
1503     { &CLSID_SAXXMLReader,   "CLSID_SAXXMLReader",   VARIANT_TRUE },
1504     { &CLSID_SAXXMLReader30, "CLSID_SAXXMLReader30", VARIANT_TRUE },
1505     { &CLSID_SAXXMLReader40, "CLSID_SAXXMLReader40", VARIANT_TRUE },
1506     { &CLSID_SAXXMLReader60, "CLSID_SAXXMLReader60", VARIANT_TRUE },
1507     { 0 }
1508 };
1509
1510 static void test_saxreader_features(void)
1511 {
1512     const struct feature_ns_entry_t *entry = feature_ns_entry_data;
1513     ISAXXMLReader *reader;
1514
1515     while (entry->guid)
1516     {
1517         VARIANT_BOOL value;
1518         HRESULT hr;
1519
1520         hr = CoCreateInstance(entry->guid, NULL, CLSCTX_INPROC_SERVER, &IID_ISAXXMLReader, (void**)&reader);
1521         if (hr != S_OK)
1522         {
1523             win_skip("can't create %s instance\n", entry->clsid);
1524             entry++;
1525             continue;
1526         }
1527
1528         value = 0xc;
1529         hr = ISAXXMLReader_getFeature(reader, _bstr_("http://xml.org/sax/features/namespaces"), &value);
1530         EXPECT_HR(hr, S_OK);
1531
1532         ok(entry->value == value, "%s: got wrong default value %x, expected %x\n", entry->clsid, value, entry->value);
1533
1534         ISAXXMLReader_Release(reader);
1535
1536         entry++;
1537     }
1538 }
1539
1540 /* UTF-8 data with UTF-8 BOM and UTF-16 in prolog */
1541 static const CHAR UTF8BOMTest[] =
1542 "\xEF\xBB\xBF<?xml version = \"1.0\" encoding = \"UTF-16\"?>\n"
1543 "<a></a>\n";
1544
1545 struct enc_test_entry_t {
1546     const GUID *guid;
1547     const char *clsid;
1548     const char *data;
1549     HRESULT hr;
1550     int todo;
1551 };
1552
1553 static const struct enc_test_entry_t encoding_test_data[] = {
1554     { &CLSID_SAXXMLReader,   "CLSID_SAXXMLReader",   UTF8BOMTest, 0xc00ce56f, 1 },
1555     { &CLSID_SAXXMLReader30, "CLSID_SAXXMLReader30", UTF8BOMTest, 0xc00ce56f, 1 },
1556     { &CLSID_SAXXMLReader40, "CLSID_SAXXMLReader40", UTF8BOMTest, S_OK, 0 },
1557     { &CLSID_SAXXMLReader60, "CLSID_SAXXMLReader60", UTF8BOMTest, S_OK, 0 },
1558     { 0 }
1559 };
1560
1561 static void test_encoding(void)
1562 {
1563     const struct enc_test_entry_t *entry = encoding_test_data;
1564     static const WCHAR testXmlW[] = {'t','e','s','t','.','x','m','l',0};
1565     static const CHAR testXmlA[] = "test.xml";
1566     ISAXXMLReader *reader;
1567     DWORD written;
1568     HANDLE file;
1569     HRESULT hr;
1570
1571     while (entry->guid)
1572     {
1573         hr = CoCreateInstance(entry->guid, NULL, CLSCTX_INPROC_SERVER, &IID_ISAXXMLReader, (void**)&reader);
1574         if (hr != S_OK)
1575         {
1576             win_skip("can't create %s instance\n", entry->clsid);
1577             entry++;
1578             continue;
1579         }
1580
1581         file = CreateFileA(testXmlA, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
1582         ok(file != INVALID_HANDLE_VALUE, "Could not create file: %u\n", GetLastError());
1583         WriteFile(file, UTF8BOMTest, sizeof(UTF8BOMTest)-1, &written, NULL);
1584         CloseHandle(file);
1585
1586         hr = ISAXXMLReader_parseURL(reader, testXmlW);
1587         if (entry->todo)
1588             todo_wine ok(hr == entry->hr, "Expected 0x%08x, got 0x%08x. CLSID %s\n", entry->hr, hr, entry->clsid);
1589         else
1590             ok(hr == entry->hr, "Expected 0x%08x, got 0x%08x. CLSID %s\n", entry->hr, hr, entry->clsid);
1591
1592         DeleteFileA(testXmlA);
1593         ISAXXMLReader_Release(reader);
1594
1595         entry++;
1596     }
1597 }
1598
1599 static void test_mxwriter_contenthandler(void)
1600 {
1601     ISAXContentHandler *handler;
1602     IMXWriter *writer, *writer2;
1603     HRESULT hr;
1604
1605     hr = CoCreateInstance(&CLSID_MXXMLWriter, NULL, CLSCTX_INPROC_SERVER,
1606             &IID_IMXWriter, (void**)&writer);
1607     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
1608
1609     EXPECT_REF(writer, 1);
1610
1611     hr = IMXWriter_QueryInterface(writer, &IID_ISAXContentHandler, (void**)&handler);
1612     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
1613     EXPECT_REF(writer, 2);
1614     EXPECT_REF(handler, 2);
1615
1616     hr = ISAXContentHandler_QueryInterface(handler, &IID_IMXWriter, (void**)&writer2);
1617     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
1618     ok(writer2 == writer, "got %p, expected %p\n", writer2, writer);
1619     EXPECT_REF(writer, 3);
1620     EXPECT_REF(writer2, 3);
1621     IMXWriter_Release(writer2);
1622
1623     ISAXContentHandler_Release(handler);
1624     IMXWriter_Release(writer);
1625 }
1626
1627 struct msxmlsupported_data_t
1628 {
1629     const GUID *clsid;
1630     const char *name;
1631     BOOL supported;
1632 };
1633
1634 static struct msxmlsupported_data_t msxmlsupported_data[] =
1635 {
1636     { &CLSID_MXXMLWriter,   "MXXMLWriter" },
1637     { &CLSID_MXXMLWriter30, "MXXMLWriter30" },
1638     { &CLSID_MXXMLWriter40, "MXXMLWriter40" },
1639     { &CLSID_MXXMLWriter60, "MXXMLWriter60" },
1640     { NULL }
1641 };
1642
1643 static BOOL is_mxwriter_supported(const GUID *clsid, const struct msxmlsupported_data_t *table)
1644 {
1645     while (table->clsid)
1646     {
1647         if (table->clsid == clsid) return table->supported;
1648         table++;
1649     }
1650     return FALSE;
1651 }
1652
1653 struct mxwriter_props_t
1654 {
1655     const GUID *clsid;
1656     VARIANT_BOOL bom;
1657     VARIANT_BOOL disable_escape;
1658     VARIANT_BOOL indent;
1659     VARIANT_BOOL omitdecl;
1660     VARIANT_BOOL standalone;
1661     const char *encoding;
1662 };
1663
1664 static const struct mxwriter_props_t mxwriter_default_props[] =
1665 {
1666     { &CLSID_MXXMLWriter,   VARIANT_TRUE, VARIANT_FALSE, VARIANT_FALSE, VARIANT_FALSE, VARIANT_FALSE, "UTF-16" },
1667     { &CLSID_MXXMLWriter30, VARIANT_TRUE, VARIANT_FALSE, VARIANT_FALSE, VARIANT_FALSE, VARIANT_FALSE, "UTF-16" },
1668     { &CLSID_MXXMLWriter40, VARIANT_TRUE, VARIANT_FALSE, VARIANT_FALSE, VARIANT_FALSE, VARIANT_FALSE, "UTF-16" },
1669     { &CLSID_MXXMLWriter60, VARIANT_TRUE, VARIANT_FALSE, VARIANT_FALSE, VARIANT_FALSE, VARIANT_FALSE, "UTF-16" },
1670     { NULL }
1671 };
1672
1673 static void test_mxwriter_default_properties(const struct mxwriter_props_t *table)
1674 {
1675     int i = 0;
1676
1677     while (table->clsid)
1678     {
1679         IMXWriter *writer;
1680         VARIANT_BOOL b;
1681         BSTR encoding;
1682         HRESULT hr;
1683
1684         if (!is_mxwriter_supported(table->clsid, msxmlsupported_data))
1685         {
1686             table++;
1687             i++;
1688             continue;
1689         }
1690
1691         hr = CoCreateInstance(table->clsid, NULL, CLSCTX_INPROC_SERVER,
1692             &IID_IMXWriter, (void**)&writer);
1693         EXPECT_HR(hr, S_OK);
1694
1695         b = !table->bom;
1696         hr = IMXWriter_get_byteOrderMark(writer, &b);
1697         EXPECT_HR(hr, S_OK);
1698         ok(table->bom == b, "test %d: got BOM %d, expected %d\n", i, b, table->bom);
1699
1700         b = !table->disable_escape;
1701         hr = IMXWriter_get_disableOutputEscaping(writer, &b);
1702         EXPECT_HR(hr, S_OK);
1703         ok(table->disable_escape == b, "test %d: got disable escape %d, expected %d\n", i, b,
1704            table->disable_escape);
1705
1706         b = !table->indent;
1707         hr = IMXWriter_get_indent(writer, &b);
1708         EXPECT_HR(hr, S_OK);
1709         ok(table->indent == b, "test %d: got indent %d, expected %d\n", i, b, table->indent);
1710
1711         b = !table->omitdecl;
1712         hr = IMXWriter_get_omitXMLDeclaration(writer, &b);
1713         EXPECT_HR(hr, S_OK);
1714         ok(table->omitdecl == b, "test %d: got omitdecl %d, expected %d\n", i, b, table->omitdecl);
1715
1716         b = !table->standalone;
1717         hr = IMXWriter_get_standalone(writer, &b);
1718         EXPECT_HR(hr, S_OK);
1719         ok(table->standalone == b, "test %d: got standalone %d, expected %d\n", i, b, table->standalone);
1720
1721         hr = IMXWriter_get_encoding(writer, &encoding);
1722         EXPECT_HR(hr, S_OK);
1723         ok(!lstrcmpW(encoding, _bstr_(table->encoding)), "test %d: got encoding %s, expected %s\n",
1724             i, wine_dbgstr_w(encoding), table->encoding);
1725         SysFreeString(encoding);
1726
1727         IMXWriter_Release(writer);
1728
1729         table++;
1730         i++;
1731     }
1732 }
1733
1734 static void test_mxwriter_properties(void)
1735 {
1736     static const WCHAR utf16W[] = {'U','T','F','-','1','6',0};
1737     static const WCHAR emptyW[] = {0};
1738     static const WCHAR testW[] = {'t','e','s','t',0};
1739     IMXWriter *writer;
1740     VARIANT_BOOL b;
1741     HRESULT hr;
1742     BSTR str, str2;
1743
1744     test_mxwriter_default_properties(mxwriter_default_props);
1745
1746     hr = CoCreateInstance(&CLSID_MXXMLWriter, NULL, CLSCTX_INPROC_SERVER,
1747             &IID_IMXWriter, (void**)&writer);
1748     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
1749
1750     hr = IMXWriter_get_disableOutputEscaping(writer, NULL);
1751     ok(hr == E_POINTER, "got %08x\n", hr);
1752
1753     hr = IMXWriter_get_byteOrderMark(writer, NULL);
1754     ok(hr == E_POINTER, "got %08x\n", hr);
1755
1756     hr = IMXWriter_get_indent(writer, NULL);
1757     ok(hr == E_POINTER, "got %08x\n", hr);
1758
1759     hr = IMXWriter_get_omitXMLDeclaration(writer, NULL);
1760     ok(hr == E_POINTER, "got %08x\n", hr);
1761
1762     hr = IMXWriter_get_standalone(writer, NULL);
1763     ok(hr == E_POINTER, "got %08x\n", hr);
1764
1765     /* set and check */
1766     hr = IMXWriter_put_standalone(writer, VARIANT_TRUE);
1767     ok(hr == S_OK, "got %08x\n", hr);
1768
1769     b = VARIANT_FALSE;
1770     hr = IMXWriter_get_standalone(writer, &b);
1771     ok(hr == S_OK, "got %08x\n", hr);
1772     ok(b == VARIANT_TRUE, "got %d\n", b);
1773
1774     hr = IMXWriter_get_encoding(writer, NULL);
1775     ok(hr == E_POINTER, "got %08x\n", hr);
1776
1777     /* UTF-16 is a default setting apparently */
1778     str = (void*)0xdeadbeef;
1779     hr = IMXWriter_get_encoding(writer, &str);
1780     ok(hr == S_OK, "got %08x\n", hr);
1781     ok(lstrcmpW(str, utf16W) == 0, "expected empty string, got %s\n", wine_dbgstr_w(str));
1782
1783     str2 = (void*)0xdeadbeef;
1784     hr = IMXWriter_get_encoding(writer, &str2);
1785     ok(hr == S_OK, "got %08x\n", hr);
1786     ok(str != str2, "expected newly allocated, got same %p\n", str);
1787
1788     SysFreeString(str2);
1789     SysFreeString(str);
1790
1791     /* put empty string */
1792     str = SysAllocString(emptyW);
1793     hr = IMXWriter_put_encoding(writer, str);
1794     ok(hr == E_INVALIDARG, "got %08x\n", hr);
1795     SysFreeString(str);
1796
1797     str = (void*)0xdeadbeef;
1798     hr = IMXWriter_get_encoding(writer, &str);
1799     ok(hr == S_OK, "got %08x\n", hr);
1800     ok(!lstrcmpW(str, emptyW) == 0, "expected empty string, got %s\n", wine_dbgstr_w(str));
1801     SysFreeString(str);
1802
1803     /* invalid encoding name */
1804     str = SysAllocString(testW);
1805     hr = IMXWriter_put_encoding(writer, str);
1806     ok(hr == E_INVALIDARG, "got %08x\n", hr);
1807     SysFreeString(str);
1808
1809     hr = IMXWriter_get_version(writer, NULL);
1810     ok(hr == E_POINTER, "got %08x\n", hr);
1811     /* default version is 'surprisingly' 1.0 */
1812     hr = IMXWriter_get_version(writer, &str);
1813     ok(hr == S_OK, "got %08x\n", hr);
1814     ok(!lstrcmpW(str, _bstr_("1.0")), "got %s\n", wine_dbgstr_w(str));
1815     SysFreeString(str);
1816
1817     /* store version string as is */
1818     hr = IMXWriter_put_version(writer, NULL);
1819     ok(hr == E_INVALIDARG, "got %08x\n", hr);
1820
1821     hr = IMXWriter_put_version(writer, _bstr_("1.0"));
1822     ok(hr == S_OK, "got %08x\n", hr);
1823
1824     hr = IMXWriter_put_version(writer, _bstr_(""));
1825     ok(hr == S_OK, "got %08x\n", hr);
1826     hr = IMXWriter_get_version(writer, &str);
1827     ok(hr == S_OK, "got %08x\n", hr);
1828     ok(!lstrcmpW(str, _bstr_("")), "got %s\n", wine_dbgstr_w(str));
1829     SysFreeString(str);
1830
1831     hr = IMXWriter_put_version(writer, _bstr_("a.b"));
1832     ok(hr == S_OK, "got %08x\n", hr);
1833     hr = IMXWriter_get_version(writer, &str);
1834     ok(hr == S_OK, "got %08x\n", hr);
1835     ok(!lstrcmpW(str, _bstr_("a.b")), "got %s\n", wine_dbgstr_w(str));
1836     SysFreeString(str);
1837
1838     hr = IMXWriter_put_version(writer, _bstr_("2.0"));
1839     ok(hr == S_OK, "got %08x\n", hr);
1840     hr = IMXWriter_get_version(writer, &str);
1841     ok(hr == S_OK, "got %08x\n", hr);
1842     ok(!lstrcmpW(str, _bstr_("2.0")), "got %s\n", wine_dbgstr_w(str));
1843     SysFreeString(str);
1844
1845     IMXWriter_Release(writer);
1846     free_bstrs();
1847 }
1848
1849 static void test_mxwriter_flush(void)
1850 {
1851     ISAXContentHandler *content;
1852     IMXWriter *writer;
1853     LARGE_INTEGER pos;
1854     ULARGE_INTEGER pos2;
1855     IStream *stream;
1856     VARIANT dest;
1857     HRESULT hr;
1858
1859     hr = CoCreateInstance(&CLSID_MXXMLWriter, NULL, CLSCTX_INPROC_SERVER,
1860             &IID_IMXWriter, (void**)&writer);
1861     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
1862
1863     hr = CreateStreamOnHGlobal(NULL, TRUE, &stream);
1864     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
1865     EXPECT_REF(stream, 1);
1866
1867     /* detach when nothing was attached */
1868     V_VT(&dest) = VT_EMPTY;
1869     hr = IMXWriter_put_output(writer, dest);
1870     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
1871
1872     /* attach stream */
1873     V_VT(&dest) = VT_UNKNOWN;
1874     V_UNKNOWN(&dest) = (IUnknown*)stream;
1875     hr = IMXWriter_put_output(writer, dest);
1876     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
1877     todo_wine EXPECT_REF(stream, 3);
1878
1879     /* detach setting VT_EMPTY destination */
1880     V_VT(&dest) = VT_EMPTY;
1881     hr = IMXWriter_put_output(writer, dest);
1882     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
1883     EXPECT_REF(stream, 1);
1884
1885     V_VT(&dest) = VT_UNKNOWN;
1886     V_UNKNOWN(&dest) = (IUnknown*)stream;
1887     hr = IMXWriter_put_output(writer, dest);
1888     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
1889
1890     /* flush() doesn't detach a stream */
1891     hr = IMXWriter_flush(writer);
1892     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
1893     todo_wine EXPECT_REF(stream, 3);
1894
1895     pos.QuadPart = 0;
1896     hr = IStream_Seek(stream, pos, STREAM_SEEK_CUR, &pos2);
1897     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
1898     ok(pos2.QuadPart == 0, "expected stream beginning\n");
1899
1900     hr = IMXWriter_QueryInterface(writer, &IID_ISAXContentHandler, (void**)&content);
1901     ok(hr == S_OK, "got %08x\n", hr);
1902
1903     hr = ISAXContentHandler_startDocument(content);
1904     ok(hr == S_OK, "got %08x\n", hr);
1905
1906     pos.QuadPart = 0;
1907     hr = IStream_Seek(stream, pos, STREAM_SEEK_CUR, &pos2);
1908     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
1909     ok(pos2.QuadPart != 0, "expected stream beginning\n");
1910
1911     /* already started */
1912     hr = ISAXContentHandler_startDocument(content);
1913     ok(hr == S_OK, "got %08x\n", hr);
1914
1915     hr = ISAXContentHandler_endDocument(content);
1916     ok(hr == S_OK, "got %08x\n", hr);
1917
1918     /* flushed on endDocument() */
1919     pos.QuadPart = 0;
1920     hr = IStream_Seek(stream, pos, STREAM_SEEK_CUR, &pos2);
1921     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
1922     ok(pos2.QuadPart != 0, "expected stream position moved\n");
1923
1924     ISAXContentHandler_Release(content);
1925     IStream_Release(stream);
1926     IMXWriter_Release(writer);
1927 }
1928
1929 static void test_mxwriter_startenddocument(void)
1930 {
1931     ISAXContentHandler *content;
1932     IMXWriter *writer;
1933     VARIANT dest;
1934     HRESULT hr;
1935
1936     hr = CoCreateInstance(&CLSID_MXXMLWriter, NULL, CLSCTX_INPROC_SERVER,
1937             &IID_IMXWriter, (void**)&writer);
1938     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
1939
1940     hr = IMXWriter_QueryInterface(writer, &IID_ISAXContentHandler, (void**)&content);
1941     ok(hr == S_OK, "got %08x\n", hr);
1942
1943     hr = ISAXContentHandler_startDocument(content);
1944     ok(hr == S_OK, "got %08x\n", hr);
1945
1946     hr = ISAXContentHandler_endDocument(content);
1947     ok(hr == S_OK, "got %08x\n", hr);
1948
1949     V_VT(&dest) = VT_EMPTY;
1950     hr = IMXWriter_get_output(writer, &dest);
1951     ok(hr == S_OK, "got %08x\n", hr);
1952     ok(V_VT(&dest) == VT_BSTR, "got %d\n", V_VT(&dest));
1953     ok(!lstrcmpW(_bstr_("<?xml version=\"1.0\" encoding=\"UTF-16\" standalone=\"no\"?>\r\n"), V_BSTR(&dest)),
1954         "got wrong content %s\n", wine_dbgstr_w(V_BSTR(&dest)));
1955     VariantClear(&dest);
1956
1957     /* now try another startDocument */
1958     hr = ISAXContentHandler_startDocument(content);
1959     ok(hr == S_OK, "got %08x\n", hr);
1960     /* and get duplicated prolog */
1961     V_VT(&dest) = VT_EMPTY;
1962     hr = IMXWriter_get_output(writer, &dest);
1963     ok(hr == S_OK, "got %08x\n", hr);
1964     ok(V_VT(&dest) == VT_BSTR, "got %d\n", V_VT(&dest));
1965     ok(!lstrcmpW(_bstr_("<?xml version=\"1.0\" encoding=\"UTF-16\" standalone=\"no\"?>\r\n"
1966                         "<?xml version=\"1.0\" encoding=\"UTF-16\" standalone=\"no\"?>\r\n"), V_BSTR(&dest)),
1967         "got wrong content %s\n", wine_dbgstr_w(V_BSTR(&dest)));
1968     VariantClear(&dest);
1969
1970     ISAXContentHandler_Release(content);
1971     IMXWriter_Release(writer);
1972
1973     /* now with omitted declaration */
1974     hr = CoCreateInstance(&CLSID_MXXMLWriter, NULL, CLSCTX_INPROC_SERVER,
1975             &IID_IMXWriter, (void**)&writer);
1976     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
1977
1978     hr = IMXWriter_QueryInterface(writer, &IID_ISAXContentHandler, (void**)&content);
1979     ok(hr == S_OK, "got %08x\n", hr);
1980
1981     hr = IMXWriter_put_omitXMLDeclaration(writer, VARIANT_TRUE);
1982     ok(hr == S_OK, "got %08x\n", hr);
1983
1984     hr = ISAXContentHandler_startDocument(content);
1985     ok(hr == S_OK, "got %08x\n", hr);
1986
1987     hr = ISAXContentHandler_endDocument(content);
1988     ok(hr == S_OK, "got %08x\n", hr);
1989
1990     V_VT(&dest) = VT_EMPTY;
1991     hr = IMXWriter_get_output(writer, &dest);
1992     ok(hr == S_OK, "got %08x\n", hr);
1993     ok(V_VT(&dest) == VT_BSTR, "got %d\n", V_VT(&dest));
1994     ok(!lstrcmpW(_bstr_(""), V_BSTR(&dest)), "got wrong content %s\n", wine_dbgstr_w(V_BSTR(&dest)));
1995     VariantClear(&dest);
1996
1997     ISAXContentHandler_Release(content);
1998     IMXWriter_Release(writer);
1999
2000     free_bstrs();
2001 }
2002
2003 enum startendtype
2004 {
2005     StartElement,
2006     EndElement,
2007     StartEndElement
2008 };
2009
2010 struct writer_startendelement_t {
2011     const GUID *clsid;
2012     enum startendtype type;
2013     const char *uri;
2014     const char *local_name;
2015     const char *qname;
2016     const char *output;
2017     HRESULT hr;
2018     ISAXAttributes *attr;
2019 };
2020
2021 static const struct writer_startendelement_t writer_startendelement[] = {
2022     /* 0 */
2023     { &CLSID_MXXMLWriter,   StartElement, NULL, NULL, NULL, NULL, E_INVALIDARG },
2024     { &CLSID_MXXMLWriter30, StartElement, NULL, NULL, NULL, NULL, E_INVALIDARG },
2025     { &CLSID_MXXMLWriter40, StartElement, NULL, NULL, NULL, NULL, E_INVALIDARG },
2026     { &CLSID_MXXMLWriter60, StartElement, NULL, NULL, NULL, "<>", S_OK },
2027     { &CLSID_MXXMLWriter,   StartElement, "uri", NULL, NULL, NULL, E_INVALIDARG },
2028     /* 5 */
2029     { &CLSID_MXXMLWriter30, StartElement, "uri", NULL, NULL, NULL, E_INVALIDARG },
2030     { &CLSID_MXXMLWriter40, StartElement, "uri", NULL, NULL, NULL, E_INVALIDARG },
2031     { &CLSID_MXXMLWriter60, StartElement, "uri", NULL, NULL, "<>", S_OK },
2032     { &CLSID_MXXMLWriter,   StartElement, NULL, "local", NULL, NULL, E_INVALIDARG },
2033     { &CLSID_MXXMLWriter30, StartElement, NULL, "local", NULL, NULL, E_INVALIDARG },
2034     /* 10 */
2035     { &CLSID_MXXMLWriter40, StartElement, NULL, "local", NULL, NULL, E_INVALIDARG },
2036     { &CLSID_MXXMLWriter60, StartElement, NULL, "local", NULL, "<>", S_OK },
2037     { &CLSID_MXXMLWriter,   StartElement, NULL, NULL, "qname", NULL, E_INVALIDARG },
2038     { &CLSID_MXXMLWriter30, StartElement, NULL, NULL, "qname", NULL, E_INVALIDARG },
2039     { &CLSID_MXXMLWriter40, StartElement, NULL, NULL, "qname", NULL, E_INVALIDARG },
2040     /* 15 */
2041     { &CLSID_MXXMLWriter60, StartElement, NULL, NULL, "qname", "<qname>", S_OK },
2042     { &CLSID_MXXMLWriter,   StartElement, "uri", "local", "qname", "<qname>", S_OK },
2043     { &CLSID_MXXMLWriter30, StartElement, "uri", "local", "qname", "<qname>", S_OK },
2044     { &CLSID_MXXMLWriter40, StartElement, "uri", "local", "qname", "<qname>", S_OK },
2045     { &CLSID_MXXMLWriter60, StartElement, "uri", "local", "qname", "<qname>", S_OK },
2046     /* 20 */
2047     { &CLSID_MXXMLWriter,   StartElement, "uri", "local", NULL, NULL, E_INVALIDARG },
2048     { &CLSID_MXXMLWriter30, StartElement, "uri", "local", NULL, NULL, E_INVALIDARG },
2049     { &CLSID_MXXMLWriter40, StartElement, "uri", "local", NULL, NULL, E_INVALIDARG },
2050     { &CLSID_MXXMLWriter60, StartElement, "uri", "local", NULL, "<>", S_OK },
2051     { &CLSID_MXXMLWriter,   StartElement, "uri", "local", "uri:local", "<uri:local>", S_OK },
2052     /* 25 */
2053     { &CLSID_MXXMLWriter30, StartElement, "uri", "local", "uri:local", "<uri:local>", S_OK },
2054     { &CLSID_MXXMLWriter40, StartElement, "uri", "local", "uri:local", "<uri:local>", S_OK },
2055     { &CLSID_MXXMLWriter60, StartElement, "uri", "local", "uri:local", "<uri:local>", S_OK },
2056     { &CLSID_MXXMLWriter,   StartElement, "uri", "local", "uri:local2", "<uri:local2>", S_OK },
2057     { &CLSID_MXXMLWriter30, StartElement, "uri", "local", "uri:local2", "<uri:local2>", S_OK },
2058     /* 30 */
2059     { &CLSID_MXXMLWriter40, StartElement, "uri", "local", "uri:local2", "<uri:local2>", S_OK },
2060     { &CLSID_MXXMLWriter60, StartElement, "uri", "local", "uri:local2", "<uri:local2>", S_OK },
2061     /* endElement tests */
2062     { &CLSID_MXXMLWriter,   EndElement, NULL, NULL, NULL, NULL, E_INVALIDARG },
2063     { &CLSID_MXXMLWriter30, EndElement, NULL, NULL, NULL, NULL, E_INVALIDARG },
2064     { &CLSID_MXXMLWriter40, EndElement, NULL, NULL, NULL, NULL, E_INVALIDARG },
2065     /* 35 */
2066     { &CLSID_MXXMLWriter60, EndElement, NULL, NULL, NULL, "</>", S_OK },
2067     { &CLSID_MXXMLWriter,   EndElement, "uri", NULL, NULL, NULL, E_INVALIDARG },
2068     { &CLSID_MXXMLWriter30, EndElement, "uri", NULL, NULL, NULL, E_INVALIDARG },
2069     { &CLSID_MXXMLWriter40, EndElement, "uri", NULL, NULL, NULL, E_INVALIDARG },
2070     { &CLSID_MXXMLWriter60, EndElement, "uri", NULL, NULL, "</>", S_OK },
2071     /* 40 */
2072     { &CLSID_MXXMLWriter,   EndElement, NULL, "local", NULL, NULL, E_INVALIDARG },
2073     { &CLSID_MXXMLWriter30, EndElement, NULL, "local", NULL, NULL, E_INVALIDARG },
2074     { &CLSID_MXXMLWriter40, EndElement, NULL, "local", NULL, NULL, E_INVALIDARG },
2075     { &CLSID_MXXMLWriter60, EndElement, NULL, "local", NULL, "</>", S_OK },
2076     { &CLSID_MXXMLWriter,   EndElement, NULL, NULL, "qname", NULL, E_INVALIDARG },
2077     /* 45 */
2078     { &CLSID_MXXMLWriter30, EndElement, NULL, NULL, "qname", NULL, E_INVALIDARG },
2079     { &CLSID_MXXMLWriter40, EndElement, NULL, NULL, "qname", NULL, E_INVALIDARG },
2080     { &CLSID_MXXMLWriter60, EndElement, NULL, NULL, "qname", "</qname>", S_OK },
2081     { &CLSID_MXXMLWriter,   EndElement, "uri", "local", "qname", "</qname>", S_OK },
2082     { &CLSID_MXXMLWriter30, EndElement, "uri", "local", "qname", "</qname>", S_OK },
2083     /* 50 */
2084     { &CLSID_MXXMLWriter40, EndElement, "uri", "local", "qname", "</qname>", S_OK },
2085     { &CLSID_MXXMLWriter60, EndElement, "uri", "local", "qname", "</qname>", S_OK },
2086     { &CLSID_MXXMLWriter,   EndElement, "uri", "local", NULL, NULL, E_INVALIDARG },
2087     { &CLSID_MXXMLWriter30, EndElement, "uri", "local", NULL, NULL, E_INVALIDARG },
2088     { &CLSID_MXXMLWriter40, EndElement, "uri", "local", NULL, NULL, E_INVALIDARG },
2089     /* 55 */
2090     { &CLSID_MXXMLWriter60, EndElement, "uri", "local", NULL, "</>", S_OK },
2091     { &CLSID_MXXMLWriter,   EndElement, "uri", "local", "uri:local", "</uri:local>", S_OK },
2092     { &CLSID_MXXMLWriter30, EndElement, "uri", "local", "uri:local", "</uri:local>", S_OK },
2093     { &CLSID_MXXMLWriter40, EndElement, "uri", "local", "uri:local", "</uri:local>", S_OK },
2094     { &CLSID_MXXMLWriter60, EndElement, "uri", "local", "uri:local", "</uri:local>", S_OK },
2095     /* 60 */
2096     { &CLSID_MXXMLWriter,   EndElement, "uri", "local", "uri:local2", "</uri:local2>", S_OK },
2097     { &CLSID_MXXMLWriter30, EndElement, "uri", "local", "uri:local2", "</uri:local2>", S_OK },
2098     { &CLSID_MXXMLWriter40, EndElement, "uri", "local", "uri:local2", "</uri:local2>", S_OK },
2099     { &CLSID_MXXMLWriter60, EndElement, "uri", "local", "uri:local2", "</uri:local2>", S_OK },
2100
2101     /* with attributes */
2102     { &CLSID_MXXMLWriter,   StartElement, "uri", "local", "uri:local", "<uri:local a:attr1=\"a1\" attr2=\"a2\">", S_OK, &saxattributes },
2103     /* 65 */
2104     { &CLSID_MXXMLWriter30, StartElement, "uri", "local", "uri:local", "<uri:local a:attr1=\"a1\" attr2=\"a2\">", S_OK, &saxattributes },
2105     { &CLSID_MXXMLWriter40, StartElement, "uri", "local", "uri:local", "<uri:local a:attr1=\"a1\" attr2=\"a2\">", S_OK, &saxattributes },
2106     { &CLSID_MXXMLWriter60, StartElement, "uri", "local", "uri:local", "<uri:local a:attr1=\"a1\" attr2=\"a2\">", S_OK, &saxattributes },
2107     /* empty elements */
2108     { &CLSID_MXXMLWriter,   StartEndElement, "uri", "local", "uri:local", "<uri:local a:attr1=\"a1\" attr2=\"a2\"/>", S_OK, &saxattributes },
2109     { &CLSID_MXXMLWriter30, StartEndElement, "uri", "local", "uri:local", "<uri:local a:attr1=\"a1\" attr2=\"a2\"/>", S_OK, &saxattributes },
2110     /* 70 */
2111     { &CLSID_MXXMLWriter40, StartEndElement, "uri", "local", "uri:local", "<uri:local a:attr1=\"a1\" attr2=\"a2\"/>", S_OK, &saxattributes },
2112     { &CLSID_MXXMLWriter60, StartEndElement, "uri", "local", "uri:local", "<uri:local a:attr1=\"a1\" attr2=\"a2\"/>", S_OK, &saxattributes },
2113     { &CLSID_MXXMLWriter,   StartEndElement, "", "", "", "</>", S_OK },
2114     { &CLSID_MXXMLWriter30, StartEndElement, "", "", "", "</>", S_OK },
2115     { &CLSID_MXXMLWriter40, StartEndElement, "", "", "", "</>", S_OK },
2116     /* 75 */
2117     { &CLSID_MXXMLWriter60, StartEndElement, "", "", "", "</>", S_OK },
2118     { NULL }
2119 };
2120
2121 static void get_supported_mxwriter_data(struct msxmlsupported_data_t *table)
2122 {
2123     while (table->clsid)
2124     {
2125         IMXWriter *writer;
2126         HRESULT hr;
2127
2128         hr = CoCreateInstance(table->clsid, NULL, CLSCTX_INPROC_SERVER,
2129             &IID_IMXWriter, (void**)&writer);
2130         if (hr == S_OK) IMXWriter_Release(writer);
2131
2132         table->supported = hr == S_OK;
2133         if (hr != S_OK) win_skip("class %s not supported\n", table->name);
2134
2135         table++;
2136     }
2137 }
2138
2139 static void test_mxwriter_startendelement_batch(const struct writer_startendelement_t *table)
2140 {
2141     int i = 0;
2142
2143     while (table->clsid)
2144     {
2145         ISAXContentHandler *content;
2146         IMXWriter *writer;
2147         HRESULT hr;
2148
2149         if (!is_mxwriter_supported(table->clsid, msxmlsupported_data))
2150         {
2151             table++;
2152             i++;
2153             continue;
2154         }
2155
2156         hr = CoCreateInstance(table->clsid, NULL, CLSCTX_INPROC_SERVER,
2157             &IID_IMXWriter, (void**)&writer);
2158         EXPECT_HR(hr, S_OK);
2159
2160         hr = IMXWriter_QueryInterface(writer, &IID_ISAXContentHandler, (void**)&content);
2161         EXPECT_HR(hr, S_OK);
2162
2163         hr = IMXWriter_put_omitXMLDeclaration(writer, VARIANT_TRUE);
2164         EXPECT_HR(hr, S_OK);
2165
2166         hr = ISAXContentHandler_startDocument(content);
2167         EXPECT_HR(hr, S_OK);
2168
2169         if (table->type == StartElement)
2170         {
2171             hr = ISAXContentHandler_startElement(content, _bstr_(table->uri), lstrlen(table->uri),
2172                 _bstr_(table->local_name), lstrlen(table->local_name), _bstr_(table->qname), lstrlen(table->qname), table->attr);
2173             ok(hr == table->hr, "test %d: got 0x%08x, expected 0x%08x\n", i, hr, table->hr);
2174         }
2175         else if (table->type == EndElement)
2176         {
2177             hr = ISAXContentHandler_endElement(content, _bstr_(table->uri), lstrlen(table->uri),
2178                 _bstr_(table->local_name), lstrlen(table->local_name), _bstr_(table->qname), lstrlen(table->qname));
2179             ok(hr == table->hr, "test %d: got 0x%08x, expected 0x%08x\n", i, hr, table->hr);
2180         }
2181         else
2182         {
2183             hr = ISAXContentHandler_startElement(content, _bstr_(table->uri), lstrlen(table->uri),
2184                 _bstr_(table->local_name), lstrlen(table->local_name), _bstr_(table->qname), lstrlen(table->qname), table->attr);
2185             ok(hr == table->hr, "test %d: got 0x%08x, expected 0x%08x\n", i, hr, table->hr);
2186             hr = ISAXContentHandler_endElement(content, _bstr_(table->uri), lstrlen(table->uri),
2187                 _bstr_(table->local_name), lstrlen(table->local_name), _bstr_(table->qname), lstrlen(table->qname));
2188             ok(hr == table->hr, "test %d: got 0x%08x, expected 0x%08x\n", i, hr, table->hr);
2189         }
2190
2191         /* test output */
2192         if (hr == S_OK)
2193         {
2194             VARIANT dest;
2195
2196             V_VT(&dest) = VT_EMPTY;
2197             hr = IMXWriter_get_output(writer, &dest);
2198             EXPECT_HR(hr, S_OK);
2199             ok(V_VT(&dest) == VT_BSTR, "got %d\n", V_VT(&dest));
2200             ok(!lstrcmpW(_bstr_(table->output), V_BSTR(&dest)),
2201                 "test %d: got wrong content %s, expected %s\n", i, wine_dbgstr_w(V_BSTR(&dest)), table->output);
2202             VariantClear(&dest);
2203         }
2204
2205         ISAXContentHandler_Release(content);
2206         IMXWriter_Release(writer);
2207
2208         table++;
2209         i++;
2210     }
2211
2212     free_bstrs();
2213 }
2214
2215 static void test_mxwriter_startendelement(void)
2216 {
2217     ISAXContentHandler *content;
2218     IMXWriter *writer;
2219     VARIANT dest;
2220     HRESULT hr;
2221
2222     test_mxwriter_startendelement_batch(writer_startendelement);
2223
2224     hr = CoCreateInstance(&CLSID_MXXMLWriter, NULL, CLSCTX_INPROC_SERVER,
2225             &IID_IMXWriter, (void**)&writer);
2226     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
2227
2228     hr = IMXWriter_QueryInterface(writer, &IID_ISAXContentHandler, (void**)&content);
2229     ok(hr == S_OK, "got %08x\n", hr);
2230
2231     hr = IMXWriter_put_omitXMLDeclaration(writer, VARIANT_TRUE);
2232     ok(hr == S_OK, "got %08x\n", hr);
2233
2234     hr = ISAXContentHandler_startDocument(content);
2235     ok(hr == S_OK, "got %08x\n", hr);
2236
2237     /* all string pointers should be not null */
2238     hr = ISAXContentHandler_startElement(content, _bstr_(""), 0, _bstr_("b"), 1, _bstr_(""), 0, NULL);
2239     ok(hr == S_OK, "got %08x\n", hr);
2240
2241     V_VT(&dest) = VT_EMPTY;
2242     hr = IMXWriter_get_output(writer, &dest);
2243     ok(hr == S_OK, "got %08x\n", hr);
2244     ok(V_VT(&dest) == VT_BSTR, "got %d\n", V_VT(&dest));
2245     ok(!lstrcmpW(_bstr_("<>"), V_BSTR(&dest)), "got wrong content %s\n", wine_dbgstr_w(V_BSTR(&dest)));
2246     VariantClear(&dest);
2247
2248     hr = ISAXContentHandler_startElement(content, _bstr_(""), 0, _bstr_(""), 0, _bstr_("b"), 1, NULL);
2249     ok(hr == S_OK, "got %08x\n", hr);
2250
2251     V_VT(&dest) = VT_EMPTY;
2252     hr = IMXWriter_get_output(writer, &dest);
2253     ok(hr == S_OK, "got %08x\n", hr);
2254     ok(V_VT(&dest) == VT_BSTR, "got %d\n", V_VT(&dest));
2255     ok(!lstrcmpW(_bstr_("<><b>"), V_BSTR(&dest)), "got wrong content %s\n", wine_dbgstr_w(V_BSTR(&dest)));
2256     VariantClear(&dest);
2257
2258     hr = ISAXContentHandler_endElement(content, NULL, 0, NULL, 0, _bstr_("a:b"), 3);
2259     EXPECT_HR(hr, E_INVALIDARG);
2260
2261     hr = ISAXContentHandler_endElement(content, NULL, 0, _bstr_("b"), 1, _bstr_("a:b"), 3);
2262     EXPECT_HR(hr, E_INVALIDARG);
2263
2264     /* only local name is an error too */
2265     hr = ISAXContentHandler_endElement(content, NULL, 0, _bstr_("b"), 1, NULL, 0);
2266     EXPECT_HR(hr, E_INVALIDARG);
2267
2268     hr = ISAXContentHandler_endElement(content, _bstr_(""), 0, _bstr_(""), 0, _bstr_("b"), 1);
2269     EXPECT_HR(hr, S_OK);
2270
2271     V_VT(&dest) = VT_EMPTY;
2272     hr = IMXWriter_get_output(writer, &dest);
2273     EXPECT_HR(hr, S_OK);
2274     ok(V_VT(&dest) == VT_BSTR, "got %d\n", V_VT(&dest));
2275     ok(!lstrcmpW(_bstr_("<><b></b>"), V_BSTR(&dest)), "got wrong content %s\n", wine_dbgstr_w(V_BSTR(&dest)));
2276     VariantClear(&dest);
2277
2278     hr = ISAXContentHandler_endDocument(content);
2279     EXPECT_HR(hr, S_OK);
2280
2281     V_VT(&dest) = VT_EMPTY;
2282     hr = IMXWriter_put_output(writer, dest);
2283     EXPECT_HR(hr, S_OK);
2284
2285     hr = ISAXContentHandler_startDocument(content);
2286     EXPECT_HR(hr, S_OK);
2287
2288     hr = ISAXContentHandler_startElement(content, _bstr_(""), 0, _bstr_(""), 0, _bstr_("abcdef"), 3, NULL);
2289     EXPECT_HR(hr, S_OK);
2290
2291     V_VT(&dest) = VT_EMPTY;
2292     hr = IMXWriter_get_output(writer, &dest);
2293     EXPECT_HR(hr, S_OK);
2294     ok(V_VT(&dest) == VT_BSTR, "got %d\n", V_VT(&dest));
2295     ok(!lstrcmpW(_bstr_("<abc>"), V_BSTR(&dest)), "got wrong content %s\n", wine_dbgstr_w(V_BSTR(&dest)));
2296     VariantClear(&dest);
2297
2298     ISAXContentHandler_endDocument(content);
2299     IMXWriter_flush(writer);
2300
2301     hr = ISAXContentHandler_endElement(content, _bstr_(""), 0, _bstr_(""), 0, _bstr_("abdcdef"), 3);
2302     EXPECT_HR(hr, S_OK);
2303     V_VT(&dest) = VT_EMPTY;
2304     hr = IMXWriter_get_output(writer, &dest);
2305     EXPECT_HR(hr, S_OK);
2306     ok(V_VT(&dest) == VT_BSTR, "got %d\n", V_VT(&dest));
2307     ok(!lstrcmpW(_bstr_("<abc></abd>"), V_BSTR(&dest)), "got wrong content %s\n", wine_dbgstr_w(V_BSTR(&dest)));
2308     VariantClear(&dest);
2309
2310     ISAXContentHandler_Release(content);
2311     IMXWriter_Release(writer);
2312     free_bstrs();
2313 }
2314
2315 static void test_mxwriter_characters(void)
2316 {
2317     static const WCHAR chardataW[] = {'T','E','S','T','C','H','A','R','D','A','T','A',' ','.',0};
2318     ISAXContentHandler *content;
2319     IMXWriter *writer;
2320     VARIANT dest;
2321     HRESULT hr;
2322
2323     hr = CoCreateInstance(&CLSID_MXXMLWriter, NULL, CLSCTX_INPROC_SERVER,
2324             &IID_IMXWriter, (void**)&writer);
2325     EXPECT_HR(hr, S_OK);
2326
2327     hr = IMXWriter_QueryInterface(writer, &IID_ISAXContentHandler, (void**)&content);
2328     EXPECT_HR(hr, S_OK);
2329
2330     hr = IMXWriter_put_omitXMLDeclaration(writer, VARIANT_TRUE);
2331     EXPECT_HR(hr, S_OK);
2332
2333     hr = ISAXContentHandler_startDocument(content);
2334     EXPECT_HR(hr, S_OK);
2335
2336     hr = ISAXContentHandler_characters(content, NULL, 0);
2337     EXPECT_HR(hr, E_INVALIDARG);
2338
2339     hr = ISAXContentHandler_characters(content, chardataW, 0);
2340     EXPECT_HR(hr, S_OK);
2341
2342     hr = ISAXContentHandler_characters(content, chardataW, sizeof(chardataW)/sizeof(WCHAR) - 1);
2343     EXPECT_HR(hr, S_OK);
2344
2345     V_VT(&dest) = VT_EMPTY;
2346     hr = IMXWriter_get_output(writer, &dest);
2347     EXPECT_HR(hr, S_OK);
2348     ok(V_VT(&dest) == VT_BSTR, "got %d\n", V_VT(&dest));
2349     ok(!lstrcmpW(_bstr_("TESTCHARDATA ."), V_BSTR(&dest)), "got wrong content %s\n", wine_dbgstr_w(V_BSTR(&dest)));
2350     VariantClear(&dest);
2351
2352     hr = ISAXContentHandler_endDocument(content);
2353     EXPECT_HR(hr, S_OK);
2354
2355     ISAXContentHandler_Release(content);
2356     IMXWriter_Release(writer);
2357
2358     /* try empty characters data to see if element is closed */
2359     hr = CoCreateInstance(&CLSID_MXXMLWriter, NULL, CLSCTX_INPROC_SERVER,
2360             &IID_IMXWriter, (void**)&writer);
2361     EXPECT_HR(hr, S_OK);
2362
2363     hr = IMXWriter_QueryInterface(writer, &IID_ISAXContentHandler, (void**)&content);
2364     EXPECT_HR(hr, S_OK);
2365
2366     hr = IMXWriter_put_omitXMLDeclaration(writer, VARIANT_TRUE);
2367     EXPECT_HR(hr, S_OK);
2368
2369     hr = ISAXContentHandler_startDocument(content);
2370     EXPECT_HR(hr, S_OK);
2371
2372     hr = ISAXContentHandler_startElement(content, _bstr_(""), 0, _bstr_(""), 0, _bstr_("a"), 1, NULL);
2373     EXPECT_HR(hr, S_OK);
2374
2375     hr = ISAXContentHandler_characters(content, chardataW, 0);
2376     EXPECT_HR(hr, S_OK);
2377
2378     hr = ISAXContentHandler_endElement(content, _bstr_(""), 0, _bstr_(""), 0, _bstr_("a"), 1);
2379     EXPECT_HR(hr, S_OK);
2380
2381     V_VT(&dest) = VT_EMPTY;
2382     hr = IMXWriter_get_output(writer, &dest);
2383     EXPECT_HR(hr, S_OK);
2384     ok(V_VT(&dest) == VT_BSTR, "got %d\n", V_VT(&dest));
2385     ok(!lstrcmpW(_bstr_("<a></a>"), V_BSTR(&dest)), "got wrong content %s\n", wine_dbgstr_w(V_BSTR(&dest)));
2386     VariantClear(&dest);
2387
2388     ISAXContentHandler_Release(content);
2389     IMXWriter_Release(writer);
2390
2391     free_bstrs();
2392 }
2393
2394 static const mxwriter_stream_test mxwriter_stream_tests[] = {
2395     {
2396         VARIANT_TRUE,"UTF-16",
2397         {
2398             {FALSE,(const BYTE*)szUtf16BOM,sizeof(szUtf16BOM),TRUE},
2399             {FALSE,(const BYTE*)szUtf16XML,sizeof(szUtf16XML)},
2400             {TRUE}
2401         }
2402     },
2403     {
2404         VARIANT_FALSE,"UTF-16",
2405         {
2406             {FALSE,(const BYTE*)szUtf16XML,sizeof(szUtf16XML)},
2407             {TRUE}
2408         }
2409     },
2410     {
2411         VARIANT_TRUE,"UTF-8",
2412         {
2413             {FALSE,(const BYTE*)szUtf8XML,sizeof(szUtf8XML)-1},
2414             /* For some reason Windows makes an empty write call when UTF-8 encoding is used
2415              * and the writer is released.
2416              */
2417             {FALSE,NULL,0},
2418             {TRUE}
2419         }
2420     },
2421     {
2422         VARIANT_TRUE,"UTF-16",
2423         {
2424             {FALSE,(const BYTE*)szUtf16BOM,sizeof(szUtf16BOM),TRUE},
2425             {FALSE,(const BYTE*)szUtf16XML,sizeof(szUtf16XML)},
2426             {TRUE}
2427         }
2428     },
2429     {
2430         VARIANT_TRUE,"UTF-16",
2431         {
2432             {FALSE,(const BYTE*)szUtf16BOM,sizeof(szUtf16BOM),TRUE,TRUE},
2433             {FALSE,(const BYTE*)szUtf16XML,sizeof(szUtf16XML)},
2434             {TRUE}
2435         }
2436     }
2437 };
2438
2439 static void test_mxwriter_stream(void)
2440 {
2441     IMXWriter *writer;
2442     ISAXContentHandler *content;
2443     HRESULT hr;
2444     VARIANT dest;
2445     IStream *stream;
2446     LARGE_INTEGER pos;
2447     ULARGE_INTEGER pos2;
2448     DWORD test_count = sizeof(mxwriter_stream_tests)/sizeof(mxwriter_stream_tests[0]);
2449
2450     for(current_stream_test_index = 0; current_stream_test_index < test_count; ++current_stream_test_index) {
2451         const mxwriter_stream_test *test = mxwriter_stream_tests+current_stream_test_index;
2452
2453         hr = CoCreateInstance(&CLSID_MXXMLWriter, NULL, CLSCTX_INPROC_SERVER,
2454                 &IID_IMXWriter, (void**)&writer);
2455         ok(hr == S_OK, "CoCreateInstance failed: %08x\n", hr);
2456
2457         hr = IMXWriter_QueryInterface(writer, &IID_ISAXContentHandler, (void**)&content);
2458         ok(hr == S_OK, "QueryInterface(ISAXContentHandler) failed: %08x\n", hr);
2459
2460         hr = IMXWriter_put_encoding(writer, _bstr_(test->encoding));
2461         ok(hr == S_OK, "put_encoding failed with %08x on test %d\n", hr, current_stream_test_index);
2462
2463         V_VT(&dest) = VT_UNKNOWN;
2464         V_UNKNOWN(&dest) = (IUnknown*)&mxstream;
2465         hr = IMXWriter_put_output(writer, dest);
2466         ok(hr == S_OK, "put_output failed with %08x on test %d\n", hr, current_stream_test_index);
2467         VariantClear(&dest);
2468
2469         hr = IMXWriter_put_byteOrderMark(writer, test->bom);
2470         ok(hr == S_OK, "put_byteOrderMark failed with %08x on test %d\n", hr, current_stream_test_index);
2471
2472         current_write_test = test->expected_writes;
2473
2474         hr = ISAXContentHandler_startDocument(content);
2475         ok(hr == S_OK, "startDocument failed with %08x on test %d\n", hr, current_stream_test_index);
2476
2477         hr = ISAXContentHandler_endDocument(content);
2478         ok(hr == S_OK, "endDocument failed with %08x on test %d\n", hr, current_stream_test_index);
2479
2480         ISAXContentHandler_Release(content);
2481         IMXWriter_Release(writer);
2482
2483         ok(current_write_test->last, "The last %d write calls on test %d were missed\n",
2484             (int)(current_write_test-test->expected_writes), current_stream_test_index);
2485     }
2486
2487     hr = CoCreateInstance(&CLSID_MXXMLWriter, NULL, CLSCTX_INPROC_SERVER,
2488             &IID_IMXWriter, (void**)&writer);
2489     ok(hr == S_OK, "CoCreateInstance failed: %08x\n", hr);
2490
2491     hr = CreateStreamOnHGlobal(NULL, TRUE, &stream);
2492     ok(hr == S_OK, "CreateStreamOnHGlobal failed: %08x\n", hr);
2493
2494     hr = IMXWriter_QueryInterface(writer, &IID_ISAXContentHandler, (void**)&content);
2495     ok(hr == S_OK, "QueryInterface(ISAXContentHandler) failed: %08x\n", hr);
2496
2497     hr = IMXWriter_put_encoding(writer, _bstr_("UTF-8"));
2498     ok(hr == S_OK, "put_encoding failed: %08x\n", hr);
2499
2500     V_VT(&dest) = VT_UNKNOWN;
2501     V_UNKNOWN(&dest) = (IUnknown*)stream;
2502     hr = IMXWriter_put_output(writer, dest);
2503     ok(hr == S_OK, "put_output failed: %08x\n", hr);
2504
2505     hr = ISAXContentHandler_startDocument(content);
2506     ok(hr == S_OK, "startDocument failed: %08x\n", hr);
2507
2508     /* Setting output of the mxwriter causes the current output to be flushed,
2509      * and the writer to start over.
2510      */
2511     V_VT(&dest) = VT_EMPTY;
2512     hr = IMXWriter_put_output(writer, dest);
2513     ok(hr == S_OK, "put_output failed: %08x\n", hr);
2514
2515     pos.QuadPart = 0;
2516     hr = IStream_Seek(stream, pos, STREAM_SEEK_CUR, &pos2);
2517     ok(hr == S_OK, "Seek failed: %08x\n", hr);
2518     ok(pos2.QuadPart != 0, "expected stream position moved\n");
2519
2520     hr = ISAXContentHandler_startDocument(content);
2521     ok(hr == S_OK, "startDocument failed: %08x\n", hr);
2522
2523     hr = ISAXContentHandler_endDocument(content);
2524     ok(hr == S_OK, "endDocument failed: %08x\n", hr);
2525
2526     V_VT(&dest) = VT_EMPTY;
2527     hr = IMXWriter_get_output(writer, &dest);
2528     ok(hr == S_OK, "get_output failed: %08x\n", hr);
2529     ok(V_VT(&dest) == VT_BSTR, "Expected VT_BSTR, got %d\n", V_VT(&dest));
2530     ok(!lstrcmpW(_bstr_("<?xml version=\"1.0\" encoding=\"UTF-16\" standalone=\"no\"?>\r\n"), V_BSTR(&dest)),
2531             "Got wrong content: %s\n", wine_dbgstr_w(V_BSTR(&dest)));
2532     VariantClear(&dest);
2533
2534     ISAXContentHandler_Release(content);
2535     IMXWriter_Release(writer);
2536
2537     free_bstrs();
2538 }
2539
2540 static void test_mxwriter_encoding(void)
2541 {
2542     IMXWriter *writer;
2543     ISAXContentHandler *content;
2544     HRESULT hr;
2545     VARIANT dest;
2546
2547     hr = CoCreateInstance(&CLSID_MXXMLWriter, NULL, CLSCTX_INPROC_SERVER,
2548             &IID_IMXWriter, (void**)&writer);
2549     ok(hr == S_OK, "CoCreateInstance failed: %08x\n", hr);
2550
2551     hr = IMXWriter_QueryInterface(writer, &IID_ISAXContentHandler, (void**)&content);
2552     ok(hr == S_OK, "QueryInterface(ISAXContentHandler) failed: %08x\n", hr);
2553
2554     hr = IMXWriter_put_encoding(writer, _bstr_("UTF-8"));
2555     ok(hr == S_OK, "put_encoding failed: %08x\n", hr);
2556
2557     hr = ISAXContentHandler_startDocument(content);
2558     ok(hr == S_OK, "startDocument failed: %08x\n", hr);
2559
2560     hr = ISAXContentHandler_endDocument(content);
2561     ok(hr == S_OK, "endDocument failed: %08x\n", hr);
2562
2563     /* The content is always re-encoded to UTF-16 when the output is
2564      * retrieved as a BSTR.
2565      */
2566     V_VT(&dest) = VT_EMPTY;
2567     hr = IMXWriter_get_output(writer, &dest);
2568     todo_wine ok(hr == S_OK, "get_output failed: %08x\n", hr);
2569     todo_wine ok(V_VT(&dest) == VT_BSTR, "Expected VT_BSTR, got %d\n", V_VT(&dest));
2570     if (V_VT(&dest) == VT_BSTR) todo_wine ok(!lstrcmpW(_bstr_("<?xml version=\"1.0\" encoding=\"UTF-16\" standalone=\"no\"?>\r\n"), V_BSTR(&dest)),
2571             "got wrong content: %s\n", wine_dbgstr_w(V_BSTR(&dest)));
2572     VariantClear(&dest);
2573
2574     ISAXContentHandler_Release(content);
2575     IMXWriter_Release(writer);
2576
2577     free_bstrs();
2578 }
2579
2580 START_TEST(saxreader)
2581 {
2582     ISAXXMLReader *reader;
2583     HRESULT hr;
2584
2585     hr = CoInitialize(NULL);
2586     ok(hr == S_OK, "failed to init com\n");
2587
2588     hr = CoCreateInstance(&CLSID_SAXXMLReader, NULL, CLSCTX_INPROC_SERVER,
2589             &IID_ISAXXMLReader, (void**)&reader);
2590
2591     if(FAILED(hr))
2592     {
2593         skip("Failed to create SAXXMLReader instance\n");
2594         CoUninitialize();
2595         return;
2596     }
2597     ISAXXMLReader_Release(reader);
2598
2599     test_saxreader(0);
2600     test_saxreader(3);
2601     test_saxreader(6);
2602     test_saxreader_properties();
2603     test_saxreader_features();
2604     test_encoding();
2605
2606     /* MXXMLWriter tests */
2607     get_supported_mxwriter_data(msxmlsupported_data);
2608     if (is_mxwriter_supported(&CLSID_MXXMLWriter, msxmlsupported_data))
2609     {
2610         test_mxwriter_contenthandler();
2611         test_mxwriter_startenddocument();
2612         test_mxwriter_startendelement();
2613         test_mxwriter_characters();
2614         test_mxwriter_properties();
2615         test_mxwriter_flush();
2616         test_mxwriter_stream();
2617         test_mxwriter_encoding();
2618     }
2619     else
2620         win_skip("MXXMLWriter not supported\n");
2621
2622     CoUninitialize();
2623 }