dlls/webservices/tests/msg.c

   1 /*
   2  * Copyright 2016 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 static void test_WsCreateMessage(void)
  25 {
  26     HRESULT hr;
  27     WS_MESSAGE *msg;
  28     WS_MESSAGE_STATE state;
  29     WS_ENVELOPE_VERSION env_version;
  30     WS_ADDRESSING_VERSION addr_version;
  31     WS_MESSAGE_PROPERTY prop;
  32
  33     hr = WsCreateMessage( 0, 0, NULL, 0, NULL, NULL );
  34     ok( hr == E_INVALIDARG, "got %08x\n", hr );
  35
  36     hr = WsCreateMessage( 0, 0, NULL, 0, &msg, NULL );
  37     ok( hr == E_INVALIDARG, "got %08x\n", hr );
  38
  39     hr = WsCreateMessage( WS_ENVELOPE_VERSION_SOAP_1_1, 0, NULL, 0, &msg, NULL );
  40     ok( hr == E_INVALIDARG, "got %08x\n", hr );
  41
  42     hr = WsCreateMessage( 0, WS_ADDRESSING_VERSION_0_9, NULL, 0, &msg, NULL );
  43     ok( hr == E_INVALIDARG, "got %08x\n", hr );
  44
  45     env_version = WS_ENVELOPE_VERSION_SOAP_1_1;
  46     prop.id = WS_MESSAGE_PROPERTY_ENVELOPE_VERSION;
  47     prop.value = &env_version;
  48     prop.valueSize = sizeof(env_version);
  49     hr = WsCreateMessage( WS_ENVELOPE_VERSION_SOAP_1_1, WS_ADDRESSING_VERSION_0_9, &prop,
  50                           1, &msg, NULL );
  51     ok( hr == E_INVALIDARG, "got %08x\n", hr );
  52
  53     hr = WsCreateMessage( WS_ENVELOPE_VERSION_SOAP_1_1, WS_ADDRESSING_VERSION_0_9, NULL,
  54                           0, &msg, NULL );
  55     ok( hr == S_OK, "got %08x\n", hr );
  56
  57     state = 0xdeadbeef;
  58     hr = WsGetMessageProperty( msg, WS_MESSAGE_PROPERTY_STATE, &state, sizeof(state), NULL );
  59     ok( hr == S_OK, "got %08x\n", hr );
  60     ok( state == WS_MESSAGE_STATE_EMPTY, "got %u\n", state );
  61
  62     env_version = 0xdeadbeef;
  63     hr = WsGetMessageProperty( msg, WS_MESSAGE_PROPERTY_ENVELOPE_VERSION, &env_version,
  64                                sizeof(env_version), NULL );
  65     ok( hr == S_OK, "got %08x\n", hr );
  66     ok( env_version == WS_ENVELOPE_VERSION_SOAP_1_1, "got %u\n", env_version );
  67
  68     addr_version = 0xdeadbeef;
  69     hr = WsGetMessageProperty( msg, WS_MESSAGE_PROPERTY_ADDRESSING_VERSION, &addr_version,
  70                                sizeof(addr_version), NULL );
  71     ok( hr == S_OK, "got %08x\n", hr );
  72     ok( addr_version == WS_ADDRESSING_VERSION_0_9, "got %u\n", addr_version );
  73
  74     state = WS_MESSAGE_STATE_EMPTY;
  75     hr = WsSetMessageProperty( msg, WS_MESSAGE_PROPERTY_STATE, &state, sizeof(state), NULL );
  76     ok( hr == WS_E_INVALID_OPERATION, "got %08x\n", hr );
  77
  78     env_version = WS_ENVELOPE_VERSION_SOAP_1_1;
  79     hr = WsSetMessageProperty( msg, WS_MESSAGE_PROPERTY_ENVELOPE_VERSION, &env_version,
  80                                sizeof(env_version), NULL );
  81     ok( hr == WS_E_INVALID_OPERATION, "got %08x\n", hr );
  82
  83     addr_version = WS_ADDRESSING_VERSION_0_9;
  84     hr = WsSetMessageProperty( msg, WS_MESSAGE_PROPERTY_ADDRESSING_VERSION, &addr_version,
  85                                sizeof(addr_version), NULL );
  86     ok( hr == WS_E_INVALID_OPERATION, "got %08x\n", hr );
  87     WsFreeMessage( msg );
  88 }
  89
  90 static void test_WsCreateMessageForChannel(void)
  91 {
  92     HRESULT hr;
  93     WS_CHANNEL *channel;
  94     WS_MESSAGE *msg;
  95     WS_MESSAGE_STATE state;
  96     WS_ENVELOPE_VERSION env_version;
  97     WS_ADDRESSING_VERSION addr_version;
  98     WS_CHANNEL_PROPERTY prop;
  99     BOOL addressed;
 100
 101     hr = WsCreateMessageForChannel( NULL, NULL, 0, NULL, NULL );
 102     ok( hr == E_INVALIDARG, "got %08x\n", hr );
 103
 104     hr = WsCreateMessageForChannel( NULL, NULL, 0, &msg, NULL );
 105     ok( hr == E_INVALIDARG, "got %08x\n", hr );
 106
 107     hr = WsCreateChannel( WS_CHANNEL_TYPE_REQUEST, WS_HTTP_CHANNEL_BINDING, NULL, 0, NULL,
 108                           &channel, NULL );
 109     ok( hr == S_OK, "got %08x\n", hr );
 110
 111     hr = WsCreateMessageForChannel( channel, NULL, 0, &msg, NULL );
 112     ok( hr == S_OK, "got %08x\n", hr );
 113
 114     state = 0xdeadbeef;
 115     hr = WsGetMessageProperty( msg, WS_MESSAGE_PROPERTY_STATE, &state, sizeof(state), NULL );
 116     ok( hr == S_OK, "got %08x\n", hr );
 117     ok( state == WS_MESSAGE_STATE_EMPTY, "got %u\n", state );
 118
 119     env_version = 0xdeadbeef;
 120     hr = WsGetMessageProperty( msg, WS_MESSAGE_PROPERTY_ENVELOPE_VERSION, &env_version,
 121                                sizeof(env_version), NULL );
 122     ok( hr == S_OK, "got %08x\n", hr );
 123     ok( env_version == WS_ENVELOPE_VERSION_SOAP_1_2, "got %u\n", env_version );
 124
 125     addr_version = 0xdeadbeef;
 126     hr = WsGetMessageProperty( msg, WS_MESSAGE_PROPERTY_ADDRESSING_VERSION, &addr_version,
 127                                sizeof(addr_version), NULL );
 128     ok( hr == S_OK, "got %08x\n", hr );
 129     ok( addr_version == WS_ADDRESSING_VERSION_1_0, "got %u\n", addr_version );
 130
 131     hr = WsGetMessageProperty( msg, WS_MESSAGE_PROPERTY_IS_ADDRESSED, &addressed, sizeof(addressed),
 132                                NULL );
 133     ok( hr == WS_E_INVALID_OPERATION, "got %08x\n", hr );
 134
 135     WsFreeChannel( channel );
 136     WsFreeMessage( msg );
 137
 138     env_version = WS_ENVELOPE_VERSION_SOAP_1_1;
 139     prop.id = WS_CHANNEL_PROPERTY_ENVELOPE_VERSION;
 140     prop.value = &env_version;
 141     prop.valueSize = sizeof(env_version);
 142     hr = WsCreateChannel( WS_CHANNEL_TYPE_REQUEST, WS_HTTP_CHANNEL_BINDING, &prop, 1, NULL,
 143                           &channel, NULL );
 144     ok( hr == S_OK, "got %08x\n", hr );
 145
 146     hr = WsCreateMessageForChannel( channel, NULL, 0, &msg, NULL );
 147     ok( hr == S_OK, "got %08x\n", hr );
 148
 149     env_version = 0xdeadbeef;
 150     hr = WsGetMessageProperty( msg, WS_MESSAGE_PROPERTY_ENVELOPE_VERSION, &env_version,
 151                                sizeof(env_version), NULL );
 152     ok( hr == S_OK, "got %08x\n", hr );
 153     ok( env_version == WS_ENVELOPE_VERSION_SOAP_1_1, "got %u\n", env_version );
 154
 155     WsFreeChannel( channel );
 156     WsFreeMessage( msg );
 157 }
 158
 159 static void test_WsInitializeMessage(void)
 160 {
 161     HRESULT hr;
 162     WS_MESSAGE *msg;
 163     WS_MESSAGE_STATE state;
 164     WS_ENVELOPE_VERSION env_version;
 165     WS_ADDRESSING_VERSION addr_version;
 166     BOOL addressed;
 167
 168     return;
 169     hr = WsInitializeMessage( NULL, WS_REQUEST_MESSAGE, NULL, NULL );
 170     ok( hr == E_INVALIDARG, "got %08x\n", hr );
 171
 172     hr = WsCreateMessage( WS_ENVELOPE_VERSION_SOAP_1_1, WS_ADDRESSING_VERSION_0_9, NULL,
 173                           0, &msg, NULL );
 174     ok( hr == S_OK, "got %08x\n", hr );
 175
 176     hr = WsInitializeMessage( msg, 0xdeadbeef, NULL, NULL );
 177     ok( hr == E_INVALIDARG, "got %08x\n", hr );
 178
 179     hr = WsInitializeMessage( msg, WS_REQUEST_MESSAGE, NULL, NULL );
 180     ok( hr == S_OK, "got %08x\n", hr );
 181
 182     hr = WsInitializeMessage( msg, WS_REQUEST_MESSAGE, NULL, NULL );
 183     ok( hr == WS_E_INVALID_OPERATION, "got %08x\n", hr );
 184
 185     state = 0xdeadbeef;
 186     hr = WsGetMessageProperty( msg, WS_MESSAGE_PROPERTY_STATE, &state, sizeof(state), NULL );
 187     ok( hr == S_OK, "got %08x\n", hr );
 188     ok( state == WS_MESSAGE_STATE_INITIALIZED, "got %u\n", state );
 189
 190     addressed = -1;
 191     hr = WsGetMessageProperty( msg, WS_MESSAGE_PROPERTY_IS_ADDRESSED, &addressed, sizeof(addressed),
 192                                NULL );
 193     ok( hr == S_OK, "got %08x\n", hr );
 194     ok( !addressed, "unexpected value %d\n", addressed );
 195
 196     state = WS_MESSAGE_STATE_EMPTY;
 197     hr = WsSetMessageProperty( msg, WS_MESSAGE_PROPERTY_STATE, &state, sizeof(state), NULL );
 198     ok( hr == E_INVALIDARG, "got %08x\n", hr );
 199
 200     env_version = WS_ENVELOPE_VERSION_SOAP_1_1;
 201     hr = WsSetMessageProperty( msg, WS_MESSAGE_PROPERTY_ENVELOPE_VERSION, &env_version,
 202                                sizeof(env_version), NULL );
 203     ok( hr == E_INVALIDARG, "got %08x\n", hr );
 204
 205     addr_version = WS_ADDRESSING_VERSION_0_9;
 206     hr = WsSetMessageProperty( msg, WS_MESSAGE_PROPERTY_ADDRESSING_VERSION, &addr_version,
 207                                sizeof(addr_version), NULL );
 208     ok( hr == E_INVALIDARG, "got %08x\n", hr );
 209     WsFreeMessage( msg );
 210 }
 211
 212 static void test_WsAddressMessage(void)
 213 {
 214     static WCHAR localhost[] = {'h','t','t','p',':','/','/','l','o','c','a','l','h','o','s','t','/',0};
 215     HRESULT hr;
 216     WS_MESSAGE *msg;
 217     WS_ENDPOINT_ADDRESS endpoint;
 218     BOOL addressed;
 219
 220     hr = WsAddressMessage( NULL, NULL, NULL );
 221     ok( hr == E_INVALIDARG, "got %08x\n", hr );
 222
 223     hr = WsCreateMessage( WS_ENVELOPE_VERSION_SOAP_1_1, WS_ADDRESSING_VERSION_0_9, NULL,
 224                           0, &msg, NULL );
 225     ok( hr == S_OK, "got %08x\n", hr );
 226
 227     hr = WsGetMessageProperty( msg, WS_MESSAGE_PROPERTY_IS_ADDRESSED, &addressed, sizeof(addressed),
 228                                NULL );
 229     ok( hr == WS_E_INVALID_OPERATION, "got %08x\n", hr );
 230
 231     hr = WsAddressMessage( msg, NULL, NULL );
 232     ok( hr == WS_E_INVALID_OPERATION, "got %08x\n", hr );
 233
 234     hr = WsInitializeMessage( msg, WS_REQUEST_MESSAGE, NULL, NULL );
 235     ok( hr == S_OK, "got %08x\n", hr );
 236
 237     addressed = -1;
 238     hr = WsGetMessageProperty( msg, WS_MESSAGE_PROPERTY_IS_ADDRESSED, &addressed, sizeof(addressed),
 239                                NULL );
 240     ok( hr == S_OK, "got %08x\n", hr );
 241     ok( !addressed, "unexpected value %d\n", addressed );
 242
 243     hr = WsAddressMessage( msg, NULL, NULL );
 244     ok( hr == S_OK, "got %08x\n", hr );
 245
 246     addressed = -1;
 247     hr = WsGetMessageProperty( msg, WS_MESSAGE_PROPERTY_IS_ADDRESSED, &addressed, sizeof(addressed),
 248                                NULL );
 249     ok( hr == S_OK, "got %08x\n", hr );
 250     ok( addressed == TRUE, "unexpected value %d\n", addressed );
 251     WsFreeMessage( msg );
 252
 253     hr = WsCreateMessage( WS_ENVELOPE_VERSION_SOAP_1_1, WS_ADDRESSING_VERSION_0_9, NULL,
 254                           0, &msg, NULL );
 255     ok( hr == S_OK, "got %08x\n", hr );
 256
 257     hr = WsInitializeMessage( msg, WS_REQUEST_MESSAGE, NULL, NULL );
 258     ok( hr == S_OK, "got %08x\n", hr );
 259
 260     memset( &endpoint, 0, sizeof(endpoint) );
 261     endpoint.url.chars  = localhost;
 262     endpoint.url.length = sizeof(localhost)/sizeof(localhost[0]);
 263     hr = WsAddressMessage( msg, &endpoint, NULL );
 264     ok( hr == S_OK, "got %08x\n", hr );
 265
 266     addressed = -1;
 267     hr = WsGetMessageProperty( msg, WS_MESSAGE_PROPERTY_IS_ADDRESSED, &addressed, sizeof(addressed),
 268                                NULL );
 269     ok( hr == S_OK, "got %08x\n", hr );
 270     ok( addressed == TRUE, "unexpected value %d\n", addressed );
 271     WsFreeMessage( msg );
 272 }
 273
 274 static HRESULT set_output( WS_XML_WRITER *writer )
 275 {
 276     WS_XML_WRITER_TEXT_ENCODING text = { {WS_XML_WRITER_ENCODING_TYPE_TEXT}, WS_CHARSET_UTF8 };
 277     WS_XML_WRITER_BUFFER_OUTPUT buf = { {WS_XML_WRITER_OUTPUT_TYPE_BUFFER} };
 278     return WsSetOutput( writer, &text.encoding, &buf.output, NULL, 0, NULL );
 279 }
 280
 281 static void check_output( WS_XML_WRITER *writer, const char *expected, int len, unsigned int skip_start,
 282                           unsigned int skip_len, unsigned int line )
 283 {
 284     WS_BYTES bytes;
 285     HRESULT hr;
 286
 287     if (len == -1) len = strlen( expected );
 288     memset( &bytes, 0, sizeof(bytes) );
 289     hr = WsGetWriterProperty( writer, WS_XML_WRITER_PROPERTY_BYTES, &bytes, sizeof(bytes), NULL );
 290     ok( hr == S_OK, "%u: got %08x\n", line, hr );
 291     ok( bytes.length == len, "%u: got %u expected %u\n", line, bytes.length, len );
 292     if (bytes.length != len) return;
 293     if (skip_start)
 294     {
 295         ok( !memcmp( bytes.bytes, expected, skip_start ), "%u: got %s expected %s\n", line,
 296             bytes.bytes, expected );
 297         ok( !memcmp( bytes.bytes + skip_start + skip_len, expected + skip_start + skip_len,
 298             len - skip_start - skip_len), "%u: got %s expected %s\n", line, bytes.bytes, expected );
 299     }
 300     else
 301         ok( !memcmp( bytes.bytes, expected, len ), "%u: got %s expected %s\n", line, bytes.bytes,
 302             expected );
 303 }
 304
 305 static void check_output_header( WS_MESSAGE *msg, const char *expected, int len, unsigned int skip_start,
 306                                  unsigned int skip_len, unsigned int line )
 307 {
 308     WS_XML_WRITER *writer;
 309     WS_XML_BUFFER *buf;
 310     HRESULT hr;
 311
 312     hr = WsCreateWriter( NULL, 0, &writer, NULL );
 313     ok( hr == S_OK, "got %08x\n", hr );
 314
 315     hr = set_output( writer );
 316     ok( hr == S_OK, "got %08x\n", hr );
 317
 318     hr = WsGetMessageProperty( msg, WS_MESSAGE_PROPERTY_HEADER_BUFFER, &buf, sizeof(buf), NULL );
 319     ok( hr == S_OK, "got %08x\n", hr );
 320
 321     hr = WsWriteXmlBuffer( writer, buf, NULL );
 322     ok( hr == S_OK, "got %08x\n", hr );
 323
 324     check_output( writer, expected, len, skip_start, skip_len, line );
 325     WsFreeWriter( writer );
 326 }
 327
 328 static void test_WsWriteEnvelopeStart(void)
 329 {
 330     static const char expected[] =
 331         "<s:Envelope xmlns:a=\"http://schemas.xmlsoap.org/ws/2004/08/addressing\" "
 332         "xmlns:s=\"http://schemas.xmlsoap.org/soap/envelope/\"><s:Header>"
 333         "<a:MessageID>urn:uuid:00000000-0000-0000-0000-000000000000</a:MessageID>"
 334         "<a:ReplyTo><a:Address>http://schemas.xmlsoap.org/ws/2004/08/addressing/role/anonymous</a:Address>"
 335         "</a:ReplyTo></s:Header>";
 336     static const char expected2[] =
 337         "<s:Envelope xmlns:a=\"http://schemas.xmlsoap.org/ws/2004/08/addressing\" "
 338         "xmlns:s=\"http://schemas.xmlsoap.org/soap/envelope/\"><s:Header>"
 339         "<a:MessageID>urn:uuid:00000000-0000-0000-0000-000000000000</a:MessageID>"
 340         "<a:ReplyTo><a:Address>http://schemas.xmlsoap.org/ws/2004/08/addressing/role/anonymous</a:Address>"
 341         "</a:ReplyTo></s:Header><s:Body/></s:Envelope>";
 342     static const char expected3[] =
 343         "<s:Envelope xmlns:s=\"http://schemas.xmlsoap.org/soap/envelope/\"><s:Header/><s:Body/></s:Envelope>";
 344     HRESULT hr;
 345     WS_MESSAGE *msg;
 346     WS_XML_WRITER *writer;
 347     WS_MESSAGE_STATE state;
 348
 349     hr = WsWriteEnvelopeStart( NULL, NULL, NULL, NULL, NULL );
 350     ok( hr == E_INVALIDARG, "got %08x\n", hr );
 351
 352     hr = WsCreateWriter( NULL, 0, &writer, NULL );
 353     ok( hr == S_OK, "got %08x\n", hr );
 354
 355     hr = WsWriteEnvelopeStart( NULL, writer, NULL, NULL, NULL );
 356     ok( hr == E_INVALIDARG, "got %08x\n", hr );
 357
 358     hr = WsCreateMessage( WS_ENVELOPE_VERSION_SOAP_1_1, WS_ADDRESSING_VERSION_0_9, NULL, 0, &msg,
 359                           NULL );
 360     ok( hr == S_OK, "got %08x\n", hr );
 361
 362     hr = WsWriteEnvelopeStart( msg, writer, NULL, NULL, NULL );
 363     ok( hr == WS_E_INVALID_OPERATION, "got %08x\n", hr );
 364
 365     hr = WsInitializeMessage( msg, WS_REQUEST_MESSAGE, NULL, NULL );
 366     ok( hr == S_OK, "got %08x\n", hr );
 367
 368     hr = set_output( writer );
 369     ok( hr == S_OK, "got %08x\n", hr );
 370
 371     hr = WsWriteEnvelopeStart( msg, writer, NULL, NULL, NULL );
 372     ok( hr == S_OK, "got %08x\n", hr );
 373     check_output( writer, expected, -1, strstr(expected, "urn:uuid:") - expected, 46, __LINE__ );
 374     check_output_header( msg, expected2, -1, strstr(expected2, "urn:uuid:") - expected2, 46, __LINE__ );
 375
 376     state = 0xdeadbeef;
 377     hr = WsGetMessageProperty( msg, WS_MESSAGE_PROPERTY_STATE, &state, sizeof(state), NULL );
 378     ok( hr == S_OK, "got %08x\n", hr );
 379     ok( state == WS_MESSAGE_STATE_WRITING, "got %u\n", state );
 380     WsFreeMessage( msg );
 381
 382     hr = WsCreateMessage( WS_ENVELOPE_VERSION_SOAP_1_1, WS_ADDRESSING_VERSION_TRANSPORT, NULL, 0, &msg,
 383                           NULL );
 384     ok( hr == S_OK, "got %08x\n", hr );
 385
 386     hr = WsInitializeMessage( msg, WS_REQUEST_MESSAGE, NULL, NULL );
 387     ok( hr == S_OK, "got %08x\n", hr );
 388
 389     hr = set_output( writer );
 390     ok( hr == S_OK, "got %08x\n", hr );
 391
 392     hr = WsWriteEnvelopeStart( msg, writer, NULL, NULL, NULL );
 393     ok( hr == S_OK, "got %08x\n", hr );
 394     check_output_header( msg, expected3, -1, 0, 0, __LINE__ );
 395
 396     WsFreeMessage( msg );
 397     WsFreeWriter( writer );
 398 }
 399
 400 static void test_WsWriteEnvelopeEnd(void)
 401 {
 402     static const char expected[] =
 403         "<s:Envelope xmlns:a=\"http://www.w3.org/2005/08/addressing\" "
 404         "xmlns:s=\"http://www.w3.org/2003/05/soap-envelope\"><s:Header>"
 405         "<a:MessageID>urn:uuid:00000000-0000-0000-0000-000000000000</a:MessageID>"
 406         "</s:Header><s:Body/></s:Envelope>";
 407     HRESULT hr;
 408     WS_MESSAGE *msg;
 409     WS_XML_WRITER *writer;
 410     WS_MESSAGE_STATE state;
 411
 412     hr = WsWriteEnvelopeEnd( NULL, NULL );
 413     ok( hr == E_INVALIDARG, "got %08x\n", hr );
 414
 415     hr = WsCreateMessage( WS_ENVELOPE_VERSION_SOAP_1_2, WS_ADDRESSING_VERSION_1_0, NULL, 0, &msg,
 416                           NULL );
 417     ok( hr == S_OK, "got %08x\n", hr );
 418
 419     hr = WsWriteEnvelopeEnd( msg, NULL );
 420     ok( hr == WS_E_INVALID_OPERATION, "got %08x\n", hr );
 421
 422     hr = WsInitializeMessage( msg, WS_REQUEST_MESSAGE, NULL, NULL );
 423     ok( hr == S_OK, "got %08x\n", hr );
 424
 425     hr = WsWriteEnvelopeEnd( msg, NULL );
 426     ok( hr == WS_E_INVALID_OPERATION, "got %08x\n", hr );
 427
 428     hr = WsCreateWriter( NULL, 0, &writer, NULL );
 429     ok( hr == S_OK, "got %08x\n", hr );
 430
 431     hr = set_output( writer );
 432     ok( hr == S_OK, "got %08x\n", hr );
 433
 434     hr = WsWriteEnvelopeStart( msg, writer, NULL, NULL, NULL );
 435     ok( hr == S_OK, "got %08x\n", hr );
 436
 437     hr = WsWriteEnvelopeEnd( msg, NULL );
 438     ok( hr == S_OK, "got %08x\n", hr );
 439     check_output( writer, expected, -1, strstr(expected, "urn:uuid:") - expected, 46, __LINE__ );
 440     check_output_header( msg, expected, -1, strstr(expected, "urn:uuid:") - expected, 46, __LINE__ );
 441
 442     state = 0xdeadbeef;
 443     hr = WsGetMessageProperty( msg, WS_MESSAGE_PROPERTY_STATE, &state, sizeof(state), NULL );
 444     ok( hr == S_OK, "got %08x\n", hr );
 445     ok( state == WS_MESSAGE_STATE_DONE, "got %u\n", state );
 446
 447     WsFreeMessage( msg );
 448     WsFreeWriter( writer );
 449 }
 450
 451 static void test_WsWriteBody(void)
 452 {
 453     static char expected[] =
 454         "<s:Envelope xmlns:a=\"http://www.w3.org/2005/08/addressing\" "
 455         "xmlns:s=\"http://www.w3.org/2003/05/soap-envelope\"><s:Header>"
 456         "<a:MessageID>urn:uuid:00000000-0000-0000-0000-000000000000</a:MessageID>"
 457         "</s:Header><s:Body><u xmlns=\"ns\"><val>1</val></u></s:Body></s:Envelope>";
 458     static char expected2[] =
 459         "<s:Envelope xmlns:a=\"http://www.w3.org/2005/08/addressing\" "
 460         "xmlns:s=\"http://www.w3.org/2003/05/soap-envelope\"><s:Header>"
 461         "<a:MessageID>urn:uuid:00000000-0000-0000-0000-000000000000</a:MessageID>"
 462         "</s:Header><s:Body/></s:Envelope>";
 463     WS_XML_STRING localname = {1, (BYTE *)"t"}, localname2 = {1, (BYTE *)"u"};
 464     WS_XML_STRING val = {3, (BYTE *)"val"}, ns = {2, (BYTE *)"ns"};
 465     HRESULT hr;
 466     WS_MESSAGE *msg;
 467     WS_XML_WRITER *writer;
 468     WS_MESSAGE_STATE state;
 469     WS_ELEMENT_DESCRIPTION desc;
 470     WS_STRUCT_DESCRIPTION s;
 471     WS_FIELD_DESCRIPTION f, *fields[1];
 472     struct test
 473     {
 474         UINT32 val;
 475     } test, *ptr;
 476
 477     hr = WsCreateMessage( WS_ENVELOPE_VERSION_SOAP_1_2, WS_ADDRESSING_VERSION_1_0, NULL, 0, &msg,
 478                           NULL );
 479     ok( hr == S_OK, "got %08x\n", hr );
 480
 481     hr = WsInitializeMessage( msg, WS_REQUEST_MESSAGE, NULL, NULL );
 482     ok( hr == S_OK, "got %08x\n", hr );
 483
 484     hr = WsCreateWriter( NULL, 0, &writer, NULL );
 485     ok( hr == S_OK, "got %08x\n", hr );
 486
 487     hr = set_output( writer );
 488     ok( hr == S_OK, "got %08x\n", hr );
 489
 490     hr = WsWriteEnvelopeStart( msg, writer, NULL, NULL, NULL );
 491     ok( hr == S_OK, "got %08x\n", hr );
 492
 493     hr = WsWriteBody( NULL, NULL, 0, NULL, 0, NULL );
 494     ok( hr == E_INVALIDARG, "got %08x\n", hr );
 495
 496     hr = WsWriteBody( msg, NULL, 0, NULL, 0, NULL );
 497     ok( hr == E_INVALIDARG, "got %08x\n", hr );
 498
 499     memset( &f, 0, sizeof(f) );
 500     f.mapping   = WS_ELEMENT_FIELD_MAPPING;
 501     f.localName = &val;
 502     f.ns        = &ns;
 503     f.type      = WS_UINT32_TYPE;
 504     fields[0] = &f;
 505
 506     memset( &s, 0, sizeof(s) );
 507     s.size          = sizeof(struct test);
 508     s.alignment     = TYPE_ALIGNMENT(struct test);
 509     s.fields        = fields;
 510     s.fieldCount    = 1;
 511     s.typeLocalName = &localname;
 512     s.typeNs        = &ns;
 513
 514     desc.elementLocalName = &localname2;
 515     desc.elementNs        = &ns;
 516     desc.type             = WS_STRUCT_TYPE;
 517     desc.typeDescription  = &s;
 518
 519     ptr = &test;
 520     test.val = 1;
 521     hr = WsWriteBody( msg, &desc, WS_WRITE_REQUIRED_POINTER, &ptr, sizeof(ptr), NULL );
 522     ok( hr == S_OK, "got %08x\n", hr );
 523     check_output( writer, expected, 240, strstr(expected, "urn:uuid:") - expected, 46, __LINE__ );
 524     check_output_header( msg, expected2, -1, strstr(expected2, "urn:uuid:") - expected2, 46, __LINE__ );
 525
 526     state = 0xdeadbeef;
 527     hr = WsGetMessageProperty( msg, WS_MESSAGE_PROPERTY_STATE, &state, sizeof(state), NULL );
 528     ok( hr == S_OK, "got %08x\n", hr );
 529     ok( state == WS_MESSAGE_STATE_WRITING, "got %u\n", state );
 530
 531     hr = WsWriteEnvelopeEnd( msg, NULL );
 532     ok( hr == S_OK, "got %08x\n", hr );
 533     check_output( writer, expected, -1, strstr(expected, "urn:uuid:") - expected, 46, __LINE__ );
 534     check_output_header( msg, expected2, -1, strstr(expected2, "urn:uuid:") - expected2, 46, __LINE__ );
 535
 536     hr = WsWriteBody( msg, &desc, WS_WRITE_REQUIRED_POINTER, &ptr, sizeof(ptr), NULL );
 537     ok( hr == WS_E_INVALID_OPERATION, "got %08x\n", hr );
 538
 539     WsFreeMessage( msg );
 540     WsFreeWriter( writer );
 541 }
 542
 543 static void test_WsSetHeader(void)
 544 {
 545     static const char expected[] =
 546         "<s:Envelope xmlns:a=\"http://www.w3.org/2005/08/addressing\" "
 547         "xmlns:s=\"http://www.w3.org/2003/05/soap-envelope\"><s:Header>"
 548         "<a:MessageID>urn:uuid:00000000-0000-0000-0000-000000000000</a:MessageID>"
 549         "<a:Action s:mustUnderstand=\"1\">action</a:Action></s:Header>"
 550         "<s:Body/></s:Envelope>";
 551    static const char expected2[] =
 552         "<s:Envelope xmlns:a=\"http://www.w3.org/2005/08/addressing\" "
 553         "xmlns:s=\"http://www.w3.org/2003/05/soap-envelope\"><s:Header>"
 554         "<a:MessageID>urn:uuid:00000000-0000-0000-0000-000000000000</a:MessageID>"
 555         "<a:Action s:mustUnderstand=\"1\">action2</a:Action></s:Header>"
 556         "<s:Body/></s:Envelope>";
 557     static const WCHAR action[] = {'a','c','t','i','o','n',0};
 558     static const WS_XML_STRING action2 = {7, (BYTE *)"action2"};
 559     HRESULT hr;
 560     WS_MESSAGE *msg;
 561     WS_XML_WRITER *writer;
 562     const WCHAR *ptr = action;
 563
 564     hr = WsSetHeader( NULL, 0, 0, 0, NULL, 0, NULL );
 565     ok( hr == E_INVALIDARG, "got %08x\n", hr );
 566
 567     hr = WsCreateMessage( WS_ADDRESSING_VERSION_1_0, WS_ENVELOPE_VERSION_SOAP_1_2, NULL, 0, &msg,
 568                           NULL );
 569     ok( hr == S_OK, "got %08x\n", hr );
 570
 571     hr = WsSetHeader( msg, 0, 0, 0, NULL, 0, NULL );
 572     ok( hr == E_INVALIDARG, "got %08x\n", hr );
 573
 574     hr = WsSetHeader( msg, WS_ACTION_HEADER, WS_WSZ_TYPE, WS_WRITE_REQUIRED_POINTER, &ptr,
 575                       sizeof(ptr), NULL );
 576     ok( hr == WS_E_INVALID_OPERATION, "got %08x\n", hr );
 577
 578     hr = WsInitializeMessage( msg, WS_REQUEST_MESSAGE, NULL, NULL );
 579     ok( hr == S_OK, "got %08x\n", hr );
 580
 581     hr = WsSetHeader( msg, 0, WS_WSZ_TYPE, WS_WRITE_REQUIRED_POINTER, &ptr, sizeof(ptr), NULL );
 582     ok( hr == E_INVALIDARG, "got %08x\n", hr );
 583
 584     hr = WsSetHeader( msg, WS_ACTION_HEADER, WS_WSZ_TYPE, WS_WRITE_REQUIRED_POINTER, &ptr,
 585                       sizeof(ptr), NULL );
 586     ok( hr == S_OK, "got %08x\n", hr );
 587     check_output_header( msg, expected, -1, strstr(expected, "urn:uuid:") - expected, 46, __LINE__ );
 588
 589     hr = WsCreateWriter( NULL, 0, &writer, NULL );
 590     ok( hr == S_OK, "got %08x\n", hr );
 591
 592     hr = set_output( writer );
 593     ok( hr == S_OK, "got %08x\n", hr );
 594
 595     hr = WsWriteEnvelopeStart( msg, writer, NULL, NULL, NULL );
 596     ok( hr == S_OK, "got %08x\n", hr );
 597     check_output( writer, expected, 250, strstr(expected, "urn:uuid:") - expected, 46, __LINE__ );
 598     check_output_header( msg, expected, -1, strstr(expected, "urn:uuid:") - expected, 46, __LINE__ );
 599
 600     /* called after WsWriteEnvelopeStart */
 601     hr = WsSetHeader( msg, WS_ACTION_HEADER, WS_XML_STRING_TYPE, WS_WRITE_REQUIRED_VALUE, &action2,
 602                       sizeof(action2), NULL );
 603     ok( hr == S_OK, "got %08x\n", hr );
 604     check_output( writer, expected, 250, strstr(expected, "urn:uuid:") - expected, 46, __LINE__ );
 605     check_output_header( msg, expected2, -1, strstr(expected2, "urn:uuid:") - expected2, 46, __LINE__ );
 606
 607     WsFreeMessage( msg );
 608     WsFreeWriter( writer );
 609 }
 610
 611 static void test_WsRemoveHeader(void)
 612 {
 613     static const char expected[] =
 614         "<s:Envelope xmlns:a=\"http://www.w3.org/2005/08/addressing\" "
 615         "xmlns:s=\"http://www.w3.org/2003/05/soap-envelope\"><s:Header>"
 616         "<a:MessageID>urn:uuid:00000000-0000-0000-0000-000000000000</a:MessageID>"
 617         "<a:Action s:mustUnderstand=\"1\">action</a:Action></s:Header>"
 618         "<s:Body/></s:Envelope>";
 619    static const char expected2[] =
 620         "<s:Envelope xmlns:a=\"http://www.w3.org/2005/08/addressing\" "
 621         "xmlns:s=\"http://www.w3.org/2003/05/soap-envelope\"><s:Header>"
 622         "<a:MessageID>urn:uuid:00000000-0000-0000-0000-000000000000</a:MessageID>"
 623         "</s:Header><s:Body/></s:Envelope>";
 624     static const WS_XML_STRING action = {6, (BYTE *)"action"};
 625     HRESULT hr;
 626     WS_MESSAGE *msg;
 627
 628     hr = WsSetHeader( NULL, 0, 0, 0, NULL, 0, NULL );
 629     ok( hr == E_INVALIDARG, "got %08x\n", hr );
 630
 631     hr = WsCreateMessage( WS_ADDRESSING_VERSION_1_0, WS_ENVELOPE_VERSION_SOAP_1_2, NULL, 0, &msg,
 632                           NULL );
 633     ok( hr == S_OK, "got %08x\n", hr );
 634
 635     hr = WsRemoveHeader( NULL, 0, NULL );
 636     ok( hr == E_INVALIDARG, "got %08x\n", hr );
 637
 638     hr = WsRemoveHeader( msg, 0, NULL );
 639     ok( hr == WS_E_INVALID_OPERATION, "got %08x\n", hr );
 640
 641     hr = WsRemoveHeader( msg, WS_ACTION_HEADER, NULL );
 642     ok( hr == WS_E_INVALID_OPERATION, "got %08x\n", hr );
 643
 644     hr = WsInitializeMessage( msg, WS_REQUEST_MESSAGE, NULL, NULL );
 645     ok( hr == S_OK, "got %08x\n", hr );
 646     check_output_header( msg, expected2, -1, strstr(expected2, "urn:uuid:") - expected2, 46, __LINE__ );
 647
 648     hr = WsRemoveHeader( msg, 0, NULL );
 649     ok( hr == E_INVALIDARG, "got %08x\n", hr );
 650
 651     hr = WsRemoveHeader( msg, WS_ACTION_HEADER, NULL );
 652     ok( hr == S_OK, "got %08x\n", hr );
 653     check_output_header( msg, expected2, -1, strstr(expected2, "urn:uuid:") - expected2, 46, __LINE__ );
 654
 655     hr = WsSetHeader( msg, WS_ACTION_HEADER, WS_XML_STRING_TYPE, WS_WRITE_REQUIRED_VALUE, &action,
 656                       sizeof(action), NULL );
 657     ok( hr == S_OK, "got %08x\n", hr );
 658     check_output_header( msg, expected, -1, strstr(expected, "urn:uuid:") - expected, 46, __LINE__ );
 659
 660     hr = WsRemoveHeader( msg, WS_ACTION_HEADER, NULL );
 661     ok( hr == S_OK, "got %08x\n", hr );
 662     check_output_header( msg, expected2, -1, strstr(expected2, "urn:uuid:") - expected2, 46, __LINE__ );
 663
 664     /* again */
 665     hr = WsRemoveHeader( msg, WS_ACTION_HEADER, NULL );
 666     ok( hr == S_OK, "got %08x\n", hr );
 667     check_output_header( msg, expected2, -1, strstr(expected2, "urn:uuid:") - expected2, 46, __LINE__ );
 668
 669     WsFreeMessage( msg );
 670 }
 671
 672 static void test_WsAddMappedHeader(void)
 673 {
 674     static const WS_XML_STRING header = {6, (BYTE *)"Header"}, value = {5, (BYTE *)"value"};
 675     WS_MESSAGE *msg;
 676     HRESULT hr;
 677
 678     hr = WsAddMappedHeader( NULL, NULL, 0, 0, NULL, 0, NULL );
 679     ok( hr == E_INVALIDARG, "got %08x\n", hr );
 680
 681     hr = WsCreateMessage( WS_ADDRESSING_VERSION_1_0, WS_ENVELOPE_VERSION_SOAP_1_2, NULL, 0, &msg, NULL );
 682     ok( hr == S_OK, "got %08x\n", hr );
 683
 684     hr = WsAddMappedHeader( msg, NULL, 0, 0, NULL, 0, NULL );
 685     ok( hr == E_INVALIDARG, "got %08x\n", hr );
 686
 687     hr = WsAddMappedHeader( msg, &header, 0, 0, NULL, 0, NULL );
 688     ok( hr == WS_E_INVALID_OPERATION, "got %08x\n", hr );
 689
 690     hr = WsInitializeMessage( msg, WS_REQUEST_MESSAGE, NULL, NULL );
 691     ok( hr == S_OK, "got %08x\n", hr );
 692
 693     hr = WsAddMappedHeader( msg, &header, WS_XML_STRING_TYPE, WS_WRITE_REQUIRED_VALUE, NULL, 0, NULL );
 694     ok( hr == E_INVALIDARG, "got %08x\n", hr );
 695
 696     hr = WsAddMappedHeader( msg, &header, WS_XML_STRING_TYPE, WS_WRITE_REQUIRED_VALUE, &value, sizeof(value), NULL );
 697     ok( hr == S_OK, "got %08x\n", hr );
 698
 699     /* again */
 700     hr = WsAddMappedHeader( msg, &header, WS_XML_STRING_TYPE, WS_WRITE_REQUIRED_VALUE, &value, sizeof(value), NULL );
 701     ok( hr == S_OK, "got %08x\n", hr );
 702
 703     WsFreeMessage( msg );
 704 }
 705
 706 static void test_WsRemoveMappedHeader(void)
 707 {
 708     static const WS_XML_STRING header = {6, (BYTE *)"Header"}, value = {5, (BYTE *)"value"};
 709     WS_MESSAGE *msg;
 710     HRESULT hr;
 711
 712     hr = WsRemoveMappedHeader( NULL, NULL, NULL );
 713     ok( hr == E_INVALIDARG, "got %08x\n", hr );
 714
 715     hr = WsCreateMessage( WS_ADDRESSING_VERSION_1_0, WS_ENVELOPE_VERSION_SOAP_1_2, NULL, 0, &msg, NULL );
 716     ok( hr == S_OK, "got %08x\n", hr );
 717
 718     hr = WsRemoveMappedHeader( msg, NULL, NULL );
 719     ok( hr == E_INVALIDARG, "got %08x\n", hr );
 720
 721     hr = WsRemoveMappedHeader( msg, &header, NULL );
 722     ok( hr == WS_E_INVALID_OPERATION, "got %08x\n", hr );
 723
 724     hr = WsInitializeMessage( msg, WS_REQUEST_MESSAGE, NULL, NULL );
 725     ok( hr == S_OK, "got %08x\n", hr );
 726
 727     hr = WsAddMappedHeader( msg, &header, WS_XML_STRING_TYPE, WS_WRITE_REQUIRED_VALUE, &value, sizeof(value), NULL );
 728     ok( hr == S_OK, "got %08x\n", hr );
 729
 730     hr = WsRemoveMappedHeader( msg, &header, NULL );
 731     ok( hr == S_OK, "got %08x\n", hr );
 732
 733     /* again */
 734     hr = WsRemoveMappedHeader( msg, &header, NULL );
 735     ok( hr == S_OK, "got %08x\n", hr );
 736
 737     WsFreeMessage( msg );
 738 }
 739
 740 static void test_WsAddCustomHeader(void)
 741 {
 742    static const char expected[] =
 743         "<s:Envelope xmlns:a=\"http://www.w3.org/2005/08/addressing\" "
 744         "xmlns:s=\"http://www.w3.org/2003/05/soap-envelope\"><s:Header>"
 745         "<a:MessageID>urn:uuid:00000000-0000-0000-0000-000000000000</a:MessageID>"
 746         "<header xmlns=\"ns\">value</header></s:Header><s:Body/></s:Envelope>";
 747    static const char expected2[] =
 748         "<s:Envelope xmlns:a=\"http://www.w3.org/2005/08/addressing\" "
 749         "xmlns:s=\"http://www.w3.org/2003/05/soap-envelope\"><s:Header>"
 750         "<a:MessageID>urn:uuid:00000000-0000-0000-0000-000000000000</a:MessageID>"
 751         "</s:Header><s:Body/></s:Envelope>";
 752     static WS_XML_STRING header = {6, (BYTE *)"header"}, ns = {2, (BYTE *)"ns"};
 753     static WCHAR valueW[] = {'v','a','l','u','e',0};
 754     HRESULT hr;
 755     WS_MESSAGE *msg;
 756     WS_ELEMENT_DESCRIPTION desc;
 757     WS_STRUCT_DESCRIPTION s;
 758     WS_FIELD_DESCRIPTION f, *fields[1];
 759     struct header
 760     {
 761         const WCHAR *value;
 762     } test;
 763
 764     hr = WsAddCustomHeader( NULL, NULL, 0, NULL, 0, 0, NULL );
 765     ok( hr == E_INVALIDARG, "got %08x\n", hr );
 766
 767     hr = WsCreateMessage( WS_ADDRESSING_VERSION_1_0, WS_ENVELOPE_VERSION_SOAP_1_2, NULL, 0, &msg, NULL );
 768     ok( hr == S_OK, "got %08x\n", hr );
 769
 770     hr = WsAddCustomHeader( msg, NULL, 0, NULL, 0, 0, NULL );
 771     ok( hr == E_INVALIDARG, "got %08x\n", hr );
 772
 773     memset( &f, 0, sizeof(f) );
 774     f.mapping = WS_TEXT_FIELD_MAPPING;
 775     f.type    = WS_WSZ_TYPE;
 776     fields[0] = &f;
 777
 778     memset( &s, 0, sizeof(s) );
 779     s.size       = sizeof(struct header);
 780     s.alignment  = TYPE_ALIGNMENT(struct header);
 781     s.fields     = fields;
 782     s.fieldCount = 1;
 783
 784     desc.elementLocalName = &header;
 785     desc.elementNs        = &ns;
 786     desc.type             = WS_STRUCT_TYPE;
 787     desc.typeDescription  = &s;
 788     hr = WsAddCustomHeader( msg, &desc, 0, NULL, 0, 0, NULL );
 789     ok( hr == WS_E_INVALID_OPERATION, "got %08x\n", hr );
 790
 791     hr = WsInitializeMessage( msg, WS_REQUEST_MESSAGE, NULL, NULL );
 792     ok( hr == S_OK, "got %08x\n", hr );
 793     check_output_header( msg, expected2, -1, strstr(expected2, "urn:uuid:") - expected2, 46, __LINE__ );
 794
 795     test.value = valueW;
 796     hr = WsAddCustomHeader( msg, &desc, WS_WRITE_REQUIRED_VALUE, &test, sizeof(test), 0, NULL );
 797     ok( hr == S_OK, "got %08x\n", hr );
 798     check_output_header( msg, expected, -1, strstr(expected, "urn:uuid:") - expected, 46, __LINE__ );
 799
 800     hr = WsAddCustomHeader( msg, &desc, WS_WRITE_REQUIRED_VALUE, NULL, 0, 0, NULL );
 801     ok( hr == E_INVALIDARG, "got %08x\n", hr );
 802
 803     WsFreeMessage( msg );
 804 }
 805
 806 static void test_WsRemoveCustomHeader(void)
 807 {
 808    static const char expected[] =
 809         "<s:Envelope xmlns:a=\"http://www.w3.org/2005/08/addressing\" "
 810         "xmlns:s=\"http://www.w3.org/2003/05/soap-envelope\"><s:Header>"
 811         "<a:MessageID>urn:uuid:00000000-0000-0000-0000-000000000000</a:MessageID>"
 812         "<test xmlns=\"ns\">value</test></s:Header><s:Body/></s:Envelope>";
 813    static const char expected2[] =
 814         "<s:Envelope xmlns:a=\"http://www.w3.org/2005/08/addressing\" "
 815         "xmlns:s=\"http://www.w3.org/2003/05/soap-envelope\"><s:Header>"
 816         "<a:MessageID>urn:uuid:00000000-0000-0000-0000-000000000000</a:MessageID>"
 817         "</s:Header><s:Body/></s:Envelope>";
 818     static WS_XML_STRING localname = {4, (BYTE *)"test"}, ns = {2, (BYTE *)"ns"};
 819     static const WS_XML_STRING value = {5, (BYTE *)"value"};
 820     HRESULT hr;
 821     WS_MESSAGE *msg;
 822     WS_ELEMENT_DESCRIPTION desc;
 823
 824     hr = WsRemoveCustomHeader( NULL, NULL, NULL, NULL );
 825     ok( hr == E_INVALIDARG, "got %08x\n", hr );
 826
 827     hr = WsCreateMessage( WS_ADDRESSING_VERSION_1_0, WS_ENVELOPE_VERSION_SOAP_1_2, NULL, 0, &msg, NULL );
 828     ok( hr == S_OK, "got %08x\n", hr );
 829
 830     hr = WsRemoveCustomHeader( msg, &localname, &ns, NULL );
 831     ok( hr == WS_E_INVALID_OPERATION, "got %08x\n", hr );
 832
 833     hr = WsInitializeMessage( msg, WS_REQUEST_MESSAGE, NULL, NULL );
 834     ok( hr == S_OK, "got %08x\n", hr );
 835     check_output_header( msg, expected2, -1, strstr(expected2, "urn:uuid:") - expected2, 46, __LINE__ );
 836
 837     desc.elementLocalName = &localname;
 838     desc.elementNs        = &ns;
 839     desc.type             = WS_XML_STRING_TYPE;
 840     desc.typeDescription  = NULL;
 841     hr = WsAddCustomHeader( msg, &desc, WS_WRITE_REQUIRED_VALUE, &value, sizeof(value), 0, NULL );
 842     ok( hr == S_OK, "got %08x\n", hr );
 843     check_output_header( msg, expected, -1, strstr(expected, "urn:uuid:") - expected, 46, __LINE__ );
 844
 845     hr = WsRemoveCustomHeader( msg, NULL, NULL, NULL );
 846     ok( hr == E_INVALIDARG, "got %08x\n", hr );
 847
 848     hr = WsRemoveCustomHeader( msg, &localname, NULL, NULL );
 849     ok( hr == E_INVALIDARG, "got %08x\n", hr );
 850
 851     hr = WsRemoveCustomHeader( msg, &localname, &ns, NULL );
 852     ok( hr == S_OK, "got %08x\n", hr );
 853     check_output_header( msg, expected2, -1, strstr(expected2, "urn:uuid:") - expected2, 46, __LINE__ );
 854
 855     /* again */
 856     hr = WsRemoveCustomHeader( msg, &localname, &ns, NULL );
 857     ok( hr == S_OK, "got %08x\n", hr );
 858
 859     WsFreeMessage( msg );
 860 }
 861
 862 static HRESULT set_input( WS_XML_READER *reader, const char *data, ULONG size )
 863 {
 864     WS_XML_READER_TEXT_ENCODING text = {{WS_XML_READER_ENCODING_TYPE_TEXT}, WS_CHARSET_AUTO};
 865     WS_XML_READER_BUFFER_INPUT buf;
 866
 867     buf.input.inputType = WS_XML_READER_INPUT_TYPE_BUFFER;
 868     buf.encodedData     = (void *)data;
 869     buf.encodedDataSize = size;
 870     return WsSetInput( reader, &text.encoding, &buf.input, NULL, 0, NULL );
 871 }
 872
 873 static void test_WsReadEnvelopeStart(void)
 874 {
 875     static const char xml[] =
 876         "<s:Envelope xmlns:s=\"http://schemas.xmlsoap.org/soap/envelope/\"><s:Body/></s:Envelope>";
 877     WS_MESSAGE *msg, *msg2;
 878     WS_XML_READER *reader;
 879     WS_MESSAGE_STATE state;
 880     HRESULT hr;
 881
 882     hr = WsReadEnvelopeStart( NULL, NULL, NULL, NULL, NULL );
 883     ok( hr == E_INVALIDARG, "got %08x\n", hr );
 884
 885     hr = WsCreateMessage( WS_ADDRESSING_VERSION_0_9, WS_ENVELOPE_VERSION_SOAP_1_1, NULL, 0, &msg, NULL );
 886     ok( hr == S_OK, "got %08x\n", hr );
 887
 888     hr = WsReadEnvelopeStart( msg, NULL, NULL, NULL, NULL );
 889     ok( hr == E_INVALIDARG, "got %08x\n", hr );
 890
 891     hr = WsCreateReader( NULL, 0, &reader, NULL );
 892     ok( hr == S_OK, "got %08x\n", hr );
 893
 894     hr = WsInitializeMessage( msg, WS_REQUEST_MESSAGE, NULL, NULL );
 895     ok( hr == S_OK, "got %08x\n", hr );
 896
 897     hr = WsReadEnvelopeStart( msg, reader, NULL, NULL, NULL );
 898     ok( hr == WS_E_INVALID_OPERATION, "got %08x\n", hr );
 899
 900     hr = WsCreateMessage( WS_ADDRESSING_VERSION_0_9, WS_ENVELOPE_VERSION_SOAP_1_1, NULL, 0, &msg2, NULL );
 901     ok( hr == S_OK, "got %08x\n", hr );
 902
 903     hr = set_input( reader, xml, strlen(xml) );
 904     ok( hr == S_OK, "got %08x\n", hr );
 905
 906     hr = WsReadEnvelopeStart( msg2, reader, NULL, NULL, NULL );
 907     ok( hr == S_OK, "got %08x\n", hr );
 908
 909     state = 0xdeadbeef;
 910     hr = WsGetMessageProperty( msg2, WS_MESSAGE_PROPERTY_STATE, &state, sizeof(state), NULL );
 911     ok( hr == S_OK, "got %08x\n", hr );
 912     ok( state == WS_MESSAGE_STATE_READING, "got %u\n", state );
 913
 914     WsFreeMessage( msg );
 915     WsFreeMessage( msg2 );
 916     WsFreeReader( reader );
 917 }
 918
 919 static void test_WsReadEnvelopeEnd(void)
 920 {
 921     static const char xml[] =
 922         "<s:Envelope xmlns:s=\"http://schemas.xmlsoap.org/soap/envelope/\"><s:Body></s:Body></s:Envelope>";
 923     WS_MESSAGE *msg, *msg2;
 924     WS_XML_READER *reader;
 925     WS_MESSAGE_STATE state;
 926     HRESULT hr;
 927
 928     hr = WsReadEnvelopeEnd( NULL, NULL );
 929     ok( hr == E_INVALIDARG, "got %08x\n", hr );
 930
 931     hr = WsCreateMessage( WS_ADDRESSING_VERSION_0_9, WS_ENVELOPE_VERSION_SOAP_1_1, NULL, 0, &msg, NULL );
 932     ok( hr == S_OK, "got %08x\n", hr );
 933
 934     hr = WsCreateReader( NULL, 0, &reader, NULL );
 935     ok( hr == S_OK, "got %08x\n", hr );
 936
 937     hr = WsInitializeMessage( msg, WS_REQUEST_MESSAGE, NULL, NULL );
 938     ok( hr == S_OK, "got %08x\n", hr );
 939
 940     hr = WsCreateMessage( WS_ADDRESSING_VERSION_0_9, WS_ENVELOPE_VERSION_SOAP_1_1, NULL, 0, &msg2, NULL );
 941     ok( hr == S_OK, "got %08x\n", hr );
 942
 943     hr = set_input( reader, xml, strlen(xml) );
 944     ok( hr == S_OK, "got %08x\n", hr );
 945
 946     hr = WsReadEnvelopeEnd( msg2, NULL );
 947     ok( hr == WS_E_INVALID_OPERATION, "got %08x\n", hr );
 948
 949     hr = WsReadEnvelopeStart( msg2, reader, NULL, NULL, NULL );
 950     ok( hr == S_OK, "got %08x\n", hr );
 951
 952     hr = WsReadEnvelopeEnd( msg2, NULL );
 953     ok( hr == S_OK, "got %08x\n", hr );
 954
 955     state = 0xdeadbeef;
 956     hr = WsGetMessageProperty( msg2, WS_MESSAGE_PROPERTY_STATE, &state, sizeof(state), NULL );
 957     ok( hr == S_OK, "got %08x\n", hr );
 958     ok( state == WS_MESSAGE_STATE_DONE, "got %u\n", state );
 959
 960     WsFreeMessage( msg );
 961     WsFreeMessage( msg2 );
 962     WsFreeReader( reader );
 963 }
 964
 965 static void test_WsReadBody(void)
 966 {
 967     static const char xml[] =
 968         "<s:Envelope xmlns:s=\"http://schemas.xmlsoap.org/soap/envelope/\"><s:Body>"
 969         "<u xmlns=\"ns\"><val>1</val></u></s:Body></s:Envelope>";
 970     WS_HEAP *heap;
 971     WS_MESSAGE *msg, *msg2;
 972     WS_XML_READER *reader;
 973     WS_MESSAGE_STATE state;
 974     WS_XML_STRING localname = {1, (BYTE *)"t"}, localname2 = {1, (BYTE *)"u"};
 975     WS_XML_STRING val = {3, (BYTE *)"val"}, ns = {2, (BYTE *)"ns"};
 976     WS_ELEMENT_DESCRIPTION desc;
 977     WS_STRUCT_DESCRIPTION s;
 978     WS_FIELD_DESCRIPTION f, *fields[1];
 979     struct test
 980     {
 981         UINT32 val;
 982     } test;
 983     HRESULT hr;
 984
 985     hr = WsCreateHeap( 1 << 16, 0, NULL, 0, &heap, NULL );
 986     ok( hr == S_OK, "got %08x\n", hr );
 987
 988     hr = WsReadBody( NULL, NULL, 0, NULL, NULL, 0, NULL );
 989     ok( hr == E_INVALIDARG, "got %08x\n", hr );
 990
 991     hr = WsCreateMessage( WS_ADDRESSING_VERSION_0_9, WS_ENVELOPE_VERSION_SOAP_1_1, NULL, 0, &msg, NULL );
 992     ok( hr == S_OK, "got %08x\n", hr );
 993
 994     hr = WsCreateReader( NULL, 0, &reader, NULL );
 995     ok( hr == S_OK, "got %08x\n", hr );
 996
 997     hr = WsInitializeMessage( msg, WS_REQUEST_MESSAGE, NULL, NULL );
 998     ok( hr == S_OK, "got %08x\n", hr );
 999
1000     hr = WsCreateMessage( WS_ADDRESSING_VERSION_0_9, WS_ENVELOPE_VERSION_SOAP_1_1, NULL, 0, &msg2, NULL );
1001     ok( hr == S_OK, "got %08x\n", hr );
1002
1003     hr = WsReadBody( msg2, NULL, 0, NULL, NULL, 0, NULL );
1004     ok( hr == E_INVALIDARG, "got %08x\n", hr );
1005
1006     hr = set_input( reader, xml, strlen(xml) );
1007     ok( hr == S_OK, "got %08x\n", hr );
1008
1009     hr = WsReadEnvelopeStart( msg2, reader, NULL, NULL, NULL );
1010     ok( hr == S_OK, "got %08x\n", hr );
1011
1012     hr = WsReadBody( msg2, NULL, WS_READ_REQUIRED_VALUE, heap, &test, sizeof(test), NULL );
1013     ok( hr == E_INVALIDARG, "got %08x\n", hr );
1014
1015     memset( &f, 0, sizeof(f) );
1016     f.mapping   = WS_ELEMENT_FIELD_MAPPING;
1017     f.localName = &val;
1018     f.ns        = &ns;
1019     f.type      = WS_UINT32_TYPE;
1020     fields[0] = &f;
1021
1022     memset( &s, 0, sizeof(s) );
1023     s.size          = sizeof(struct test);
1024     s.alignment     = TYPE_ALIGNMENT(struct test);
1025     s.fields        = fields;
1026     s.fieldCount    = 1;
1027     s.typeLocalName = &localname;
1028     s.typeNs        = &ns;
1029
1030     desc.elementLocalName = &localname2;
1031     desc.elementNs        = &ns;
1032     desc.type             = WS_STRUCT_TYPE;
1033     desc.typeDescription  = &s;
1034
1035     memset( &test, 0, sizeof(test) );
1036     hr = WsReadBody( msg2, &desc, WS_READ_REQUIRED_VALUE, heap, &test, sizeof(test), NULL );
1037     ok( hr == S_OK, "got %08x\n", hr );
1038     ok( test.val == 1, "got %u\n", test.val );
1039
1040     state = 0xdeadbeef;
1041     hr = WsGetMessageProperty( msg2, WS_MESSAGE_PROPERTY_STATE, &state, sizeof(state), NULL );
1042     ok( hr == S_OK, "got %08x\n", hr );
1043     ok( state == WS_MESSAGE_STATE_READING, "got %u\n", state );
1044
1045     hr = WsReadEnvelopeEnd( msg2, NULL );
1046     ok( hr == S_OK, "got %08x\n", hr );
1047
1048     WsFreeMessage( msg );
1049     WsFreeMessage( msg2 );
1050     WsFreeReader( reader );
1051     WsFreeHeap( heap );
1052 }
1053
1054 START_TEST(msg)
1055 {
1056     test_WsCreateMessage();
1057     test_WsCreateMessageForChannel();
1058     test_WsInitializeMessage();
1059     test_WsAddressMessage();
1060     test_WsWriteEnvelopeStart();
1061     test_WsWriteEnvelopeEnd();
1062     test_WsWriteBody();
1063     test_WsSetHeader();
1064     test_WsRemoveHeader();
1065     test_WsAddMappedHeader();
1066     test_WsRemoveMappedHeader();
1067     test_WsAddCustomHeader();
1068     test_WsRemoveCustomHeader();
1069     test_WsReadEnvelopeStart();
1070     test_WsReadEnvelopeEnd();
1071     test_WsReadBody();
1072 }