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
  40 static HRESULT WINAPI testoutput_QueryInterface(IUnknown *iface, REFIID riid, void **obj)
  41 {
  42     if (IsEqualGUID(riid, &IID_IUnknown)) {
  43         *obj = iface;
  44         return S_OK;
  45     }
  46     else {
  47         ok(0, "unknown riid=%s\n", wine_dbgstr_guid(riid));
  48         return E_NOINTERFACE;
  49     }
  50 }
  51
  52 static ULONG WINAPI testoutput_AddRef(IUnknown *iface)
  53 {
  54     return 2;
  55 }
  56
  57 static ULONG WINAPI testoutput_Release(IUnknown *iface)
  58 {
  59     return 1;
  60 }
  61
  62 static const IUnknownVtbl testoutputvtbl = {
  63     testoutput_QueryInterface,
  64     testoutput_AddRef,
  65     testoutput_Release
  66 };
  67
  68 static IUnknown testoutput = { &testoutputvtbl };
  69
  70 static HRESULT WINAPI teststream_QueryInterface(ISequentialStream *iface, REFIID riid, void **obj)
  71 {
  72     if (IsEqualIID(riid, &IID_IUnknown) || IsEqualIID(riid, &IID_ISequentialStream))
  73     {
  74         *obj = iface;
  75         return S_OK;
  76     }
  77
  78     *obj = NULL;
  79     return E_NOINTERFACE;
  80 }
  81
  82 static ULONG WINAPI teststream_AddRef(ISequentialStream *iface)
  83 {
  84     return 2;
  85 }
  86
  87 static ULONG WINAPI teststream_Release(ISequentialStream *iface)
  88 {
  89     return 1;
  90 }
  91
  92 static HRESULT WINAPI teststream_Read(ISequentialStream *iface, void *pv, ULONG cb, ULONG *pread)
  93 {
  94     ok(0, "unexpected call\n");
  95     return E_NOTIMPL;
  96 }
  97
  98 static ULONG g_write_len;
  99 static HRESULT WINAPI teststream_Write(ISequentialStream *iface, const void *pv, ULONG cb, ULONG *written)
 100 {
 101     g_write_len = cb;
 102     *written = cb;
 103     return S_OK;
 104 }
 105
 106 static const ISequentialStreamVtbl teststreamvtbl =
 107 {
 108     teststream_QueryInterface,
 109     teststream_AddRef,
 110     teststream_Release,
 111     teststream_Read,
 112     teststream_Write
 113 };
 114
 115 static ISequentialStream teststream = { &teststreamvtbl };
 116
 117 static void test_writer_create(void)
 118 {
 119     HRESULT hr;
 120     IXmlWriter *writer;
 121     LONG_PTR value;
 122
 123     /* crashes native */
 124     if (0)
 125     {
 126         pCreateXmlWriter(&IID_IXmlWriter, NULL, NULL);
 127         pCreateXmlWriter(NULL, (void**)&writer, NULL);
 128     }
 129
 130     hr = pCreateXmlWriter(&IID_IXmlWriter, (void**)&writer, NULL);
 131     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
 132
 133     /* check default properties values */
 134     value = 0;
 135     hr = IXmlWriter_GetProperty(writer, XmlWriterProperty_ByteOrderMark, &value);
 136     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
 137     ok(value == TRUE, "got %ld\n", value);
 138
 139     value = TRUE;
 140     hr = IXmlWriter_GetProperty(writer, XmlWriterProperty_Indent, &value);
 141     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
 142     ok(value == FALSE, "got %ld\n", value);
 143
 144     value = TRUE;
 145     hr = IXmlWriter_GetProperty(writer, XmlWriterProperty_OmitXmlDeclaration, &value);
 146     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
 147     ok(value == FALSE, "got %ld\n", value);
 148
 149     value = XmlConformanceLevel_Auto;
 150     hr = IXmlWriter_GetProperty(writer, XmlWriterProperty_ConformanceLevel, &value);
 151     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
 152     ok(value == XmlConformanceLevel_Document, "got %ld\n", value);
 153
 154     IXmlWriter_Release(writer);
 155 }
 156
 157 static BOOL init_pointers(void)
 158 {
 159     /* don't free module here, it's to be unloaded on exit */
 160     HMODULE mod = LoadLibraryA("xmllite.dll");
 161
 162     if (!mod)
 163     {
 164         win_skip("xmllite library not available\n");
 165         return FALSE;
 166     }
 167
 168 #define MAKEFUNC(f) if (!(p##f = (void*)GetProcAddress(mod, #f))) return FALSE;
 169     MAKEFUNC(CreateXmlWriter);
 170     MAKEFUNC(CreateXmlWriterOutputWithEncodingName);
 171 #undef MAKEFUNC
 172
 173     return TRUE;
 174 }
 175
 176 static void test_writeroutput(void)
 177 {
 178     static const WCHAR utf16W[] = {'u','t','f','-','1','6',0};
 179     IXmlWriterOutput *output;
 180     IUnknown *unk;
 181     HRESULT hr;
 182
 183     output = NULL;
 184     hr = pCreateXmlWriterOutputWithEncodingName(&testoutput, NULL, NULL, &output);
 185     ok(hr == S_OK, "got %08x\n", hr);
 186     IUnknown_Release(output);
 187
 188     hr = pCreateXmlWriterOutputWithEncodingName(&testoutput, NULL, utf16W, &output);
 189     ok(hr == S_OK, "got %08x\n", hr);
 190     unk = NULL;
 191     hr = IUnknown_QueryInterface(output, &IID_IXmlWriterOutput, (void**)&unk);
 192     ok(hr == S_OK, "got %08x\n", hr);
 193     ok(unk != NULL, "got %p\n", unk);
 194     /* releasing 'unk' crashes on native */
 195     IUnknown_Release(output);
 196 }
 197
 198 static void test_writestartdocument(void)
 199 {
 200     static const char fullprolog[] = "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>";
 201     static const char prologversion[] = "<?xml version=\"1.0\"?>";
 202     static const WCHAR versionW[] = {'v','e','r','s','i','o','n','=','"','1','.','0','"',0};
 203     static const WCHAR xmlW[] = {'x','m','l',0};
 204     IXmlWriter *writer;
 205     HGLOBAL hglobal;
 206     IStream *stream;
 207     HRESULT hr;
 208     char *ptr;
 209
 210     hr = pCreateXmlWriter(&IID_IXmlWriter, (void**)&writer, NULL);
 211     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
 212
 213     /* output not set */
 214     hr = IXmlWriter_WriteStartDocument(writer, XmlStandalone_Yes);
 215     ok(hr == E_UNEXPECTED, "got 0x%08x\n", hr);
 216
 217     hr = IXmlWriter_WriteProcessingInstruction(writer, xmlW, versionW);
 218     ok(hr == E_UNEXPECTED, "got 0x%08x\n", hr);
 219
 220     hr = IXmlWriter_Flush(writer);
 221     ok(hr == S_OK, "got 0x%08x\n", hr);
 222
 223     hr = CreateStreamOnHGlobal(NULL, TRUE, &stream);
 224     ok(hr == S_OK, "got 0x%08x\n", hr);
 225
 226     hr = IXmlWriter_SetOutput(writer, (IUnknown*)stream);
 227     ok(hr == S_OK, "got 0x%08x\n", hr);
 228
 229     /* nothing written yet */
 230     hr = IXmlWriter_Flush(writer);
 231     ok(hr == S_OK, "got 0x%08x\n", hr);
 232
 233     hr = IXmlWriter_WriteStartDocument(writer, XmlStandalone_Yes);
 234     ok(hr == S_OK, "got 0x%08x\n", hr);
 235
 236     hr = IXmlWriter_Flush(writer);
 237     ok(hr == S_OK, "got 0x%08x\n", hr);
 238
 239     hr = GetHGlobalFromStream(stream, &hglobal);
 240     ok(hr == S_OK, "got 0x%08x\n", hr);
 241
 242     ptr = GlobalLock(hglobal);
 243     ok(!strncmp(ptr, fullprolog, strlen(fullprolog)), "got %s, expected %s\n", ptr, fullprolog);
 244     GlobalUnlock(hglobal);
 245
 246     /* one more time */
 247     hr = IXmlWriter_WriteStartDocument(writer, XmlStandalone_Yes);
 248     ok(hr == WR_E_INVALIDACTION, "got 0x%08x\n", hr);
 249     IStream_Release(stream);
 250
 251     /* now add PI manually, and try to start a document */
 252     hr = CreateStreamOnHGlobal(NULL, TRUE, &stream);
 253     ok(hr == S_OK, "got 0x%08x\n", hr);
 254
 255     hr = IXmlWriter_SetOutput(writer, (IUnknown*)stream);
 256     ok(hr == S_OK, "got 0x%08x\n", hr);
 257
 258     hr = IXmlWriter_WriteProcessingInstruction(writer, xmlW, versionW);
 259     ok(hr == S_OK, "got 0x%08x\n", hr);
 260
 261     hr = IXmlWriter_WriteStartDocument(writer, XmlStandalone_Yes);
 262     ok(hr == S_OK, "got 0x%08x\n", hr);
 263
 264     hr = IXmlWriter_WriteStartDocument(writer, XmlStandalone_Yes);
 265     ok(hr == WR_E_INVALIDACTION, "got 0x%08x\n", hr);
 266
 267     /* another attempt to add 'xml' PI */
 268     hr = IXmlWriter_WriteProcessingInstruction(writer, xmlW, versionW);
 269     ok(hr == WR_E_INVALIDACTION, "got 0x%08x\n", hr);
 270
 271     hr = IXmlWriter_Flush(writer);
 272     ok(hr == S_OK, "got 0x%08x\n", hr);
 273
 274     hr = GetHGlobalFromStream(stream, &hglobal);
 275     ok(hr == S_OK, "got 0x%08x\n", hr);
 276
 277     ptr = GlobalLock(hglobal);
 278     ok(!strncmp(ptr, prologversion, strlen(prologversion)), "got %s\n", ptr);
 279     GlobalUnlock(hglobal);
 280
 281     IStream_Release(stream);
 282     IXmlWriter_Release(writer);
 283 }
 284
 285 static void test_flush(void)
 286 {
 287     IXmlWriter *writer;
 288     HRESULT hr;
 289
 290     hr = pCreateXmlWriter(&IID_IXmlWriter, (void**)&writer, NULL);
 291     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
 292
 293     hr = IXmlWriter_SetOutput(writer, (IUnknown*)&teststream);
 294     ok(hr == S_OK, "got 0x%08x\n", hr);
 295
 296     hr = IXmlWriter_WriteStartDocument(writer, XmlStandalone_Yes);
 297     ok(hr == S_OK, "got 0x%08x\n", hr);
 298
 299     g_write_len = 0;
 300     hr = IXmlWriter_Flush(writer);
 301     ok(hr == S_OK, "got 0x%08x\n", hr);
 302     ok(g_write_len > 0, "got %d\n", g_write_len);
 303
 304     g_write_len = 1;
 305     hr = IXmlWriter_Flush(writer);
 306     ok(hr == S_OK, "got 0x%08x\n", hr);
 307     ok(g_write_len == 0, "got %d\n", g_write_len);
 308
 309     /* Release() flushes too */
 310     g_write_len = 1;
 311     IXmlWriter_Release(writer);
 312     ok(g_write_len == 0, "got %d\n", g_write_len);
 313 }
 314
 315 static void test_omitxmldeclaration(void)
 316 {
 317     static const char prologversion[] = "<?xml version=\"1.0\"?>";
 318     static const WCHAR versionW[] = {'v','e','r','s','i','o','n','=','"','1','.','0','"',0};
 319     static const WCHAR xmlW[] = {'x','m','l',0};
 320     IXmlWriter *writer;
 321     HGLOBAL hglobal;
 322     IStream *stream;
 323     HRESULT hr;
 324     char *ptr;
 325
 326     hr = pCreateXmlWriter(&IID_IXmlWriter, (void**)&writer, NULL);
 327     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
 328
 329     hr = CreateStreamOnHGlobal(NULL, TRUE, &stream);
 330     ok(hr == S_OK, "got 0x%08x\n", hr);
 331
 332     hr = IXmlWriter_SetOutput(writer, (IUnknown*)stream);
 333     ok(hr == S_OK, "got 0x%08x\n", hr);
 334
 335     hr = IXmlWriter_SetProperty(writer, XmlWriterProperty_OmitXmlDeclaration, TRUE);
 336     ok(hr == S_OK, "got 0x%08x\n", hr);
 337
 338     hr = IXmlWriter_WriteStartDocument(writer, XmlStandalone_Yes);
 339     ok(hr == S_OK, "got 0x%08x\n", hr);
 340
 341     hr = IXmlWriter_Flush(writer);
 342     ok(hr == S_OK, "got 0x%08x\n", hr);
 343
 344     hr = GetHGlobalFromStream(stream, &hglobal);
 345     ok(hr == S_OK, "got 0x%08x\n", hr);
 346
 347     ptr = GlobalLock(hglobal);
 348     ok(!ptr, "got %p\n", ptr);
 349     GlobalUnlock(hglobal);
 350
 351     /* one more time */
 352     hr = IXmlWriter_WriteStartDocument(writer, XmlStandalone_Yes);
 353     ok(hr == WR_E_INVALIDACTION, "got 0x%08x\n", hr);
 354
 355     IStream_Release(stream);
 356
 357     /* now add PI manually, and try to start a document */
 358     hr = CreateStreamOnHGlobal(NULL, TRUE, &stream);
 359     ok(hr == S_OK, "got 0x%08x\n", hr);
 360
 361     hr = IXmlWriter_SetOutput(writer, (IUnknown*)stream);
 362     ok(hr == S_OK, "got 0x%08x\n", hr);
 363
 364     hr = IXmlWriter_WriteProcessingInstruction(writer, xmlW, versionW);
 365     ok(hr == S_OK, "got 0x%08x\n", hr);
 366
 367     hr = IXmlWriter_Flush(writer);
 368     ok(hr == S_OK, "got 0x%08x\n", hr);
 369
 370     hr = GetHGlobalFromStream(stream, &hglobal);
 371     ok(hr == S_OK, "got 0x%08x\n", hr);
 372
 373     ptr = GlobalLock(hglobal);
 374     ok(!strncmp(ptr, prologversion, strlen(prologversion)), "got %s\n", ptr);
 375     GlobalUnlock(hglobal);
 376
 377     hr = IXmlWriter_WriteStartDocument(writer, XmlStandalone_Yes);
 378     ok(hr == S_OK, "got 0x%08x\n", hr);
 379
 380     hr = IXmlWriter_Flush(writer);
 381     ok(hr == S_OK, "got 0x%08x\n", hr);
 382
 383     ptr = GlobalLock(hglobal);
 384     ok(!strncmp(ptr, prologversion, strlen(prologversion)), "got %s\n", ptr);
 385     GlobalUnlock(hglobal);
 386
 387     hr = IXmlWriter_WriteStartDocument(writer, XmlStandalone_Yes);
 388     ok(hr == WR_E_INVALIDACTION, "got 0x%08x\n", hr);
 389
 390     hr = IXmlWriter_Flush(writer);
 391     ok(hr == S_OK, "got 0x%08x\n", hr);
 392
 393     ptr = GlobalLock(hglobal);
 394     ok(!strncmp(ptr, prologversion, strlen(prologversion)), "got %s\n", ptr);
 395     GlobalUnlock(hglobal);
 396
 397     /* another attempt to add 'xml' PI */
 398     hr = IXmlWriter_WriteProcessingInstruction(writer, xmlW, versionW);
 399     ok(hr == WR_E_INVALIDACTION, "got 0x%08x\n", hr);
 400
 401     hr = IXmlWriter_Flush(writer);
 402     ok(hr == S_OK, "got 0x%08x\n", hr);
 403
 404     IStream_Release(stream);
 405     IXmlWriter_Release(writer);
 406 }
 407
 408 static void test_bom(void)
 409 {
 410     static const WCHAR versionW[] = {'v','e','r','s','i','o','n','=','"','1','.','0','"',0};
 411     static const WCHAR utf16W[] = {'u','t','f','-','1','6',0};
 412     static const WCHAR xmlW[] = {'x','m','l',0};
 413     static const WCHAR aW[] = {'a',0};
 414     IXmlWriterOutput *output;
 415     unsigned char *ptr;
 416     IXmlWriter *writer;
 417     IStream *stream;
 418     HGLOBAL hglobal;
 419     HRESULT hr;
 420
 421     hr = CreateStreamOnHGlobal(NULL, TRUE, &stream);
 422     ok(hr == S_OK, "got 0x%08x\n", hr);
 423
 424     hr = pCreateXmlWriterOutputWithEncodingName((IUnknown*)stream, NULL, utf16W, &output);
 425     ok(hr == S_OK, "got %08x\n", hr);
 426
 427     hr = pCreateXmlWriter(&IID_IXmlWriter, (void**)&writer, NULL);
 428     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
 429
 430     hr = IXmlWriter_SetProperty(writer, XmlWriterProperty_OmitXmlDeclaration, TRUE);
 431     ok(hr == S_OK, "got 0x%08x\n", hr);
 432
 433     hr = IXmlWriter_SetOutput(writer, output);
 434     ok(hr == S_OK, "got 0x%08x\n", hr);
 435
 436     /* BOM is on by default */
 437     hr = IXmlWriter_WriteStartDocument(writer, XmlStandalone_Yes);
 438     ok(hr == S_OK, "got 0x%08x\n", hr);
 439
 440     hr = IXmlWriter_Flush(writer);
 441     ok(hr == S_OK, "got 0x%08x\n", hr);
 442
 443     hr = GetHGlobalFromStream(stream, &hglobal);
 444     ok(hr == S_OK, "got 0x%08x\n", hr);
 445
 446     ptr = GlobalLock(hglobal);
 447     ok(ptr[0] == 0xff && ptr[1] == 0xfe, "got %x,%x\n", ptr[0], ptr[1]);
 448     GlobalUnlock(hglobal);
 449
 450     IStream_Release(stream);
 451     IUnknown_Release(output);
 452
 453     /* start with PI */
 454     hr = CreateStreamOnHGlobal(NULL, TRUE, &stream);
 455     ok(hr == S_OK, "got 0x%08x\n", hr);
 456
 457     hr = pCreateXmlWriterOutputWithEncodingName((IUnknown*)stream, NULL, utf16W, &output);
 458     ok(hr == S_OK, "got %08x\n", hr);
 459
 460     hr = IXmlWriter_SetOutput(writer, output);
 461     ok(hr == S_OK, "got 0x%08x\n", hr);
 462
 463     hr = IXmlWriter_WriteProcessingInstruction(writer, xmlW, versionW);
 464     ok(hr == S_OK, "got 0x%08x\n", hr);
 465
 466     hr = IXmlWriter_Flush(writer);
 467     ok(hr == S_OK, "got 0x%08x\n", hr);
 468
 469     hr = GetHGlobalFromStream(stream, &hglobal);
 470     ok(hr == S_OK, "got 0x%08x\n", hr);
 471
 472     ptr = GlobalLock(hglobal);
 473     ok(ptr[0] == 0xff && ptr[1] == 0xfe, "got %x,%x\n", ptr[0], ptr[1]);
 474     GlobalUnlock(hglobal);
 475
 476     IUnknown_Release(output);
 477     IStream_Release(stream);
 478
 479     /* start with element */
 480     hr = CreateStreamOnHGlobal(NULL, TRUE, &stream);
 481     ok(hr == S_OK, "got 0x%08x\n", hr);
 482
 483     hr = pCreateXmlWriterOutputWithEncodingName((IUnknown*)stream, NULL, utf16W, &output);
 484     ok(hr == S_OK, "got %08x\n", hr);
 485
 486     hr = IXmlWriter_SetOutput(writer, output);
 487     ok(hr == S_OK, "got 0x%08x\n", hr);
 488
 489     hr = IXmlWriter_WriteStartElement(writer, NULL, aW, NULL);
 490     ok(hr == S_OK, "got 0x%08x\n", hr);
 491
 492     hr = IXmlWriter_Flush(writer);
 493     ok(hr == S_OK, "got 0x%08x\n", hr);
 494
 495     hr = GetHGlobalFromStream(stream, &hglobal);
 496     ok(hr == S_OK, "got 0x%08x\n", hr);
 497
 498     ptr = GlobalLock(hglobal);
 499     ok(ptr[0] == 0xff && ptr[1] == 0xfe, "got %x,%x\n", ptr[0], ptr[1]);
 500     GlobalUnlock(hglobal);
 501
 502     IUnknown_Release(output);
 503     IStream_Release(stream);
 504
 505     /* WriteElementString */
 506     hr = CreateStreamOnHGlobal(NULL, TRUE, &stream);
 507     ok(hr == S_OK, "got 0x%08x\n", hr);
 508
 509     hr = pCreateXmlWriterOutputWithEncodingName((IUnknown*)stream, NULL, utf16W, &output);
 510     ok(hr == S_OK, "got %08x\n", hr);
 511
 512     hr = IXmlWriter_SetOutput(writer, output);
 513     ok(hr == S_OK, "got 0x%08x\n", hr);
 514
 515     hr = IXmlWriter_WriteElementString(writer, NULL, aW, NULL, NULL);
 516     ok(hr == S_OK, "got 0x%08x\n", hr);
 517
 518     hr = IXmlWriter_Flush(writer);
 519     ok(hr == S_OK, "got 0x%08x\n", hr);
 520
 521     hr = GetHGlobalFromStream(stream, &hglobal);
 522     ok(hr == S_OK, "got 0x%08x\n", hr);
 523
 524     ptr = GlobalLock(hglobal);
 525     ok(ptr[0] == 0xff && ptr[1] == 0xfe, "got %x,%x\n", ptr[0], ptr[1]);
 526     GlobalUnlock(hglobal);
 527
 528     IUnknown_Release(output);
 529     IStream_Release(stream);
 530
 531     IXmlWriter_Release(writer);
 532 }
 533
 534 static void test_writestartelement(void)
 535 {
 536     static const WCHAR valueW[] = {'v','a','l','u','e',0};
 537     static const char *str = "<a><b>value</b>";
 538     static const WCHAR aW[] = {'a',0};
 539     static const WCHAR bW[] = {'b',0};
 540     char *ptr;
 541     IXmlWriter *writer;
 542     IStream *stream;
 543     HGLOBAL hglobal;
 544     HRESULT hr;
 545
 546     hr = CreateStreamOnHGlobal(NULL, TRUE, &stream);
 547     ok(hr == S_OK, "got 0x%08x\n", hr);
 548
 549     hr = pCreateXmlWriter(&IID_IXmlWriter, (void**)&writer, NULL);
 550     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
 551
 552     hr = IXmlWriter_WriteStartElement(writer, NULL, aW, NULL);
 553     ok(hr == E_UNEXPECTED, "got 0x%08x\n", hr);
 554
 555     hr = IXmlWriter_SetOutput(writer, (IUnknown*)stream);
 556     ok(hr == S_OK, "got 0x%08x\n", hr);
 557
 558     hr = IXmlWriter_WriteStartElement(writer, aW, NULL, NULL);
 559     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
 560
 561     hr = IXmlWriter_WriteStartElement(writer, NULL, NULL, NULL);
 562     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
 563
 564     hr = IXmlWriter_WriteStartElement(writer, NULL, NULL, aW);
 565     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
 566
 567     hr = IXmlWriter_WriteStartElement(writer, NULL, aW, NULL);
 568     ok(hr == S_OK, "got 0x%08x\n", hr);
 569
 570     hr = GetHGlobalFromStream(stream, &hglobal);
 571     ok(hr == S_OK, "got 0x%08x\n", hr);
 572
 573     hr = IXmlWriter_WriteStartDocument(writer, XmlStandalone_Yes);
 574     ok(hr == WR_E_INVALIDACTION, "got 0x%08x\n", hr);
 575
 576     hr = IXmlWriter_Flush(writer);
 577     ok(hr == S_OK, "got 0x%08x\n", hr);
 578
 579     ptr = GlobalLock(hglobal);
 580     ok(!strncmp(ptr, "<a", 2), "got %s\n", ptr);
 581     GlobalUnlock(hglobal);
 582
 583     hr = IXmlWriter_WriteStartDocument(writer, XmlStandalone_Yes);
 584     ok(hr == WR_E_INVALIDACTION, "got 0x%08x\n", hr);
 585
 586     hr = IXmlWriter_WriteStartElement(writer, NULL, NULL, NULL);
 587     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
 588
 589     hr = IXmlWriter_WriteProcessingInstruction(writer, aW, aW);
 590     ok(hr == WR_E_INVALIDACTION, "got 0x%08x\n", hr);
 591
 592     IStream_Release(stream);
 593     IXmlWriter_Release(writer);
 594
 595     /* WriteElementString */
 596     hr = pCreateXmlWriter(&IID_IXmlWriter, (void**)&writer, NULL);
 597     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
 598
 599     hr = CreateStreamOnHGlobal(NULL, TRUE, &stream);
 600     ok(hr == S_OK, "got 0x%08x\n", hr);
 601
 602     hr = IXmlWriter_WriteElementString(writer, NULL, bW, NULL, valueW);
 603     ok(hr == E_UNEXPECTED, "got 0x%08x\n", hr);
 604
 605     hr = IXmlWriter_SetOutput(writer, (IUnknown*)stream);
 606     ok(hr == S_OK, "got 0x%08x\n", hr);
 607
 608     hr = IXmlWriter_WriteStartElement(writer, NULL, aW, NULL);
 609     ok(hr == S_OK, "got 0x%08x\n", hr);
 610
 611     hr = IXmlWriter_WriteElementString(writer, NULL, bW, NULL, valueW);
 612     ok(hr == S_OK, "got 0x%08x\n", hr);
 613
 614     hr = IXmlWriter_Flush(writer);
 615     ok(hr == S_OK, "got 0x%08x\n", hr);
 616
 617     hr = GetHGlobalFromStream(stream, &hglobal);
 618     ok(hr == S_OK, "got 0x%08x\n", hr);
 619
 620     ptr = GlobalLock(hglobal);
 621     ok(!strncmp(ptr, str, strlen(str)), "got %s\n", ptr);
 622     GlobalUnlock(hglobal);
 623
 624     IStream_Release(stream);
 625     IXmlWriter_Release(writer);
 626 }
 627
 628 static void test_writeendelement(void)
 629 {
 630     static const WCHAR aW[] = {'a',0};
 631     static const WCHAR bW[] = {'b',0};
 632     char *ptr;
 633     IXmlWriter *writer;
 634     IStream *stream;
 635     HGLOBAL hglobal;
 636     HRESULT hr;
 637
 638     hr = CreateStreamOnHGlobal(NULL, TRUE, &stream);
 639     ok(hr == S_OK, "got 0x%08x\n", hr);
 640
 641     hr = pCreateXmlWriter(&IID_IXmlWriter, (void**)&writer, NULL);
 642     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
 643
 644     hr = IXmlWriter_SetOutput(writer, (IUnknown*)stream);
 645     ok(hr == S_OK, "got 0x%08x\n", hr);
 646
 647     hr = IXmlWriter_WriteStartElement(writer, NULL, aW, NULL);
 648     ok(hr == S_OK, "got 0x%08x\n", hr);
 649
 650     hr = IXmlWriter_WriteStartElement(writer, NULL, bW, NULL);
 651     ok(hr == S_OK, "got 0x%08x\n", hr);
 652
 653     hr = IXmlWriter_WriteEndElement(writer);
 654     ok(hr == S_OK, "got 0x%08x\n", hr);
 655
 656     hr = IXmlWriter_WriteEndElement(writer);
 657     ok(hr == S_OK, "got 0x%08x\n", hr);
 658
 659     hr = GetHGlobalFromStream(stream, &hglobal);
 660     ok(hr == S_OK, "got 0x%08x\n", hr);
 661
 662     hr = IXmlWriter_Flush(writer);
 663     ok(hr == S_OK, "got 0x%08x\n", hr);
 664
 665     ptr = GlobalLock(hglobal);
 666     ok(!strncmp(ptr, "<a><b /></a>", 12), "got %s\n", ptr);
 667     GlobalUnlock(hglobal);
 668
 669     IXmlWriter_Release(writer);
 670     IStream_Release(stream);
 671 }
 672
 673 START_TEST(writer)
 674 {
 675     if (!init_pointers())
 676        return;
 677
 678     test_writer_create();
 679     test_writeroutput();
 680     test_writestartdocument();
 681     test_writestartelement();
 682     test_writeendelement();
 683     test_flush();
 684     test_omitxmldeclaration();
 685     test_bom();
 686 }