dlls/xmllite/tests/writer.c

   1 /*
   2  * XMLLite IXmlWriter tests
   3  *
   4  * Copyright 2011 (C) Alistair Leslie-Hughes
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20 #define COBJMACROS
  21
  22 #include <stdarg.h>
  23 #include <stdio.h>
  24
  25 #include "windef.h"
  26 #include "winbase.h"
  27 #include "ole2.h"
  28 #include "xmllite.h"
  29 #include "wine/test.h"
  30
  31 #include "initguid.h"
  32 DEFINE_GUID(IID_IXmlWriterOutput, 0xc1131708, 0x0f59, 0x477f, 0x93, 0x59, 0x7d, 0x33, 0x24, 0x51, 0xbc, 0x1a);
  33
  34 static HRESULT (WINAPI *pCreateXmlWriter)(REFIID riid, void **ppvObject, IMalloc *pMalloc);
  35 static HRESULT (WINAPI *pCreateXmlWriterOutputWithEncodingName)(IUnknown *stream,
  36                                                                 IMalloc *imalloc,
  37                                                                 LPCWSTR encoding_name,
  38                                                                 IXmlWriterOutput **output);
  39 static HRESULT (WINAPI *pCreateXmlWriterOutputWithEncodingCodePage)(IUnknown *stream,
  40                                                                     IMalloc *imalloc,
  41                                                                     UINT codepage,
  42                                                                     IXmlWriterOutput **output);
  43
  44 static HRESULT WINAPI testoutput_QueryInterface(IUnknown *iface, REFIID riid, void **obj)
  45 {
  46     if (IsEqualGUID(riid, &IID_IUnknown)) {
  47         *obj = iface;
  48         return S_OK;
  49     }
  50     else {
  51         ok(0, "unknown riid=%s\n", wine_dbgstr_guid(riid));
  52         return E_NOINTERFACE;
  53     }
  54 }
  55
  56 static ULONG WINAPI testoutput_AddRef(IUnknown *iface)
  57 {
  58     return 2;
  59 }
  60
  61 static ULONG WINAPI testoutput_Release(IUnknown *iface)
  62 {
  63     return 1;
  64 }
  65
  66 static const IUnknownVtbl testoutputvtbl = {
  67     testoutput_QueryInterface,
  68     testoutput_AddRef,
  69     testoutput_Release
  70 };
  71
  72 static IUnknown testoutput = { &testoutputvtbl };
  73
  74 static HRESULT WINAPI teststream_QueryInterface(ISequentialStream *iface, REFIID riid, void **obj)
  75 {
  76     if (IsEqualIID(riid, &IID_IUnknown) || IsEqualIID(riid, &IID_ISequentialStream))
  77     {
  78         *obj = iface;
  79         return S_OK;
  80     }
  81
  82     *obj = NULL;
  83     return E_NOINTERFACE;
  84 }
  85
  86 static ULONG WINAPI teststream_AddRef(ISequentialStream *iface)
  87 {
  88     return 2;
  89 }
  90
  91 static ULONG WINAPI teststream_Release(ISequentialStream *iface)
  92 {
  93     return 1;
  94 }
  95
  96 static HRESULT WINAPI teststream_Read(ISequentialStream *iface, void *pv, ULONG cb, ULONG *pread)
  97 {
  98     ok(0, "unexpected call\n");
  99     return E_NOTIMPL;
 100 }
 101
 102 static ULONG g_write_len;
 103 static HRESULT WINAPI teststream_Write(ISequentialStream *iface, const void *pv, ULONG cb, ULONG *written)
 104 {
 105     g_write_len = cb;
 106     *written = cb;
 107     return S_OK;
 108 }
 109
 110 static const ISequentialStreamVtbl teststreamvtbl =
 111 {
 112     teststream_QueryInterface,
 113     teststream_AddRef,
 114     teststream_Release,
 115     teststream_Read,
 116     teststream_Write
 117 };
 118
 119 static ISequentialStream teststream = { &teststreamvtbl };
 120
 121 static void test_writer_create(void)
 122 {
 123     HRESULT hr;
 124     IXmlWriter *writer;
 125     LONG_PTR value;
 126
 127     /* crashes native */
 128     if (0)
 129     {
 130         pCreateXmlWriter(&IID_IXmlWriter, NULL, NULL);
 131         pCreateXmlWriter(NULL, (void**)&writer, NULL);
 132     }
 133
 134     hr = pCreateXmlWriter(&IID_IXmlWriter, (void**)&writer, NULL);
 135     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
 136
 137     /* check default properties values */
 138     value = 0;
 139     hr = IXmlWriter_GetProperty(writer, XmlWriterProperty_ByteOrderMark, &value);
 140     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
 141     ok(value == TRUE, "got %ld\n", value);
 142
 143     value = TRUE;
 144     hr = IXmlWriter_GetProperty(writer, XmlWriterProperty_Indent, &value);
 145     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
 146     ok(value == FALSE, "got %ld\n", value);
 147
 148     value = TRUE;
 149     hr = IXmlWriter_GetProperty(writer, XmlWriterProperty_OmitXmlDeclaration, &value);
 150     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
 151     ok(value == FALSE, "got %ld\n", value);
 152
 153     value = XmlConformanceLevel_Auto;
 154     hr = IXmlWriter_GetProperty(writer, XmlWriterProperty_ConformanceLevel, &value);
 155     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
 156     ok(value == XmlConformanceLevel_Document, "got %ld\n", value);
 157
 158     IXmlWriter_Release(writer);
 159 }
 160
 161 static BOOL init_pointers(void)
 162 {
 163     /* don't free module here, it's to be unloaded on exit */
 164     HMODULE mod = LoadLibraryA("xmllite.dll");
 165
 166     if (!mod)
 167     {
 168         win_skip("xmllite library not available\n");
 169         return FALSE;
 170     }
 171
 172 #define MAKEFUNC(f) if (!(p##f = (void*)GetProcAddress(mod, #f))) return FALSE;
 173     MAKEFUNC(CreateXmlWriter);
 174     MAKEFUNC(CreateXmlWriterOutputWithEncodingName);
 175     MAKEFUNC(CreateXmlWriterOutputWithEncodingCodePage);
 176 #undef MAKEFUNC
 177
 178     return TRUE;
 179 }
 180
 181 static void test_writeroutput(void)
 182 {
 183     static const WCHAR utf16W[] = {'u','t','f','-','1','6',0};
 184     IXmlWriterOutput *output;
 185     IUnknown *unk;
 186     HRESULT hr;
 187
 188     output = NULL;
 189     hr = pCreateXmlWriterOutputWithEncodingName(&testoutput, NULL, NULL, &output);
 190     ok(hr == S_OK, "got %08x\n", hr);
 191     IUnknown_Release(output);
 192
 193     hr = pCreateXmlWriterOutputWithEncodingName(&testoutput, NULL, utf16W, &output);
 194     ok(hr == S_OK, "got %08x\n", hr);
 195     unk = NULL;
 196     hr = IUnknown_QueryInterface(output, &IID_IXmlWriterOutput, (void**)&unk);
 197     ok(hr == S_OK, "got %08x\n", hr);
 198     ok(unk != NULL, "got %p\n", unk);
 199     /* releasing 'unk' crashes on native */
 200     IUnknown_Release(output);
 201
 202     output = NULL;
 203     hr = pCreateXmlWriterOutputWithEncodingCodePage(&testoutput, NULL, ~0u, &output);
 204     ok(hr == S_OK, "got %08x\n", hr);
 205     IUnknown_Release(output);
 206
 207     hr = pCreateXmlWriterOutputWithEncodingCodePage(&testoutput, NULL, CP_UTF8, &output);
 208     ok(hr == S_OK, "got %08x\n", hr);
 209     unk = NULL;
 210     hr = IUnknown_QueryInterface(output, &IID_IXmlWriterOutput, (void**)&unk);
 211     ok(hr == S_OK, "got %08x\n", hr);
 212     ok(unk != NULL, "got %p\n", unk);
 213     /* releasing 'unk' crashes on native */
 214     IUnknown_Release(output);
 215 }
 216
 217 static void test_writestartdocument(void)
 218 {
 219     static const char fullprolog[] = "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>";
 220     static const char prologversion[] = "<?xml version=\"1.0\"?>";
 221     static const WCHAR versionW[] = {'v','e','r','s','i','o','n','=','"','1','.','0','"',0};
 222     static const WCHAR xmlW[] = {'x','m','l',0};
 223     IXmlWriter *writer;
 224     HGLOBAL hglobal;
 225     IStream *stream;
 226     HRESULT hr;
 227     char *ptr;
 228
 229     hr = pCreateXmlWriter(&IID_IXmlWriter, (void**)&writer, NULL);
 230     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
 231
 232     /* output not set */
 233     hr = IXmlWriter_WriteStartDocument(writer, XmlStandalone_Yes);
 234     ok(hr == E_UNEXPECTED, "got 0x%08x\n", hr);
 235
 236     hr = IXmlWriter_WriteProcessingInstruction(writer, xmlW, versionW);
 237     ok(hr == E_UNEXPECTED, "got 0x%08x\n", hr);
 238
 239     hr = IXmlWriter_Flush(writer);
 240     ok(hr == S_OK, "got 0x%08x\n", hr);
 241
 242     hr = CreateStreamOnHGlobal(NULL, TRUE, &stream);
 243     ok(hr == S_OK, "got 0x%08x\n", hr);
 244
 245     hr = IXmlWriter_SetOutput(writer, (IUnknown*)stream);
 246     ok(hr == S_OK, "got 0x%08x\n", hr);
 247
 248     /* nothing written yet */
 249     hr = IXmlWriter_Flush(writer);
 250     ok(hr == S_OK, "got 0x%08x\n", hr);
 251
 252     hr = IXmlWriter_WriteStartDocument(writer, XmlStandalone_Yes);
 253     ok(hr == S_OK, "got 0x%08x\n", hr);
 254
 255     hr = IXmlWriter_Flush(writer);
 256     ok(hr == S_OK, "got 0x%08x\n", hr);
 257
 258     hr = GetHGlobalFromStream(stream, &hglobal);
 259     ok(hr == S_OK, "got 0x%08x\n", hr);
 260
 261     ptr = GlobalLock(hglobal);
 262     ok(!strncmp(ptr, fullprolog, strlen(fullprolog)), "got %s, expected %s\n", ptr, fullprolog);
 263     GlobalUnlock(hglobal);
 264
 265     /* one more time */
 266     hr = IXmlWriter_WriteStartDocument(writer, XmlStandalone_Yes);
 267     ok(hr == WR_E_INVALIDACTION, "got 0x%08x\n", hr);
 268     IStream_Release(stream);
 269
 270     /* now add PI manually, and try to start a document */
 271     hr = CreateStreamOnHGlobal(NULL, TRUE, &stream);
 272     ok(hr == S_OK, "got 0x%08x\n", hr);
 273
 274     hr = IXmlWriter_SetOutput(writer, (IUnknown*)stream);
 275     ok(hr == S_OK, "got 0x%08x\n", hr);
 276
 277     hr = IXmlWriter_WriteProcessingInstruction(writer, xmlW, versionW);
 278     ok(hr == S_OK, "got 0x%08x\n", hr);
 279
 280     hr = IXmlWriter_WriteStartDocument(writer, XmlStandalone_Yes);
 281     ok(hr == S_OK, "got 0x%08x\n", hr);
 282
 283     hr = IXmlWriter_WriteStartDocument(writer, XmlStandalone_Yes);
 284     ok(hr == WR_E_INVALIDACTION, "got 0x%08x\n", hr);
 285
 286     /* another attempt to add 'xml' PI */
 287     hr = IXmlWriter_WriteProcessingInstruction(writer, xmlW, versionW);
 288     ok(hr == WR_E_INVALIDACTION, "got 0x%08x\n", hr);
 289
 290     hr = IXmlWriter_Flush(writer);
 291     ok(hr == S_OK, "got 0x%08x\n", hr);
 292
 293     hr = GetHGlobalFromStream(stream, &hglobal);
 294     ok(hr == S_OK, "got 0x%08x\n", hr);
 295
 296     ptr = GlobalLock(hglobal);
 297     ok(!strncmp(ptr, prologversion, strlen(prologversion)), "got %s\n", ptr);
 298     GlobalUnlock(hglobal);
 299
 300     IStream_Release(stream);
 301     IXmlWriter_Release(writer);
 302 }
 303
 304 static void test_flush(void)
 305 {
 306     IXmlWriter *writer;
 307     HRESULT hr;
 308
 309     hr = pCreateXmlWriter(&IID_IXmlWriter, (void**)&writer, NULL);
 310     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
 311
 312     hr = IXmlWriter_SetOutput(writer, (IUnknown*)&teststream);
 313     ok(hr == S_OK, "got 0x%08x\n", hr);
 314
 315     hr = IXmlWriter_WriteStartDocument(writer, XmlStandalone_Yes);
 316     ok(hr == S_OK, "got 0x%08x\n", hr);
 317
 318     g_write_len = 0;
 319     hr = IXmlWriter_Flush(writer);
 320     ok(hr == S_OK, "got 0x%08x\n", hr);
 321     ok(g_write_len > 0, "got %d\n", g_write_len);
 322
 323     g_write_len = 1;
 324     hr = IXmlWriter_Flush(writer);
 325     ok(hr == S_OK, "got 0x%08x\n", hr);
 326     ok(g_write_len == 0, "got %d\n", g_write_len);
 327
 328     /* Release() flushes too */
 329     g_write_len = 1;
 330     IXmlWriter_Release(writer);
 331     ok(g_write_len == 0, "got %d\n", g_write_len);
 332 }
 333
 334 static void test_omitxmldeclaration(void)
 335 {
 336     static const char prologversion[] = "<?xml version=\"1.0\"?>";
 337     static const WCHAR versionW[] = {'v','e','r','s','i','o','n','=','"','1','.','0','"',0};
 338     static const WCHAR xmlW[] = {'x','m','l',0};
 339     IXmlWriter *writer;
 340     HGLOBAL hglobal;
 341     IStream *stream;
 342     HRESULT hr;
 343     char *ptr;
 344
 345     hr = pCreateXmlWriter(&IID_IXmlWriter, (void**)&writer, NULL);
 346     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
 347
 348     hr = CreateStreamOnHGlobal(NULL, TRUE, &stream);
 349     ok(hr == S_OK, "got 0x%08x\n", hr);
 350
 351     hr = IXmlWriter_SetOutput(writer, (IUnknown*)stream);
 352     ok(hr == S_OK, "got 0x%08x\n", hr);
 353
 354     hr = IXmlWriter_SetProperty(writer, XmlWriterProperty_OmitXmlDeclaration, TRUE);
 355     ok(hr == S_OK, "got 0x%08x\n", hr);
 356
 357     hr = IXmlWriter_WriteStartDocument(writer, XmlStandalone_Yes);
 358     ok(hr == S_OK, "got 0x%08x\n", hr);
 359
 360     hr = IXmlWriter_Flush(writer);
 361     ok(hr == S_OK, "got 0x%08x\n", hr);
 362
 363     hr = GetHGlobalFromStream(stream, &hglobal);
 364     ok(hr == S_OK, "got 0x%08x\n", hr);
 365
 366     ptr = GlobalLock(hglobal);
 367     ok(!ptr, "got %p\n", ptr);
 368     GlobalUnlock(hglobal);
 369
 370     /* one more time */
 371     hr = IXmlWriter_WriteStartDocument(writer, XmlStandalone_Yes);
 372     ok(hr == WR_E_INVALIDACTION, "got 0x%08x\n", hr);
 373
 374     IStream_Release(stream);
 375
 376     /* now add PI manually, and try to start a document */
 377     hr = CreateStreamOnHGlobal(NULL, TRUE, &stream);
 378     ok(hr == S_OK, "got 0x%08x\n", hr);
 379
 380     hr = IXmlWriter_SetOutput(writer, (IUnknown*)stream);
 381     ok(hr == S_OK, "got 0x%08x\n", hr);
 382
 383     hr = IXmlWriter_WriteProcessingInstruction(writer, xmlW, versionW);
 384     ok(hr == S_OK, "got 0x%08x\n", hr);
 385
 386     hr = IXmlWriter_Flush(writer);
 387     ok(hr == S_OK, "got 0x%08x\n", hr);
 388
 389     hr = GetHGlobalFromStream(stream, &hglobal);
 390     ok(hr == S_OK, "got 0x%08x\n", hr);
 391
 392     ptr = GlobalLock(hglobal);
 393     ok(!strncmp(ptr, prologversion, strlen(prologversion)), "got %s\n", ptr);
 394     GlobalUnlock(hglobal);
 395
 396     hr = IXmlWriter_WriteStartDocument(writer, XmlStandalone_Yes);
 397     ok(hr == S_OK, "got 0x%08x\n", hr);
 398
 399     hr = IXmlWriter_Flush(writer);
 400     ok(hr == S_OK, "got 0x%08x\n", hr);
 401
 402     ptr = GlobalLock(hglobal);
 403     ok(!strncmp(ptr, prologversion, strlen(prologversion)), "got %s\n", ptr);
 404     GlobalUnlock(hglobal);
 405
 406     hr = IXmlWriter_WriteStartDocument(writer, XmlStandalone_Yes);
 407     ok(hr == WR_E_INVALIDACTION, "got 0x%08x\n", hr);
 408
 409     hr = IXmlWriter_Flush(writer);
 410     ok(hr == S_OK, "got 0x%08x\n", hr);
 411
 412     ptr = GlobalLock(hglobal);
 413     ok(!strncmp(ptr, prologversion, strlen(prologversion)), "got %s\n", ptr);
 414     GlobalUnlock(hglobal);
 415
 416     /* another attempt to add 'xml' PI */
 417     hr = IXmlWriter_WriteProcessingInstruction(writer, xmlW, versionW);
 418     ok(hr == WR_E_INVALIDACTION, "got 0x%08x\n", hr);
 419
 420     hr = IXmlWriter_Flush(writer);
 421     ok(hr == S_OK, "got 0x%08x\n", hr);
 422
 423     IStream_Release(stream);
 424     IXmlWriter_Release(writer);
 425 }
 426
 427 static void test_bom(void)
 428 {
 429     static const WCHAR versionW[] = {'v','e','r','s','i','o','n','=','"','1','.','0','"',0};
 430     static const WCHAR utf16W[] = {'u','t','f','-','1','6',0};
 431     static const WCHAR xmlW[] = {'x','m','l',0};
 432     static const WCHAR aW[] = {'a',0};
 433     IXmlWriterOutput *output;
 434     unsigned char *ptr;
 435     IXmlWriter *writer;
 436     IStream *stream;
 437     HGLOBAL hglobal;
 438     HRESULT hr;
 439
 440     hr = CreateStreamOnHGlobal(NULL, TRUE, &stream);
 441     ok(hr == S_OK, "got 0x%08x\n", hr);
 442
 443     hr = pCreateXmlWriterOutputWithEncodingName((IUnknown*)stream, NULL, utf16W, &output);
 444     ok(hr == S_OK, "got %08x\n", hr);
 445
 446     hr = pCreateXmlWriter(&IID_IXmlWriter, (void**)&writer, NULL);
 447     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
 448
 449     hr = IXmlWriter_SetProperty(writer, XmlWriterProperty_OmitXmlDeclaration, TRUE);
 450     ok(hr == S_OK, "got 0x%08x\n", hr);
 451
 452     hr = IXmlWriter_SetOutput(writer, output);
 453     ok(hr == S_OK, "got 0x%08x\n", hr);
 454
 455     /* BOM is on by default */
 456     hr = IXmlWriter_WriteStartDocument(writer, XmlStandalone_Yes);
 457     ok(hr == S_OK, "got 0x%08x\n", hr);
 458
 459     hr = IXmlWriter_Flush(writer);
 460     ok(hr == S_OK, "got 0x%08x\n", hr);
 461
 462     hr = GetHGlobalFromStream(stream, &hglobal);
 463     ok(hr == S_OK, "got 0x%08x\n", hr);
 464
 465     ptr = GlobalLock(hglobal);
 466     ok(ptr[0] == 0xff && ptr[1] == 0xfe, "got %x,%x\n", ptr[0], ptr[1]);
 467     GlobalUnlock(hglobal);
 468
 469     IStream_Release(stream);
 470     IUnknown_Release(output);
 471
 472     /* start with PI */
 473     hr = CreateStreamOnHGlobal(NULL, TRUE, &stream);
 474     ok(hr == S_OK, "got 0x%08x\n", hr);
 475
 476     hr = pCreateXmlWriterOutputWithEncodingName((IUnknown*)stream, NULL, utf16W, &output);
 477     ok(hr == S_OK, "got %08x\n", hr);
 478
 479     hr = IXmlWriter_SetOutput(writer, output);
 480     ok(hr == S_OK, "got 0x%08x\n", hr);
 481
 482     hr = IXmlWriter_WriteProcessingInstruction(writer, xmlW, versionW);
 483     ok(hr == S_OK, "got 0x%08x\n", hr);
 484
 485     hr = IXmlWriter_Flush(writer);
 486     ok(hr == S_OK, "got 0x%08x\n", hr);
 487
 488     hr = GetHGlobalFromStream(stream, &hglobal);
 489     ok(hr == S_OK, "got 0x%08x\n", hr);
 490
 491     ptr = GlobalLock(hglobal);
 492     ok(ptr[0] == 0xff && ptr[1] == 0xfe, "got %x,%x\n", ptr[0], ptr[1]);
 493     GlobalUnlock(hglobal);
 494
 495     IUnknown_Release(output);
 496     IStream_Release(stream);
 497
 498     /* start with element */
 499     hr = CreateStreamOnHGlobal(NULL, TRUE, &stream);
 500     ok(hr == S_OK, "got 0x%08x\n", hr);
 501
 502     hr = pCreateXmlWriterOutputWithEncodingName((IUnknown*)stream, NULL, utf16W, &output);
 503     ok(hr == S_OK, "got %08x\n", hr);
 504
 505     hr = IXmlWriter_SetOutput(writer, output);
 506     ok(hr == S_OK, "got 0x%08x\n", hr);
 507
 508     hr = IXmlWriter_WriteStartElement(writer, NULL, aW, NULL);
 509     ok(hr == S_OK, "got 0x%08x\n", hr);
 510
 511     hr = IXmlWriter_Flush(writer);
 512     ok(hr == S_OK, "got 0x%08x\n", hr);
 513
 514     hr = GetHGlobalFromStream(stream, &hglobal);
 515     ok(hr == S_OK, "got 0x%08x\n", hr);
 516
 517     ptr = GlobalLock(hglobal);
 518     ok(ptr[0] == 0xff && ptr[1] == 0xfe, "got %x,%x\n", ptr[0], ptr[1]);
 519     GlobalUnlock(hglobal);
 520
 521     IUnknown_Release(output);
 522     IStream_Release(stream);
 523
 524     /* WriteElementString */
 525     hr = CreateStreamOnHGlobal(NULL, TRUE, &stream);
 526     ok(hr == S_OK, "got 0x%08x\n", hr);
 527
 528     hr = pCreateXmlWriterOutputWithEncodingName((IUnknown*)stream, NULL, utf16W, &output);
 529     ok(hr == S_OK, "got %08x\n", hr);
 530
 531     hr = IXmlWriter_SetOutput(writer, output);
 532     ok(hr == S_OK, "got 0x%08x\n", hr);
 533
 534     hr = IXmlWriter_WriteElementString(writer, NULL, aW, NULL, NULL);
 535     ok(hr == S_OK, "got 0x%08x\n", hr);
 536
 537     hr = IXmlWriter_Flush(writer);
 538     ok(hr == S_OK, "got 0x%08x\n", hr);
 539
 540     hr = GetHGlobalFromStream(stream, &hglobal);
 541     ok(hr == S_OK, "got 0x%08x\n", hr);
 542
 543     ptr = GlobalLock(hglobal);
 544     ok(ptr[0] == 0xff && ptr[1] == 0xfe, "got %x,%x\n", ptr[0], ptr[1]);
 545     GlobalUnlock(hglobal);
 546
 547     IUnknown_Release(output);
 548     IStream_Release(stream);
 549
 550     IXmlWriter_Release(writer);
 551 }
 552
 553 static void test_writestartelement(void)
 554 {
 555     static const WCHAR valueW[] = {'v','a','l','u','e',0};
 556     static const char *str = "<a><b>value</b>";
 557     static const WCHAR aW[] = {'a',0};
 558     static const WCHAR bW[] = {'b',0};
 559     char *ptr;
 560     IXmlWriter *writer;
 561     IStream *stream;
 562     HGLOBAL hglobal;
 563     HRESULT hr;
 564
 565     hr = CreateStreamOnHGlobal(NULL, TRUE, &stream);
 566     ok(hr == S_OK, "got 0x%08x\n", hr);
 567
 568     hr = pCreateXmlWriter(&IID_IXmlWriter, (void**)&writer, NULL);
 569     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
 570
 571     hr = IXmlWriter_WriteStartElement(writer, NULL, aW, NULL);
 572     ok(hr == E_UNEXPECTED, "got 0x%08x\n", hr);
 573
 574     hr = IXmlWriter_SetOutput(writer, (IUnknown*)stream);
 575     ok(hr == S_OK, "got 0x%08x\n", hr);
 576
 577     hr = IXmlWriter_WriteStartElement(writer, aW, NULL, NULL);
 578     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
 579
 580     hr = IXmlWriter_WriteStartElement(writer, NULL, NULL, NULL);
 581     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
 582
 583     hr = IXmlWriter_WriteStartElement(writer, NULL, NULL, aW);
 584     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
 585
 586     hr = IXmlWriter_WriteStartElement(writer, NULL, aW, NULL);
 587     ok(hr == S_OK, "got 0x%08x\n", hr);
 588
 589     hr = GetHGlobalFromStream(stream, &hglobal);
 590     ok(hr == S_OK, "got 0x%08x\n", hr);
 591
 592     hr = IXmlWriter_WriteStartDocument(writer, XmlStandalone_Yes);
 593     ok(hr == WR_E_INVALIDACTION, "got 0x%08x\n", hr);
 594
 595     hr = IXmlWriter_Flush(writer);
 596     ok(hr == S_OK, "got 0x%08x\n", hr);
 597
 598     ptr = GlobalLock(hglobal);
 599     ok(!strncmp(ptr, "<a", 2), "got %s\n", ptr);
 600     GlobalUnlock(hglobal);
 601
 602     hr = IXmlWriter_WriteStartDocument(writer, XmlStandalone_Yes);
 603     ok(hr == WR_E_INVALIDACTION, "got 0x%08x\n", hr);
 604
 605     hr = IXmlWriter_WriteStartElement(writer, NULL, NULL, NULL);
 606     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
 607
 608     hr = IXmlWriter_WriteProcessingInstruction(writer, aW, aW);
 609     ok(hr == WR_E_INVALIDACTION, "got 0x%08x\n", hr);
 610
 611     IStream_Release(stream);
 612     IXmlWriter_Release(writer);
 613
 614     /* WriteElementString */
 615     hr = pCreateXmlWriter(&IID_IXmlWriter, (void**)&writer, NULL);
 616     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
 617
 618     hr = CreateStreamOnHGlobal(NULL, TRUE, &stream);
 619     ok(hr == S_OK, "got 0x%08x\n", hr);
 620
 621     hr = IXmlWriter_WriteElementString(writer, NULL, bW, NULL, valueW);
 622     ok(hr == E_UNEXPECTED, "got 0x%08x\n", hr);
 623
 624     hr = IXmlWriter_SetOutput(writer, (IUnknown*)stream);
 625     ok(hr == S_OK, "got 0x%08x\n", hr);
 626
 627     hr = IXmlWriter_WriteStartElement(writer, NULL, aW, NULL);
 628     ok(hr == S_OK, "got 0x%08x\n", hr);
 629
 630     hr = IXmlWriter_WriteElementString(writer, NULL, bW, NULL, valueW);
 631     ok(hr == S_OK, "got 0x%08x\n", hr);
 632
 633     hr = IXmlWriter_Flush(writer);
 634     ok(hr == S_OK, "got 0x%08x\n", hr);
 635
 636     hr = GetHGlobalFromStream(stream, &hglobal);
 637     ok(hr == S_OK, "got 0x%08x\n", hr);
 638
 639     ptr = GlobalLock(hglobal);
 640     ok(!strncmp(ptr, str, strlen(str)), "got %s\n", ptr);
 641     GlobalUnlock(hglobal);
 642
 643     IStream_Release(stream);
 644     IXmlWriter_Release(writer);
 645 }
 646
 647 static void test_writeendelement(void)
 648 {
 649     static const WCHAR aW[] = {'a',0};
 650     static const WCHAR bW[] = {'b',0};
 651     char *ptr;
 652     IXmlWriter *writer;
 653     IStream *stream;
 654     HGLOBAL hglobal;
 655     HRESULT hr;
 656
 657     hr = CreateStreamOnHGlobal(NULL, TRUE, &stream);
 658     ok(hr == S_OK, "got 0x%08x\n", hr);
 659
 660     hr = pCreateXmlWriter(&IID_IXmlWriter, (void**)&writer, NULL);
 661     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
 662
 663     hr = IXmlWriter_SetOutput(writer, (IUnknown*)stream);
 664     ok(hr == S_OK, "got 0x%08x\n", hr);
 665
 666     hr = IXmlWriter_WriteStartElement(writer, NULL, aW, NULL);
 667     ok(hr == S_OK, "got 0x%08x\n", hr);
 668
 669     hr = IXmlWriter_WriteStartElement(writer, NULL, bW, NULL);
 670     ok(hr == S_OK, "got 0x%08x\n", hr);
 671
 672     hr = IXmlWriter_WriteEndElement(writer);
 673     ok(hr == S_OK, "got 0x%08x\n", hr);
 674
 675     hr = IXmlWriter_WriteEndElement(writer);
 676     ok(hr == S_OK, "got 0x%08x\n", hr);
 677
 678     hr = GetHGlobalFromStream(stream, &hglobal);
 679     ok(hr == S_OK, "got 0x%08x\n", hr);
 680
 681     hr = IXmlWriter_Flush(writer);
 682     ok(hr == S_OK, "got 0x%08x\n", hr);
 683
 684     ptr = GlobalLock(hglobal);
 685     ok(!strncmp(ptr, "<a><b /></a>", 12), "got %s\n", ptr);
 686     GlobalUnlock(hglobal);
 687
 688     IXmlWriter_Release(writer);
 689     IStream_Release(stream);
 690 }
 691
 692 static void test_writeenddocument(void)
 693 {
 694     static const WCHAR aW[] = {'a',0};
 695     static const WCHAR bW[] = {'b',0};
 696     IXmlWriter *writer;
 697     IStream *stream;
 698     HGLOBAL hglobal;
 699     HRESULT hr;
 700     char *ptr;
 701
 702     hr = CreateStreamOnHGlobal(NULL, TRUE, &stream);
 703     ok(hr == S_OK, "got 0x%08x\n", hr);
 704
 705     hr = pCreateXmlWriter(&IID_IXmlWriter, (void**)&writer, NULL);
 706     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
 707
 708     hr = IXmlWriter_WriteEndDocument(writer);
 709     ok(hr == E_UNEXPECTED, "got 0x%08x\n", hr);
 710
 711     hr = IXmlWriter_SetOutput(writer, (IUnknown*)stream);
 712     ok(hr == S_OK, "got 0x%08x\n", hr);
 713
 714     /* WriteEndDocument resets it to initial state */
 715     hr = IXmlWriter_WriteEndDocument(writer);
 716     ok(hr == WR_E_INVALIDACTION, "got 0x%08x\n", hr);
 717
 718     hr = IXmlWriter_WriteEndDocument(writer);
 719     ok(hr == WR_E_INVALIDACTION, "got 0x%08x\n", hr);
 720
 721     hr = IXmlWriter_WriteStartDocument(writer, XmlStandalone_Omit);
 722     ok(hr == WR_E_INVALIDACTION, "got 0x%08x\n", hr);
 723
 724     hr = IXmlWriter_WriteStartElement(writer, NULL, aW, NULL);
 725     ok(hr == WR_E_INVALIDACTION, "got 0x%08x\n", hr);
 726
 727     hr = IXmlWriter_SetOutput(writer, (IUnknown*)stream);
 728     ok(hr == S_OK, "got 0x%08x\n", hr);
 729
 730     hr = IXmlWriter_WriteStartElement(writer, NULL, aW, NULL);
 731     ok(hr == S_OK, "got 0x%08x\n", hr);
 732
 733     hr = IXmlWriter_WriteStartElement(writer, NULL, bW, NULL);
 734     ok(hr == S_OK, "got 0x%08x\n", hr);
 735
 736     hr = IXmlWriter_WriteEndDocument(writer);
 737     ok(hr == S_OK, "got 0x%08x\n", hr);
 738
 739     hr = GetHGlobalFromStream(stream, &hglobal);
 740     ok(hr == S_OK, "got 0x%08x\n", hr);
 741
 742     ptr = GlobalLock(hglobal);
 743     ok(ptr == NULL, "got %p\n", ptr);
 744
 745     /* we still need to flush manually, WriteEndDocument doesn't do that */
 746     hr = IXmlWriter_Flush(writer);
 747     ok(hr == S_OK, "got 0x%08x\n", hr);
 748
 749     ptr = GlobalLock(hglobal);
 750     ok(ptr != NULL, "got %p\n", ptr);
 751     ok(!strncmp(ptr, "<a><b /></a>", 12), "got %s\n", ptr);
 752     GlobalUnlock(hglobal);
 753
 754     IXmlWriter_Release(writer);
 755     IStream_Release(stream);
 756 }
 757
 758 START_TEST(writer)
 759 {
 760     if (!init_pointers())
 761        return;
 762
 763     test_writer_create();
 764     test_writeroutput();
 765     test_writestartdocument();
 766     test_writestartelement();
 767     test_writeendelement();
 768     test_flush();
 769     test_omitxmldeclaration();
 770     test_bom();
 771     test_writeenddocument();
 772 }