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