2 * XMLLite IXmlWriter tests
4 * Copyright 2011 (C) Alistair Leslie-Hughes
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.
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.
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
21 #define WIN32_NO_STATUS
23 #define COM_NO_WINDOWS_H
36 #include <wine/test.h>
39 DEFINE_GUID(IID_IXmlWriterOutput
, 0xc1131708, 0x0f59, 0x477f, 0x93, 0x59, 0x7d, 0x33, 0x24, 0x51, 0xbc, 0x1a);
41 static HRESULT (WINAPI
*pCreateXmlWriter
)(REFIID riid
, void **ppvObject
, IMalloc
*pMalloc
);
42 static HRESULT (WINAPI
*pCreateXmlWriterOutputWithEncodingName
)(IUnknown
*stream
,
44 LPCWSTR encoding_name
,
45 IXmlWriterOutput
**output
);
47 static HRESULT WINAPI
testoutput_QueryInterface(IUnknown
*iface
, REFIID riid
, void **obj
)
49 if (IsEqualGUID(riid
, &IID_IUnknown
)) {
54 ok(0, "unknown riid=%s\n", wine_dbgstr_guid(riid
));
59 static ULONG WINAPI
testoutput_AddRef(IUnknown
*iface
)
64 static ULONG WINAPI
testoutput_Release(IUnknown
*iface
)
69 static const IUnknownVtbl testoutputvtbl
= {
70 testoutput_QueryInterface
,
75 static IUnknown testoutput
= { &testoutputvtbl
};
77 static HRESULT WINAPI
teststream_QueryInterface(ISequentialStream
*iface
, REFIID riid
, void **obj
)
79 if (IsEqualIID(riid
, &IID_IUnknown
) || IsEqualIID(riid
, &IID_ISequentialStream
))
89 static ULONG WINAPI
teststream_AddRef(ISequentialStream
*iface
)
94 static ULONG WINAPI
teststream_Release(ISequentialStream
*iface
)
99 static HRESULT WINAPI
teststream_Read(ISequentialStream
*iface
, void *pv
, ULONG cb
, ULONG
*pread
)
101 ok(0, "unexpected call\n");
105 static ULONG g_write_len
;
106 static HRESULT WINAPI
teststream_Write(ISequentialStream
*iface
, const void *pv
, ULONG cb
, ULONG
*written
)
113 static const ISequentialStreamVtbl teststreamvtbl
=
115 teststream_QueryInterface
,
122 static ISequentialStream teststream
= { &teststreamvtbl
};
124 static void test_writer_create(void)
133 pCreateXmlWriter(&IID_IXmlWriter
, NULL
, NULL
);
134 pCreateXmlWriter(NULL
, (void**)&writer
, NULL
);
137 hr
= pCreateXmlWriter(&IID_IXmlWriter
, (void**)&writer
, NULL
);
138 ok(hr
== S_OK
, "Expected S_OK, got %08x\n", hr
);
140 /* check default properties values */
142 hr
= IXmlWriter_GetProperty(writer
, XmlWriterProperty_ByteOrderMark
, &value
);
143 ok(hr
== S_OK
, "Expected S_OK, got %08x\n", hr
);
144 ok(value
== TRUE
, "got %ld\n", value
);
147 hr
= IXmlWriter_GetProperty(writer
, XmlWriterProperty_Indent
, &value
);
148 ok(hr
== S_OK
, "Expected S_OK, got %08x\n", hr
);
149 ok(value
== FALSE
, "got %ld\n", value
);
152 hr
= IXmlWriter_GetProperty(writer
, XmlWriterProperty_OmitXmlDeclaration
, &value
);
153 ok(hr
== S_OK
, "Expected S_OK, got %08x\n", hr
);
154 ok(value
== FALSE
, "got %ld\n", value
);
156 value
= XmlConformanceLevel_Auto
;
157 hr
= IXmlWriter_GetProperty(writer
, XmlWriterProperty_ConformanceLevel
, &value
);
158 ok(hr
== S_OK
, "Expected S_OK, got %08x\n", hr
);
159 ok(value
== XmlConformanceLevel_Document
, "got %ld\n", value
);
161 IXmlWriter_Release(writer
);
164 static BOOL
init_pointers(void)
166 /* don't free module here, it's to be unloaded on exit */
167 HMODULE mod
= LoadLibraryA("xmllite.dll");
171 win_skip("xmllite library not available\n");
175 #define MAKEFUNC(f) if (!(p##f = (void*)GetProcAddress(mod, #f))) return FALSE;
176 MAKEFUNC(CreateXmlWriter
);
177 MAKEFUNC(CreateXmlWriterOutputWithEncodingName
);
183 static void test_writeroutput(void)
185 static const WCHAR utf16W
[] = {'u','t','f','-','1','6',0};
186 IXmlWriterOutput
*output
;
191 hr
= pCreateXmlWriterOutputWithEncodingName(&testoutput
, NULL
, NULL
, &output
);
192 ok(hr
== S_OK
, "got %08x\n", hr
);
193 IUnknown_Release(output
);
195 hr
= pCreateXmlWriterOutputWithEncodingName(&testoutput
, NULL
, utf16W
, &output
);
196 ok(hr
== S_OK
, "got %08x\n", hr
);
198 hr
= IUnknown_QueryInterface(output
, &IID_IXmlWriterOutput
, (void**)&unk
);
199 ok(hr
== S_OK
, "got %08x\n", hr
);
200 ok(unk
!= NULL
, "got %p\n", unk
);
201 /* releasing 'unk' crashes on native */
202 IUnknown_Release(output
);
205 static void test_writestartdocument(void)
207 static const char fullprolog
[] = "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>";
208 static const char prologversion
[] = "<?xml version=\"1.0\"?>";
209 static const WCHAR versionW
[] = {'v','e','r','s','i','o','n','=','"','1','.','0','"',0};
210 static const WCHAR xmlW
[] = {'x','m','l',0};
217 hr
= pCreateXmlWriter(&IID_IXmlWriter
, (void**)&writer
, NULL
);
218 ok(hr
== S_OK
, "Expected S_OK, got %08x\n", hr
);
221 hr
= IXmlWriter_WriteStartDocument(writer
, XmlStandalone_Yes
);
222 ok(hr
== E_UNEXPECTED
, "got 0x%08x\n", hr
);
224 hr
= IXmlWriter_WriteProcessingInstruction(writer
, xmlW
, versionW
);
225 ok(hr
== E_UNEXPECTED
, "got 0x%08x\n", hr
);
227 hr
= IXmlWriter_Flush(writer
);
228 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
230 hr
= CreateStreamOnHGlobal(NULL
, TRUE
, &stream
);
231 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
233 hr
= IXmlWriter_SetOutput(writer
, (IUnknown
*)stream
);
234 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
236 /* nothing written yet */
237 hr
= IXmlWriter_Flush(writer
);
238 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
240 hr
= IXmlWriter_WriteStartDocument(writer
, XmlStandalone_Yes
);
241 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
243 hr
= IXmlWriter_Flush(writer
);
244 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
246 hr
= GetHGlobalFromStream(stream
, &hglobal
);
247 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
249 ptr
= GlobalLock(hglobal
);
250 ok(!strncmp(ptr
, fullprolog
, strlen(fullprolog
)), "got %s, expected %s\n", ptr
, fullprolog
);
251 GlobalUnlock(hglobal
);
254 hr
= IXmlWriter_WriteStartDocument(writer
, XmlStandalone_Yes
);
255 ok(hr
== WR_E_INVALIDACTION
, "got 0x%08x\n", hr
);
256 IStream_Release(stream
);
258 /* now add PI manually, and try to start a document */
259 hr
= CreateStreamOnHGlobal(NULL
, TRUE
, &stream
);
260 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
262 hr
= IXmlWriter_SetOutput(writer
, (IUnknown
*)stream
);
263 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
265 hr
= IXmlWriter_WriteProcessingInstruction(writer
, xmlW
, versionW
);
266 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
268 hr
= IXmlWriter_WriteStartDocument(writer
, XmlStandalone_Yes
);
269 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
271 hr
= IXmlWriter_WriteStartDocument(writer
, XmlStandalone_Yes
);
272 ok(hr
== WR_E_INVALIDACTION
, "got 0x%08x\n", hr
);
274 /* another attempt to add 'xml' PI */
275 hr
= IXmlWriter_WriteProcessingInstruction(writer
, xmlW
, versionW
);
276 ok(hr
== WR_E_INVALIDACTION
, "got 0x%08x\n", hr
);
278 hr
= IXmlWriter_Flush(writer
);
279 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
281 hr
= GetHGlobalFromStream(stream
, &hglobal
);
282 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
284 ptr
= GlobalLock(hglobal
);
285 ok(!strncmp(ptr
, prologversion
, strlen(prologversion
)), "got %s\n", ptr
);
286 GlobalUnlock(hglobal
);
288 IStream_Release(stream
);
289 IXmlWriter_Release(writer
);
292 static void test_flush(void)
297 hr
= pCreateXmlWriter(&IID_IXmlWriter
, (void**)&writer
, NULL
);
298 ok(hr
== S_OK
, "Expected S_OK, got %08x\n", hr
);
300 hr
= IXmlWriter_SetOutput(writer
, (IUnknown
*)&teststream
);
301 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
303 hr
= IXmlWriter_WriteStartDocument(writer
, XmlStandalone_Yes
);
304 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
307 hr
= IXmlWriter_Flush(writer
);
308 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
309 ok(g_write_len
> 0, "got %d\n", g_write_len
);
312 hr
= IXmlWriter_Flush(writer
);
313 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
314 ok(g_write_len
== 0, "got %d\n", g_write_len
);
316 /* Release() flushes too */
318 IXmlWriter_Release(writer
);
319 ok(g_write_len
== 0, "got %d\n", g_write_len
);
322 static void test_omitxmldeclaration(void)
324 static const char prologversion
[] = "<?xml version=\"1.0\"?>";
325 static const WCHAR versionW
[] = {'v','e','r','s','i','o','n','=','"','1','.','0','"',0};
326 static const WCHAR xmlW
[] = {'x','m','l',0};
333 hr
= pCreateXmlWriter(&IID_IXmlWriter
, (void**)&writer
, NULL
);
334 ok(hr
== S_OK
, "Expected S_OK, got %08x\n", hr
);
336 hr
= CreateStreamOnHGlobal(NULL
, TRUE
, &stream
);
337 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
339 hr
= IXmlWriter_SetOutput(writer
, (IUnknown
*)stream
);
340 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
342 hr
= IXmlWriter_SetProperty(writer
, XmlWriterProperty_OmitXmlDeclaration
, TRUE
);
343 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
345 hr
= IXmlWriter_WriteStartDocument(writer
, XmlStandalone_Yes
);
346 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
348 hr
= IXmlWriter_Flush(writer
);
349 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
351 hr
= GetHGlobalFromStream(stream
, &hglobal
);
352 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
354 ptr
= GlobalLock(hglobal
);
355 ok(!ptr
, "got %p\n", ptr
);
356 GlobalUnlock(hglobal
);
359 hr
= IXmlWriter_WriteStartDocument(writer
, XmlStandalone_Yes
);
360 ok(hr
== WR_E_INVALIDACTION
, "got 0x%08x\n", hr
);
362 IStream_Release(stream
);
364 /* now add PI manually, and try to start a document */
365 hr
= CreateStreamOnHGlobal(NULL
, TRUE
, &stream
);
366 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
368 hr
= IXmlWriter_SetOutput(writer
, (IUnknown
*)stream
);
369 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
371 hr
= IXmlWriter_WriteProcessingInstruction(writer
, xmlW
, versionW
);
372 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
374 hr
= IXmlWriter_Flush(writer
);
375 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
377 hr
= GetHGlobalFromStream(stream
, &hglobal
);
378 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
380 ptr
= GlobalLock(hglobal
);
381 ok(!strncmp(ptr
, prologversion
, strlen(prologversion
)), "got %s\n", ptr
);
382 GlobalUnlock(hglobal
);
384 hr
= IXmlWriter_WriteStartDocument(writer
, XmlStandalone_Yes
);
385 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
387 hr
= IXmlWriter_Flush(writer
);
388 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
390 ptr
= GlobalLock(hglobal
);
391 ok(!strncmp(ptr
, prologversion
, strlen(prologversion
)), "got %s\n", ptr
);
392 GlobalUnlock(hglobal
);
394 hr
= IXmlWriter_WriteStartDocument(writer
, XmlStandalone_Yes
);
395 ok(hr
== WR_E_INVALIDACTION
, "got 0x%08x\n", hr
);
397 hr
= IXmlWriter_Flush(writer
);
398 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
400 ptr
= GlobalLock(hglobal
);
401 ok(!strncmp(ptr
, prologversion
, strlen(prologversion
)), "got %s\n", ptr
);
402 GlobalUnlock(hglobal
);
404 /* another attempt to add 'xml' PI */
405 hr
= IXmlWriter_WriteProcessingInstruction(writer
, xmlW
, versionW
);
406 ok(hr
== WR_E_INVALIDACTION
, "got 0x%08x\n", hr
);
408 hr
= IXmlWriter_Flush(writer
);
409 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
411 IStream_Release(stream
);
412 IXmlWriter_Release(writer
);
415 static void test_bom(void)
417 static const WCHAR versionW
[] = {'v','e','r','s','i','o','n','=','"','1','.','0','"',0};
418 static const WCHAR utf16W
[] = {'u','t','f','-','1','6',0};
419 static const WCHAR xmlW
[] = {'x','m','l',0};
420 static const WCHAR aW
[] = {'a',0};
421 IXmlWriterOutput
*output
;
428 hr
= CreateStreamOnHGlobal(NULL
, TRUE
, &stream
);
429 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
431 hr
= pCreateXmlWriterOutputWithEncodingName((IUnknown
*)stream
, NULL
, utf16W
, &output
);
432 ok(hr
== S_OK
, "got %08x\n", hr
);
434 hr
= pCreateXmlWriter(&IID_IXmlWriter
, (void**)&writer
, NULL
);
435 ok(hr
== S_OK
, "Expected S_OK, got %08x\n", hr
);
437 hr
= IXmlWriter_SetProperty(writer
, XmlWriterProperty_OmitXmlDeclaration
, TRUE
);
438 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
440 hr
= IXmlWriter_SetOutput(writer
, output
);
441 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
443 /* BOM is on by default */
444 hr
= IXmlWriter_WriteStartDocument(writer
, XmlStandalone_Yes
);
445 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
447 hr
= IXmlWriter_Flush(writer
);
448 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
450 hr
= GetHGlobalFromStream(stream
, &hglobal
);
451 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
453 ptr
= GlobalLock(hglobal
);
454 ok(ptr
[0] == 0xff && ptr
[1] == 0xfe, "got %x,%x\n", ptr
[0], ptr
[1]);
455 GlobalUnlock(hglobal
);
457 IStream_Release(stream
);
458 IUnknown_Release(output
);
461 hr
= CreateStreamOnHGlobal(NULL
, TRUE
, &stream
);
462 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
464 hr
= pCreateXmlWriterOutputWithEncodingName((IUnknown
*)stream
, NULL
, utf16W
, &output
);
465 ok(hr
== S_OK
, "got %08x\n", hr
);
467 hr
= IXmlWriter_SetOutput(writer
, output
);
468 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
470 hr
= IXmlWriter_WriteProcessingInstruction(writer
, xmlW
, versionW
);
471 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
473 hr
= IXmlWriter_Flush(writer
);
474 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
476 hr
= GetHGlobalFromStream(stream
, &hglobal
);
477 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
479 ptr
= GlobalLock(hglobal
);
480 ok(ptr
[0] == 0xff && ptr
[1] == 0xfe, "got %x,%x\n", ptr
[0], ptr
[1]);
481 GlobalUnlock(hglobal
);
483 IUnknown_Release(output
);
484 IStream_Release(stream
);
486 /* start with element */
487 hr
= CreateStreamOnHGlobal(NULL
, TRUE
, &stream
);
488 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
490 hr
= pCreateXmlWriterOutputWithEncodingName((IUnknown
*)stream
, NULL
, utf16W
, &output
);
491 ok(hr
== S_OK
, "got %08x\n", hr
);
493 hr
= IXmlWriter_SetOutput(writer
, output
);
494 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
496 hr
= IXmlWriter_WriteStartElement(writer
, NULL
, aW
, NULL
);
497 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
499 hr
= IXmlWriter_Flush(writer
);
500 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
502 hr
= GetHGlobalFromStream(stream
, &hglobal
);
503 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
505 ptr
= GlobalLock(hglobal
);
506 ok(ptr
[0] == 0xff && ptr
[1] == 0xfe, "got %x,%x\n", ptr
[0], ptr
[1]);
507 GlobalUnlock(hglobal
);
509 IUnknown_Release(output
);
510 IStream_Release(stream
);
512 /* WriteElementString */
513 hr
= CreateStreamOnHGlobal(NULL
, TRUE
, &stream
);
514 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
516 hr
= pCreateXmlWriterOutputWithEncodingName((IUnknown
*)stream
, NULL
, utf16W
, &output
);
517 ok(hr
== S_OK
, "got %08x\n", hr
);
519 hr
= IXmlWriter_SetOutput(writer
, output
);
520 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
522 hr
= IXmlWriter_WriteElementString(writer
, NULL
, aW
, NULL
, NULL
);
523 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
525 hr
= IXmlWriter_Flush(writer
);
526 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
528 hr
= GetHGlobalFromStream(stream
, &hglobal
);
529 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
531 ptr
= GlobalLock(hglobal
);
532 ok(ptr
[0] == 0xff && ptr
[1] == 0xfe, "got %x,%x\n", ptr
[0], ptr
[1]);
533 GlobalUnlock(hglobal
);
535 IUnknown_Release(output
);
536 IStream_Release(stream
);
538 IXmlWriter_Release(writer
);
541 static void test_writestartelement(void)
543 static const WCHAR valueW
[] = {'v','a','l','u','e',0};
544 static const char *str
= "<a><b>value</b>";
545 static const WCHAR aW
[] = {'a',0};
546 static const WCHAR bW
[] = {'b',0};
553 hr
= CreateStreamOnHGlobal(NULL
, TRUE
, &stream
);
554 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
556 hr
= pCreateXmlWriter(&IID_IXmlWriter
, (void**)&writer
, NULL
);
557 ok(hr
== S_OK
, "Expected S_OK, got %08x\n", hr
);
559 hr
= IXmlWriter_WriteStartElement(writer
, NULL
, aW
, NULL
);
560 ok(hr
== E_UNEXPECTED
, "got 0x%08x\n", hr
);
562 hr
= IXmlWriter_SetOutput(writer
, (IUnknown
*)stream
);
563 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
565 hr
= IXmlWriter_WriteStartElement(writer
, aW
, NULL
, NULL
);
566 ok(hr
== E_INVALIDARG
, "got 0x%08x\n", hr
);
568 hr
= IXmlWriter_WriteStartElement(writer
, NULL
, NULL
, NULL
);
569 ok(hr
== E_INVALIDARG
, "got 0x%08x\n", hr
);
571 hr
= IXmlWriter_WriteStartElement(writer
, NULL
, NULL
, aW
);
572 ok(hr
== E_INVALIDARG
, "got 0x%08x\n", hr
);
574 hr
= IXmlWriter_WriteStartElement(writer
, NULL
, aW
, NULL
);
575 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
577 hr
= GetHGlobalFromStream(stream
, &hglobal
);
578 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
580 hr
= IXmlWriter_WriteStartDocument(writer
, XmlStandalone_Yes
);
581 ok(hr
== WR_E_INVALIDACTION
, "got 0x%08x\n", hr
);
583 hr
= IXmlWriter_Flush(writer
);
584 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
586 ptr
= GlobalLock(hglobal
);
587 ok(!strncmp(ptr
, "<a", 2), "got %s\n", ptr
);
588 GlobalUnlock(hglobal
);
590 hr
= IXmlWriter_WriteStartDocument(writer
, XmlStandalone_Yes
);
591 ok(hr
== WR_E_INVALIDACTION
, "got 0x%08x\n", hr
);
593 hr
= IXmlWriter_WriteStartElement(writer
, NULL
, NULL
, NULL
);
594 ok(hr
== E_INVALIDARG
, "got 0x%08x\n", hr
);
596 hr
= IXmlWriter_WriteProcessingInstruction(writer
, aW
, aW
);
597 ok(hr
== WR_E_INVALIDACTION
, "got 0x%08x\n", hr
);
599 IStream_Release(stream
);
600 IXmlWriter_Release(writer
);
602 /* WriteElementString */
603 hr
= pCreateXmlWriter(&IID_IXmlWriter
, (void**)&writer
, NULL
);
604 ok(hr
== S_OK
, "Expected S_OK, got %08x\n", hr
);
606 hr
= CreateStreamOnHGlobal(NULL
, TRUE
, &stream
);
607 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
609 hr
= IXmlWriter_WriteElementString(writer
, NULL
, bW
, NULL
, valueW
);
610 ok(hr
== E_UNEXPECTED
, "got 0x%08x\n", hr
);
612 hr
= IXmlWriter_SetOutput(writer
, (IUnknown
*)stream
);
613 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
615 hr
= IXmlWriter_WriteStartElement(writer
, NULL
, aW
, NULL
);
616 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
618 hr
= IXmlWriter_WriteElementString(writer
, NULL
, bW
, NULL
, valueW
);
619 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
621 hr
= IXmlWriter_Flush(writer
);
622 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
624 hr
= GetHGlobalFromStream(stream
, &hglobal
);
625 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
627 ptr
= GlobalLock(hglobal
);
628 ok(!strncmp(ptr
, str
, strlen(str
)), "got %s\n", ptr
);
629 GlobalUnlock(hglobal
);
631 IStream_Release(stream
);
632 IXmlWriter_Release(writer
);
635 static void test_writeendelement(void)
637 static const WCHAR aW
[] = {'a',0};
638 static const WCHAR bW
[] = {'b',0};
645 hr
= CreateStreamOnHGlobal(NULL
, TRUE
, &stream
);
646 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
648 hr
= pCreateXmlWriter(&IID_IXmlWriter
, (void**)&writer
, NULL
);
649 ok(hr
== S_OK
, "Expected S_OK, got %08x\n", hr
);
651 hr
= IXmlWriter_SetOutput(writer
, (IUnknown
*)stream
);
652 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
654 hr
= IXmlWriter_WriteStartElement(writer
, NULL
, aW
, NULL
);
655 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
657 hr
= IXmlWriter_WriteStartElement(writer
, NULL
, bW
, NULL
);
658 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
660 hr
= IXmlWriter_WriteEndElement(writer
);
661 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
663 hr
= IXmlWriter_WriteEndElement(writer
);
664 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
666 hr
= GetHGlobalFromStream(stream
, &hglobal
);
667 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
669 hr
= IXmlWriter_Flush(writer
);
670 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
672 ptr
= GlobalLock(hglobal
);
673 ok(!strncmp(ptr
, "<a><b /></a>", 12), "got %s\n", ptr
);
674 GlobalUnlock(hglobal
);
676 IXmlWriter_Release(writer
);
677 IStream_Release(stream
);
680 static void test_writeenddocument(void)
682 static const WCHAR aW
[] = {'a',0};
683 static const WCHAR bW
[] = {'b',0};
690 hr
= CreateStreamOnHGlobal(NULL
, TRUE
, &stream
);
691 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
693 hr
= pCreateXmlWriter(&IID_IXmlWriter
, (void**)&writer
, NULL
);
694 ok(hr
== S_OK
, "Expected S_OK, got %08x\n", hr
);
696 hr
= IXmlWriter_WriteEndDocument(writer
);
697 ok(hr
== E_UNEXPECTED
, "got 0x%08x\n", hr
);
699 hr
= IXmlWriter_SetOutput(writer
, (IUnknown
*)stream
);
700 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
702 /* WriteEndDocument resets it to initial state */
703 hr
= IXmlWriter_WriteEndDocument(writer
);
704 ok(hr
== WR_E_INVALIDACTION
, "got 0x%08x\n", hr
);
706 hr
= IXmlWriter_WriteEndDocument(writer
);
707 ok(hr
== WR_E_INVALIDACTION
, "got 0x%08x\n", hr
);
709 hr
= IXmlWriter_WriteStartDocument(writer
, XmlStandalone_Omit
);
710 ok(hr
== WR_E_INVALIDACTION
, "got 0x%08x\n", hr
);
712 hr
= IXmlWriter_WriteStartElement(writer
, NULL
, aW
, NULL
);
713 ok(hr
== WR_E_INVALIDACTION
, "got 0x%08x\n", hr
);
715 hr
= IXmlWriter_SetOutput(writer
, (IUnknown
*)stream
);
716 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
718 hr
= IXmlWriter_WriteStartElement(writer
, NULL
, aW
, NULL
);
719 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
721 hr
= IXmlWriter_WriteStartElement(writer
, NULL
, bW
, NULL
);
722 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
724 hr
= IXmlWriter_WriteEndDocument(writer
);
725 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
727 hr
= GetHGlobalFromStream(stream
, &hglobal
);
728 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
730 ptr
= GlobalLock(hglobal
);
731 ok(ptr
== NULL
, "got %p\n", ptr
);
733 /* we still need to flush manually, WriteEndDocument doesn't do that */
734 hr
= IXmlWriter_Flush(writer
);
735 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
737 ptr
= GlobalLock(hglobal
);
738 ok(ptr
!= NULL
, "got %p\n", ptr
);
739 ok(!strncmp(ptr
, "<a><b /></a>", 12), "got %s\n", ptr
);
740 GlobalUnlock(hglobal
);
742 IXmlWriter_Release(writer
);
743 IStream_Release(stream
);
748 if (!init_pointers())
751 test_writer_create();
753 test_writestartdocument();
754 test_writestartelement();
755 test_writeendelement();
757 test_omitxmldeclaration();
759 test_writeenddocument();