Sweden-Number/dlls/webservices/tests/writer.c

461 lines
16 KiB
C

/*
* Copyright 2015 Hans Leidekker for CodeWeavers
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
#include <stdio.h>
#include "windows.h"
#include "webservices.h"
#include "wine/test.h"
static HRESULT set_output( WS_XML_WRITER *writer )
{
WS_XML_WRITER_TEXT_ENCODING encoding;
WS_XML_WRITER_BUFFER_OUTPUT output;
encoding.encoding.encodingType = WS_XML_WRITER_ENCODING_TYPE_TEXT;
encoding.charSet = WS_CHARSET_UTF8;
output.output.outputType = WS_XML_WRITER_OUTPUT_TYPE_BUFFER;
return WsSetOutput( writer, &encoding.encoding, &output.output, NULL, 0, NULL );
}
static void test_WsCreateWriter(void)
{
HRESULT hr;
WS_XML_WRITER *writer;
WS_XML_WRITER_PROPERTY prop;
ULONG size, max_depth, max_attrs, indent, trim_size, max_size, max_ns;
BOOL allow_fragment, write_decl, in_attr;
WS_CHARSET charset;
WS_BUFFERS buffers;
WS_BYTES bytes;
hr = WsCreateWriter( NULL, 0, NULL, NULL ) ;
ok( hr == E_INVALIDARG, "got %08x\n", hr );
writer = NULL;
hr = WsCreateWriter( NULL, 0, &writer, NULL ) ;
ok( hr == S_OK, "got %08x\n", hr );
ok( writer != NULL, "writer not set\n" );
/* can't retrieve properties before output is set */
max_depth = 0xdeadbeef;
size = sizeof(max_depth);
hr = WsGetWriterProperty( writer, WS_XML_WRITER_PROPERTY_MAX_DEPTH, &max_depth, size, NULL );
ok( hr == WS_E_INVALID_OPERATION, "got %08x\n", hr );
ok( max_depth == 0xdeadbeef, "max_depth set\n" );
hr = set_output( writer );
ok( hr == S_OK, "got %08x\n", hr );
/* check some defaults */
max_depth = 0xdeadbeef;
size = sizeof(max_depth);
hr = WsGetWriterProperty( writer, WS_XML_WRITER_PROPERTY_MAX_DEPTH, &max_depth, size, NULL );
ok( hr == S_OK, "got %08x\n", hr );
ok( max_depth == 32, "got %u\n", max_depth );
allow_fragment = TRUE;
size = sizeof(allow_fragment);
hr = WsGetWriterProperty( writer, WS_XML_WRITER_PROPERTY_ALLOW_FRAGMENT, &allow_fragment, size, NULL );
ok( hr == S_OK, "got %08x\n", hr );
ok( !allow_fragment, "got %d\n", allow_fragment );
max_attrs = 0xdeadbeef;
size = sizeof(max_attrs);
hr = WsGetWriterProperty( writer, WS_XML_WRITER_PROPERTY_MAX_ATTRIBUTES, &max_attrs, size, NULL );
ok( hr == S_OK, "got %08x\n", hr );
ok( max_attrs == 128, "got %u\n", max_attrs );
write_decl = TRUE;
size = sizeof(write_decl);
hr = WsGetWriterProperty( writer, WS_XML_WRITER_PROPERTY_WRITE_DECLARATION, &write_decl, size, NULL );
ok( hr == S_OK, "got %08x\n", hr );
ok( !write_decl, "got %d\n", write_decl );
indent = 0xdeadbeef;
size = sizeof(indent);
hr = WsGetWriterProperty( writer, WS_XML_WRITER_PROPERTY_INDENT, &indent, size, NULL );
ok( hr == S_OK, "got %08x\n", hr );
ok( !indent, "got %u\n", indent );
trim_size = 0xdeadbeef;
size = sizeof(trim_size);
hr = WsGetWriterProperty( writer, WS_XML_WRITER_PROPERTY_BUFFER_TRIM_SIZE, &trim_size, size, NULL );
ok( hr == S_OK, "got %08x\n", hr );
ok( trim_size == 4096, "got %u\n", trim_size );
charset = 0xdeadbeef;
size = sizeof(charset);
hr = WsGetWriterProperty( writer, WS_XML_WRITER_PROPERTY_CHARSET, &charset, size, NULL );
ok( hr == S_OK, "got %08x\n", hr );
ok( charset == WS_CHARSET_UTF8, "got %u\n", charset );
buffers.bufferCount = 0xdeadbeef;
buffers.buffers = (WS_BYTES *)0xdeadbeef;
size = sizeof(buffers);
hr = WsGetWriterProperty( writer, WS_XML_WRITER_PROPERTY_BUFFERS, &buffers, size, NULL );
ok( hr == S_OK, "got %08x\n", hr );
ok( !buffers.bufferCount, "got %u\n", buffers.bufferCount );
ok( !buffers.buffers, "got %p\n", buffers.buffers );
max_size = 0xdeadbeef;
size = sizeof(max_size);
hr = WsGetWriterProperty( writer, WS_XML_WRITER_PROPERTY_BUFFER_MAX_SIZE, &max_size, size, NULL );
ok( hr == S_OK, "got %08x\n", hr );
ok( max_size == 65536, "got %u\n", max_size );
bytes.length = 0xdeadbeef;
bytes.bytes = (BYTE *)0xdeadbeef;
size = sizeof(buffers);
hr = WsGetWriterProperty( writer, WS_XML_WRITER_PROPERTY_BYTES, &bytes, size, NULL );
ok( hr == S_OK, "got %08x\n", hr );
ok( !bytes.length, "got %u\n", bytes.length );
ok( bytes.bytes != NULL, "got %p\n", bytes.bytes );
max_size = 0xdeadbeef;
size = sizeof(max_size);
hr = WsGetWriterProperty( writer, WS_XML_WRITER_PROPERTY_MAX_MIME_PARTS_BUFFER_SIZE, &max_size, size, NULL );
ok( hr == S_OK, "got %08x\n", hr );
ok( max_size == 65536, "got %u\n", max_size );
bytes.length = 0xdeadbeef;
bytes.bytes = (BYTE *)0xdeadbeef;
size = sizeof(bytes);
hr = WsGetWriterProperty( writer, WS_XML_WRITER_PROPERTY_INITIAL_BUFFER, &bytes, size, NULL );
ok( hr == S_OK, "got %08x\n", hr );
ok( !bytes.length, "got %u\n", bytes.length );
ok( !bytes.bytes, "got %p\n", bytes.bytes );
max_ns = 0xdeadbeef;
size = sizeof(max_ns);
hr = WsGetWriterProperty( writer, WS_XML_WRITER_PROPERTY_MAX_NAMESPACES, &max_ns, size, NULL );
ok( hr == S_OK, "got %08x\n", hr );
ok( max_ns == 32, "got %u\n", max_ns );
WsFreeWriter( writer );
/* change a property */
max_depth = 16;
prop.id = WS_XML_WRITER_PROPERTY_MAX_DEPTH;
prop.value = &max_depth;
prop.valueSize = sizeof(max_depth);
hr = WsCreateWriter( &prop, 1, &writer, NULL ) ;
ok( hr == S_OK, "got %08x\n", hr );
hr = set_output( writer );
ok( hr == S_OK, "got %08x\n", hr );
max_depth = 0xdeadbeef;
size = sizeof(max_depth);
hr = WsGetWriterProperty( writer, WS_XML_WRITER_PROPERTY_MAX_DEPTH, &max_depth, size, NULL );
ok( hr == S_OK, "got %08x\n", hr );
ok( max_depth == 16, "got %u\n", max_depth );
WsFreeWriter( writer );
/* show that some properties are read-only */
in_attr = TRUE;
prop.id = WS_XML_WRITER_PROPERTY_IN_ATTRIBUTE;
prop.value = &in_attr;
prop.valueSize = sizeof(in_attr);
hr = WsCreateWriter( &prop, 1, &writer, NULL ) ;
ok( hr == E_INVALIDARG, "got %08x\n", hr );
size = 1;
prop.id = WS_XML_WRITER_PROPERTY_BYTES_WRITTEN;
prop.value = &size;
prop.valueSize = sizeof(size);
hr = WsCreateWriter( &prop, 1, &writer, NULL ) ;
ok( hr == E_INVALIDARG, "got %08x\n", hr );
size = 1;
prop.id = WS_XML_WRITER_PROPERTY_BYTES_TO_CLOSE;
prop.value = &size;
prop.valueSize = sizeof(size);
hr = WsCreateWriter( &prop, 1, &writer, NULL ) ;
ok( hr == E_INVALIDARG, "got %08x\n", hr );
}
static void test_WsCreateXmlBuffer(void)
{
HRESULT hr;
WS_HEAP *heap;
WS_XML_WRITER *writer;
WS_XML_BUFFER *buffer;
WS_BYTES bytes;
ULONG size;
hr = WsCreateXmlBuffer( NULL, NULL, 0, NULL, NULL );
ok( hr == E_INVALIDARG, "got %08x\n", hr );
hr = WsCreateXmlBuffer( NULL, NULL, 0, &buffer, NULL );
ok( hr == E_INVALIDARG, "got %08x\n", hr );
hr = WsCreateHeap( 1 << 16, 0, NULL, 0, &heap, NULL );
ok( hr == S_OK, "got %08x\n", hr );
hr = WsCreateXmlBuffer( heap, NULL, 0, NULL, NULL );
ok( hr == E_INVALIDARG, "got %08x\n", hr );
buffer = NULL;
hr = WsCreateXmlBuffer( heap, NULL, 0, &buffer, NULL );
ok( hr == S_OK, "got %08x\n", hr );
ok( buffer != NULL, "buffer not set\n" );
hr = WsCreateWriter( NULL, 0, &writer, NULL ) ;
ok( hr == S_OK, "got %08x\n", hr );
size = sizeof(bytes);
hr = WsGetWriterProperty( writer, WS_XML_WRITER_PROPERTY_BYTES, &bytes, size, NULL );
ok( hr == WS_E_INVALID_OPERATION, "got %08x\n", hr );
hr = WsSetOutputToBuffer( writer, buffer, NULL, 0, NULL );
ok( hr == S_OK, "got %08x\n", hr );
size = sizeof(bytes);
hr = WsGetWriterProperty( writer, WS_XML_WRITER_PROPERTY_BYTES, &bytes, size, NULL );
todo_wine ok( hr == E_INVALIDARG, "got %08x\n", hr );
WsFreeWriter( writer );
WsFreeHeap( heap );
}
static void test_WsSetOutput(void)
{
HRESULT hr;
WS_XML_WRITER *writer;
WS_XML_WRITER_PROPERTY prop;
WS_XML_WRITER_TEXT_ENCODING encoding;
WS_XML_WRITER_BUFFER_OUTPUT output;
ULONG size, max_depth;
hr = WsCreateWriter( NULL, 0, &writer, NULL ) ;
ok( hr == S_OK, "got %08x\n", hr );
hr = WsSetOutput( NULL, NULL, NULL, NULL, 0, NULL );
ok( hr == E_INVALIDARG, "got %08x\n", hr );
encoding.encoding.encodingType = WS_XML_WRITER_ENCODING_TYPE_TEXT;
encoding.charSet = WS_CHARSET_UTF8;
output.output.outputType = WS_XML_WRITER_OUTPUT_TYPE_BUFFER;
hr = WsSetOutput( writer, &encoding.encoding, &output.output, NULL, 0, NULL );
ok( hr == S_OK, "got %08x\n", hr );
/* multiple calls are allowed */
hr = WsSetOutput( writer, &encoding.encoding, &output.output, NULL, 0, NULL );
ok( hr == S_OK, "got %08x\n", hr );
/* writer properties can be set with WsSetOutput */
max_depth = 16;
prop.id = WS_XML_WRITER_PROPERTY_MAX_DEPTH;
prop.value = &max_depth;
prop.valueSize = sizeof(max_depth);
hr = WsSetOutput( writer, &encoding.encoding, &output.output, &prop, 1, NULL );
ok( hr == S_OK, "got %08x\n", hr );
max_depth = 0xdeadbeef;
size = sizeof(max_depth);
hr = WsGetWriterProperty( writer, WS_XML_WRITER_PROPERTY_MAX_DEPTH, &max_depth, size, NULL );
ok( hr == S_OK, "got %08x\n", hr );
ok( max_depth == 16, "got %u\n", max_depth );
WsFreeWriter( writer );
}
static void test_WsSetOutputToBuffer(void)
{
HRESULT hr;
WS_HEAP *heap;
WS_XML_BUFFER *buffer;
WS_XML_WRITER *writer;
WS_XML_WRITER_PROPERTY prop;
ULONG size, max_depth;
hr = WsSetOutputToBuffer( NULL, NULL, NULL, 0, NULL );
ok( hr == E_INVALIDARG, "got %08x\n", hr );
hr = WsCreateWriter( NULL, 0, &writer, NULL ) ;
ok( hr == S_OK, "got %08x\n", hr );
hr = WsSetOutputToBuffer( writer, NULL, NULL, 0, NULL );
ok( hr == E_INVALIDARG, "got %08x\n", hr );
hr = WsCreateHeap( 1 << 16, 0, NULL, 0, &heap, NULL );
ok( hr == S_OK, "got %08x\n", hr );
hr = WsCreateXmlBuffer( heap, NULL, 0, &buffer, NULL );
ok( hr == S_OK, "got %08x\n", hr );
hr = WsSetOutputToBuffer( writer, buffer, NULL, 0, NULL );
ok( hr == S_OK, "got %08x\n", hr );
/* multiple calls are allowed */
hr = WsSetOutputToBuffer( writer, buffer, NULL, 0, NULL );
ok( hr == S_OK, "got %08x\n", hr );
/* writer properties can be set with WsSetOutputToBuffer */
max_depth = 16;
prop.id = WS_XML_WRITER_PROPERTY_MAX_DEPTH;
prop.value = &max_depth;
prop.valueSize = sizeof(max_depth);
hr = WsSetOutputToBuffer( writer, buffer, &prop, 1, NULL );
ok( hr == S_OK, "got %08x\n", hr );
max_depth = 0xdeadbeef;
size = sizeof(max_depth);
hr = WsGetWriterProperty( writer, WS_XML_WRITER_PROPERTY_MAX_DEPTH, &max_depth, size, NULL );
ok( hr == S_OK, "got %08x\n", hr );
ok( max_depth == 16, "got %u\n", max_depth );
WsFreeWriter( writer );
WsFreeHeap( heap );
}
static void check_output( WS_XML_WRITER *writer, const char *expected, unsigned int line )
{
WS_BYTES bytes;
ULONG size = sizeof(bytes);
int len = strlen( expected );
HRESULT hr;
memset( &bytes, 0, sizeof(bytes) );
hr = WsGetWriterProperty( writer, WS_XML_WRITER_PROPERTY_BYTES, &bytes, size, NULL );
ok( hr == S_OK, "%u: got %08x\n", line, hr );
ok( bytes.length == len, "%u: got %u expected %u\n", line, bytes.length, len );
if (bytes.length != len) return;
ok( !memcmp( bytes.bytes, expected, len ), "%u: got %s expected %s\n", line, bytes.bytes, expected );
}
static void test_WsWriteStartElement(void)
{
HRESULT hr;
WS_XML_WRITER *writer;
WS_XML_STRING prefix = {1, (BYTE *)"p"}, ns = {2, (BYTE *)"ns"};
WS_XML_STRING localname = {1, (BYTE *)"a"}, localname2 = {1, (BYTE *)"b"};
hr = WsCreateWriter( NULL, 0, &writer, NULL ) ;
ok( hr == S_OK, "got %08x\n", hr );
hr = set_output( writer );
ok( hr == S_OK, "got %08x\n", hr );
hr = WsWriteStartElement( NULL, &prefix, &localname, &ns, NULL );
ok( hr == E_INVALIDARG, "got %08x\n", hr );
/* first call to WsWriteStartElement doesn't output anything */
hr = WsWriteStartElement( writer, &prefix, &localname, &ns, NULL );
ok( hr == S_OK, "got %08x\n", hr );
check_output( writer, "", __LINE__ );
/* two ways to close an element */
hr = WsWriteEndStartElement( writer, NULL );
ok( hr == S_OK, "got %08x\n", hr );
check_output( writer, "<p:a xmlns:p=\"ns\">", __LINE__ );
hr = WsWriteEndElement( writer, NULL );
ok( hr == S_OK, "got %08x\n", hr );
check_output( writer, "<p:a xmlns:p=\"ns\"></p:a>", __LINE__ );
hr = set_output( writer );
ok( hr == S_OK, "got %08x\n", hr );
hr = WsWriteStartElement( writer, &prefix, &localname, &ns, NULL );
ok( hr == S_OK, "got %08x\n", hr );
hr = WsWriteEndElement( writer, NULL );
ok( hr == S_OK, "got %08x\n", hr );
check_output( writer, "<p:a xmlns:p=\"ns\"/>", __LINE__ );
/* nested elements */
hr = set_output( writer );
ok( hr == S_OK, "got %08x\n", hr );
hr = WsWriteStartElement( writer, NULL, &localname, &ns, NULL );
ok( hr == S_OK, "got %08x\n", hr );
check_output( writer, "", __LINE__ );
hr = WsWriteStartElement( writer, NULL, &localname2, &ns, NULL );
ok( hr == S_OK, "got %08x\n", hr );
check_output( writer, "<a xmlns=\"ns\">", __LINE__ );
hr = WsWriteEndElement( writer, NULL );
ok( hr == S_OK, "got %08x\n", hr );
check_output( writer, "<a xmlns=\"ns\"><b/>", __LINE__ );
hr = WsWriteEndElement( writer, NULL );
ok( hr == S_OK, "got %08x\n", hr );
check_output( writer, "<a xmlns=\"ns\"><b/></a>", __LINE__ );
WsFreeWriter( writer );
}
static void test_WsWriteStartAttribute(void)
{
HRESULT hr;
WS_XML_WRITER *writer;
WS_XML_STRING prefix = {1, (BYTE *)"p"}, localname = {3, (BYTE *)"str"}, ns = {2, (BYTE *)"ns"};
WS_XML_UTF8_TEXT text;
hr = WsCreateWriter( NULL, 0, &writer, NULL ) ;
ok( hr == S_OK, "got %08x\n", hr );
hr = set_output( writer );
ok( hr == S_OK, "got %08x\n", hr );
hr = WsWriteStartElement( writer, &prefix, &localname, &ns, NULL );
ok( hr == S_OK, "got %08x\n", hr );
hr = WsWriteStartAttribute( NULL, &prefix, &localname, &ns, FALSE, NULL );
ok( hr == E_INVALIDARG, "got %08x\n", hr );
/* WsWriteStartAttribute doesn't output anything */
localname.length = 3;
localname.bytes = (BYTE *)"len";
hr = WsWriteStartAttribute( writer, &prefix, &localname, &ns, FALSE, NULL );
ok( hr == S_OK, "got %08x\n", hr );
check_output( writer, "", __LINE__ );
text.text.textType = WS_XML_TEXT_TYPE_UTF8;
text.value.length = 1;
text.value.bytes = (BYTE *)"0";
hr = WsWriteText( writer, &text.text, NULL );
ok( hr == S_OK, "got %08x\n", hr );
check_output( writer, "", __LINE__ );
/* WsWriteEndAttribute doesn't output anything */
hr = WsWriteEndAttribute( writer, NULL );
ok( hr == S_OK, "got %08x\n", hr );
check_output( writer, "", __LINE__ );
hr = WsWriteEndElement( writer, NULL );
ok( hr == S_OK, "got %08x\n", hr );
check_output( writer, "<p:str p:len=\"0\" xmlns:p=\"ns\"/>", __LINE__ );
WsFreeWriter( writer );
}
START_TEST(writer)
{
test_WsCreateWriter();
test_WsCreateXmlBuffer();
test_WsSetOutput();
test_WsSetOutputToBuffer();
test_WsWriteStartElement();
test_WsWriteStartAttribute();
}