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 START_TEST(msg)
 673 {
 674     test_WsCreateMessage();
 675     test_WsCreateMessageForChannel();
 676     test_WsInitializeMessage();
 677     test_WsAddressMessage();
 678     test_WsWriteEnvelopeStart();
 679     test_WsWriteEnvelopeEnd();
 680     test_WsWriteBody();
 681     test_WsSetHeader();
 682     test_WsRemoveHeader();
 683 }