dlls/webservices/tests/writer.c

   1 /*
   2  * Copyright 2015 Hans Leidekker for CodeWeavers
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  */
  18
  19 #include <stdio.h>
  20 #include "windows.h"
  21 #include "webservices.h"
  22 #include "wine/test.h"
  23
  24 #include <math.h>
  25 #ifndef INFINITY
  26 static inline float __port_infinity(void)
  27 {
  28     static const unsigned __inf_bytes = 0x7f800000;
  29     return *(const float *)&__inf_bytes;
  30 }
  31 #define INFINITY __port_infinity()
  32 #endif
  33
  34 #ifndef NAN
  35 static inline float __port_nan(void)
  36 {
  37     static const unsigned __nan_bytes = 0x7fc00000;
  38     return *(const float *)&__nan_bytes;
  39 }
  40 #define NAN __port_nan()
  41 #endif
  42
  43 static HRESULT set_output( WS_XML_WRITER *writer )
  44 {
  45     WS_XML_WRITER_TEXT_ENCODING text = { {WS_XML_WRITER_ENCODING_TYPE_TEXT}, WS_CHARSET_UTF8 };
  46     WS_XML_WRITER_BUFFER_OUTPUT buf = { {WS_XML_WRITER_OUTPUT_TYPE_BUFFER} };
  47     return WsSetOutput( writer, &text.encoding, &buf.output, NULL, 0, NULL );
  48 }
  49
  50 static void test_WsCreateWriter(void)
  51 {
  52     HRESULT hr;
  53     WS_XML_WRITER *writer;
  54     WS_XML_WRITER_PROPERTY prop;
  55     ULONG size, max_depth, max_attrs, indent, trim_size, max_size, max_ns;
  56     BOOL allow_fragment, write_decl, in_attr;
  57     WS_CHARSET charset;
  58     WS_BUFFERS buffers;
  59     WS_BYTES bytes;
  60
  61     hr = WsCreateWriter( NULL, 0, NULL, NULL );
  62     ok( hr == E_INVALIDARG, "got %08x\n", hr );
  63
  64     writer = NULL;
  65     hr = WsCreateWriter( NULL, 0, &writer, NULL );
  66     ok( hr == S_OK, "got %08x\n", hr );
  67     ok( writer != NULL, "writer not set\n" );
  68
  69     /* can't retrieve properties before output is set */
  70     max_depth = 0xdeadbeef;
  71     size = sizeof(max_depth);
  72     hr = WsGetWriterProperty( writer, WS_XML_WRITER_PROPERTY_MAX_DEPTH, &max_depth, size, NULL );
  73     ok( hr == WS_E_INVALID_OPERATION, "got %08x\n", hr );
  74     ok( max_depth == 0xdeadbeef, "max_depth set\n" );
  75
  76     hr = set_output( writer );
  77     ok( hr == S_OK, "got %08x\n", hr );
  78
  79     /* check some defaults */
  80     max_depth = 0xdeadbeef;
  81     size = sizeof(max_depth);
  82     hr = WsGetWriterProperty( writer, WS_XML_WRITER_PROPERTY_MAX_DEPTH, &max_depth, size, NULL );
  83     ok( hr == S_OK, "got %08x\n", hr );
  84     ok( max_depth == 32, "got %u\n", max_depth );
  85
  86     allow_fragment = TRUE;
  87     size = sizeof(allow_fragment);
  88     hr = WsGetWriterProperty( writer, WS_XML_WRITER_PROPERTY_ALLOW_FRAGMENT, &allow_fragment, size, NULL );
  89     ok( hr == S_OK, "got %08x\n", hr );
  90     ok( !allow_fragment, "got %d\n", allow_fragment );
  91
  92     max_attrs = 0xdeadbeef;
  93     size = sizeof(max_attrs);
  94     hr = WsGetWriterProperty( writer, WS_XML_WRITER_PROPERTY_MAX_ATTRIBUTES, &max_attrs, size, NULL );
  95     ok( hr == S_OK, "got %08x\n", hr );
  96     ok( max_attrs == 128, "got %u\n", max_attrs );
  97
  98     write_decl = TRUE;
  99     size = sizeof(write_decl);
 100     hr = WsGetWriterProperty( writer, WS_XML_WRITER_PROPERTY_WRITE_DECLARATION, &write_decl, size, NULL );
 101     ok( hr == S_OK, "got %08x\n", hr );
 102     ok( !write_decl, "got %d\n", write_decl );
 103
 104     indent = 0xdeadbeef;
 105     size = sizeof(indent);
 106     hr = WsGetWriterProperty( writer, WS_XML_WRITER_PROPERTY_INDENT, &indent, size, NULL );
 107     ok( hr == S_OK, "got %08x\n", hr );
 108     ok( !indent, "got %u\n", indent );
 109
 110     trim_size = 0xdeadbeef;
 111     size = sizeof(trim_size);
 112     hr = WsGetWriterProperty( writer, WS_XML_WRITER_PROPERTY_BUFFER_TRIM_SIZE, &trim_size, size, NULL );
 113     ok( hr == S_OK, "got %08x\n", hr );
 114     ok( trim_size == 4096, "got %u\n", trim_size );
 115
 116     charset = 0xdeadbeef;
 117     size = sizeof(charset);
 118     hr = WsGetWriterProperty( writer, WS_XML_WRITER_PROPERTY_CHARSET, &charset, size, NULL );
 119     ok( hr == S_OK, "got %08x\n", hr );
 120     ok( charset == WS_CHARSET_UTF8, "got %u\n", charset );
 121
 122     buffers.bufferCount = 0xdeadbeef;
 123     buffers.buffers = (WS_BYTES *)0xdeadbeef;
 124     size = sizeof(buffers);
 125     hr = WsGetWriterProperty( writer, WS_XML_WRITER_PROPERTY_BUFFERS, &buffers, size, NULL );
 126     ok( hr == S_OK, "got %08x\n", hr );
 127     ok( !buffers.bufferCount, "got %u\n", buffers.bufferCount );
 128     ok( !buffers.buffers, "got %p\n", buffers.buffers );
 129
 130     max_size = 0xdeadbeef;
 131     size = sizeof(max_size);
 132     hr = WsGetWriterProperty( writer, WS_XML_WRITER_PROPERTY_BUFFER_MAX_SIZE, &max_size, size, NULL );
 133     ok( hr == S_OK, "got %08x\n", hr );
 134     ok( max_size == 65536, "got %u\n", max_size );
 135
 136     bytes.length = 0xdeadbeef;
 137     bytes.bytes = (BYTE *)0xdeadbeef;
 138     size = sizeof(buffers);
 139     hr = WsGetWriterProperty( writer, WS_XML_WRITER_PROPERTY_BYTES, &bytes, size, NULL );
 140     ok( hr == S_OK, "got %08x\n", hr );
 141     ok( !bytes.length, "got %u\n", bytes.length );
 142     ok( bytes.bytes != NULL, "got %p\n", bytes.bytes );
 143
 144     max_size = 0xdeadbeef;
 145     size = sizeof(max_size);
 146     hr = WsGetWriterProperty( writer, WS_XML_WRITER_PROPERTY_MAX_MIME_PARTS_BUFFER_SIZE, &max_size, size, NULL );
 147     ok( hr == S_OK, "got %08x\n", hr );
 148     ok( max_size == 65536, "got %u\n", max_size );
 149
 150     bytes.length = 0xdeadbeef;
 151     bytes.bytes = (BYTE *)0xdeadbeef;
 152     size = sizeof(bytes);
 153     hr = WsGetWriterProperty( writer, WS_XML_WRITER_PROPERTY_INITIAL_BUFFER, &bytes, size, NULL );
 154     ok( hr == S_OK, "got %08x\n", hr );
 155     ok( !bytes.length, "got %u\n", bytes.length );
 156     ok( !bytes.bytes, "got %p\n", bytes.bytes );
 157
 158     max_ns = 0xdeadbeef;
 159     size = sizeof(max_ns);
 160     hr = WsGetWriterProperty( writer, WS_XML_WRITER_PROPERTY_MAX_NAMESPACES, &max_ns, size, NULL );
 161     ok( hr == S_OK, "got %08x\n", hr );
 162     ok( max_ns == 32, "got %u\n", max_ns );
 163     WsFreeWriter( writer );
 164
 165     /* change a property */
 166     max_depth = 16;
 167     prop.id = WS_XML_WRITER_PROPERTY_MAX_DEPTH;
 168     prop.value = &max_depth;
 169     prop.valueSize = sizeof(max_depth);
 170     hr = WsCreateWriter( &prop, 1, &writer, NULL );
 171     ok( hr == S_OK, "got %08x\n", hr );
 172
 173     hr = set_output( writer );
 174     ok( hr == S_OK, "got %08x\n", hr );
 175
 176     max_depth = 0xdeadbeef;
 177     size = sizeof(max_depth);
 178     hr = WsGetWriterProperty( writer, WS_XML_WRITER_PROPERTY_MAX_DEPTH, &max_depth, size, NULL );
 179     ok( hr == S_OK, "got %08x\n", hr );
 180     ok( max_depth == 16, "got %u\n", max_depth );
 181     WsFreeWriter( writer );
 182
 183     /* show that some properties are read-only */
 184     in_attr = TRUE;
 185     prop.id = WS_XML_WRITER_PROPERTY_IN_ATTRIBUTE;
 186     prop.value = &in_attr;
 187     prop.valueSize = sizeof(in_attr);
 188     hr = WsCreateWriter( &prop, 1, &writer, NULL );
 189     ok( hr == E_INVALIDARG, "got %08x\n", hr );
 190
 191     size = 1;
 192     prop.id = WS_XML_WRITER_PROPERTY_BYTES_WRITTEN;
 193     prop.value = &size;
 194     prop.valueSize = sizeof(size);
 195     hr = WsCreateWriter( &prop, 1, &writer, NULL );
 196     ok( hr == E_INVALIDARG, "got %08x\n", hr );
 197
 198     size = 1;
 199     prop.id = WS_XML_WRITER_PROPERTY_BYTES_TO_CLOSE;
 200     prop.value = &size;
 201     prop.valueSize = sizeof(size);
 202     hr = WsCreateWriter( &prop, 1, &writer, NULL );
 203     ok( hr == E_INVALIDARG, "got %08x\n", hr );
 204 }
 205
 206 static void test_WsCreateXmlBuffer(void)
 207 {
 208     HRESULT hr;
 209     WS_HEAP *heap;
 210     WS_XML_WRITER *writer;
 211     WS_XML_BUFFER *buffer;
 212     WS_BYTES bytes;
 213     ULONG size;
 214
 215     hr = WsCreateXmlBuffer( NULL, NULL, 0, NULL, NULL );
 216     ok( hr == E_INVALIDARG, "got %08x\n", hr );
 217
 218     hr = WsCreateXmlBuffer( NULL, NULL, 0, &buffer, NULL );
 219     ok( hr == E_INVALIDARG, "got %08x\n", hr );
 220
 221     hr = WsCreateHeap( 1 << 16, 0, NULL, 0, &heap, NULL );
 222     ok( hr == S_OK, "got %08x\n", hr );
 223
 224     hr = WsCreateXmlBuffer( heap, NULL, 0, NULL, NULL );
 225     ok( hr == E_INVALIDARG, "got %08x\n", hr );
 226
 227     buffer = NULL;
 228     hr = WsCreateXmlBuffer( heap, NULL, 0, &buffer, NULL );
 229     ok( hr == S_OK, "got %08x\n", hr );
 230     ok( buffer != NULL, "buffer not set\n" );
 231
 232     hr = WsCreateWriter( NULL, 0, &writer, NULL );
 233     ok( hr == S_OK, "got %08x\n", hr );
 234
 235     size = sizeof(bytes);
 236     hr = WsGetWriterProperty( writer, WS_XML_WRITER_PROPERTY_BYTES, &bytes, size, NULL );
 237     ok( hr == WS_E_INVALID_OPERATION, "got %08x\n", hr );
 238
 239     hr = WsSetOutputToBuffer( writer, buffer, NULL, 0, NULL );
 240     ok( hr == S_OK, "got %08x\n", hr );
 241
 242     size = sizeof(bytes);
 243     hr = WsGetWriterProperty( writer, WS_XML_WRITER_PROPERTY_BYTES, &bytes, size, NULL );
 244     todo_wine ok( hr == E_INVALIDARG, "got %08x\n", hr );
 245
 246     WsFreeWriter( writer );
 247     WsFreeHeap( heap );
 248 }
 249
 250 static void test_WsSetOutput(void)
 251 {
 252     HRESULT hr;
 253     WS_XML_WRITER *writer;
 254     WS_XML_WRITER_PROPERTY prop;
 255     WS_XML_WRITER_TEXT_ENCODING encoding;
 256     WS_XML_WRITER_BUFFER_OUTPUT output;
 257     ULONG size, max_depth;
 258
 259     hr = WsCreateWriter( NULL, 0, &writer, NULL );
 260     ok( hr == S_OK, "got %08x\n", hr );
 261
 262     hr = WsSetOutput( NULL, NULL, NULL, NULL, 0, NULL );
 263     ok( hr == E_INVALIDARG, "got %08x\n", hr );
 264
 265     encoding.encoding.encodingType = WS_XML_WRITER_ENCODING_TYPE_TEXT;
 266     encoding.charSet               = WS_CHARSET_UTF8;
 267
 268     output.output.outputType = WS_XML_WRITER_OUTPUT_TYPE_BUFFER;
 269
 270     hr = WsSetOutput( writer, &encoding.encoding, &output.output, NULL, 0, NULL );
 271     ok( hr == S_OK, "got %08x\n", hr );
 272
 273     /* multiple calls are allowed */
 274     hr = WsSetOutput( writer, &encoding.encoding, &output.output, NULL, 0, NULL );
 275     ok( hr == S_OK, "got %08x\n", hr );
 276
 277     /* writer properties can be set with WsSetOutput */
 278     max_depth = 16;
 279     prop.id = WS_XML_WRITER_PROPERTY_MAX_DEPTH;
 280     prop.value = &max_depth;
 281     prop.valueSize = sizeof(max_depth);
 282     hr = WsSetOutput( writer, &encoding.encoding, &output.output, &prop, 1, NULL );
 283     ok( hr == S_OK, "got %08x\n", hr );
 284
 285     max_depth = 0xdeadbeef;
 286     size = sizeof(max_depth);
 287     hr = WsGetWriterProperty( writer, WS_XML_WRITER_PROPERTY_MAX_DEPTH, &max_depth, size, NULL );
 288     ok( hr == S_OK, "got %08x\n", hr );
 289     ok( max_depth == 16, "got %u\n", max_depth );
 290     WsFreeWriter( writer );
 291 }
 292
 293 static void test_WsSetOutputToBuffer(void)
 294 {
 295     HRESULT hr;
 296     WS_HEAP *heap;
 297     WS_XML_BUFFER *buffer;
 298     WS_XML_WRITER *writer;
 299     WS_XML_WRITER_PROPERTY prop;
 300     ULONG size, max_depth;
 301
 302     hr = WsSetOutputToBuffer( NULL, NULL, NULL, 0, NULL );
 303     ok( hr == E_INVALIDARG, "got %08x\n", hr );
 304
 305     hr = WsCreateWriter( NULL, 0, &writer, NULL );
 306     ok( hr == S_OK, "got %08x\n", hr );
 307
 308     hr = WsSetOutputToBuffer( writer, NULL, NULL, 0, NULL );
 309     ok( hr == E_INVALIDARG, "got %08x\n", hr );
 310
 311     hr = WsCreateHeap( 1 << 16, 0, NULL, 0, &heap, NULL );
 312     ok( hr == S_OK, "got %08x\n", hr );
 313
 314     hr = WsCreateXmlBuffer( heap, NULL, 0, &buffer, NULL );
 315     ok( hr == S_OK, "got %08x\n", hr );
 316
 317     hr = WsSetOutputToBuffer( writer, buffer, NULL, 0, NULL );
 318     ok( hr == S_OK, "got %08x\n", hr );
 319
 320     /* multiple calls are allowed */
 321     hr = WsSetOutputToBuffer( writer, buffer, NULL, 0, NULL );
 322     ok( hr == S_OK, "got %08x\n", hr );
 323
 324     /* writer properties can be set with WsSetOutputToBuffer */
 325     max_depth = 16;
 326     prop.id = WS_XML_WRITER_PROPERTY_MAX_DEPTH;
 327     prop.value = &max_depth;
 328     prop.valueSize = sizeof(max_depth);
 329     hr = WsSetOutputToBuffer( writer, buffer, &prop, 1, NULL );
 330     ok( hr == S_OK, "got %08x\n", hr );
 331
 332     max_depth = 0xdeadbeef;
 333     size = sizeof(max_depth);
 334     hr = WsGetWriterProperty( writer, WS_XML_WRITER_PROPERTY_MAX_DEPTH, &max_depth, size, NULL );
 335     ok( hr == S_OK, "got %08x\n", hr );
 336     ok( max_depth == 16, "got %u\n", max_depth );
 337
 338     WsFreeWriter( writer );
 339     WsFreeHeap( heap );
 340 }
 341
 342 static void check_output( WS_XML_WRITER *writer, const char *expected, unsigned int line )
 343 {
 344     WS_BYTES bytes;
 345     ULONG size = sizeof(bytes);
 346     int len = strlen( expected );
 347     HRESULT hr;
 348
 349     memset( &bytes, 0, sizeof(bytes) );
 350     hr = WsGetWriterProperty( writer, WS_XML_WRITER_PROPERTY_BYTES, &bytes, size, NULL );
 351     ok( hr == S_OK, "%u: got %08x\n", line, hr );
 352     ok( bytes.length == len, "%u: got %u expected %u\n", line, bytes.length, len );
 353     if (bytes.length != len) return;
 354     ok( !memcmp( bytes.bytes, expected, len ), "%u: got %s expected %s\n", line, bytes.bytes, expected );
 355 }
 356
 357 static void test_WsWriteStartElement(void)
 358 {
 359     HRESULT hr;
 360     WS_XML_WRITER *writer;
 361     WS_XML_STRING prefix = {1, (BYTE *)"p"}, ns = {2, (BYTE *)"ns"}, ns2 = {3, (BYTE *)"ns2"};
 362     WS_XML_STRING localname = {1, (BYTE *)"a"}, localname2 =  {1, (BYTE *)"b"};
 363
 364     hr = WsCreateWriter( NULL, 0, &writer, NULL );
 365     ok( hr == S_OK, "got %08x\n", hr );
 366
 367     hr = set_output( writer );
 368     ok( hr == S_OK, "got %08x\n", hr );
 369
 370     hr = WsWriteStartElement( NULL, &prefix, &localname, &ns, NULL );
 371     ok( hr == E_INVALIDARG, "got %08x\n", hr );
 372
 373     /* first call to WsWriteStartElement doesn't output anything */
 374     hr = WsWriteStartElement( writer, &prefix, &localname, &ns, NULL );
 375     ok( hr == S_OK, "got %08x\n", hr );
 376     check_output( writer, "", __LINE__ );
 377
 378     /* two ways to close an element */
 379     hr = WsWriteEndStartElement( writer, NULL );
 380     ok( hr == S_OK, "got %08x\n", hr );
 381     check_output( writer, "<p:a xmlns:p=\"ns\">", __LINE__ );
 382
 383     hr = WsWriteEndElement( writer, NULL );
 384     ok( hr == S_OK, "got %08x\n", hr );
 385     check_output( writer, "<p:a xmlns:p=\"ns\"></p:a>", __LINE__ );
 386
 387     hr = set_output( writer );
 388     ok( hr == S_OK, "got %08x\n", hr );
 389
 390     hr = WsWriteStartElement( writer, &prefix, &localname, &ns, NULL );
 391     ok( hr == S_OK, "got %08x\n", hr );
 392
 393     hr = WsWriteEndElement( writer, NULL );
 394     ok( hr == S_OK, "got %08x\n", hr );
 395     check_output( writer, "<p:a xmlns:p=\"ns\"/>", __LINE__ );
 396
 397     /* nested elements */
 398     hr = set_output( writer );
 399     ok( hr == S_OK, "got %08x\n", hr );
 400
 401     hr = WsWriteStartElement( writer, &prefix, &localname, &ns, NULL );
 402     ok( hr == S_OK, "got %08x\n", hr );
 403     check_output( writer, "", __LINE__ );
 404
 405     hr = WsWriteStartElement( writer, NULL, &localname2, &ns, NULL );
 406     ok( hr == S_OK, "got %08x\n", hr );
 407     check_output( writer, "<p:a xmlns:p=\"ns\">", __LINE__ );
 408
 409     hr = WsWriteEndElement( writer, NULL );
 410     ok( hr == S_OK, "got %08x\n", hr );
 411     check_output( writer, "<p:a xmlns:p=\"ns\"><p:b/>", __LINE__ );
 412
 413     hr = WsWriteEndElement( writer, NULL );
 414     ok( hr == S_OK, "got %08x\n", hr );
 415     check_output( writer, "<p:a xmlns:p=\"ns\"><p:b/></p:a>", __LINE__ );
 416
 417     hr = set_output( writer );
 418     ok( hr == S_OK, "got %08x\n", hr );
 419
 420     hr = WsWriteStartElement( writer, &prefix, &localname, &ns, NULL );
 421     ok( hr == S_OK, "got %08x\n", hr );
 422     check_output( writer, "", __LINE__ );
 423
 424     hr = WsWriteStartElement( writer, NULL, &localname2, &ns2, NULL );
 425     ok( hr == S_OK, "got %08x\n", hr );
 426     check_output( writer, "<p:a xmlns:p=\"ns\">", __LINE__ );
 427
 428     hr = WsWriteEndElement( writer, NULL );
 429     ok( hr == S_OK, "got %08x\n", hr );
 430     check_output( writer, "<p:a xmlns:p=\"ns\"><b xmlns=\"ns2\"/>", __LINE__ );
 431
 432     hr = WsWriteEndElement( writer, NULL );
 433     ok( hr == S_OK, "got %08x\n", hr );
 434     check_output( writer, "<p:a xmlns:p=\"ns\"><b xmlns=\"ns2\"/></p:a>", __LINE__ );
 435
 436     WsFreeWriter( writer );
 437 }
 438
 439 static void test_WsWriteStartAttribute(void)
 440 {
 441     HRESULT hr;
 442     WS_XML_WRITER *writer;
 443     WS_XML_STRING prefix = {1, (BYTE *)"p"}, localname = {3, (BYTE *)"str"}, ns = {2, (BYTE *)"ns"};
 444     WS_XML_UTF8_TEXT text;
 445
 446     hr = WsCreateWriter( NULL, 0, &writer, NULL );
 447     ok( hr == S_OK, "got %08x\n", hr );
 448
 449     hr = set_output( writer );
 450     ok( hr == S_OK, "got %08x\n", hr );
 451
 452     hr = WsWriteStartElement( writer, &prefix, &localname, &ns, NULL );
 453     ok( hr == S_OK, "got %08x\n", hr );
 454
 455     hr = WsWriteStartAttribute( NULL, &prefix, &localname, &ns, FALSE, NULL );
 456     ok( hr == E_INVALIDARG, "got %08x\n", hr );
 457
 458     /* WsWriteStartAttribute doesn't output anything */
 459     localname.length = 3;
 460     localname.bytes  = (BYTE *)"len";
 461     hr = WsWriteStartAttribute( writer, &prefix, &localname, &ns, FALSE, NULL );
 462     ok( hr == S_OK, "got %08x\n", hr );
 463     check_output( writer, "", __LINE__ );
 464
 465     text.text.textType = WS_XML_TEXT_TYPE_UTF8;
 466     text.value.length  = 1;
 467     text.value.bytes   = (BYTE *)"0";
 468     hr = WsWriteText( writer, &text.text, NULL );
 469     ok( hr == S_OK, "got %08x\n", hr );
 470     check_output( writer, "", __LINE__ );
 471
 472     /* WsWriteEndAttribute doesn't output anything */
 473     hr = WsWriteEndAttribute( writer, NULL );
 474     ok( hr == S_OK, "got %08x\n", hr );
 475     check_output( writer, "", __LINE__ );
 476
 477     hr = WsWriteEndElement( writer, NULL );
 478     ok( hr == S_OK, "got %08x\n", hr );
 479     check_output( writer, "<p:str p:len=\"0\" xmlns:p=\"ns\"/>", __LINE__ );
 480
 481     WsFreeWriter( writer );
 482 }
 483
 484 static void test_WsWriteType(void)
 485 {
 486     static const WCHAR testW[] = {'t','e','s','t',0};
 487     HRESULT hr;
 488     WS_XML_WRITER *writer;
 489     WS_XML_STRING prefix = {1, (BYTE*)"p"}, localname = {3, (BYTE *)"str"}, ns = {2, (BYTE *)"ns"};
 490     const WCHAR *val_str;
 491
 492     hr = WsCreateWriter( NULL, 0, &writer, NULL );
 493     ok( hr == S_OK, "got %08x\n", hr );
 494
 495     hr = set_output( writer );
 496     ok( hr == S_OK, "got %08x\n", hr );
 497
 498     val_str = testW;
 499     hr = WsWriteType( writer, WS_ELEMENT_TYPE_MAPPING, WS_WSZ_TYPE, NULL,
 500                       WS_WRITE_REQUIRED_POINTER, &val_str, sizeof(val_str), NULL );
 501     ok( hr == WS_E_INVALID_FORMAT, "got %08x\n", hr );
 502
 503     hr = set_output( writer );
 504     ok( hr == S_OK, "got %08x\n", hr );
 505
 506     hr = WsWriteStartElement( writer, &prefix, &localname, &ns, NULL );
 507     ok( hr == S_OK, "got %08x\n", hr );
 508
 509     /* required value */
 510     hr = WsWriteType( writer, WS_ELEMENT_TYPE_MAPPING, WS_WSZ_TYPE, NULL,
 511                       WS_WRITE_REQUIRED_VALUE, NULL, sizeof(testW), NULL );
 512     ok( hr == E_INVALIDARG, "got %08x\n", hr );
 513
 514     hr = WsWriteType( writer, WS_ELEMENT_TYPE_MAPPING, WS_WSZ_TYPE, NULL,
 515                       WS_WRITE_REQUIRED_VALUE, testW, sizeof(testW), NULL );
 516     ok( hr == E_INVALIDARG, "got %08x\n", hr );
 517
 518     /* required pointer */
 519     hr = WsWriteType( writer, WS_ELEMENT_TYPE_MAPPING, WS_WSZ_TYPE, NULL,
 520                       WS_WRITE_REQUIRED_POINTER, NULL, sizeof(val_str), NULL );
 521     ok( hr == E_INVALIDARG, "got %08x\n", hr );
 522
 523     hr = WsWriteType( writer, WS_ELEMENT_TYPE_MAPPING, WS_WSZ_TYPE, NULL,
 524                       WS_WRITE_REQUIRED_VALUE, testW, sizeof(testW), NULL );
 525     ok( hr == E_INVALIDARG, "got %08x\n", hr );
 526
 527     hr = WsWriteType( writer, WS_ELEMENT_TYPE_MAPPING, WS_WSZ_TYPE, NULL,
 528                       WS_WRITE_REQUIRED_POINTER, &val_str, sizeof(WCHAR **), NULL );
 529     ok( hr == S_OK, "got %08x\n", hr );
 530     check_output( writer, "<p:str xmlns:p=\"ns\">test", __LINE__ );
 531
 532     hr = WsWriteEndElement( writer, NULL );
 533     ok( hr == S_OK, "got %08x\n", hr );
 534     check_output( writer, "<p:str xmlns:p=\"ns\">test</p:str>", __LINE__ );
 535
 536     hr = set_output( writer );
 537     ok( hr == S_OK, "got %08x\n", hr );
 538
 539     hr = WsWriteStartElement( writer, &prefix, &localname, &ns, NULL );
 540     ok( hr == S_OK, "got %08x\n", hr );
 541
 542     hr = WsWriteStartAttribute( writer, NULL, &localname, &ns, FALSE, NULL );
 543     ok( hr == S_OK, "got %08x\n", hr );
 544
 545     val_str = testW;
 546     hr = WsWriteType( writer, WS_ATTRIBUTE_TYPE_MAPPING, WS_WSZ_TYPE, NULL,
 547                       WS_WRITE_REQUIRED_POINTER, &val_str, sizeof(val_str), NULL );
 548     ok( hr == S_OK, "got %08x\n", hr );
 549     check_output( writer, "", __LINE__ );
 550
 551     hr = WsWriteEndAttribute( writer, NULL );
 552     ok( hr == S_OK, "got %08x\n", hr );
 553     check_output( writer, "", __LINE__ );
 554
 555     hr = WsWriteEndElement( writer, NULL );
 556     ok( hr == S_OK, "got %08x\n", hr );
 557     check_output( writer, "<p:str p:str=\"test\" xmlns:p=\"ns\"/>", __LINE__ );
 558
 559     hr = set_output( writer );
 560     ok( hr == S_OK, "got %08x\n", hr );
 561
 562     hr = WsWriteStartElement( writer, &prefix, &localname, &ns, NULL );
 563     ok( hr == S_OK, "got %08x\n", hr );
 564
 565     val_str = testW;
 566     hr = WsWriteType( writer, WS_ELEMENT_CONTENT_TYPE_MAPPING, WS_WSZ_TYPE, NULL,
 567                       WS_WRITE_REQUIRED_POINTER, &val_str, sizeof(val_str), NULL );
 568     ok( hr == S_OK, "got %08x\n", hr );
 569     check_output( writer, "<p:str xmlns:p=\"ns\">test", __LINE__ );
 570
 571     hr = WsWriteEndElement( writer, NULL );
 572     ok( hr == S_OK, "got %08x\n", hr );
 573     check_output( writer, "<p:str xmlns:p=\"ns\">test</p:str>", __LINE__ );
 574
 575     WsFreeWriter( writer );
 576 }
 577
 578 static void test_basic_type(void)
 579 {
 580     HRESULT hr;
 581     WS_XML_WRITER *writer;
 582     WS_XML_STRING localname = {1, (BYTE *)"t"}, ns = {0, NULL};
 583     GUID guid;
 584     ULONG i;
 585     static const struct
 586     {
 587         WS_TYPE     type;
 588         INT64       val;
 589         ULONG       size;
 590         const char *result;
 591         const char *result2;
 592     }
 593     tests[] =
 594     {
 595         { WS_BOOL_TYPE, TRUE, sizeof(BOOL), "<t>true</t>", "<t t=\"true\"/>" },
 596         { WS_BOOL_TYPE, FALSE, sizeof(BOOL), "<t>false</t>", "<t t=\"false\"/>" },
 597         { WS_INT8_TYPE, -128, sizeof(INT8), "<t>-128</t>", "<t t=\"-128\"/>" },
 598         { WS_INT16_TYPE, -32768, sizeof(INT16), "<t>-32768</t>", "<t t=\"-32768\"/>" },
 599         { WS_INT32_TYPE, -2147483647 - 1, sizeof(INT32), "<t>-2147483648</t>",
 600           "<t t=\"-2147483648\"/>" },
 601         { WS_INT64_TYPE, -9223372036854775807 - 1, sizeof(INT64), "<t>-9223372036854775808</t>",
 602           "<t t=\"-9223372036854775808\"/>" },
 603         { WS_UINT8_TYPE, 255, sizeof(UINT8), "<t>255</t>", "<t t=\"255\"/>" },
 604         { WS_UINT16_TYPE, 65535, sizeof(UINT16), "<t>65535</t>", "<t t=\"65535\"/>" },
 605         { WS_UINT32_TYPE, ~0u, sizeof(UINT32), "<t>4294967295</t>", "<t t=\"4294967295\"/>" },
 606         { WS_UINT64_TYPE, ~0, sizeof(UINT64), "<t>18446744073709551615</t>",
 607           "<t t=\"18446744073709551615\"/>" },
 608     };
 609
 610     hr = WsCreateWriter( NULL, 0, &writer, NULL );
 611     ok( hr == S_OK, "got %08x\n", hr );
 612
 613     /* element content type mapping */
 614     for (i = 0; i < sizeof(tests)/sizeof(tests[0]); i++)
 615     {
 616         hr = set_output( writer );
 617         ok( hr == S_OK, "got %08x\n", hr );
 618
 619         hr = WsWriteStartElement( writer, NULL, &localname, &ns, NULL );
 620         ok( hr == S_OK, "got %08x\n", hr );
 621
 622         hr = WsWriteType( writer, WS_ELEMENT_CONTENT_TYPE_MAPPING, tests[i].type, NULL,
 623                           WS_WRITE_REQUIRED_VALUE, &tests[i].val, tests[i].size, NULL );
 624         ok( hr == S_OK, "%u: got %08x\n", i, hr );
 625
 626         hr = WsWriteEndElement( writer, NULL );
 627         ok( hr == S_OK, "got %08x\n", hr );
 628         check_output( writer, tests[i].result, __LINE__ );
 629     }
 630
 631     /* element type mapping is the same as element content type mapping for basic types */
 632     for (i = 0; i < sizeof(tests)/sizeof(tests[0]); i++)
 633     {
 634         const INT64 *ptr = &tests[i].val;
 635
 636         hr = set_output( writer );
 637         ok( hr == S_OK, "got %08x\n", hr );
 638
 639         hr = WsWriteStartElement( writer, NULL, &localname, &ns, NULL );
 640         ok( hr == S_OK, "got %08x\n", hr );
 641
 642         hr = WsWriteType( writer, WS_ELEMENT_TYPE_MAPPING, tests[i].type, NULL,
 643                           WS_WRITE_REQUIRED_POINTER, &ptr, sizeof(ptr), NULL );
 644         ok( hr == S_OK, "%u: got %08x\n", i, hr );
 645
 646         hr = WsWriteEndElement( writer, NULL );
 647         ok( hr == S_OK, "got %08x\n", hr );
 648         check_output( writer, tests[i].result, __LINE__ );
 649     }
 650
 651     /* attribute type mapping */
 652     for (i = 0; i < sizeof(tests)/sizeof(tests[0]); i++)
 653     {
 654         hr = set_output( writer );
 655         ok( hr == S_OK, "got %08x\n", hr );
 656
 657         hr = WsWriteStartElement( writer, NULL, &localname, &ns, NULL );
 658         ok( hr == S_OK, "got %08x\n", hr );
 659
 660         hr = WsWriteStartAttribute( writer, NULL, &localname, &ns, FALSE, NULL );
 661         ok( hr == S_OK, "got %08x\n", hr );
 662
 663         hr = WsWriteType( writer, WS_ATTRIBUTE_TYPE_MAPPING, tests[i].type, NULL,
 664                           WS_WRITE_REQUIRED_VALUE, &tests[i].val, tests[i].size, NULL );
 665         ok( hr == S_OK, "%u: got %08x\n", i, hr );
 666
 667         hr = WsWriteEndAttribute( writer, NULL );
 668         ok( hr == S_OK, "got %08x\n", hr );
 669
 670         hr = WsWriteEndElement( writer, NULL );
 671         ok( hr == S_OK, "got %08x\n", hr );
 672         check_output( writer, tests[i].result2, __LINE__ );
 673     }
 674
 675     hr = set_output( writer );
 676     ok( hr == S_OK, "got %08x\n", hr );
 677
 678     hr = WsWriteStartElement( writer, NULL, &localname, &ns, NULL );
 679     ok( hr == S_OK, "got %08x\n", hr );
 680
 681     memset( &guid, 0, sizeof(guid) );
 682     hr = WsWriteType( writer, WS_ELEMENT_TYPE_MAPPING, WS_GUID_TYPE, NULL, WS_WRITE_REQUIRED_VALUE,
 683                       &guid, sizeof(guid), NULL );
 684     ok( hr == S_OK, "got %08x\n", hr );
 685
 686     hr = WsWriteEndElement( writer, NULL );
 687     ok( hr == S_OK, "got %08x\n", hr );
 688     check_output( writer, "<t>00000000-0000-0000-0000-000000000000</t>", __LINE__ );
 689
 690     WsFreeWriter( writer );
 691 }
 692
 693 static void test_simple_struct_type(void)
 694 {
 695     static const WCHAR valueW[] = {'v','a','l','u','e',0};
 696     HRESULT hr;
 697     WS_XML_WRITER *writer;
 698     WS_STRUCT_DESCRIPTION s;
 699     WS_FIELD_DESCRIPTION f, *fields[1];
 700     WS_XML_STRING localname = {6, (BYTE *)"struct"}, ns = {0, NULL};
 701     struct test
 702     {
 703         const WCHAR *field;
 704     } *test;
 705
 706     hr = WsCreateWriter( NULL, 0, &writer, NULL );
 707     ok( hr == S_OK, "got %08x\n", hr );
 708
 709     hr = set_output( writer );
 710     ok( hr == S_OK, "got %08x\n", hr );
 711
 712     hr = WsWriteStartElement( writer, NULL, &localname, &ns, NULL );
 713     ok( hr == S_OK, "got %08x\n", hr );
 714
 715     memset( &f, 0, sizeof(f) );
 716     f.mapping   = WS_TEXT_FIELD_MAPPING;
 717     f.type      = WS_WSZ_TYPE;
 718     fields[0] = &f;
 719
 720     memset( &s, 0, sizeof(s) );
 721     s.size          = sizeof(struct test);
 722     s.alignment     = TYPE_ALIGNMENT(struct test);
 723     s.fields        = fields;
 724     s.fieldCount    = 1;
 725
 726     test = HeapAlloc( GetProcessHeap(), 0, sizeof(*test) );
 727     test->field  = valueW;
 728     hr = WsWriteType( writer, WS_ELEMENT_CONTENT_TYPE_MAPPING, WS_STRUCT_TYPE, NULL,
 729                       WS_WRITE_REQUIRED_POINTER, &test, sizeof(test), NULL );
 730     ok( hr == E_INVALIDARG, "got %08x\n", hr );
 731
 732     hr = WsWriteType( writer, WS_ELEMENT_CONTENT_TYPE_MAPPING, WS_STRUCT_TYPE, NULL,
 733                       WS_WRITE_REQUIRED_VALUE, test, sizeof(*test), NULL );
 734     ok( hr == E_INVALIDARG, "got %08x\n", hr );
 735
 736     hr = WsWriteType( writer, WS_ELEMENT_CONTENT_TYPE_MAPPING, WS_STRUCT_TYPE, &s,
 737                       WS_WRITE_REQUIRED_POINTER, &test, sizeof(test), NULL );
 738     ok( hr == S_OK, "got %08x\n", hr );
 739
 740     hr = WsWriteEndElement( writer, NULL );
 741     ok( hr == S_OK, "got %08x\n", hr );
 742     check_output( writer, "<struct>value</struct>", __LINE__ );
 743
 744     hr = set_output( writer );
 745     ok( hr == S_OK, "got %08x\n", hr );
 746
 747     hr = WsWriteStartElement( writer, NULL, &localname, &ns, NULL );
 748     ok( hr == S_OK, "got %08x\n", hr );
 749
 750     hr = WsWriteType( writer, WS_ELEMENT_TYPE_MAPPING, WS_STRUCT_TYPE, &s,
 751                       WS_WRITE_REQUIRED_POINTER, &test, sizeof(test), NULL );
 752     ok( hr == S_OK, "got %08x\n", hr );
 753
 754     hr = WsWriteEndElement( writer, NULL );
 755     ok( hr == S_OK, "got %08x\n", hr );
 756     check_output( writer, "<struct>value</struct>", __LINE__ );
 757
 758     hr = set_output( writer );
 759     ok( hr == S_OK, "got %08x\n", hr );
 760
 761     hr = WsWriteStartElement( writer, NULL, &localname, &ns, NULL );
 762     ok( hr == S_OK, "got %08x\n", hr );
 763
 764     hr = WsWriteStartAttribute( writer, NULL, &localname, &ns, FALSE, NULL );
 765     ok( hr == S_OK, "got %08x\n", hr );
 766
 767     hr = WsWriteType( writer, WS_ATTRIBUTE_TYPE_MAPPING, WS_STRUCT_TYPE, &s,
 768                       WS_WRITE_REQUIRED_POINTER, &test, sizeof(test), NULL );
 769     ok( hr == S_OK, "got %08x\n", hr );
 770
 771     hr = WsWriteEndAttribute( writer, NULL );
 772     ok( hr == S_OK, "got %08x\n", hr );
 773
 774     hr = WsWriteEndElement( writer, NULL );
 775     ok( hr == S_OK, "got %08x\n", hr );
 776     check_output( writer, "<struct struct=\"value\"/>", __LINE__ );
 777
 778     HeapFree( GetProcessHeap(), 0, test );
 779     WsFreeWriter( writer );
 780 }
 781
 782 static void test_WsWriteElement(void)
 783 {
 784     static const WCHAR testW[] = {'t','e','s','t',0};
 785     HRESULT hr;
 786     WS_XML_WRITER *writer;
 787     WS_STRUCT_DESCRIPTION s;
 788     WS_FIELD_DESCRIPTION f, *fields[1];
 789     WS_ELEMENT_DESCRIPTION desc;
 790     WS_XML_STRING localname = {3, (BYTE *)"str"}, ns = {0, NULL};
 791     struct test { const WCHAR *str; } *test;
 792
 793     hr = WsCreateWriter( NULL, 0, &writer, NULL );
 794     ok( hr == S_OK, "got %08x\n", hr );
 795
 796     hr = set_output( writer );
 797     ok( hr == S_OK, "got %08x\n", hr );
 798
 799     /* text field mapping */
 800     memset( &f, 0, sizeof(f) );
 801     f.mapping = WS_TEXT_FIELD_MAPPING;
 802     f.type    = WS_WSZ_TYPE;
 803     fields[0] = &f;
 804
 805     memset( &s, 0, sizeof(s) );
 806     s.size       = sizeof(struct test);
 807     s.alignment  = TYPE_ALIGNMENT(struct test);
 808     s.fields     = fields;
 809     s.fieldCount = 1;
 810
 811     desc.elementLocalName = &localname;
 812     desc.elementNs        = &ns;
 813     desc.type             = WS_STRUCT_TYPE;
 814     desc.typeDescription  = &s;
 815
 816     test = HeapAlloc( GetProcessHeap(), 0, sizeof(*test) );
 817     test->str = testW;
 818     hr = WsWriteElement( NULL, &desc, WS_WRITE_REQUIRED_POINTER, &test, sizeof(test), NULL );
 819     ok( hr == E_INVALIDARG, "got %08x\n", hr );
 820
 821     hr = WsWriteElement( writer, NULL, WS_WRITE_REQUIRED_POINTER, &test, sizeof(test), NULL );
 822     ok( hr == E_INVALIDARG, "got %08x\n", hr );
 823
 824     hr = WsWriteElement( writer, &desc, WS_WRITE_REQUIRED_POINTER, NULL, 0, NULL );
 825     ok( hr == E_INVALIDARG, "got %08x\n", hr );
 826
 827     hr = WsWriteElement( writer, &desc, WS_WRITE_REQUIRED_POINTER, &test, sizeof(test), NULL );
 828     ok( hr == S_OK, "got %08x\n", hr );
 829     check_output( writer, "<str>test</str>", __LINE__ );
 830
 831     hr = set_output( writer );
 832     ok( hr == S_OK, "got %08x\n", hr );
 833
 834     hr = WsWriteStartElement( writer, NULL, &localname, &ns, NULL );
 835     ok( hr == S_OK, "got %08x\n", hr );
 836
 837     hr = WsWriteElement( writer, &desc, WS_WRITE_REQUIRED_POINTER, &test, sizeof(test), NULL );
 838     ok( hr == S_OK, "got %08x\n", hr );
 839     check_output( writer, "<str><str>test</str>", __LINE__ );
 840
 841     hr = set_output( writer );
 842     ok( hr == S_OK, "got %08x\n", hr );
 843
 844     /* attribute field mapping */
 845     f.mapping = WS_ATTRIBUTE_FIELD_MAPPING;
 846
 847     /* requires localName and ns to be set */
 848     hr = WsWriteElement( writer, &desc, WS_WRITE_REQUIRED_POINTER, &test, sizeof(test), NULL );
 849     ok( hr == E_INVALIDARG, "got %08x\n", hr );
 850
 851     hr = set_output( writer );
 852     ok( hr == S_OK, "got %08x\n", hr );
 853
 854     f.localName = &localname;
 855     f.ns        = &ns;
 856     hr = WsWriteElement( writer, &desc, WS_WRITE_REQUIRED_POINTER, &test, sizeof(test), NULL );
 857     ok( hr == S_OK, "got %08x\n", hr );
 858     check_output( writer, "<str str=\"test\"/>", __LINE__ );
 859
 860     HeapFree( GetProcessHeap(), 0, test );
 861     WsFreeWriter( writer );
 862 }
 863
 864 static void test_WsWriteValue(void)
 865 {
 866     HRESULT hr;
 867     WS_XML_WRITER *writer;
 868     WS_XML_STRING localname = {1, (BYTE *)"t"}, ns = {0, NULL};
 869     ULONG i;
 870     static const struct
 871     {
 872         WS_VALUE_TYPE type;
 873         INT64         val;
 874         ULONG         size;
 875         const char   *result;
 876         const char   *result2;
 877     }
 878     tests[] =
 879     {
 880         { WS_BOOL_VALUE_TYPE, ~0, sizeof(BOOL), "<t>true</t>", "<t t=\"true\"/>" },
 881         { WS_BOOL_VALUE_TYPE, FALSE, sizeof(BOOL), "<t>false</t>", "<t t=\"false\"/>" },
 882         { WS_INT8_VALUE_TYPE, -128, sizeof(INT8), "<t>-128</t>", "<t t=\"-128\"/>" },
 883         { WS_INT16_VALUE_TYPE, -32768, sizeof(INT16), "<t>-32768</t>", "<t t=\"-32768\"/>" },
 884         { WS_INT32_VALUE_TYPE, -2147483647 - 1, sizeof(INT32), "<t>-2147483648</t>",
 885           "<t t=\"-2147483648\"/>" },
 886         { WS_INT64_VALUE_TYPE, -9223372036854775807 - 1, sizeof(INT64), "<t>-9223372036854775808</t>",
 887           "<t t=\"-9223372036854775808\"/>" },
 888         { WS_UINT8_VALUE_TYPE, 255, sizeof(UINT8), "<t>255</t>", "<t t=\"255\"/>" },
 889         { WS_UINT16_VALUE_TYPE, 65535, sizeof(UINT16), "<t>65535</t>", "<t t=\"65535\"/>" },
 890         { WS_UINT32_VALUE_TYPE, ~0u, sizeof(UINT32), "<t>4294967295</t>", "<t t=\"4294967295\"/>" },
 891         { WS_UINT64_VALUE_TYPE, ~0, sizeof(UINT64), "<t>18446744073709551615</t>",
 892           "<t t=\"18446744073709551615\"/>" },
 893     };
 894
 895     hr = WsCreateWriter( NULL, 0, &writer, NULL );
 896     ok( hr == S_OK, "got %08x\n", hr );
 897
 898     hr = set_output( writer );
 899     ok( hr == S_OK, "got %08x\n", hr );
 900
 901     hr = WsWriteValue( NULL, tests[0].type, &tests[0].val, tests[0].size, NULL );
 902     ok( hr == E_INVALIDARG, "got %08x\n", hr );
 903
 904     hr = WsWriteValue( writer, tests[0].type, &tests[0].val, tests[0].size, NULL );
 905     ok( hr == WS_E_INVALID_FORMAT, "got %08x\n", hr );
 906
 907     hr = set_output( writer );
 908     ok( hr == S_OK, "got %08x\n", hr );
 909
 910     hr = WsWriteStartElement( writer, NULL, &localname, &ns, NULL );
 911     ok( hr == S_OK, "got %08x\n", hr );
 912
 913     /* zero size */
 914     hr = WsWriteValue( writer, tests[0].type, &tests[0].val, 0, NULL );
 915     ok( hr == E_INVALIDARG, "got %08x\n", hr );
 916
 917     hr = set_output( writer );
 918     ok( hr == S_OK, "got %08x\n", hr );
 919
 920     hr = WsWriteStartElement( writer, NULL, &localname, &ns, NULL );
 921     ok( hr == S_OK, "got %08x\n", hr );
 922
 923     /* NULL value */
 924     hr = WsWriteValue( writer, tests[0].type, NULL, 0, NULL );
 925     ok( hr == E_INVALIDARG, "got %08x\n", hr );
 926
 927     /* element type mapping */
 928     for (i = 0; i < sizeof(tests)/sizeof(tests[0]); i++)
 929     {
 930         hr = set_output( writer );
 931         ok( hr == S_OK, "got %08x\n", hr );
 932
 933         hr = WsWriteStartElement( writer, NULL, &localname, &ns, NULL );
 934         ok( hr == S_OK, "got %08x\n", hr );
 935
 936         hr = WsWriteValue( writer, tests[i].type, &tests[i].val, tests[i].size, NULL );
 937         ok( hr == S_OK, "%u: got %08x\n", i, hr );
 938
 939         hr = WsWriteEndElement( writer, NULL );
 940         ok( hr == S_OK, "got %08x\n", hr );
 941         check_output( writer, tests[i].result, __LINE__ );
 942     }
 943
 944     /* attribute type mapping */
 945     for (i = 0; i < sizeof(tests)/sizeof(tests[0]); i++)
 946     {
 947         hr = set_output( writer );
 948         ok( hr == S_OK, "got %08x\n", hr );
 949
 950         hr = WsWriteStartElement( writer, NULL, &localname, &ns, NULL );
 951         ok( hr == S_OK, "got %08x\n", hr );
 952
 953         hr = WsWriteStartAttribute( writer, NULL, &localname, &ns, FALSE, NULL );
 954         ok( hr == S_OK, "got %08x\n", hr );
 955
 956         hr = WsWriteValue( writer, tests[i].type, &tests[i].val, tests[i].size, NULL );
 957         ok( hr == S_OK, "%u: got %08x\n", i, hr );
 958
 959         hr = WsWriteEndAttribute( writer, NULL );
 960         ok( hr == S_OK, "got %08x\n", hr );
 961
 962         hr = WsWriteEndElement( writer, NULL );
 963         ok( hr == S_OK, "got %08x\n", hr );
 964         check_output( writer, tests[i].result2, __LINE__ );
 965     }
 966
 967     WsFreeWriter( writer );
 968 }
 969
 970 static void test_WsWriteAttribute(void)
 971 {
 972     static const WCHAR testW[] = {'t','e','s','t',0};
 973     HRESULT hr;
 974     WS_XML_WRITER *writer;
 975     WS_STRUCT_DESCRIPTION s;
 976     WS_FIELD_DESCRIPTION f, *fields[1];
 977     WS_ATTRIBUTE_DESCRIPTION desc;
 978     WS_XML_STRING localname = {3, (BYTE *)"str"}, ns = {0, NULL};
 979     struct test { const WCHAR *str; } *test;
 980
 981     hr = WsCreateWriter( NULL, 0, &writer, NULL );
 982     ok( hr == S_OK, "got %08x\n", hr );
 983
 984     hr = set_output( writer );
 985     ok( hr == S_OK, "got %08x\n", hr );
 986
 987     /* text field mapping */
 988     memset( &f, 0, sizeof(f) );
 989     f.mapping = WS_TEXT_FIELD_MAPPING;
 990     f.type    = WS_WSZ_TYPE;
 991     fields[0] = &f;
 992
 993     memset( &s, 0, sizeof(s) );
 994     s.size       = sizeof(struct test);
 995     s.alignment  = TYPE_ALIGNMENT(struct test);
 996     s.fields     = fields;
 997     s.fieldCount = 1;
 998
 999     desc.attributeLocalName = &localname;
1000     desc.attributeNs        = &ns;
1001     desc.type               = WS_STRUCT_TYPE;
1002     desc.typeDescription    = &s;
1003
1004     test = HeapAlloc( GetProcessHeap(), 0, sizeof(*test) );
1005     test->str = testW;
1006     hr = WsWriteAttribute( NULL, &desc, WS_WRITE_REQUIRED_POINTER, &test, sizeof(test), NULL );
1007     ok( hr == E_INVALIDARG, "got %08x\n", hr );
1008
1009     hr = WsWriteAttribute( writer, NULL, WS_WRITE_REQUIRED_POINTER, &test, sizeof(test), NULL );
1010     ok( hr == E_INVALIDARG, "got %08x\n", hr );
1011
1012     hr = WsWriteAttribute( writer, &desc, WS_WRITE_REQUIRED_POINTER, NULL, 0, NULL );
1013     ok( hr == E_INVALIDARG, "got %08x\n", hr );
1014
1015     hr = WsWriteAttribute( writer, &desc, WS_WRITE_REQUIRED_POINTER, &test, sizeof(test), NULL );
1016     ok( hr == WS_E_INVALID_OPERATION, "got %08x\n", hr );
1017
1018     hr = set_output( writer );
1019     ok( hr == S_OK, "got %08x\n", hr );
1020
1021     hr = WsWriteStartElement( writer, NULL, &localname, &ns, NULL );
1022     ok( hr == S_OK, "got %08x\n", hr );
1023
1024     hr = WsWriteAttribute( writer, &desc, WS_WRITE_REQUIRED_POINTER, &test, sizeof(test), NULL );
1025     ok( hr == S_OK, "got %08x\n", hr );
1026
1027     hr = WsWriteEndElement( writer, NULL );
1028     ok( hr == S_OK, "got %08x\n", hr );
1029     check_output( writer, "<str str=\"test\"/>", __LINE__ );
1030
1031     HeapFree( GetProcessHeap(), 0, test );
1032     WsFreeWriter( writer );
1033 }
1034
1035 static void test_WsWriteStartCData(void)
1036 {
1037     HRESULT hr;
1038     WS_XML_WRITER *writer;
1039     WS_XML_STRING localname = {1, (BYTE *)"t"}, ns = {0, NULL};
1040     WS_XML_UTF8_TEXT text;
1041
1042     hr = WsCreateWriter( NULL, 0, &writer, NULL );
1043     ok( hr == S_OK, "got %08x\n", hr );
1044
1045     hr = set_output( writer );
1046     ok( hr == S_OK, "got %08x\n", hr );
1047
1048     hr = WsWriteStartElement( writer, NULL, &localname, &ns, NULL );
1049     ok( hr == S_OK, "got %08x\n", hr );
1050
1051     hr = WsWriteEndCData( writer, NULL );
1052     ok( hr == WS_E_INVALID_OPERATION, "got %08x\n", hr );
1053
1054     hr = set_output( writer );
1055     ok( hr == S_OK, "got %08x\n", hr );
1056
1057     hr = WsWriteStartElement( writer, NULL, &localname, &ns, NULL );
1058     ok( hr == S_OK, "got %08x\n", hr );
1059     check_output( writer, "", __LINE__ );
1060
1061     hr = WsWriteStartCData( writer, NULL );
1062     ok( hr == S_OK, "got %08x\n", hr );
1063     check_output( writer, "<t><![CDATA[", __LINE__ );
1064
1065     text.text.textType = WS_XML_TEXT_TYPE_UTF8;
1066     text.value.bytes = (BYTE *)"<data>";
1067     text.value.length = 6;
1068     hr = WsWriteText( writer, &text.text, NULL );
1069     ok( hr == S_OK, "got %08x\n", hr );
1070     check_output( writer, "<t><![CDATA[<data>", __LINE__ );
1071
1072     hr = WsWriteEndCData( writer, NULL );
1073     ok( hr == S_OK, "got %08x\n", hr );
1074     check_output( writer, "<t><![CDATA[<data>]]>", __LINE__ );
1075
1076     hr = WsWriteEndElement( writer, NULL );
1077     ok( hr == S_OK, "got %08x\n", hr );
1078     check_output( writer, "<t><![CDATA[<data>]]></t>", __LINE__ );
1079
1080     WsFreeWriter( writer );
1081 }
1082
1083 static void check_output_buffer( WS_XML_BUFFER *buffer, const char *expected, unsigned int line )
1084 {
1085     WS_XML_WRITER *writer;
1086     WS_BYTES bytes;
1087     ULONG size = sizeof(bytes);
1088     int len = strlen(expected);
1089     HRESULT hr;
1090
1091     hr = WsCreateWriter( NULL, 0, &writer, NULL );
1092     ok( hr == S_OK, "got %08x\n", hr );
1093
1094     hr = set_output( writer );
1095     ok( hr == S_OK, "got %08x\n", hr );
1096
1097     hr = WsWriteXmlBuffer( writer, buffer, NULL );
1098     ok( hr == S_OK, "got %08x\n", hr );
1099
1100     memset( &bytes, 0, sizeof(bytes) );
1101     hr = WsGetWriterProperty( writer, WS_XML_WRITER_PROPERTY_BYTES, &bytes, size, NULL );
1102     ok( hr == S_OK, "%u: got %08x\n", line, hr );
1103     ok( bytes.length == len, "%u: got %u expected %u\n", line, bytes.length, len );
1104     if (bytes.length != len) return;
1105     ok( !memcmp( bytes.bytes, expected, len ), "%u: got %s expected %s\n", line, bytes.bytes, expected );
1106
1107     WsFreeWriter( writer );
1108 }
1109
1110 static void prepare_xmlns_test( WS_XML_WRITER *writer, WS_HEAP **heap, WS_XML_BUFFER **buffer )
1111 {
1112     WS_XML_STRING prefix = {6, (BYTE *)"prefix"}, localname = {1, (BYTE *)"t"}, ns = {2, (BYTE *)"ns"};
1113     HRESULT hr;
1114
1115     hr = WsCreateHeap( 1 << 16, 0, NULL, 0, heap, NULL );
1116     ok( hr == S_OK, "got %08x\n", hr );
1117
1118     hr = WsCreateXmlBuffer( *heap, NULL, 0, buffer, NULL );
1119     ok( hr == S_OK, "got %08x\n", hr );
1120
1121     hr = WsSetOutputToBuffer( writer, *buffer, NULL, 0, NULL );
1122     ok( hr == S_OK, "got %08x\n", hr );
1123
1124     hr = WsWriteStartElement( writer, &prefix, &localname, &ns, NULL );
1125     ok( hr == S_OK, "got %08x\n", hr );
1126 }
1127
1128 static void test_WsWriteXmlnsAttribute(void)
1129 {
1130     WS_XML_STRING ns = {2, (BYTE *)"ns"}, ns2 = {3, (BYTE *)"ns2"};
1131     WS_XML_STRING prefix = {6, (BYTE *)"prefix"}, prefix2 = {7, (BYTE *)"prefix2"};
1132     WS_XML_STRING xmlns = {6, (BYTE *)"xmlns"}, attr = {4, (BYTE *)"attr"};
1133     WS_XML_STRING localname = {1, (BYTE *)"u"};
1134     WS_HEAP *heap;
1135     WS_XML_BUFFER *buffer;
1136     WS_XML_WRITER *writer;
1137     HRESULT hr;
1138
1139     hr = WsCreateHeap( 1 << 16, 0, NULL, 0, &heap, NULL );
1140     ok( hr == S_OK, "got %08x\n", hr );
1141
1142     hr = WsCreateXmlBuffer( heap, NULL, 0, &buffer, NULL );
1143     ok( hr == S_OK, "got %08x\n", hr );
1144
1145     hr = WsCreateWriter( NULL, 0, &writer, NULL );
1146     ok( hr == S_OK, "got %08x\n", hr );
1147
1148     hr = WsWriteXmlnsAttribute( NULL, NULL, NULL, FALSE, NULL );
1149     ok( hr == E_INVALIDARG, "got %08x\n", hr );
1150     WsFreeHeap( heap );
1151
1152     prepare_xmlns_test( writer, &heap, &buffer );
1153     hr = WsWriteXmlnsAttribute( writer, NULL, NULL, FALSE, NULL );
1154     ok( hr == E_INVALIDARG, "got %08x\n", hr );
1155     WsFreeHeap( heap );
1156
1157     prepare_xmlns_test( writer, &heap, &buffer );
1158     hr = WsWriteXmlnsAttribute( writer, &prefix2, NULL, FALSE, NULL );
1159     ok( hr == E_INVALIDARG, "got %08x\n", hr );
1160
1161     hr = WsSetOutputToBuffer( writer, buffer, NULL, 0, NULL );
1162     ok( hr == S_OK, "got %08x\n", hr );
1163     hr = WsWriteXmlnsAttribute( writer, NULL, &ns, FALSE, NULL );
1164     ok( hr == WS_E_INVALID_OPERATION, "got %08x\n", hr );
1165     WsFreeHeap( heap );
1166
1167     /* no prefix */
1168     prepare_xmlns_test( writer, &heap, &buffer );
1169     hr = WsWriteXmlnsAttribute( writer, NULL, &ns2, FALSE, NULL );
1170     ok( hr == S_OK, "got %08x\n", hr );
1171     hr = WsWriteEndElement( writer, NULL );
1172     ok( hr == S_OK, "got %08x\n", hr );
1173     check_output_buffer( buffer, "<prefix:t xmlns:prefix=\"ns\" xmlns=\"ns2\"/>", __LINE__ );
1174     WsFreeHeap( heap );
1175
1176     /* prefix */
1177     prepare_xmlns_test( writer, &heap, &buffer );
1178     hr = WsWriteXmlnsAttribute( writer, &prefix2, &ns2, FALSE, NULL );
1179     ok( hr == S_OK, "got %08x\n", hr );
1180     hr = WsWriteEndElement( writer, NULL );
1181     ok( hr == S_OK, "got %08x\n", hr );
1182     check_output_buffer( buffer, "<prefix:t xmlns:prefix2=\"ns2\" xmlns:prefix=\"ns\"/>", __LINE__ );
1183     WsFreeHeap( heap );
1184
1185     /* implicitly set element prefix namespace */
1186     prepare_xmlns_test( writer, &heap, &buffer );
1187     hr = WsWriteEndElement( writer, NULL );
1188     ok( hr == S_OK, "got %08x\n", hr );
1189     check_output_buffer( buffer, "<prefix:t xmlns:prefix=\"ns\"/>", __LINE__ );
1190     WsFreeHeap( heap );
1191
1192     /* explicitly set element prefix namespace */
1193     prepare_xmlns_test( writer, &heap, &buffer );
1194     hr = WsWriteXmlnsAttribute( writer, &prefix, &ns, TRUE, NULL );
1195     ok( hr == S_OK, "got %08x\n", hr );
1196     hr = WsWriteEndElement( writer, NULL );
1197     ok( hr == S_OK, "got %08x\n", hr );
1198     check_output_buffer( buffer, "<prefix:t xmlns:prefix='ns'/>", __LINE__ );
1199     WsFreeHeap( heap );
1200
1201     /* repeated calls, same namespace */
1202     prepare_xmlns_test( writer, &heap, &buffer );
1203     hr = WsWriteXmlnsAttribute( writer, &prefix2, &ns, FALSE, NULL );
1204     ok( hr == S_OK, "got %08x\n", hr );
1205     hr = WsWriteXmlnsAttribute( writer, &prefix2, &ns, FALSE, NULL );
1206     ok( hr == S_OK, "got %08x\n", hr );
1207     hr = WsWriteEndElement( writer, NULL );
1208     ok( hr == S_OK, "got %08x\n", hr );
1209     check_output_buffer( buffer, "<prefix:t xmlns:prefix2=\"ns\" xmlns:prefix=\"ns\"/>", __LINE__ );
1210     WsFreeHeap( heap );
1211
1212     /* repeated calls, different namespace */
1213     prepare_xmlns_test( writer, &heap, &buffer );
1214     hr = WsWriteXmlnsAttribute( writer, &prefix2, &ns, FALSE, NULL );
1215     ok( hr == S_OK, "got %08x\n", hr );
1216     hr = WsWriteXmlnsAttribute( writer, &prefix2, &ns2, FALSE, NULL );
1217     ok( hr == S_OK, "got %08x\n", hr );
1218     hr = WsWriteEndElement( writer, NULL );
1219     todo_wine ok( hr == WS_E_INVALID_FORMAT, "got %08x\n", hr );
1220     WsFreeHeap( heap );
1221
1222     /* single quotes */
1223     prepare_xmlns_test( writer, &heap, &buffer );
1224     hr = WsWriteXmlnsAttribute( writer, &prefix2, &ns, TRUE, NULL );
1225     ok( hr == S_OK, "got %08x\n", hr );
1226     hr = WsWriteEndElement( writer, NULL );
1227     ok( hr == S_OK, "got %08x\n", hr );
1228     check_output_buffer( buffer, "<prefix:t xmlns:prefix2='ns' xmlns:prefix=\"ns\"/>", __LINE__ );
1229     WsFreeHeap( heap );
1230
1231     /* different namespace, different prefix */
1232     prepare_xmlns_test( writer, &heap, &buffer );
1233     hr = WsWriteXmlnsAttribute( writer, &prefix2, &ns2, TRUE, NULL );
1234     ok( hr == S_OK, "got %08x\n", hr );
1235     hr = WsWriteEndElement( writer, NULL );
1236     ok( hr == S_OK, "got %08x\n", hr );
1237     check_output_buffer( buffer, "<prefix:t xmlns:prefix2='ns2' xmlns:prefix=\"ns\"/>", __LINE__ );
1238     WsFreeHeap( heap );
1239
1240     /* different namespace, same prefix */
1241     prepare_xmlns_test( writer, &heap, &buffer );
1242     hr = WsWriteXmlnsAttribute( writer, &prefix, &ns2, TRUE, NULL );
1243     ok( hr == S_OK, "got %08x\n", hr );
1244     hr = WsWriteEndElement( writer, NULL );
1245     todo_wine ok( hr == WS_E_INVALID_FORMAT, "got %08x\n", hr );
1246     WsFreeHeap( heap );
1247
1248     /* regular attribute */
1249     prepare_xmlns_test( writer, &heap, &buffer );
1250     hr = WsWriteStartAttribute( writer, &xmlns, &prefix2, &ns2, TRUE, NULL );
1251     ok( hr == S_OK, "got %08x\n", hr );
1252     hr = WsWriteEndAttribute( writer, NULL );
1253     ok( hr == S_OK, "got %08x\n", hr );
1254     hr = WsWriteEndElement( writer, NULL );
1255     todo_wine ok( hr == WS_E_INVALID_FORMAT, "got %08x\n", hr );
1256     WsFreeHeap( heap );
1257
1258     /* attribute order */
1259     prepare_xmlns_test( writer, &heap, &buffer );
1260     hr = WsWriteXmlnsAttribute( writer, &prefix, &ns, TRUE, NULL );
1261     ok( hr == S_OK, "got %08x\n", hr );
1262     hr = WsWriteStartAttribute( writer, &prefix, &attr, &ns, TRUE, NULL );
1263     ok( hr == S_OK, "got %08x\n", hr );
1264     hr = WsWriteEndAttribute( writer, NULL );
1265     ok( hr == S_OK, "got %08x\n", hr );
1266     hr = WsWriteXmlnsAttribute( writer, &prefix2, &ns2, TRUE, NULL );
1267     ok( hr == S_OK, "got %08x\n", hr );
1268     hr = WsWriteEndElement( writer, NULL );
1269     ok( hr == S_OK, "got %08x\n", hr );
1270     check_output_buffer( buffer, "<prefix:t prefix:attr='' xmlns:prefix='ns' xmlns:prefix2='ns2'/>", __LINE__ );
1271     WsFreeHeap( heap );
1272
1273     /* scope */
1274     prepare_xmlns_test( writer, &heap, &buffer );
1275     hr = WsWriteXmlnsAttribute( writer, &prefix2, &ns2, TRUE, NULL );
1276     ok( hr == S_OK, "got %08x\n", hr );
1277     hr = WsWriteStartElement( writer, &prefix2, &localname, &ns2, NULL );
1278     ok( hr == S_OK, "got %08x\n", hr );
1279     hr = WsWriteEndElement( writer, NULL );
1280     ok( hr == S_OK, "got %08x\n", hr );
1281     hr = WsWriteEndElement( writer, NULL );
1282     ok( hr == S_OK, "got %08x\n", hr );
1283     check_output_buffer( buffer, "<prefix:t xmlns:prefix2='ns2' xmlns:prefix=\"ns\"><prefix2:u/></prefix:t>",
1284                         __LINE__ );
1285     WsFreeHeap( heap );
1286
1287     WsFreeWriter( writer );
1288 }
1289
1290 static void prepare_prefix_test( WS_XML_WRITER *writer )
1291 {
1292     const WS_XML_STRING p = {1, (BYTE *)"p"}, localname = {1, (BYTE *)"t"}, ns = {2, (BYTE *)"ns"};
1293     HRESULT hr;
1294
1295     hr = set_output( writer );
1296     ok( hr == S_OK, "got %08x\n", hr );
1297     hr = WsWriteStartElement( writer, &p, &localname, &ns, NULL );
1298     ok( hr == S_OK, "got %08x\n", hr );
1299     hr = WsWriteEndStartElement( writer, NULL );
1300     ok( hr == S_OK, "got %08x\n", hr );
1301 }
1302
1303 static void test_WsGetPrefixFromNamespace(void)
1304 {
1305     const WS_XML_STRING p = {1, (BYTE *)"p"}, localname = {1, (BYTE *)"t"}, *prefix;
1306     const WS_XML_STRING ns = {2, (BYTE *)"ns"}, ns2 = {3, (BYTE *)"ns2"};
1307     WS_XML_WRITER *writer;
1308     HRESULT hr;
1309
1310     hr = WsCreateWriter( NULL, 0, &writer, NULL );
1311     ok( hr == S_OK, "got %08x\n", hr );
1312
1313     hr = set_output( writer );
1314     ok( hr == S_OK, "got %08x\n", hr );
1315     hr = WsWriteStartElement( writer, &p, &localname, &ns, NULL );
1316     ok( hr == S_OK, "got %08x\n", hr );
1317
1318     hr = WsGetPrefixFromNamespace( NULL, NULL, FALSE, NULL, NULL );
1319     ok( hr == E_INVALIDARG, "got %08x\n", hr );
1320
1321     hr = WsGetPrefixFromNamespace( NULL, NULL, FALSE, &prefix, NULL );
1322     ok( hr == E_INVALIDARG, "got %08x\n", hr );
1323
1324     hr = WsGetPrefixFromNamespace( writer, NULL, FALSE, &prefix, NULL );
1325     ok( hr == E_INVALIDARG, "got %08x\n", hr );
1326
1327     /* element must be committed */
1328     hr = set_output( writer );
1329     ok( hr == S_OK, "got %08x\n", hr );
1330     hr = WsWriteStartElement( writer, &p, &localname, &ns, NULL );
1331     ok( hr == S_OK, "got %08x\n", hr );
1332     hr = WsGetPrefixFromNamespace( writer, &ns, TRUE, &prefix, NULL );
1333     ok( hr == WS_E_INVALID_FORMAT, "got %08x\n", hr );
1334
1335     /* but writer can't be positioned on end element node */
1336     hr = set_output( writer );
1337     ok( hr == S_OK, "got %08x\n", hr );
1338     hr = WsWriteStartElement( writer, &p, &localname, &ns, NULL );
1339     ok( hr == S_OK, "got %08x\n", hr );
1340     hr = WsWriteEndElement( writer, NULL );
1341     ok( hr == S_OK, "got %08x\n", hr );
1342     hr = WsGetPrefixFromNamespace( writer, &ns, TRUE, &prefix, NULL );
1343     ok( hr == WS_E_INVALID_FORMAT, "got %08x\n", hr );
1344
1345     /* required = TRUE */
1346     prefix = NULL;
1347     prepare_prefix_test( writer );
1348     hr = WsGetPrefixFromNamespace( writer, &ns, TRUE, &prefix, NULL );
1349     ok( hr == S_OK, "got %08x\n", hr );
1350     ok( prefix != NULL, "prefix not set\n" );
1351     if (prefix)
1352     {
1353         ok( prefix->length == 1, "got %u\n", prefix->length );
1354         ok( !memcmp( prefix->bytes, "p", 1 ), "wrong prefix\n" );
1355     }
1356
1357     prefix = (const WS_XML_STRING *)0xdeadbeef;
1358     hr = WsGetPrefixFromNamespace( writer, &ns2, TRUE, &prefix, NULL );
1359     ok( hr == WS_E_INVALID_FORMAT, "got %08x\n", hr );
1360     ok( prefix == (const WS_XML_STRING *)0xdeadbeef, "prefix set\n" );
1361
1362     /* required = FALSE */
1363     prefix = NULL;
1364     prepare_prefix_test( writer );
1365     hr = WsGetPrefixFromNamespace( writer, &ns, FALSE, &prefix, NULL );
1366     ok( hr == S_OK, "got %08x\n", hr );
1367     ok( prefix != NULL, "prefix not set\n" );
1368     if (prefix)
1369     {
1370         ok( prefix->length == 1, "got %u\n", prefix->length );
1371         ok( !memcmp( prefix->bytes, "p", 1 ), "wrong prefix\n" );
1372     }
1373
1374     prefix = (const WS_XML_STRING *)0xdeadbeef;
1375     hr = WsGetPrefixFromNamespace( writer, &ns2, FALSE, &prefix, NULL );
1376     ok( hr == S_FALSE, "got %08x\n", hr );
1377     ok( prefix == NULL, "prefix not set\n" );
1378
1379     WsFreeWriter( writer );
1380 }
1381
1382 static void test_complex_struct_type(void)
1383 {
1384     static const char expected[] =
1385         "<o:OfficeConfig xmlns:o=\"urn:schemas-microsoft-com:office:office\">"
1386         "<o:services o:GenerationTime=\"2015-09-03T18:47:54\"/>"
1387         "</o:OfficeConfig>";
1388     static const WCHAR timestampW[] =
1389         {'2','0','1','5','-','0','9','-','0','3','T','1','8',':','4','7',':','5','4',0};
1390     WS_XML_STRING str_officeconfig = {12, (BYTE *)"OfficeConfig"};
1391     WS_XML_STRING str_services = {8, (BYTE *)"services"};
1392     WS_XML_STRING str_generationtime = {14, (BYTE *)"GenerationTime"};
1393     WS_XML_STRING ns = {39, (BYTE *)"urn:schemas-microsoft-com:office:office"};
1394     WS_XML_STRING prefix = {1, (BYTE *)"o"};
1395     DWORD size;
1396     HRESULT hr;
1397     WS_HEAP *heap;
1398     WS_XML_BUFFER *buffer;
1399     WS_XML_WRITER *writer;
1400     WS_STRUCT_DESCRIPTION s, s2;
1401     WS_FIELD_DESCRIPTION f, f2, *fields[1], *fields2[1];
1402     struct services
1403     {
1404         const WCHAR *generationtime;
1405     };
1406     struct officeconfig
1407     {
1408         struct services *services;
1409     } *test;
1410
1411     hr = WsCreateWriter( NULL, 0, &writer, NULL );
1412     ok( hr == S_OK, "got %08x\n", hr );
1413
1414     hr = WsCreateHeap( 1 << 16, 0, NULL, 0, &heap, NULL );
1415     ok( hr == S_OK, "got %08x\n", hr );
1416
1417     hr = WsCreateXmlBuffer( heap, NULL, 0, &buffer, NULL );
1418     ok( hr == S_OK, "got %08x\n", hr );
1419
1420     hr = WsSetOutputToBuffer( writer, buffer, NULL, 0, NULL );
1421     ok( hr == S_OK, "got %08x\n", hr );
1422
1423     hr = WsWriteStartElement( writer, &prefix, &str_officeconfig, &ns, NULL );
1424     ok( hr == S_OK, "got %08x\n", hr );
1425
1426     memset( &f2, 0, sizeof(f2) );
1427     f2.mapping         = WS_ATTRIBUTE_FIELD_MAPPING;
1428     f2.localName       = &str_generationtime;
1429     f2.ns              = &ns;
1430     f2.type            = WS_WSZ_TYPE;
1431     f2.options         = WS_FIELD_OPTIONAL;
1432     fields2[0] = &f2;
1433
1434     memset( &s2, 0, sizeof(s2) );
1435     s2.size          = sizeof(*test->services);
1436     s2.alignment     = 4;
1437     s2.fields        = fields2;
1438     s2.fieldCount    = 1;
1439     s2.typeLocalName = &str_services;
1440     s2.typeNs        = &ns;
1441
1442     memset( &f, 0, sizeof(f) );
1443     f.mapping         = WS_ELEMENT_FIELD_MAPPING;
1444     f.localName       = &str_services;
1445     f.ns              = &ns;
1446     f.type            = WS_STRUCT_TYPE;
1447     f.typeDescription = &s2;
1448     f.options         = WS_FIELD_POINTER;
1449     fields[0] = &f;
1450
1451     memset( &s, 0, sizeof(s) );
1452     s.size          = sizeof(*test);
1453     s.alignment     = 4;
1454     s.fields        = fields;
1455     s.fieldCount    = 1;
1456     s.typeLocalName = &str_officeconfig;
1457     s.typeNs        = &ns;
1458
1459     size = sizeof(struct officeconfig) + sizeof(struct services);
1460     test = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, size );
1461     test->services = (struct services *)(test + 1);
1462     test->services->generationtime = timestampW;
1463     hr = WsWriteType( writer, WS_ELEMENT_CONTENT_TYPE_MAPPING, WS_STRUCT_TYPE, &s,
1464                       WS_WRITE_REQUIRED_POINTER, &test, sizeof(test), NULL );
1465     ok( hr == S_OK, "got %08x\n", hr );
1466
1467     hr = WsWriteEndElement( writer, NULL );
1468     ok( hr == S_OK, "got %08x\n", hr );
1469     check_output_buffer( buffer, expected, __LINE__ );
1470
1471     HeapFree( GetProcessHeap(), 0, test );
1472     WsFreeWriter( writer );
1473     WsFreeHeap( heap );
1474 }
1475
1476 static void test_WsMoveWriter(void)
1477 {
1478     WS_XML_STRING localname = {1, (BYTE *)"a"}, localname2 = {1, (BYTE *)"b"}, ns = {0, NULL};
1479     WS_HEAP *heap;
1480     WS_XML_WRITER *writer;
1481     WS_XML_BUFFER *buffer;
1482     HRESULT hr;
1483
1484     hr = WsMoveWriter( NULL, WS_MOVE_TO_EOF, NULL, NULL );
1485     ok( hr == E_INVALIDARG, "got %08x\n", hr );
1486
1487     hr = WsCreateHeap( 1 << 16, 0, NULL, 0, &heap, NULL );
1488     ok( hr == S_OK, "got %08x\n", hr );
1489
1490     hr = WsCreateWriter( NULL, 0, &writer, NULL );
1491     ok( hr == S_OK, "got %08x\n", hr );
1492
1493     hr = set_output( writer );
1494     ok( hr == S_OK, "got %08x\n", hr );
1495
1496     /* writer must be set to an XML buffer */
1497     hr = WsMoveWriter( writer, WS_MOVE_TO_EOF, NULL, NULL );
1498     todo_wine ok( hr == WS_E_INVALID_OPERATION, "got %08x\n", hr );
1499
1500     hr = WsCreateXmlBuffer( heap, NULL, 0, &buffer, NULL );
1501     ok( hr == S_OK, "got %08x\n", hr );
1502
1503     hr = WsSetOutputToBuffer( writer, buffer, NULL, 0, NULL );
1504     ok( hr == S_OK, "got %08x\n", hr );
1505
1506     hr = WsMoveWriter( writer, WS_MOVE_TO_EOF, NULL, NULL );
1507     ok( hr == S_OK, "got %08x\n", hr );
1508
1509     /* <a><b/></a> */
1510     hr = WsWriteStartElement( writer, NULL, &localname, &ns, NULL );
1511     ok( hr == S_OK, "got %08x\n", hr );
1512
1513     hr = WsWriteStartElement( writer, NULL, &localname2, &ns, NULL );
1514     ok( hr == S_OK, "got %08x\n", hr );
1515
1516     hr = WsWriteEndElement( writer, NULL );
1517     ok( hr == S_OK, "got %08x\n", hr );
1518
1519     hr = WsWriteEndElement( writer, NULL );
1520     ok( hr == S_OK, "got %08x\n", hr );
1521
1522     hr = WsMoveWriter( writer, WS_MOVE_TO_EOF, NULL, NULL );
1523     ok( hr == S_OK, "got %08x\n", hr );
1524
1525     hr = WsMoveWriter( writer, WS_MOVE_TO_ROOT_ELEMENT, NULL, NULL );
1526     ok( hr == S_OK, "got %08x\n", hr );
1527
1528     hr = WsMoveWriter( writer, WS_MOVE_TO_CHILD_ELEMENT, NULL, NULL );
1529     ok( hr == S_OK, "got %08x\n", hr );
1530
1531     hr = WsMoveWriter( writer, WS_MOVE_TO_END_ELEMENT, NULL, NULL );
1532     ok( hr == S_OK, "got %08x\n", hr );
1533
1534     hr = WsMoveWriter( writer, WS_MOVE_TO_PARENT_ELEMENT, NULL, NULL );
1535     ok( hr == S_OK, "got %08x\n", hr );
1536
1537     hr = WsMoveWriter( writer, WS_MOVE_TO_END_ELEMENT, NULL, NULL );
1538     ok( hr == S_OK, "got %08x\n", hr );
1539
1540     hr = WsMoveWriter( writer, WS_MOVE_TO_BOF, NULL, NULL );
1541     ok( hr == E_INVALIDARG, "got %08x\n", hr );
1542
1543     WsFreeWriter( writer );
1544     WsFreeHeap( heap );
1545 }
1546
1547 static void test_WsGetWriterPosition(void)
1548 {
1549     WS_HEAP *heap;
1550     WS_XML_WRITER *writer;
1551     WS_XML_BUFFER *buffer;
1552     WS_XML_NODE_POSITION pos;
1553     HRESULT hr;
1554
1555     hr = WsGetWriterPosition( NULL, NULL, NULL );
1556     ok( hr == E_INVALIDARG, "got %08x\n", hr );
1557
1558     hr = WsCreateHeap( 1 << 16, 0, NULL, 0, &heap, NULL );
1559     ok( hr == S_OK, "got %08x\n", hr );
1560
1561     hr = WsCreateWriter( NULL, 0, &writer, NULL );
1562     ok( hr == S_OK, "got %08x\n", hr );
1563
1564     hr = WsGetWriterPosition( writer, &pos, NULL );
1565     ok( hr == WS_E_INVALID_OPERATION, "got %08x\n", hr );
1566
1567     hr = set_output( writer );
1568     ok( hr == S_OK, "got %08x\n", hr );
1569
1570     /* writer must be set to an XML buffer */
1571     hr = WsGetWriterPosition( writer, &pos, NULL );
1572     todo_wine ok( hr == WS_E_INVALID_OPERATION, "got %08x\n", hr );
1573
1574     hr = WsCreateXmlBuffer( heap, NULL, 0, &buffer, NULL );
1575     ok( hr == S_OK, "got %08x\n", hr );
1576
1577     hr = WsSetOutputToBuffer( writer, buffer, NULL, 0, NULL );
1578     ok( hr == S_OK, "got %08x\n", hr );
1579
1580     hr = WsGetWriterPosition( writer, NULL, NULL );
1581     ok( hr == E_INVALIDARG, "got %08x\n", hr );
1582
1583     pos.buffer = pos.node = NULL;
1584     hr = WsGetWriterPosition( writer, &pos, NULL );
1585     ok( hr == S_OK, "got %08x\n", hr );
1586     ok( pos.buffer != NULL, "buffer not set\n" );
1587     ok( pos.node != NULL, "node not set\n" );
1588
1589     WsFreeWriter( writer );
1590     WsFreeHeap( heap );
1591 }
1592
1593 static void test_WsSetWriterPosition(void)
1594 {
1595     WS_XML_STRING localname = {1, (BYTE *)"t"}, ns = {0, NULL};
1596     WS_HEAP *heap;
1597     WS_XML_WRITER *writer;
1598     WS_XML_BUFFER *buf1, *buf2;
1599     WS_XML_NODE_POSITION pos;
1600     HRESULT hr;
1601
1602     hr = WsCreateHeap( 1 << 16, 0, NULL, 0, &heap, NULL );
1603     ok( hr == S_OK, "got %08x\n", hr );
1604
1605     hr = WsSetWriterPosition( NULL, NULL, NULL );
1606     ok( hr == E_INVALIDARG, "got %08x\n", hr );
1607
1608     hr = WsCreateWriter( NULL, 0, &writer, NULL );
1609     ok( hr == S_OK, "got %08x\n", hr );
1610
1611     hr = WsCreateXmlBuffer( heap, NULL, 0, &buf1, NULL );
1612     ok( hr == S_OK, "got %08x\n", hr );
1613
1614     hr = WsSetOutputToBuffer( writer, buf1, NULL, 0, NULL );
1615     ok( hr == S_OK, "got %08x\n", hr );
1616
1617     hr = WsSetWriterPosition( writer, NULL, NULL );
1618     ok( hr == E_INVALIDARG, "got %08x\n", hr );
1619
1620     pos.buffer = pos.node = NULL;
1621     hr = WsGetWriterPosition( writer, &pos, NULL );
1622     ok( hr == S_OK, "got %08x\n", hr );
1623     ok( pos.buffer == buf1, "wrong buffer\n" );
1624     ok( pos.node != NULL, "node not set\n" );
1625
1626     hr = WsSetWriterPosition( writer, &pos, NULL );
1627     ok( hr == S_OK, "got %08x\n", hr );
1628
1629     /* different buffer */
1630     hr = WsCreateXmlBuffer( heap, NULL, 0, &buf2, NULL );
1631     ok( hr == S_OK, "got %08x\n", hr );
1632
1633     pos.buffer = buf2;
1634     hr = WsSetWriterPosition( writer, &pos, NULL );
1635     ok( hr == E_INVALIDARG, "got %08x\n", hr );
1636
1637     hr = WsSetOutputToBuffer( writer, buf1, NULL, 0, NULL );
1638     ok( hr == S_OK, "got %08x\n", hr );
1639
1640     /* try to write at non-final position */
1641     hr = WsWriteStartElement( writer, NULL, &localname, &ns, NULL );
1642     ok( hr == S_OK, "got %08x\n", hr );
1643
1644     pos.buffer = pos.node = NULL;
1645     hr = WsGetWriterPosition( writer, &pos, NULL );
1646     ok( hr == S_OK, "got %08x\n", hr );
1647     ok( pos.buffer == buf1, "wrong buffer\n" );
1648     ok( pos.node != NULL, "node not set\n" );
1649
1650     hr = WsWriteEndElement( writer, NULL );
1651     ok( hr == S_OK, "got %08x\n", hr );
1652     check_output_buffer( buf1, "<t/>", __LINE__ );
1653
1654     hr = WsSetWriterPosition( writer, &pos, NULL );
1655     ok( hr == S_OK, "got %08x\n", hr );
1656
1657     hr = WsWriteStartElement( writer, NULL, &localname, &ns, NULL );
1658     todo_wine ok( hr == WS_E_INVALID_FORMAT, "got %08x\n", hr );
1659
1660     WsFreeWriter( writer );
1661     WsFreeHeap( heap );
1662 }
1663
1664 static void test_WsWriteXmlBuffer(void)
1665 {
1666     WS_XML_STRING localname = {1, (BYTE *)"t"}, ns = {0, NULL};
1667     WS_XML_WRITER *writer1, *writer2;
1668     WS_XML_BUFFER *buffer1, *buffer2;
1669     WS_HEAP *heap;
1670     HRESULT hr;
1671
1672     hr = WsCreateHeap( 1 << 16, 0, NULL, 0, &heap, NULL );
1673     ok( hr == S_OK, "got %08x\n", hr );
1674
1675     hr = WsCreateXmlBuffer( NULL, NULL, 0, NULL, NULL );
1676     ok( hr == E_INVALIDARG, "got %08x\n", hr );
1677
1678     hr = WsCreateWriter( NULL, 0, &writer1, NULL );
1679     ok( hr == S_OK, "got %08x\n", hr );
1680
1681     hr = WsCreateXmlBuffer( heap, NULL, 0, NULL, NULL );
1682     ok( hr == E_INVALIDARG, "got %08x\n", hr );
1683
1684     hr = WsCreateXmlBuffer( heap, NULL, 0, &buffer1, NULL );
1685     ok( hr == S_OK, "got %08x\n", hr );
1686
1687     hr = WsSetOutputToBuffer( writer1, buffer1, NULL, 0, NULL );
1688     ok( hr == S_OK, "got %08x\n", hr );
1689
1690     hr = WsWriteStartElement( writer1, NULL, &localname, &ns, NULL );
1691     ok( hr == S_OK, "got %08x\n", hr );
1692
1693     hr = WsWriteEndElement( writer1, NULL );
1694     ok( hr == S_OK, "got %08x\n", hr );
1695     check_output_buffer( buffer1, "<t/>", __LINE__ );
1696
1697     hr = WsCreateWriter( NULL, 0, &writer2, NULL );
1698     ok( hr == S_OK, "got %08x\n", hr );
1699
1700     hr = WsCreateXmlBuffer( heap, NULL, 0, &buffer2, NULL );
1701     ok( hr == S_OK, "got %08x\n", hr );
1702
1703     hr = WsSetOutputToBuffer( writer2, buffer2, NULL, 0, NULL );
1704     ok( hr == S_OK, "got %08x\n", hr );
1705
1706     hr = WsWriteXmlBuffer( writer2, buffer1, NULL );
1707     ok( hr == S_OK, "got %08x\n", hr );
1708     check_output_buffer( buffer2, "<t/>", __LINE__ );
1709
1710     hr = WsMoveWriter( writer2, WS_MOVE_TO_PREVIOUS_ELEMENT, NULL, NULL );
1711     todo_wine ok( hr == S_OK, "got %08x\n", hr );
1712
1713     hr = WsWriteXmlBuffer( writer2, buffer1, NULL );
1714     todo_wine ok( hr == WS_E_INVALID_FORMAT, "got %08x\n", hr );
1715
1716     WsFreeWriter( writer1 );
1717     WsFreeWriter( writer2 );
1718     WsFreeHeap( heap );
1719 }
1720
1721 static void test_WsWriteNode(void)
1722 {
1723     WS_XML_STRING localname = {1, (BYTE *)"t"}, localname2 = {4, (BYTE *)"attr"}, ns = {0, NULL};
1724     WS_XML_WRITER *writer;
1725     WS_XML_BUFFER *buffer;
1726     WS_XML_UTF8_TEXT utf8;
1727     WS_XML_ATTRIBUTE attr, *attrs[1];
1728     WS_XML_ELEMENT_NODE elem;
1729     WS_XML_COMMENT_NODE comment;
1730     WS_XML_NODE node;
1731     WS_XML_TEXT_NODE text;
1732     WS_HEAP *heap;
1733     HRESULT hr;
1734
1735     hr = WsCreateHeap( 1 << 16, 0, NULL, 0, &heap, NULL );
1736     ok( hr == S_OK, "got %08x\n", hr );
1737
1738     hr = WsWriteNode( NULL, NULL, NULL );
1739     ok( hr == E_INVALIDARG, "got %08x\n", hr );
1740
1741     hr = WsCreateWriter( NULL, 0, &writer, NULL );
1742     ok( hr == S_OK, "got %08x\n", hr );
1743
1744     hr = WsWriteNode( writer, NULL, NULL );
1745     todo_wine ok( hr == WS_E_INVALID_OPERATION, "got %08x\n", hr );
1746
1747     hr = WsCreateXmlBuffer( heap, NULL, 0, &buffer, NULL );
1748     ok( hr == S_OK, "got %08x\n", hr );
1749
1750     hr = WsSetOutputToBuffer( writer, buffer, NULL, 0, NULL );
1751     ok( hr == S_OK, "got %08x\n", hr );
1752
1753     utf8.text.textType = WS_XML_TEXT_TYPE_UTF8;
1754     utf8.value.bytes   = (BYTE *)"value";
1755     utf8.value.length  = sizeof("value") - 1;
1756
1757     attr.singleQuote = TRUE;
1758     attr.isXmlNs     = FALSE;
1759     attr.prefix      = NULL;
1760     attr.localName   = &localname2;
1761     attr.ns          = &ns;
1762     attr.value       = &utf8.text;
1763     attrs[0] = &attr;
1764
1765     elem.node.nodeType  = WS_XML_NODE_TYPE_ELEMENT;
1766     elem.prefix         = NULL;
1767     elem.localName      = &localname;
1768     elem.ns             = &ns;
1769     elem.attributeCount = 1;
1770     elem.attributes     = attrs;
1771     elem.isEmpty        = FALSE;
1772     hr = WsWriteNode( writer, (const WS_XML_NODE *)&elem, NULL );
1773     ok( hr == S_OK, "got %08x\n", hr );
1774
1775     comment.node.nodeType = WS_XML_NODE_TYPE_COMMENT;
1776     comment.value.bytes   = (BYTE *)"comment";
1777     comment.value.length  = sizeof("comment") - 1;
1778     hr = WsWriteNode( writer, (const WS_XML_NODE *)&comment, NULL );
1779     ok( hr == S_OK, "got %08x\n", hr );
1780
1781     node.nodeType = WS_XML_NODE_TYPE_EOF;
1782     hr = WsWriteNode( writer, &node, NULL );
1783     ok( hr == S_OK, "got %08x\n", hr );
1784
1785     node.nodeType = WS_XML_NODE_TYPE_BOF;
1786     hr = WsWriteNode( writer, &node, NULL );
1787     ok( hr == S_OK, "got %08x\n", hr );
1788
1789     node.nodeType = WS_XML_NODE_TYPE_CDATA;
1790     hr = WsWriteNode( writer, &node, NULL );
1791     ok( hr == S_OK, "got %08x\n", hr );
1792
1793     utf8.value.bytes   = (BYTE *)"cdata";
1794     utf8.value.length  = sizeof("cdata") - 1;
1795     text.node.nodeType = WS_XML_NODE_TYPE_TEXT;
1796     text.text          = &utf8.text;
1797     hr = WsWriteNode( writer, (const WS_XML_NODE *)&text, NULL );
1798     ok( hr == S_OK, "got %08x\n", hr );
1799
1800     node.nodeType = WS_XML_NODE_TYPE_END_CDATA;
1801     hr = WsWriteNode( writer, &node, NULL );
1802     ok( hr == S_OK, "got %08x\n", hr );
1803
1804     utf8.value.bytes   = (BYTE *)"text";
1805     utf8.value.length  = sizeof("text") - 1;
1806     hr = WsWriteNode( writer, (const WS_XML_NODE *)&text, NULL );
1807     ok( hr == S_OK, "got %08x\n", hr );
1808
1809     node.nodeType = WS_XML_NODE_TYPE_END_ELEMENT;
1810     hr = WsWriteNode( writer, &node, NULL );
1811     ok( hr == S_OK, "got %08x\n", hr );
1812     check_output_buffer( buffer, "<t attr='value'><!--comment--><![CDATA[cdata]]>text</t>", __LINE__ );
1813
1814     WsFreeWriter( writer );
1815     WsFreeHeap( heap );
1816 }
1817
1818 static HRESULT set_input( WS_XML_READER *reader, const char *data, ULONG size )
1819 {
1820     WS_XML_READER_TEXT_ENCODING enc;
1821     WS_XML_READER_BUFFER_INPUT input;
1822
1823     enc.encoding.encodingType = WS_XML_READER_ENCODING_TYPE_TEXT;
1824     enc.charSet               = WS_CHARSET_AUTO;
1825
1826     input.input.inputType = WS_XML_READER_INPUT_TYPE_BUFFER;
1827     input.encodedData     = (void *)data;
1828     input.encodedDataSize = size;
1829
1830     return WsSetInput( reader, &enc.encoding, &input.input, NULL, 0, NULL );
1831 }
1832
1833 static void test_WsCopyNode(void)
1834 {
1835     WS_XML_STRING localname = {1, (BYTE *)"t"}, localname2 = {1, (BYTE *)"u"}, ns = {0, NULL};
1836     WS_XML_NODE_POSITION pos, pos2;
1837     WS_XML_WRITER *writer;
1838     WS_XML_READER *reader;
1839     WS_XML_BUFFER *buffer;
1840     WS_HEAP *heap;
1841     HRESULT hr;
1842
1843     hr = WsCreateHeap( 1 << 16, 0, NULL, 0, &heap, NULL );
1844     ok( hr == S_OK, "got %08x\n", hr );
1845
1846     hr = WsCreateWriter( NULL, 0, &writer, NULL );
1847     ok( hr == S_OK, "got %08x\n", hr );
1848
1849     hr = WsCreateXmlBuffer( heap, NULL, 0, &buffer, NULL );
1850     ok( hr == S_OK, "got %08x\n", hr );
1851
1852     hr = WsSetOutputToBuffer( writer, buffer, NULL, 0, NULL );
1853     ok( hr == S_OK, "got %08x\n", hr );
1854
1855     hr = WsWriteStartElement( writer, NULL, &localname, &ns, NULL );
1856     ok( hr == S_OK, "got %08x\n", hr );
1857
1858     hr = WsWriteStartElement( writer, NULL, &localname2, &ns, NULL );
1859     ok( hr == S_OK, "got %08x\n", hr );
1860
1861     hr = WsWriteEndElement( writer, NULL );
1862     ok( hr == S_OK, "got %08x\n", hr );
1863
1864     hr = WsGetWriterPosition( writer, &pos, NULL );
1865     ok( hr == S_OK, "got %08x\n", hr );
1866
1867     hr = WsWriteEndElement( writer, NULL );
1868     ok( hr == S_OK, "got %08x\n", hr );
1869     check_output_buffer( buffer, "<t><u/></t>", __LINE__ );
1870
1871     hr = WsCreateReader( NULL, 0, &reader, NULL );
1872     ok( hr == S_OK, "got %08x\n", hr );
1873
1874     hr = set_input( reader, "<v/>", sizeof("<v/>") - 1 );
1875     ok( hr == S_OK, "got %08x\n", hr );
1876
1877     hr = WsFillReader( reader, sizeof("<v/>") - 1, NULL, NULL );
1878     ok( hr == S_OK, "got %08x\n", hr );
1879
1880     hr = WsReadToStartElement( reader, NULL, NULL, NULL, NULL );
1881     ok( hr == S_OK, "got %08x\n", hr );
1882
1883     hr = WsSetWriterPosition( writer, &pos, NULL );
1884     ok( hr == S_OK, "got %08x\n", hr );
1885
1886     hr = WsCopyNode( writer, reader, NULL );
1887     ok( hr == S_OK, "got %08x\n", hr );
1888     check_output_buffer( buffer, "<t><u/><v/></t>", __LINE__ );
1889
1890     hr = WsGetWriterPosition( writer, &pos2, NULL );
1891     ok( hr == S_OK, "got %08x\n", hr );
1892     ok( pos2.buffer == pos.buffer, "wrong buffer\n" );
1893     ok( pos2.node == pos.node, "wrong node\n" );
1894
1895     WsFreeReader( reader );
1896     WsFreeWriter( writer );
1897     WsFreeHeap( heap );
1898 }
1899
1900 static void test_text_types(void)
1901 {
1902     static const WCHAR utf16W[] = {'u','t','f','1','6'};
1903     WS_XML_STRING localname = {1, (BYTE *)"t"}, ns = {0, NULL};
1904     WS_XML_WRITER *writer;
1905     static const WS_XML_UTF8_TEXT val_utf8 = { {WS_XML_TEXT_TYPE_UTF8}, {4, (BYTE *)"utf8"} };
1906     static WS_XML_UTF16_TEXT val_utf16 = { {WS_XML_TEXT_TYPE_UTF16} };
1907     static const WS_XML_GUID_TEXT val_guid = { {WS_XML_TEXT_TYPE_GUID} };
1908     static const WS_XML_UNIQUE_ID_TEXT val_urn = { {WS_XML_TEXT_TYPE_UNIQUE_ID} };
1909     static const WS_XML_BOOL_TEXT val_bool = { {WS_XML_TEXT_TYPE_BOOL}, TRUE };
1910     static const WS_XML_INT32_TEXT val_int32 = { {WS_XML_TEXT_TYPE_INT32}, -2147483647 - 1 };
1911     static const WS_XML_INT64_TEXT val_int64 = { {WS_XML_TEXT_TYPE_INT64}, -9223372036854775807 - 1 };
1912     static const WS_XML_UINT64_TEXT val_uint64 = { {WS_XML_TEXT_TYPE_UINT64}, ~0 };
1913     static const struct
1914     {
1915         const WS_XML_TEXT *text;
1916         const char        *result;
1917     }
1918     tests[] =
1919     {
1920         { &val_utf8.text,   "<t>utf8</t>" },
1921         { &val_utf16.text,  "<t>utf16</t>" },
1922         { &val_guid.text,   "<t>00000000-0000-0000-0000-000000000000</t>" },
1923         { &val_urn.text,    "<t>urn:uuid:00000000-0000-0000-0000-000000000000</t>" },
1924         { &val_bool.text,   "<t>true</t>" },
1925         { &val_int32.text,  "<t>-2147483648</t>" },
1926         { &val_int64.text,  "<t>-9223372036854775808</t>" },
1927         { &val_uint64.text, "<t>18446744073709551615</t>" },
1928     };
1929     HRESULT hr;
1930     ULONG i;
1931
1932     val_utf16.bytes     = (BYTE *)utf16W;
1933     val_utf16.byteCount = sizeof(utf16W);
1934
1935     hr = WsCreateWriter( NULL, 0, &writer, NULL );
1936     ok( hr == S_OK, "got %08x\n", hr );
1937
1938     for (i = 0; i < sizeof(tests)/sizeof(tests[0]); i++)
1939     {
1940         hr = set_output( writer );
1941         ok( hr == S_OK, "got %08x\n", hr );
1942         hr = WsWriteStartElement( writer, NULL, &localname, &ns, NULL );
1943         ok( hr == S_OK, "%u: got %08x\n", i, hr );
1944
1945         hr = WsWriteText( writer, tests[i].text, NULL );
1946         ok( hr == S_OK, "%u: got %08x\n", i, hr );
1947
1948         hr = WsWriteEndElement( writer, NULL );
1949         ok( hr == S_OK, "%u: got %08x\n", i, hr );
1950         check_output( writer, tests[i].result, __LINE__ );
1951     }
1952
1953     WsFreeWriter( writer );
1954 }
1955
1956 static void test_double(void)
1957 {
1958     WS_XML_STRING localname = {1, (BYTE *)"t"}, ns = {0, NULL};
1959     static const struct
1960     {
1961         double      val;
1962         const char *result;
1963     }
1964     tests[] =
1965     {
1966         {0.0, "<t>0</t>"},
1967         {1.0, "<t>1</t>"},
1968         {-1.0, "<t>-1</t>"},
1969         {1.0000000000000001, "<t>1</t>"},
1970         {1.0000000000000002, "<t>1.0000000000000002</t>"},
1971         {1.0000000000000003, "<t>1.0000000000000002</t>"},
1972         {1.0000000000000004, "<t>1.0000000000000004</t>"},
1973         {100000000000000, "<t>100000000000000</t>"},
1974         {1000000000000000, "<t>1E+15</t>"},
1975         {0.1, "<t>0.1</t>"},
1976         {0.01, "<t>1E-2</t>"},
1977         {-0.1, "<t>-0.1</t>"},
1978         {-0.01, "<t>-1E-2</t>"},
1979         {1.7976931348623158e308, "<t>1.7976931348623157E+308</t>"},
1980         {-1.7976931348623158e308, "<t>-1.7976931348623157E+308</t>"},
1981     };
1982     HRESULT hr;
1983     WS_XML_WRITER *writer;
1984     WS_XML_DOUBLE_TEXT text;
1985     ULONG i;
1986
1987     hr = WsCreateWriter( NULL, 0, &writer, NULL ) ;
1988     ok( hr == S_OK, "got %08x\n", hr );
1989
1990     text.text.textType = WS_XML_TEXT_TYPE_DOUBLE;
1991     for (i = 0; i < sizeof(tests)/sizeof(tests[0]); i++)
1992     {
1993         hr = set_output( writer );
1994         ok( hr == S_OK, "got %08x\n", hr );
1995         hr = WsWriteStartElement( writer, NULL, &localname, &ns, NULL );
1996         ok( hr == S_OK, "%u: got %08x\n", i, hr );
1997
1998         text.value = tests[i].val;
1999         hr = WsWriteText( writer, &text.text, NULL );
2000         ok( hr == S_OK, "%u: got %08x\n", i, hr );
2001
2002         hr = WsWriteEndElement( writer, NULL );
2003         ok( hr == S_OK, "%u: got %08x\n", i, hr );
2004         check_output( writer, tests[i].result, __LINE__ );
2005     }
2006
2007     hr = set_output( writer );
2008     ok( hr == S_OK, "got %08x\n", hr );
2009     hr = WsWriteStartElement( writer, NULL, &localname, &ns, NULL );
2010     ok( hr == S_OK, "got %08x\n", hr );
2011
2012     text.value = NAN;
2013     hr = WsWriteText( writer, &text.text, NULL );
2014     ok( hr == S_OK, "got %08x\n", hr );
2015
2016     hr = WsWriteEndElement( writer, NULL );
2017     ok( hr == S_OK, "got %08x\n", hr );
2018     check_output( writer, "<t>NaN</t>", __LINE__ );
2019
2020     hr = set_output( writer );
2021     ok( hr == S_OK, "got %08x\n", hr );
2022     hr = WsWriteStartElement( writer, NULL, &localname, &ns, NULL );
2023     ok( hr == S_OK, "got %08x\n", hr );
2024
2025     text.value = INFINITY;
2026     hr = WsWriteText( writer, &text.text, NULL );
2027     ok( hr == S_OK, "got %08x\n", hr );
2028
2029     hr = WsWriteEndElement( writer, NULL );
2030     ok( hr == S_OK, "got %08x\n", hr );
2031     check_output( writer, "<t>INF</t>", __LINE__ );
2032
2033     hr = set_output( writer );
2034     ok( hr == S_OK, "got %08x\n", hr );
2035     hr = WsWriteStartElement( writer, NULL, &localname, &ns, NULL );
2036     ok( hr == S_OK, "got %08x\n", hr );
2037
2038     text.value = -INFINITY;
2039     hr = WsWriteText( writer, &text.text, NULL );
2040     ok( hr == S_OK, "got %08x\n", hr );
2041
2042     hr = WsWriteEndElement( writer, NULL );
2043     ok( hr == S_OK, "got %08x\n", hr );
2044     check_output( writer, "<t>-INF</t>", __LINE__ );
2045
2046     WsFreeWriter( writer );
2047 }
2048
2049 START_TEST(writer)
2050 {
2051     test_WsCreateWriter();
2052     test_WsCreateXmlBuffer();
2053     test_WsSetOutput();
2054     test_WsSetOutputToBuffer();
2055     test_WsWriteStartElement();
2056     test_WsWriteStartAttribute();
2057     test_WsWriteType();
2058     test_basic_type();
2059     test_simple_struct_type();
2060     test_WsWriteElement();
2061     test_WsWriteValue();
2062     test_WsWriteAttribute();
2063     test_WsWriteStartCData();
2064     test_WsWriteXmlnsAttribute();
2065     test_WsGetPrefixFromNamespace();
2066     test_complex_struct_type();
2067     test_WsMoveWriter();
2068     test_WsGetWriterPosition();
2069     test_WsSetWriterPosition();
2070     test_WsWriteXmlBuffer();
2071     test_WsWriteNode();
2072     test_WsCopyNode();
2073     test_text_types();
2074     test_double();
2075 }