?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
winhttp: Don't refill buffer after receiving server response.
[wine.git] / dlls / webservices / tests / msg.c
blobb1c0237dc3f1d5e9c2cd375b1becf1fc9c14762e
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 %#lx\n", hr );
35
36 hr = WsCreateMessage( 0, 0, NULL, 0, &msg, NULL );
37 ok( hr == E_INVALIDARG, "got %#lx\n", hr );
38
39 hr = WsCreateMessage( WS_ENVELOPE_VERSION_SOAP_1_1, 0, NULL, 0, &msg, NULL );
40 ok( hr == E_INVALIDARG, "got %#lx\n", hr );
41
42 hr = WsCreateMessage( 0, WS_ADDRESSING_VERSION_0_9, NULL, 0, &msg, NULL );
43 ok( hr == E_INVALIDARG, "got %#lx\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 %#lx\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 %#lx\n", hr );
56
57 state = 0xdeadbeef;
58 hr = WsGetMessageProperty( msg, WS_MESSAGE_PROPERTY_STATE, &state, sizeof(state), NULL );
59 ok( hr == S_OK, "got %#lx\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 %#lx\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 %#lx\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 %#lx\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 %#lx\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 %#lx\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 %#lx\n", hr );
103
104 hr = WsCreateMessageForChannel( NULL, NULL, 0, &msg, NULL );
105 ok( hr == E_INVALIDARG, "got %#lx\n", hr );
106
107 /* HTTP */
108 hr = WsCreateChannel( WS_CHANNEL_TYPE_REQUEST, WS_HTTP_CHANNEL_BINDING, NULL, 0, NULL,
109 &channel, NULL );
110 ok( hr == S_OK, "got %#lx\n", hr );
111
112 hr = WsCreateMessageForChannel( channel, NULL, 0, &msg, NULL );
113 ok( hr == S_OK, "got %#lx\n", hr );
114
115 state = 0xdeadbeef;
116 hr = WsGetMessageProperty( msg, WS_MESSAGE_PROPERTY_STATE, &state, sizeof(state), NULL );
117 ok( hr == S_OK, "got %#lx\n", hr );
118 ok( state == WS_MESSAGE_STATE_EMPTY, "got %u\n", state );
119
120 env_version = 0xdeadbeef;
121 hr = WsGetMessageProperty( msg, WS_MESSAGE_PROPERTY_ENVELOPE_VERSION, &env_version,
122 sizeof(env_version), NULL );
123 ok( hr == S_OK, "got %#lx\n", hr );
124 ok( env_version == WS_ENVELOPE_VERSION_SOAP_1_2, "got %u\n", env_version );
125
126 addr_version = 0xdeadbeef;
127 hr = WsGetMessageProperty( msg, WS_MESSAGE_PROPERTY_ADDRESSING_VERSION, &addr_version,
128 sizeof(addr_version), NULL );
129 ok( hr == S_OK, "got %#lx\n", hr );
130 ok( addr_version == WS_ADDRESSING_VERSION_1_0, "got %u\n", addr_version );
131
132 hr = WsGetMessageProperty( msg, WS_MESSAGE_PROPERTY_IS_ADDRESSED, &addressed, sizeof(addressed),
133 NULL );
134 ok( hr == WS_E_INVALID_OPERATION, "got %#lx\n", hr );
135
136 WsFreeChannel( channel );
137 WsFreeMessage( msg );
138
139 env_version = WS_ENVELOPE_VERSION_SOAP_1_1;
140 prop.id = WS_CHANNEL_PROPERTY_ENVELOPE_VERSION;
141 prop.value = &env_version;
142 prop.valueSize = sizeof(env_version);
143 hr = WsCreateChannel( WS_CHANNEL_TYPE_REQUEST, WS_HTTP_CHANNEL_BINDING, &prop, 1, NULL,
144 &channel, NULL );
145 ok( hr == S_OK, "got %#lx\n", hr );
146
147 hr = WsCreateMessageForChannel( channel, NULL, 0, &msg, NULL );
148 ok( hr == S_OK, "got %#lx\n", hr );
149
150 env_version = 0xdeadbeef;
151 hr = WsGetMessageProperty( msg, WS_MESSAGE_PROPERTY_ENVELOPE_VERSION, &env_version,
152 sizeof(env_version), NULL );
153 ok( hr == S_OK, "got %#lx\n", hr );
154 ok( env_version == WS_ENVELOPE_VERSION_SOAP_1_1, "got %u\n", env_version );
155
156 WsFreeChannel( channel );
157 WsFreeMessage( msg );
158
159 /* TCP */
160 hr = WsCreateChannel( WS_CHANNEL_TYPE_DUPLEX_SESSION, WS_TCP_CHANNEL_BINDING, NULL, 0, NULL,
161 &channel, NULL );
162 ok( hr == S_OK, "got %#lx\n", hr );
163
164 hr = WsCreateMessageForChannel( channel, NULL, 0, &msg, NULL );
165 ok( hr == S_OK, "got %#lx\n", hr );
166
167 state = 0xdeadbeef;
168 hr = WsGetMessageProperty( msg, WS_MESSAGE_PROPERTY_STATE, &state, sizeof(state), NULL );
169 ok( hr == S_OK, "got %#lx\n", hr );
170 ok( state == WS_MESSAGE_STATE_EMPTY, "got %u\n", state );
171
172 env_version = 0xdeadbeef;
173 hr = WsGetMessageProperty( msg, WS_MESSAGE_PROPERTY_ENVELOPE_VERSION, &env_version,
174 sizeof(env_version), NULL );
175 ok( hr == S_OK, "got %#lx\n", hr );
176 ok( env_version == WS_ENVELOPE_VERSION_SOAP_1_2, "got %u\n", env_version );
177
178 addr_version = 0xdeadbeef;
179 hr = WsGetMessageProperty( msg, WS_MESSAGE_PROPERTY_ADDRESSING_VERSION, &addr_version,
180 sizeof(addr_version), NULL );
181 ok( hr == S_OK, "got %#lx\n", hr );
182 ok( addr_version == WS_ADDRESSING_VERSION_1_0, "got %u\n", addr_version );
183
184 WsFreeChannel( channel );
185 WsFreeMessage( msg );
186
187 /* UDP */
188 hr = WsCreateChannel( WS_CHANNEL_TYPE_DUPLEX, WS_UDP_CHANNEL_BINDING, NULL, 0, NULL,
189 &channel, NULL );
190 ok( hr == S_OK, "got %#lx\n", hr );
191
192 hr = WsCreateMessageForChannel( channel, NULL, 0, &msg, NULL );
193 ok( hr == S_OK, "got %#lx\n", hr );
194
195 env_version = 0xdeadbeef;
196 hr = WsGetMessageProperty( msg, WS_MESSAGE_PROPERTY_ENVELOPE_VERSION, &env_version,
197 sizeof(env_version), NULL );
198 ok( hr == S_OK, "got %#lx\n", hr );
199 ok( env_version == WS_ENVELOPE_VERSION_SOAP_1_2, "got %u\n", env_version );
200
201 addr_version = 0xdeadbeef;
202 hr = WsGetMessageProperty( msg, WS_MESSAGE_PROPERTY_ADDRESSING_VERSION, &addr_version,
203 sizeof(addr_version), NULL );
204 ok( hr == S_OK, "got %#lx\n", hr );
205 ok( addr_version == WS_ADDRESSING_VERSION_1_0, "got %u\n", addr_version );
206
207 WsFreeChannel( channel );
208 WsFreeMessage( msg );
209 }
210
211 static void test_WsInitializeMessage(void)
212 {
213 HRESULT hr;
214 WS_MESSAGE *msg;
215 WS_MESSAGE_STATE state;
216 WS_ENVELOPE_VERSION env_version;
217 WS_ADDRESSING_VERSION addr_version;
218 BOOL addressed;
219
220 hr = WsInitializeMessage( NULL, WS_REQUEST_MESSAGE, NULL, NULL );
221 ok( hr == E_INVALIDARG, "got %#lx\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 %#lx\n", hr );
226
227 hr = WsInitializeMessage( msg, 0xdeadbeef, NULL, NULL );
228 ok( hr == E_INVALIDARG, "got %#lx\n", hr );
229
230 hr = WsInitializeMessage( msg, WS_REQUEST_MESSAGE, NULL, NULL );
231 ok( hr == S_OK, "got %#lx\n", hr );
232
233 hr = WsInitializeMessage( msg, WS_REQUEST_MESSAGE, NULL, NULL );
234 ok( hr == WS_E_INVALID_OPERATION, "got %#lx\n", hr );
235
236 state = 0xdeadbeef;
237 hr = WsGetMessageProperty( msg, WS_MESSAGE_PROPERTY_STATE, &state, sizeof(state), NULL );
238 ok( hr == S_OK, "got %#lx\n", hr );
239 ok( state == WS_MESSAGE_STATE_INITIALIZED, "got %u\n", state );
240
241 addressed = -1;
242 hr = WsGetMessageProperty( msg, WS_MESSAGE_PROPERTY_IS_ADDRESSED, &addressed, sizeof(addressed),
243 NULL );
244 ok( hr == S_OK, "got %#lx\n", hr );
245 ok( !addressed, "unexpected value %d\n", addressed );
246
247 state = WS_MESSAGE_STATE_EMPTY;
248 hr = WsSetMessageProperty( msg, WS_MESSAGE_PROPERTY_STATE, &state, sizeof(state), NULL );
249 ok( hr == E_INVALIDARG, "got %#lx\n", hr );
250
251 env_version = WS_ENVELOPE_VERSION_SOAP_1_1;
252 hr = WsSetMessageProperty( msg, WS_MESSAGE_PROPERTY_ENVELOPE_VERSION, &env_version,
253 sizeof(env_version), NULL );
254 ok( hr == E_INVALIDARG, "got %#lx\n", hr );
255
256 addr_version = WS_ADDRESSING_VERSION_0_9;
257 hr = WsSetMessageProperty( msg, WS_MESSAGE_PROPERTY_ADDRESSING_VERSION, &addr_version,
258 sizeof(addr_version), NULL );
259 ok( hr == E_INVALIDARG, "got %#lx\n", hr );
260 WsFreeMessage( msg );
261 }
262
263 static void test_WsAddressMessage(void)
264 {
265 HRESULT hr;
266 WS_MESSAGE *msg;
267 WS_ENDPOINT_ADDRESS endpoint;
268 BOOL addressed;
269
270 hr = WsAddressMessage( NULL, NULL, NULL );
271 ok( hr == E_INVALIDARG, "got %#lx\n", hr );
272
273 hr = WsCreateMessage( WS_ENVELOPE_VERSION_SOAP_1_1, WS_ADDRESSING_VERSION_0_9, NULL,
274 0, &msg, NULL );
275 ok( hr == S_OK, "got %#lx\n", hr );
276
277 hr = WsGetMessageProperty( msg, WS_MESSAGE_PROPERTY_IS_ADDRESSED, &addressed, sizeof(addressed),
278 NULL );
279 ok( hr == WS_E_INVALID_OPERATION, "got %#lx\n", hr );
280
281 hr = WsAddressMessage( msg, NULL, NULL );
282 ok( hr == WS_E_INVALID_OPERATION, "got %#lx\n", hr );
283
284 hr = WsInitializeMessage( msg, WS_REQUEST_MESSAGE, NULL, NULL );
285 ok( hr == S_OK, "got %#lx\n", hr );
286
287 addressed = -1;
288 hr = WsGetMessageProperty( msg, WS_MESSAGE_PROPERTY_IS_ADDRESSED, &addressed, sizeof(addressed),
289 NULL );
290 ok( hr == S_OK, "got %#lx\n", hr );
291 ok( !addressed, "unexpected value %d\n", addressed );
292
293 hr = WsAddressMessage( msg, NULL, NULL );
294 ok( hr == S_OK, "got %#lx\n", hr );
295
296 addressed = -1;
297 hr = WsGetMessageProperty( msg, WS_MESSAGE_PROPERTY_IS_ADDRESSED, &addressed, sizeof(addressed),
298 NULL );
299 ok( hr == S_OK, "got %#lx\n", hr );
300 ok( addressed == TRUE, "unexpected value %d\n", addressed );
301 WsFreeMessage( msg );
302
303 hr = WsCreateMessage( WS_ENVELOPE_VERSION_SOAP_1_1, WS_ADDRESSING_VERSION_0_9, NULL,
304 0, &msg, NULL );
305 ok( hr == S_OK, "got %#lx\n", hr );
306
307 hr = WsInitializeMessage( msg, WS_REQUEST_MESSAGE, NULL, NULL );
308 ok( hr == S_OK, "got %#lx\n", hr );
309
310 memset( &endpoint, 0, sizeof(endpoint) );
311 endpoint.url.chars = (WCHAR *)L"http://localhost/";
312 endpoint.url.length = ARRAY_SIZE( L"http://localhost/" ) - 1;
313 hr = WsAddressMessage( msg, &endpoint, NULL );
314 ok( hr == S_OK, "got %#lx\n", hr );
315
316 addressed = -1;
317 hr = WsGetMessageProperty( msg, WS_MESSAGE_PROPERTY_IS_ADDRESSED, &addressed, sizeof(addressed),
318 NULL );
319 ok( hr == S_OK, "got %#lx\n", hr );
320 ok( addressed == TRUE, "unexpected value %d\n", addressed );
321 WsFreeMessage( msg );
322 }
323
324 static HRESULT set_output( WS_XML_WRITER *writer )
325 {
326 WS_XML_WRITER_TEXT_ENCODING text = { {WS_XML_WRITER_ENCODING_TYPE_TEXT}, WS_CHARSET_UTF8 };
327 WS_XML_WRITER_BUFFER_OUTPUT buf = { {WS_XML_WRITER_OUTPUT_TYPE_BUFFER} };
328 return WsSetOutput( writer, &text.encoding, &buf.output, NULL, 0, NULL );
329 }
330
331 static void check_output( WS_XML_WRITER *writer, const char *expected, int len, unsigned int skip_start,
332 unsigned int skip_len, unsigned int line )
333 {
334 WS_BYTES bytes;
335 HRESULT hr;
336
337 if (len == -1) len = strlen( expected );
338 memset( &bytes, 0, sizeof(bytes) );
339 hr = WsGetWriterProperty( writer, WS_XML_WRITER_PROPERTY_BYTES, &bytes, sizeof(bytes), NULL );
340 ok( hr == S_OK, "%u: got %#lx\n", line, hr );
341 ok( bytes.length == len, "%u: got %lu expected %d\n", line, bytes.length, len );
342 if (bytes.length != len) return;
343 if (skip_start)
344 {
345 ok( !memcmp( bytes.bytes, expected, skip_start ), "%u: got %s expected %s\n", line,
346 bytes.bytes, expected );
347 ok( !memcmp( bytes.bytes + skip_start + skip_len, expected + skip_start + skip_len,
348 len - skip_start - skip_len), "%u: got %s expected %s\n", line, bytes.bytes, expected );
349 }
350 else
351 ok( !memcmp( bytes.bytes, expected, len ), "%u: got %s expected %s\n", line, bytes.bytes,
352 expected );
353 }
354
355 static void check_output_header( WS_MESSAGE *msg, const char *expected, int len, unsigned int skip_start,
356 unsigned int skip_len, unsigned int line )
357 {
358 WS_XML_WRITER *writer;
359 WS_XML_BUFFER *buf;
360 HRESULT hr;
361
362 hr = WsCreateWriter( NULL, 0, &writer, NULL );
363 ok( hr == S_OK, "got %#lx\n", hr );
364
365 hr = set_output( writer );
366 ok( hr == S_OK, "got %#lx\n", hr );
367
368 hr = WsGetMessageProperty( msg, WS_MESSAGE_PROPERTY_HEADER_BUFFER, &buf, sizeof(buf), NULL );
369 ok( hr == S_OK, "got %#lx\n", hr );
370
371 hr = WsWriteXmlBuffer( writer, buf, NULL );
372 ok( hr == S_OK, "got %#lx\n", hr );
373
374 check_output( writer, expected, len, skip_start, skip_len, line );
375 WsFreeWriter( writer );
376 }
377
378 static void test_WsWriteEnvelopeStart(void)
379 {
380 static const char expected[] =
381 "<s:Envelope xmlns:a=\"http://schemas.xmlsoap.org/ws/2004/08/addressing\" "
382 "xmlns:s=\"http://schemas.xmlsoap.org/soap/envelope/\"><s:Header>"
383 "<a:MessageID>urn:uuid:00000000-0000-0000-0000-000000000000</a:MessageID>"
384 "<a:ReplyTo><a:Address>http://schemas.xmlsoap.org/ws/2004/08/addressing/role/anonymous</a:Address>"
385 "</a:ReplyTo></s:Header>";
386 static const char expected2[] =
387 "<s:Envelope xmlns:a=\"http://schemas.xmlsoap.org/ws/2004/08/addressing\" "
388 "xmlns:s=\"http://schemas.xmlsoap.org/soap/envelope/\"><s:Header>"
389 "<a:MessageID>urn:uuid:00000000-0000-0000-0000-000000000000</a:MessageID>"
390 "<a:ReplyTo><a:Address>http://schemas.xmlsoap.org/ws/2004/08/addressing/role/anonymous</a:Address>"
391 "</a:ReplyTo></s:Header><s:Body/></s:Envelope>";
392 static const char expected3[] =
393 "<s:Envelope xmlns:s=\"http://schemas.xmlsoap.org/soap/envelope/\"><s:Header/><s:Body/></s:Envelope>";
394 static const char expected4[] =
395 "<Envelope><Header/><Body/></Envelope>";
396 static const char expected5[] =
397 "<s:Envelope xmlns:a=\"http://www.w3.org/2005/08/addressing\" "
398 "xmlns:s=\"http://www.w3.org/2003/05/soap-envelope\"><s:Header>"
399 "<a:MessageID>urn:uuid:00000000-0000-0000-0000-000000000000</a:MessageID>"
400 "</s:Header><s:Body/></s:Envelope>";
401 static const char expected6[] =
402 "<s:Envelope xmlns:s=\"http://www.w3.org/2003/05/soap-envelope\"><s:Header/><s:Body/></s:Envelope>";
403 static const char expected7[] =
404 "<s:Envelope xmlns:a=\"http://www.w3.org/2005/08/addressing\" "
405 "xmlns:s=\"http://schemas.xmlsoap.org/soap/envelope/\"><s:Header>"
406 "<a:MessageID>urn:uuid:00000000-0000-0000-0000-000000000000</a:MessageID>"
407 "</s:Header><s:Body/></s:Envelope>";
408 static const char expected8[] =
409 "<s:Envelope xmlns:a=\"http://www.w3.org/2005/08/addressing\" "
410 "xmlns:s=\"http://schemas.xmlsoap.org/soap/envelope/\"><s:Header/><s:Body/></s:Envelope>";
411 static const char expected9[] =
412 "<s:Envelope xmlns:a=\"http://schemas.xmlsoap.org/ws/2004/08/addressing\" "
413 "xmlns:s=\"http://schemas.xmlsoap.org/soap/envelope/\"><s:Header>"
414 "<a:MessageID>urn:uuid:00000000-0000-0000-0000-000000000000</a:MessageID>"
415 "<a:ReplyTo><a:Address>http://schemas.xmlsoap.org/ws/2004/08/addressing/role/anonymous</a:Address>"
416 "</a:ReplyTo><a:To s:mustUnderstand=\"1\">http://localhost/</a:To></s:Header><s:Body/></s:Envelope>";
417 static const char expected10[] =
418 "<s:Envelope xmlns:a=\"http://www.w3.org/2005/08/addressing\" "
419 "xmlns:s=\"http://schemas.xmlsoap.org/soap/envelope/\"><s:Header>"
420 "<a:MessageID>urn:uuid:00000000-0000-0000-0000-000000000000</a:MessageID>"
421 "<a:To s:mustUnderstand=\"1\">http://localhost/</a:To></s:Header><s:Body/></s:Envelope>";
422 HRESULT hr;
423 WS_MESSAGE *msg;
424 WS_XML_WRITER *writer;
425 WS_MESSAGE_STATE state;
426 WS_ENDPOINT_ADDRESS addr;
427
428 memset( &addr, 0, sizeof(addr) );
429 addr.url.chars = (WCHAR *) L"http://localhost/";
430 addr.url.length = 17;
431
432 hr = WsWriteEnvelopeStart( NULL, NULL, NULL, NULL, NULL );
433 ok( hr == E_INVALIDARG, "got %#lx\n", hr );
434
435 hr = WsCreateWriter( NULL, 0, &writer, NULL );
436 ok( hr == S_OK, "got %#lx\n", hr );
437
438 hr = WsWriteEnvelopeStart( NULL, writer, NULL, NULL, NULL );
439 ok( hr == E_INVALIDARG, "got %#lx\n", hr );
440
441 hr = WsCreateMessage( WS_ENVELOPE_VERSION_SOAP_1_1, WS_ADDRESSING_VERSION_0_9, NULL, 0, &msg, NULL );
442 ok( hr == S_OK, "got %#lx\n", hr );
443
444 hr = WsWriteEnvelopeStart( msg, writer, NULL, NULL, NULL );
445 ok( hr == WS_E_INVALID_OPERATION, "got %#lx\n", hr );
446
447 hr = WsInitializeMessage( msg, WS_REQUEST_MESSAGE, NULL, NULL );
448 ok( hr == S_OK, "got %#lx\n", hr );
449 hr = set_output( writer );
450 ok( hr == S_OK, "got %#lx\n", hr );
451 hr = WsWriteEnvelopeStart( msg, writer, NULL, NULL, NULL );
452 ok( hr == S_OK, "got %#lx\n", hr );
453 check_output( writer, expected, -1, strstr(expected, "urn:uuid:") - expected, 46, __LINE__ );
454 check_output_header( msg, expected2, -1, strstr(expected2, "urn:uuid:") - expected2, 46, __LINE__ );
455
456 state = 0xdeadbeef;
457 hr = WsGetMessageProperty( msg, WS_MESSAGE_PROPERTY_STATE, &state, sizeof(state), NULL );
458 ok( hr == S_OK, "got %#lx\n", hr );
459 ok( state == WS_MESSAGE_STATE_WRITING, "got %u\n", state );
460 WsFreeMessage( msg );
461
462 hr = WsCreateMessage( WS_ENVELOPE_VERSION_SOAP_1_1, WS_ADDRESSING_VERSION_TRANSPORT, NULL, 0, &msg, NULL );
463 ok( hr == S_OK, "got %#lx\n", hr );
464 hr = WsInitializeMessage( msg, WS_REQUEST_MESSAGE, NULL, NULL );
465 ok( hr == S_OK, "got %#lx\n", hr );
466 hr = set_output( writer );
467 ok( hr == S_OK, "got %#lx\n", hr );
468 hr = WsWriteEnvelopeStart( msg, writer, NULL, NULL, NULL );
469 ok( hr == S_OK, "got %#lx\n", hr );
470 check_output_header( msg, expected3, -1, 0, 0, __LINE__ );
471 WsFreeMessage( msg );
472
473 hr = WsCreateMessage( WS_ENVELOPE_VERSION_NONE, WS_ADDRESSING_VERSION_TRANSPORT, NULL, 0, &msg, NULL );
474 ok( hr == S_OK, "got %#lx\n", hr );
475 hr = WsInitializeMessage( msg, WS_REQUEST_MESSAGE, NULL, NULL );
476 ok( hr == S_OK, "got %#lx\n", hr );
477 hr = set_output( writer );
478 ok( hr == S_OK, "got %#lx\n", hr );
479 hr = WsWriteEnvelopeStart( msg, writer, NULL, NULL, NULL );
480 ok( hr == S_OK, "got %#lx\n", hr );
481 check_output_header( msg, expected4, -1, 0, 0, __LINE__ );
482 WsFreeMessage( msg );
483
484 hr = WsCreateMessage( WS_ENVELOPE_VERSION_SOAP_1_2, WS_ADDRESSING_VERSION_1_0, NULL, 0, &msg, NULL );
485 ok( hr == S_OK, "got %#lx\n", hr );
486 hr = WsInitializeMessage( msg, WS_REQUEST_MESSAGE, NULL, NULL );
487 ok( hr == S_OK, "got %#lx\n", hr );
488 hr = set_output( writer );
489 ok( hr == S_OK, "got %#lx\n", hr );
490 hr = WsWriteEnvelopeStart( msg, writer, NULL, NULL, NULL );
491 ok( hr == S_OK, "got %#lx\n", hr );
492 check_output_header( msg, expected5, -1, strstr(expected5, "urn:uuid:") - expected5, 46, __LINE__ );
493 WsFreeMessage( msg );
494
495 hr = WsCreateMessage( WS_ENVELOPE_VERSION_SOAP_1_2, WS_ADDRESSING_VERSION_TRANSPORT, NULL, 0, &msg, NULL );
496 ok( hr == S_OK, "got %#lx\n", hr );
497 hr = WsInitializeMessage( msg, WS_REQUEST_MESSAGE, NULL, NULL );
498 ok( hr == S_OK, "got %#lx\n", hr );
499 hr = set_output( writer );
500 ok( hr == S_OK, "got %#lx\n", hr );
501 hr = WsWriteEnvelopeStart( msg, writer, NULL, NULL, NULL );
502 ok( hr == S_OK, "got %#lx\n", hr );
503 check_output_header( msg, expected6, -1, 0, 0, __LINE__ );
504 WsFreeMessage( msg );
505
506 hr = WsCreateMessage( WS_ENVELOPE_VERSION_SOAP_1_1, WS_ADDRESSING_VERSION_1_0, NULL, 0, &msg, NULL );
507 ok( hr == S_OK, "got %#lx\n", hr );
508 hr = WsInitializeMessage( msg, WS_REQUEST_MESSAGE, NULL, NULL );
509 ok( hr == S_OK, "got %#lx\n", hr );
510 hr = set_output( writer );
511 ok( hr == S_OK, "got %#lx\n", hr );
512 hr = WsWriteEnvelopeStart( msg, writer, NULL, NULL, NULL );
513 ok( hr == S_OK, "got %#lx\n", hr );
514 check_output_header( msg, expected7, -1, strstr(expected7, "urn:uuid:") - expected7, 46, __LINE__ );
515 WsFreeMessage( msg );
516
517 hr = WsCreateMessage( WS_ENVELOPE_VERSION_SOAP_1_1, WS_ADDRESSING_VERSION_1_0, NULL, 0, &msg, NULL );
518 ok( hr == S_OK, "got %#lx\n", hr );
519 hr = WsInitializeMessage( msg, WS_BLANK_MESSAGE, NULL, NULL );
520 ok( hr == S_OK, "got %#lx\n", hr );
521 hr = set_output( writer );
522 ok( hr == S_OK, "got %#lx\n", hr );
523 hr = WsWriteEnvelopeStart( msg, writer, NULL, NULL, NULL );
524 ok( hr == S_OK, "got %#lx\n", hr );
525 check_output_header( msg, expected8, -1, 0, 0, __LINE__ );
526 WsFreeMessage( msg );
527
528 hr = WsCreateMessage( WS_ENVELOPE_VERSION_SOAP_1_1, WS_ADDRESSING_VERSION_0_9, NULL, 0, &msg, NULL );
529 ok( hr == S_OK, "got %#lx\n", hr );
530 hr = WsInitializeMessage( msg, WS_REQUEST_MESSAGE, NULL, NULL );
531 ok( hr == S_OK, "got %#lx\n", hr );
532 hr = WsAddressMessage( msg, &addr, NULL );
533 hr = set_output( writer );
534 ok( hr == S_OK, "got %#lx\n", hr );
535 hr = WsWriteEnvelopeStart( msg, writer, NULL, NULL, NULL );
536 ok( hr == S_OK, "got %#lx\n", hr );
537 check_output_header( msg, expected9, -1, strstr(expected9, "urn:uuid:") - expected9, 46, __LINE__ );
538 WsFreeMessage( msg );
539
540 hr = WsCreateMessage( WS_ENVELOPE_VERSION_SOAP_1_1, WS_ADDRESSING_VERSION_1_0, NULL, 0, &msg, NULL );
541 ok( hr == S_OK, "got %#lx\n", hr );
542 hr = WsInitializeMessage( msg, WS_REQUEST_MESSAGE, NULL, NULL );
543 ok( hr == S_OK, "got %#lx\n", hr );
544 hr = WsAddressMessage( msg, &addr, NULL );
545 hr = set_output( writer );
546 ok( hr == S_OK, "got %#lx\n", hr );
547 hr = WsWriteEnvelopeStart( msg, writer, NULL, NULL, NULL );
548 ok( hr == S_OK, "got %#lx\n", hr );
549 check_output_header( msg, expected10, -1, strstr(expected10, "urn:uuid:") - expected10, 46, __LINE__ );
550 WsFreeMessage( msg );
551
552 hr = WsCreateMessage( WS_ENVELOPE_VERSION_SOAP_1_2, WS_ADDRESSING_VERSION_1_0, NULL, 0, &msg, NULL );
553 ok( hr == S_OK, "got %#lx\n", hr );
554 hr = WsInitializeMessage( msg, WS_REQUEST_MESSAGE, NULL, NULL );
555 ok( hr == S_OK, "got %#lx\n", hr );
556 WsFreeMessage( msg );
557
558 hr = WsCreateMessage( WS_ENVELOPE_VERSION_NONE, WS_ADDRESSING_VERSION_0_9, NULL, 0, &msg, NULL );
559 ok( hr == E_INVALIDARG, "got %#lx\n", hr );
560 hr = WsCreateMessage( WS_ENVELOPE_VERSION_NONE, WS_ADDRESSING_VERSION_1_0, NULL, 0, &msg, NULL );
561 ok( hr == E_INVALIDARG, "got %#lx\n", hr );
562 WsFreeWriter( writer );
563 }
564
565 static void test_WsWriteEnvelopeEnd(void)
566 {
567 static const char expected[] =
568 "<s:Envelope xmlns:a=\"http://www.w3.org/2005/08/addressing\" "
569 "xmlns:s=\"http://www.w3.org/2003/05/soap-envelope\"><s:Header>"
570 "<a:MessageID>urn:uuid:00000000-0000-0000-0000-000000000000</a:MessageID>"
571 "</s:Header><s:Body/></s:Envelope>";
572 HRESULT hr;
573 WS_MESSAGE *msg;
574 WS_XML_WRITER *writer;
575 WS_MESSAGE_STATE state;
576
577 hr = WsWriteEnvelopeEnd( NULL, NULL );
578 ok( hr == E_INVALIDARG, "got %#lx\n", hr );
579
580 hr = WsCreateMessage( WS_ENVELOPE_VERSION_SOAP_1_2, WS_ADDRESSING_VERSION_1_0, NULL, 0, &msg,
581 NULL );
582 ok( hr == S_OK, "got %#lx\n", hr );
583
584 hr = WsWriteEnvelopeEnd( msg, NULL );
585 ok( hr == WS_E_INVALID_OPERATION, "got %#lx\n", hr );
586
587 hr = WsInitializeMessage( msg, WS_REQUEST_MESSAGE, NULL, NULL );
588 ok( hr == S_OK, "got %#lx\n", hr );
589
590 hr = WsWriteEnvelopeEnd( msg, NULL );
591 ok( hr == WS_E_INVALID_OPERATION, "got %#lx\n", hr );
592
593 hr = WsCreateWriter( NULL, 0, &writer, NULL );
594 ok( hr == S_OK, "got %#lx\n", hr );
595
596 hr = set_output( writer );
597 ok( hr == S_OK, "got %#lx\n", hr );
598
599 hr = WsWriteEnvelopeStart( msg, writer, NULL, NULL, NULL );
600 ok( hr == S_OK, "got %#lx\n", hr );
601
602 hr = WsWriteEnvelopeEnd( msg, NULL );
603 ok( hr == S_OK, "got %#lx\n", hr );
604 check_output( writer, expected, -1, strstr(expected, "urn:uuid:") - expected, 46, __LINE__ );
605 check_output_header( msg, expected, -1, strstr(expected, "urn:uuid:") - expected, 46, __LINE__ );
606
607 state = 0xdeadbeef;
608 hr = WsGetMessageProperty( msg, WS_MESSAGE_PROPERTY_STATE, &state, sizeof(state), NULL );
609 ok( hr == S_OK, "got %#lx\n", hr );
610 ok( state == WS_MESSAGE_STATE_DONE, "got %u\n", state );
611
612 WsFreeMessage( msg );
613 WsFreeWriter( writer );
614 }
615
616 static void test_WsWriteBody(void)
617 {
618 static char expected[] =
619 "<s:Envelope xmlns:a=\"http://www.w3.org/2005/08/addressing\" "
620 "xmlns:s=\"http://www.w3.org/2003/05/soap-envelope\"><s:Header>"
621 "<a:MessageID>urn:uuid:00000000-0000-0000-0000-000000000000</a:MessageID>"
622 "</s:Header><s:Body><u xmlns=\"ns\"><val>1</val></u></s:Body></s:Envelope>";
623 static char expected2[] =
624 "<s:Envelope xmlns:a=\"http://www.w3.org/2005/08/addressing\" "
625 "xmlns:s=\"http://www.w3.org/2003/05/soap-envelope\"><s:Header>"
626 "<a:MessageID>urn:uuid:00000000-0000-0000-0000-000000000000</a:MessageID>"
627 "</s:Header><s:Body/></s:Envelope>";
628 WS_XML_STRING localname = {1, (BYTE *)"t"}, localname2 = {1, (BYTE *)"u"};
629 WS_XML_STRING val = {3, (BYTE *)"val"}, ns = {2, (BYTE *)"ns"};
630 HRESULT hr;
631 WS_MESSAGE *msg;
632 WS_XML_WRITER *writer;
633 WS_MESSAGE_STATE state;
634 WS_ELEMENT_DESCRIPTION desc;
635 WS_STRUCT_DESCRIPTION s;
636 WS_FIELD_DESCRIPTION f, *fields[1];
637 struct test
638 {
639 UINT32 val;
640 } test, *ptr;
641
642 hr = WsCreateMessage( WS_ENVELOPE_VERSION_SOAP_1_2, WS_ADDRESSING_VERSION_1_0, NULL, 0, &msg,
643 NULL );
644 ok( hr == S_OK, "got %#lx\n", hr );
645
646 hr = WsInitializeMessage( msg, WS_REQUEST_MESSAGE, NULL, NULL );
647 ok( hr == S_OK, "got %#lx\n", hr );
648
649 hr = WsCreateWriter( NULL, 0, &writer, NULL );
650 ok( hr == S_OK, "got %#lx\n", hr );
651
652 hr = set_output( writer );
653 ok( hr == S_OK, "got %#lx\n", hr );
654
655 hr = WsWriteEnvelopeStart( msg, writer, NULL, NULL, NULL );
656 ok( hr == S_OK, "got %#lx\n", hr );
657
658 hr = WsWriteBody( NULL, NULL, 0, NULL, 0, NULL );
659 ok( hr == E_INVALIDARG, "got %#lx\n", hr );
660
661 hr = WsWriteBody( msg, NULL, 0, NULL, 0, NULL );
662 ok( hr == E_INVALIDARG, "got %#lx\n", hr );
663
664 memset( &f, 0, sizeof(f) );
665 f.mapping = WS_ELEMENT_FIELD_MAPPING;
666 f.localName = &val;
667 f.ns = &ns;
668 f.type = WS_UINT32_TYPE;
669 fields[0] = &f;
670
671 memset( &s, 0, sizeof(s) );
672 s.size = sizeof(struct test);
673 s.alignment = TYPE_ALIGNMENT(struct test);
674 s.fields = fields;
675 s.fieldCount = 1;
676 s.typeLocalName = &localname;
677 s.typeNs = &ns;
678
679 desc.elementLocalName = &localname2;
680 desc.elementNs = &ns;
681 desc.type = WS_STRUCT_TYPE;
682 desc.typeDescription = &s;
683
684 ptr = &test;
685 test.val = 1;
686 hr = WsWriteBody( msg, &desc, WS_WRITE_REQUIRED_POINTER, &ptr, sizeof(ptr), NULL );
687 ok( hr == S_OK, "got %#lx\n", hr );
688 check_output( writer, expected, 240, strstr(expected, "urn:uuid:") - expected, 46, __LINE__ );
689 check_output_header( msg, expected2, -1, strstr(expected2, "urn:uuid:") - expected2, 46, __LINE__ );
690
691 state = 0xdeadbeef;
692 hr = WsGetMessageProperty( msg, WS_MESSAGE_PROPERTY_STATE, &state, sizeof(state), NULL );
693 ok( hr == S_OK, "got %#lx\n", hr );
694 ok( state == WS_MESSAGE_STATE_WRITING, "got %u\n", state );
695
696 hr = WsWriteEnvelopeEnd( msg, NULL );
697 ok( hr == S_OK, "got %#lx\n", hr );
698 check_output( writer, expected, -1, strstr(expected, "urn:uuid:") - expected, 46, __LINE__ );
699 check_output_header( msg, expected2, -1, strstr(expected2, "urn:uuid:") - expected2, 46, __LINE__ );
700
701 hr = WsWriteBody( msg, &desc, WS_WRITE_REQUIRED_POINTER, &ptr, sizeof(ptr), NULL );
702 ok( hr == WS_E_INVALID_OPERATION, "got %#lx\n", hr );
703
704 WsFreeMessage( msg );
705 WsFreeWriter( writer );
706 }
707
708 static void test_WsSetHeader(void)
709 {
710 static const char expected[] =
711 "<s:Envelope xmlns:a=\"http://www.w3.org/2005/08/addressing\" "
712 "xmlns:s=\"http://www.w3.org/2003/05/soap-envelope\"><s:Header>"
713 "<a:MessageID>urn:uuid:00000000-0000-0000-0000-000000000000</a:MessageID>"
714 "<a:Action s:mustUnderstand=\"1\">action</a:Action></s:Header>"
715 "<s:Body/></s:Envelope>";
716 static const char expected2[] =
717 "<s:Envelope xmlns:a=\"http://www.w3.org/2005/08/addressing\" "
718 "xmlns:s=\"http://www.w3.org/2003/05/soap-envelope\"><s:Header>"
719 "<a:MessageID>urn:uuid:00000000-0000-0000-0000-000000000000</a:MessageID>"
720 "<a:Action s:mustUnderstand=\"1\">action2</a:Action></s:Header>"
721 "<s:Body/></s:Envelope>";
722 static const WS_XML_STRING action2 = {7, (BYTE *)"action2"};
723 HRESULT hr;
724 WS_MESSAGE *msg;
725 WS_XML_WRITER *writer;
726 const WCHAR *ptr = L"action";
727
728 hr = WsSetHeader( NULL, 0, 0, 0, NULL, 0, NULL );
729 ok( hr == E_INVALIDARG, "got %#lx\n", hr );
730
731 hr = WsCreateMessage( WS_ENVELOPE_VERSION_SOAP_1_2, WS_ADDRESSING_VERSION_1_0, NULL, 0, &msg,
732 NULL );
733 ok( hr == S_OK, "got %#lx\n", hr );
734
735 hr = WsSetHeader( msg, 0, 0, 0, NULL, 0, NULL );
736 ok( hr == E_INVALIDARG, "got %#lx\n", hr );
737
738 hr = WsSetHeader( msg, WS_ACTION_HEADER, WS_WSZ_TYPE, WS_WRITE_REQUIRED_POINTER, &ptr,
739 sizeof(ptr), NULL );
740 ok( hr == WS_E_INVALID_OPERATION, "got %#lx\n", hr );
741
742 hr = WsInitializeMessage( msg, WS_REQUEST_MESSAGE, NULL, NULL );
743 ok( hr == S_OK, "got %#lx\n", hr );
744
745 hr = WsSetHeader( msg, 0, WS_WSZ_TYPE, WS_WRITE_REQUIRED_POINTER, &ptr, sizeof(ptr), NULL );
746 ok( hr == E_INVALIDARG, "got %#lx\n", hr );
747
748 hr = WsSetHeader( msg, WS_ACTION_HEADER, WS_WSZ_TYPE, WS_WRITE_REQUIRED_POINTER, &ptr,
749 sizeof(ptr), NULL );
750 ok( hr == S_OK, "got %#lx\n", hr );
751 check_output_header( msg, expected, -1, strstr(expected, "urn:uuid:") - expected, 46, __LINE__ );
752
753 hr = WsCreateWriter( NULL, 0, &writer, NULL );
754 ok( hr == S_OK, "got %#lx\n", hr );
755
756 hr = set_output( writer );
757 ok( hr == S_OK, "got %#lx\n", hr );
758
759 hr = WsWriteEnvelopeStart( msg, writer, NULL, NULL, NULL );
760 ok( hr == S_OK, "got %#lx\n", hr );
761 check_output( writer, expected, 250, strstr(expected, "urn:uuid:") - expected, 46, __LINE__ );
762 check_output_header( msg, expected, -1, strstr(expected, "urn:uuid:") - expected, 46, __LINE__ );
763
764 /* called after WsWriteEnvelopeStart */
765 hr = WsSetHeader( msg, WS_ACTION_HEADER, WS_XML_STRING_TYPE, WS_WRITE_REQUIRED_VALUE, &action2,
766 sizeof(action2), NULL );
767 ok( hr == S_OK, "got %#lx\n", hr );
768 check_output( writer, expected, 250, strstr(expected, "urn:uuid:") - expected, 46, __LINE__ );
769 check_output_header( msg, expected2, -1, strstr(expected2, "urn:uuid:") - expected2, 46, __LINE__ );
770
771 WsFreeMessage( msg );
772 WsFreeWriter( writer );
773 }
774
775 static void test_WsRemoveHeader(void)
776 {
777 static const char expected[] =
778 "<s:Envelope xmlns:a=\"http://www.w3.org/2005/08/addressing\" "
779 "xmlns:s=\"http://www.w3.org/2003/05/soap-envelope\"><s:Header>"
780 "<a:MessageID>urn:uuid:00000000-0000-0000-0000-000000000000</a:MessageID>"
781 "<a:Action s:mustUnderstand=\"1\">action</a:Action></s:Header>"
782 "<s:Body/></s:Envelope>";
783 static const char expected2[] =
784 "<s:Envelope xmlns:a=\"http://www.w3.org/2005/08/addressing\" "
785 "xmlns:s=\"http://www.w3.org/2003/05/soap-envelope\"><s:Header>"
786 "<a:MessageID>urn:uuid:00000000-0000-0000-0000-000000000000</a:MessageID>"
787 "</s:Header><s:Body/></s:Envelope>";
788 static const WS_XML_STRING action = {6, (BYTE *)"action"};
789 HRESULT hr;
790 WS_MESSAGE *msg;
791
792 hr = WsSetHeader( NULL, 0, 0, 0, NULL, 0, NULL );
793 ok( hr == E_INVALIDARG, "got %#lx\n", hr );
794
795 hr = WsCreateMessage( WS_ENVELOPE_VERSION_SOAP_1_2, WS_ADDRESSING_VERSION_1_0, NULL, 0, &msg,
796 NULL );
797 ok( hr == S_OK, "got %#lx\n", hr );
798
799 hr = WsRemoveHeader( NULL, 0, NULL );
800 ok( hr == E_INVALIDARG, "got %#lx\n", hr );
801
802 hr = WsRemoveHeader( msg, 0, NULL );
803 ok( hr == WS_E_INVALID_OPERATION, "got %#lx\n", hr );
804
805 hr = WsRemoveHeader( msg, WS_ACTION_HEADER, NULL );
806 ok( hr == WS_E_INVALID_OPERATION, "got %#lx\n", hr );
807
808 hr = WsInitializeMessage( msg, WS_REQUEST_MESSAGE, NULL, NULL );
809 ok( hr == S_OK, "got %#lx\n", hr );
810 check_output_header( msg, expected2, -1, strstr(expected2, "urn:uuid:") - expected2, 46, __LINE__ );
811
812 hr = WsRemoveHeader( msg, 0, NULL );
813 ok( hr == E_INVALIDARG, "got %#lx\n", hr );
814
815 hr = WsRemoveHeader( msg, WS_ACTION_HEADER, NULL );
816 ok( hr == S_OK, "got %#lx\n", hr );
817 check_output_header( msg, expected2, -1, strstr(expected2, "urn:uuid:") - expected2, 46, __LINE__ );
818
819 hr = WsSetHeader( msg, WS_ACTION_HEADER, WS_XML_STRING_TYPE, WS_WRITE_REQUIRED_VALUE, &action,
820 sizeof(action), NULL );
821 ok( hr == S_OK, "got %#lx\n", hr );
822 check_output_header( msg, expected, -1, strstr(expected, "urn:uuid:") - expected, 46, __LINE__ );
823
824 hr = WsRemoveHeader( msg, WS_ACTION_HEADER, NULL );
825 ok( hr == S_OK, "got %#lx\n", hr );
826 check_output_header( msg, expected2, -1, strstr(expected2, "urn:uuid:") - expected2, 46, __LINE__ );
827
828 /* again */
829 hr = WsRemoveHeader( msg, WS_ACTION_HEADER, NULL );
830 ok( hr == S_OK, "got %#lx\n", hr );
831 check_output_header( msg, expected2, -1, strstr(expected2, "urn:uuid:") - expected2, 46, __LINE__ );
832
833 WsFreeMessage( msg );
834 }
835
836 static void test_WsAddMappedHeader(void)
837 {
838 static const WS_XML_STRING header = {6, (BYTE *)"Header"}, value = {5, (BYTE *)"value"};
839 WS_MESSAGE *msg;
840 HRESULT hr;
841
842 hr = WsAddMappedHeader( NULL, NULL, 0, 0, NULL, 0, NULL );
843 ok( hr == E_INVALIDARG, "got %#lx\n", hr );
844
845 hr = WsCreateMessage( WS_ENVELOPE_VERSION_SOAP_1_2, WS_ADDRESSING_VERSION_1_0, NULL, 0, &msg, NULL );
846 ok( hr == S_OK, "got %#lx\n", hr );
847
848 hr = WsAddMappedHeader( msg, NULL, 0, 0, NULL, 0, NULL );
849 ok( hr == E_INVALIDARG, "got %#lx\n", hr );
850
851 hr = WsAddMappedHeader( msg, &header, 0, 0, NULL, 0, NULL );
852 ok( hr == WS_E_INVALID_OPERATION, "got %#lx\n", hr );
853
854 hr = WsInitializeMessage( msg, WS_REQUEST_MESSAGE, NULL, NULL );
855 ok( hr == S_OK, "got %#lx\n", hr );
856
857 hr = WsAddMappedHeader( msg, &header, WS_XML_STRING_TYPE, WS_WRITE_REQUIRED_VALUE, NULL, 0, NULL );
858 ok( hr == E_INVALIDARG, "got %#lx\n", hr );
859
860 hr = WsAddMappedHeader( msg, &header, WS_XML_STRING_TYPE, WS_WRITE_REQUIRED_VALUE, &value, sizeof(value), NULL );
861 ok( hr == S_OK, "got %#lx\n", hr );
862
863 /* again */
864 hr = WsAddMappedHeader( msg, &header, WS_XML_STRING_TYPE, WS_WRITE_REQUIRED_VALUE, &value, sizeof(value), NULL );
865 ok( hr == S_OK, "got %#lx\n", hr );
866
867 WsFreeMessage( msg );
868 }
869
870 static void test_WsRemoveMappedHeader(void)
871 {
872 static const WS_XML_STRING header = {6, (BYTE *)"Header"}, value = {5, (BYTE *)"value"};
873 WS_MESSAGE *msg;
874 HRESULT hr;
875
876 hr = WsRemoveMappedHeader( NULL, NULL, NULL );
877 ok( hr == E_INVALIDARG, "got %#lx\n", hr );
878
879 hr = WsCreateMessage( WS_ENVELOPE_VERSION_SOAP_1_2, WS_ADDRESSING_VERSION_1_0, NULL, 0, &msg, NULL );
880 ok( hr == S_OK, "got %#lx\n", hr );
881
882 hr = WsRemoveMappedHeader( msg, NULL, NULL );
883 ok( hr == E_INVALIDARG, "got %#lx\n", hr );
884
885 hr = WsRemoveMappedHeader( msg, &header, NULL );
886 ok( hr == WS_E_INVALID_OPERATION, "got %#lx\n", hr );
887
888 hr = WsInitializeMessage( msg, WS_REQUEST_MESSAGE, NULL, NULL );
889 ok( hr == S_OK, "got %#lx\n", hr );
890
891 hr = WsAddMappedHeader( msg, &header, WS_XML_STRING_TYPE, WS_WRITE_REQUIRED_VALUE, &value, sizeof(value), NULL );
892 ok( hr == S_OK, "got %#lx\n", hr );
893
894 hr = WsRemoveMappedHeader( msg, &header, NULL );
895 ok( hr == S_OK, "got %#lx\n", hr );
896
897 /* again */
898 hr = WsRemoveMappedHeader( msg, &header, NULL );
899 ok( hr == S_OK, "got %#lx\n", hr );
900
901 WsFreeMessage( msg );
902 }
903
904 static void test_WsAddCustomHeader(void)
905 {
906 static const char expected[] =
907 "<s:Envelope xmlns:a=\"http://www.w3.org/2005/08/addressing\" "
908 "xmlns:s=\"http://www.w3.org/2003/05/soap-envelope\"><s:Header>"
909 "<a:MessageID>urn:uuid:00000000-0000-0000-0000-000000000000</a:MessageID>"
910 "<header xmlns=\"ns\">value</header></s:Header><s:Body/></s:Envelope>";
911 static const char expected2[] =
912 "<s:Envelope xmlns:a=\"http://www.w3.org/2005/08/addressing\" "
913 "xmlns:s=\"http://www.w3.org/2003/05/soap-envelope\"><s:Header>"
914 "<a:MessageID>urn:uuid:00000000-0000-0000-0000-000000000000</a:MessageID>"
915 "</s:Header><s:Body/></s:Envelope>";
916 static const char expected3[] =
917 "<s:Envelope xmlns:a=\"http://www.w3.org/2005/08/addressing\" "
918 "xmlns:s=\"http://www.w3.org/2003/05/soap-envelope\"><s:Header>"
919 "<a:MessageID>urn:uuid:00000000-0000-0000-0000-000000000000</a:MessageID>"
920 "<header xmlns=\"ns\">value</header><header xmlns=\"ns\">value2</header>"
921 "</s:Header><s:Body/></s:Envelope>";
922 static const char expected4[] =
923 "<s:Envelope xmlns:a=\"http://www.w3.org/2005/08/addressing\" "
924 "xmlns:s=\"http://www.w3.org/2003/05/soap-envelope\"><s:Header>"
925 "<a:MessageID>urn:uuid:00000000-0000-0000-0000-000000000000</a:MessageID>"
926 "<header xmlns=\"ns\">value</header><header xmlns=\"ns\">value2</header>"
927 "<header2 xmlns=\"ns\">value2</header2></s:Header><s:Body/></s:Envelope>";
928 static WS_XML_STRING header = {6, (BYTE *)"header"}, ns = {2, (BYTE *)"ns"};
929 static WS_XML_STRING header2 = {7, (BYTE *)"header2"};
930 HRESULT hr;
931 WS_MESSAGE *msg;
932 WS_ELEMENT_DESCRIPTION desc;
933 WS_STRUCT_DESCRIPTION s;
934 WS_FIELD_DESCRIPTION f, *fields[1];
935 struct header
936 {
937 const WCHAR *value;
938 } test;
939
940 hr = WsAddCustomHeader( NULL, NULL, 0, NULL, 0, 0, NULL );
941 ok( hr == E_INVALIDARG, "got %#lx\n", hr );
942
943 hr = WsCreateMessage( WS_ENVELOPE_VERSION_SOAP_1_2, WS_ADDRESSING_VERSION_1_0, NULL, 0, &msg, NULL );
944 ok( hr == S_OK, "got %#lx\n", hr );
945
946 hr = WsAddCustomHeader( msg, NULL, 0, NULL, 0, 0, NULL );
947 ok( hr == E_INVALIDARG, "got %#lx\n", hr );
948
949 memset( &f, 0, sizeof(f) );
950 f.mapping = WS_TEXT_FIELD_MAPPING;
951 f.type = WS_WSZ_TYPE;
952 fields[0] = &f;
953
954 memset( &s, 0, sizeof(s) );
955 s.size = sizeof(struct header);
956 s.alignment = TYPE_ALIGNMENT(struct header);
957 s.fields = fields;
958 s.fieldCount = 1;
959
960 desc.elementLocalName = &header;
961 desc.elementNs = &ns;
962 desc.type = WS_STRUCT_TYPE;
963 desc.typeDescription = &s;
964 hr = WsAddCustomHeader( msg, &desc, 0, NULL, 0, 0, NULL );
965 ok( hr == WS_E_INVALID_OPERATION, "got %#lx\n", hr );
966
967 hr = WsInitializeMessage( msg, WS_REQUEST_MESSAGE, NULL, NULL );
968 ok( hr == S_OK, "got %#lx\n", hr );
969 check_output_header( msg, expected2, -1, strstr(expected2, "urn:uuid:") - expected2, 46, __LINE__ );
970
971 test.value = L"value";
972 hr = WsAddCustomHeader( msg, &desc, WS_WRITE_REQUIRED_VALUE, &test, sizeof(test), 0, NULL );
973 ok( hr == S_OK, "got %#lx\n", hr );
974 check_output_header( msg, expected, -1, strstr(expected, "urn:uuid:") - expected, 46, __LINE__ );
975
976 test.value = L"value2";
977 hr = WsAddCustomHeader( msg, &desc, WS_WRITE_REQUIRED_VALUE, &test, sizeof(test), 0, NULL );
978 ok( hr == S_OK, "got %#lx\n", hr );
979 check_output_header( msg, expected3, -1, strstr(expected3, "urn:uuid:") - expected3, 46, __LINE__ );
980
981 desc.elementLocalName = &header2;
982 hr = WsAddCustomHeader( msg, &desc, WS_WRITE_REQUIRED_VALUE, &test, sizeof(test), 0, NULL );
983 ok( hr == S_OK, "got %#lx\n", hr );
984 check_output_header( msg, expected4, -1, strstr(expected4, "urn:uuid:") - expected4, 46, __LINE__ );
985
986 hr = WsAddCustomHeader( msg, &desc, WS_WRITE_REQUIRED_VALUE, NULL, 0, 0, NULL );
987 ok( hr == E_INVALIDARG, "got %#lx\n", hr );
988
989 WsFreeMessage( msg );
990 }
991
992 static void test_WsRemoveCustomHeader(void)
993 {
994 static const char expected[] =
995 "<s:Envelope xmlns:a=\"http://www.w3.org/2005/08/addressing\" "
996 "xmlns:s=\"http://www.w3.org/2003/05/soap-envelope\"><s:Header>"
997 "<a:MessageID>urn:uuid:00000000-0000-0000-0000-000000000000</a:MessageID>"
998 "<test xmlns=\"ns\">value</test></s:Header><s:Body/></s:Envelope>";
999 static const char expected2[] =
1000 "<s:Envelope xmlns:a=\"http://www.w3.org/2005/08/addressing\" "
1001 "xmlns:s=\"http://www.w3.org/2003/05/soap-envelope\"><s:Header>"
1002 "<a:MessageID>urn:uuid:00000000-0000-0000-0000-000000000000</a:MessageID>"
1003 "</s:Header><s:Body/></s:Envelope>";
1004 static const char expected3[] =
1005 "<s:Envelope xmlns:a=\"http://www.w3.org/2005/08/addressing\" "
1006 "xmlns:s=\"http://www.w3.org/2003/05/soap-envelope\"><s:Header>"
1007 "<a:MessageID>urn:uuid:00000000-0000-0000-0000-000000000000</a:MessageID>"
1008 "<test xmlns=\"ns\">value</test><test xmlns=\"ns\">value2</test>"
1009 "</s:Header><s:Body/></s:Envelope>";
1010 static WS_XML_STRING localname = {4, (BYTE *)"test"}, ns = {2, (BYTE *)"ns"};
1011 static const WS_XML_STRING value = {5, (BYTE *)"value"};
1012 static const WS_XML_STRING value2 = {6, (BYTE *)"value2"};
1013 HRESULT hr;
1014 WS_MESSAGE *msg;
1015 WS_ELEMENT_DESCRIPTION desc;
1016
1017 hr = WsRemoveCustomHeader( NULL, NULL, NULL, NULL );
1018 ok( hr == E_INVALIDARG, "got %#lx\n", hr );
1019
1020 hr = WsCreateMessage( WS_ENVELOPE_VERSION_SOAP_1_2, WS_ADDRESSING_VERSION_1_0, NULL, 0, &msg, NULL );
1021 ok( hr == S_OK, "got %#lx\n", hr );
1022
1023 hr = WsRemoveCustomHeader( msg, &localname, &ns, NULL );
1024 ok( hr == WS_E_INVALID_OPERATION, "got %#lx\n", hr );
1025
1026 hr = WsInitializeMessage( msg, WS_REQUEST_MESSAGE, NULL, NULL );
1027 ok( hr == S_OK, "got %#lx\n", hr );
1028 check_output_header( msg, expected2, -1, strstr(expected2, "urn:uuid:") - expected2, 46, __LINE__ );
1029
1030 desc.elementLocalName = &localname;
1031 desc.elementNs = &ns;
1032 desc.type = WS_XML_STRING_TYPE;
1033 desc.typeDescription = NULL;
1034 hr = WsAddCustomHeader( msg, &desc, WS_WRITE_REQUIRED_VALUE, &value, sizeof(value), 0, NULL );
1035 ok( hr == S_OK, "got %#lx\n", hr );
1036 check_output_header( msg, expected, -1, strstr(expected, "urn:uuid:") - expected, 46, __LINE__ );
1037
1038 hr = WsAddCustomHeader( msg, &desc, WS_WRITE_REQUIRED_VALUE, &value2, sizeof(value2), 0, NULL );
1039 ok( hr == S_OK, "got %#lx\n", hr );
1040 check_output_header( msg, expected3, -1, strstr(expected3, "urn:uuid:") - expected3, 46, __LINE__ );
1041
1042 hr = WsRemoveCustomHeader( msg, NULL, NULL, NULL );
1043 ok( hr == E_INVALIDARG, "got %#lx\n", hr );
1044
1045 hr = WsRemoveCustomHeader( msg, &localname, NULL, NULL );
1046 ok( hr == E_INVALIDARG, "got %#lx\n", hr );
1047
1048 hr = WsRemoveCustomHeader( msg, &localname, &ns, NULL );
1049 ok( hr == S_OK, "got %#lx\n", hr );
1050 check_output_header( msg, expected2, -1, strstr(expected2, "urn:uuid:") - expected2, 46, __LINE__ );
1051
1052 /* again */
1053 hr = WsRemoveCustomHeader( msg, &localname, &ns, NULL );
1054 ok( hr == S_OK, "got %#lx\n", hr );
1055
1056 WsFreeMessage( msg );
1057 }
1058
1059 static HRESULT set_input( WS_XML_READER *reader, const char *data, ULONG size )
1060 {
1061 WS_XML_READER_TEXT_ENCODING text = {{WS_XML_READER_ENCODING_TYPE_TEXT}, WS_CHARSET_AUTO};
1062 WS_XML_READER_BUFFER_INPUT buf;
1063
1064 buf.input.inputType = WS_XML_READER_INPUT_TYPE_BUFFER;
1065 buf.encodedData = (void *)data;
1066 buf.encodedDataSize = size;
1067 return WsSetInput( reader, &text.encoding, &buf.input, NULL, 0, NULL );
1068 }
1069
1070 static void test_WsReadEnvelopeStart(void)
1071 {
1072 static const char xml[] =
1073 "<s:Envelope xmlns:s=\"http://schemas.xmlsoap.org/soap/envelope/\"><s:Body/></s:Envelope>";
1074 static const char faultxml[] =
1075 "<s:Envelope xmlns:s=\"http://schemas.xmlsoap.org/soap/envelope/\"><s:Body>"
1076 "<s:Fault/></s:Body></s:Envelope>";
1077 WS_MESSAGE *msg, *msg2, *msg3;
1078 WS_XML_READER *reader;
1079 WS_MESSAGE_STATE state;
1080 const WS_XML_NODE *node;
1081 BOOL isfault;
1082 HRESULT hr;
1083
1084 hr = WsReadEnvelopeStart( NULL, NULL, NULL, NULL, NULL );
1085 ok( hr == E_INVALIDARG, "got %#lx\n", hr );
1086
1087 hr = WsCreateMessage( WS_ENVELOPE_VERSION_SOAP_1_1, WS_ADDRESSING_VERSION_0_9, NULL, 0, &msg, NULL );
1088 ok( hr == S_OK, "got %#lx\n", hr );
1089
1090 hr = WsReadEnvelopeStart( msg, NULL, NULL, NULL, NULL );
1091 ok( hr == E_INVALIDARG, "got %#lx\n", hr );
1092
1093 hr = WsCreateReader( NULL, 0, &reader, NULL );
1094 ok( hr == S_OK, "got %#lx\n", hr );
1095
1096 hr = WsInitializeMessage( msg, WS_REQUEST_MESSAGE, NULL, NULL );
1097 ok( hr == S_OK, "got %#lx\n", hr );
1098
1099 hr = WsReadEnvelopeStart( msg, reader, NULL, NULL, NULL );
1100 ok( hr == WS_E_INVALID_OPERATION, "got %#lx\n", hr );
1101
1102 hr = WsCreateMessage( WS_ENVELOPE_VERSION_SOAP_1_1, WS_ADDRESSING_VERSION_0_9, NULL, 0, &msg2, NULL );
1103 ok( hr == S_OK, "got %#lx\n", hr );
1104
1105 hr = set_input( reader, xml, strlen(xml) );
1106 ok( hr == S_OK, "got %#lx\n", hr );
1107
1108 hr = WsReadEnvelopeStart( msg2, reader, NULL, NULL, NULL );
1109 ok( hr == S_OK, "got %#lx\n", hr );
1110
1111 state = 0xdeadbeef;
1112 hr = WsGetMessageProperty( msg2, WS_MESSAGE_PROPERTY_STATE, &state, sizeof(state), NULL );
1113 ok( hr == S_OK, "got %#lx\n", hr );
1114 ok( state == WS_MESSAGE_STATE_READING, "got %u\n", state );
1115
1116 hr = WsGetReaderNode( reader, &node, NULL );
1117 ok( hr == S_OK, "got %#lx\n", hr );
1118 ok( node->nodeType == WS_XML_NODE_TYPE_END_ELEMENT, "got %u\n", node->nodeType );
1119
1120 hr = WsReadEndElement( reader, NULL );
1121 ok( hr == S_OK, "got %#lx\n", hr );
1122
1123 hr = WsGetReaderNode( reader, &node, NULL );
1124 ok( hr == S_OK, "got %#lx\n", hr );
1125 ok( node->nodeType == WS_XML_NODE_TYPE_END_ELEMENT, "got %u\n", node->nodeType );
1126
1127 hr = WsReadEndElement( reader, NULL );
1128 ok( hr == S_OK, "got %#lx\n", hr );
1129
1130 hr = WsGetReaderNode( reader, &node, NULL );
1131 ok( hr == S_OK, "got %#lx\n", hr );
1132 ok( node->nodeType == WS_XML_NODE_TYPE_EOF, "got %u\n", node->nodeType );
1133
1134 hr = WsCreateMessage( WS_ENVELOPE_VERSION_SOAP_1_1, WS_ADDRESSING_VERSION_0_9, NULL, 0, &msg3, NULL );
1135 ok( hr == S_OK, "got %#lx\n", hr );
1136
1137 hr = set_input( reader, faultxml, strlen(faultxml) );
1138 ok( hr == S_OK, "got %#lx\n", hr );
1139
1140 hr = WsReadEnvelopeStart( msg3, reader, NULL, NULL, NULL );
1141 ok( hr == S_OK, "got %#lx\n", hr );
1142
1143 isfault = FALSE;
1144 hr = WsGetMessageProperty( msg3, WS_MESSAGE_PROPERTY_IS_FAULT, &isfault, sizeof(isfault), NULL );
1145 ok( hr == S_OK, "got %#lx\n", hr );
1146 ok( isfault, "isfault == FALSE\n" );
1147
1148 WsFreeMessage( msg );
1149 WsFreeMessage( msg2 );
1150 WsFreeMessage( msg3 );
1151 WsFreeReader( reader );
1152 }
1153
1154 static void test_WsReadEnvelopeEnd(void)
1155 {
1156 static const char xml[] =
1157 "<s:Envelope xmlns:s=\"http://schemas.xmlsoap.org/soap/envelope/\"><s:Body></s:Body></s:Envelope>";
1158 WS_MESSAGE *msg, *msg2;
1159 WS_XML_READER *reader;
1160 WS_MESSAGE_STATE state;
1161 HRESULT hr;
1162
1163 hr = WsReadEnvelopeEnd( NULL, NULL );
1164 ok( hr == E_INVALIDARG, "got %#lx\n", hr );
1165
1166 hr = WsCreateMessage( WS_ENVELOPE_VERSION_SOAP_1_1, WS_ADDRESSING_VERSION_0_9, NULL, 0, &msg, NULL );
1167 ok( hr == S_OK, "got %#lx\n", hr );
1168
1169 hr = WsCreateReader( NULL, 0, &reader, NULL );
1170 ok( hr == S_OK, "got %#lx\n", hr );
1171
1172 hr = WsInitializeMessage( msg, WS_REQUEST_MESSAGE, NULL, NULL );
1173 ok( hr == S_OK, "got %#lx\n", hr );
1174
1175 hr = WsCreateMessage( WS_ENVELOPE_VERSION_SOAP_1_1, WS_ADDRESSING_VERSION_0_9, NULL, 0, &msg2, NULL );
1176 ok( hr == S_OK, "got %#lx\n", hr );
1177
1178 hr = set_input( reader, xml, strlen(xml) );
1179 ok( hr == S_OK, "got %#lx\n", hr );
1180
1181 hr = WsReadEnvelopeEnd( msg2, NULL );
1182 ok( hr == WS_E_INVALID_OPERATION, "got %#lx\n", hr );
1183
1184 hr = WsReadEnvelopeStart( msg2, reader, NULL, NULL, NULL );
1185 ok( hr == S_OK, "got %#lx\n", hr );
1186
1187 hr = WsReadEnvelopeEnd( msg2, NULL );
1188 ok( hr == S_OK, "got %#lx\n", hr );
1189
1190 state = 0xdeadbeef;
1191 hr = WsGetMessageProperty( msg2, WS_MESSAGE_PROPERTY_STATE, &state, sizeof(state), NULL );
1192 ok( hr == S_OK, "got %#lx\n", hr );
1193 ok( state == WS_MESSAGE_STATE_DONE, "got %u\n", state );
1194
1195 WsFreeMessage( msg );
1196 WsFreeMessage( msg2 );
1197 WsFreeReader( reader );
1198 }
1199
1200 static void test_WsReadBody(void)
1201 {
1202 static const char xml[] =
1203 "<s:Envelope xmlns:s=\"http://schemas.xmlsoap.org/soap/envelope/\"><s:Body>"
1204 "<u xmlns=\"ns\"><val>1</val></u></s:Body></s:Envelope>";
1205 static const char faultxml[] =
1206 "<s:Envelope xmlns:s=\"http://schemas.xmlsoap.org/soap/envelope/\"><s:Body>"
1207 "<s:Fault><faultcode>s:Client</faultcode><faultstring>OLS Exception</faultstring></s:Fault>"
1208 "</s:Body></s:Envelope>";
1209 static const WS_XML_STRING faultcode = { 6, (BYTE *)"Client" };
1210 static const WS_STRING faultstring = { 13, (WCHAR *)L"OLS Exception" };
1211 WS_HEAP *heap;
1212 WS_MESSAGE *msg, *msg2, *msg3;
1213 WS_XML_READER *reader;
1214 WS_MESSAGE_STATE state;
1215 BOOL isfault;
1216 WS_XML_STRING localname = {1, (BYTE *)"t"}, localname2 = {1, (BYTE *)"u"};
1217 WS_XML_STRING val = {3, (BYTE *)"val"}, ns = {2, (BYTE *)"ns"};
1218 WS_ELEMENT_DESCRIPTION desc, faultdesc;
1219 WS_STRUCT_DESCRIPTION s;
1220 WS_FIELD_DESCRIPTION f, *fields[1];
1221 struct test
1222 {
1223 UINT32 val;
1224 } test;
1225 WS_FAULT fault;
1226 HRESULT hr;
1227
1228 hr = WsCreateHeap( 1 << 16, 0, NULL, 0, &heap, NULL );
1229 ok( hr == S_OK, "got %#lx\n", hr );
1230
1231 hr = WsReadBody( NULL, NULL, 0, NULL, NULL, 0, NULL );
1232 ok( hr == E_INVALIDARG, "got %#lx\n", hr );
1233
1234 hr = WsCreateMessage( WS_ENVELOPE_VERSION_SOAP_1_1, WS_ADDRESSING_VERSION_0_9, NULL, 0, &msg, NULL );
1235 ok( hr == S_OK, "got %#lx\n", hr );
1236
1237 hr = WsCreateReader( NULL, 0, &reader, NULL );
1238 ok( hr == S_OK, "got %#lx\n", hr );
1239
1240 hr = WsInitializeMessage( msg, WS_REQUEST_MESSAGE, NULL, NULL );
1241 ok( hr == S_OK, "got %#lx\n", hr );
1242
1243 hr = WsCreateMessage( WS_ENVELOPE_VERSION_SOAP_1_1, WS_ADDRESSING_VERSION_0_9, NULL, 0, &msg2, NULL );
1244 ok( hr == S_OK, "got %#lx\n", hr );
1245
1246 hr = WsReadBody( msg2, NULL, 0, NULL, NULL, 0, NULL );
1247 ok( hr == E_INVALIDARG, "got %#lx\n", hr );
1248
1249 hr = set_input( reader, xml, strlen(xml) );
1250 ok( hr == S_OK, "got %#lx\n", hr );
1251
1252 hr = WsReadEnvelopeStart( msg2, reader, NULL, NULL, NULL );
1253 ok( hr == S_OK, "got %#lx\n", hr );
1254
1255 hr = WsReadBody( msg2, NULL, WS_READ_REQUIRED_VALUE, heap, &test, sizeof(test), NULL );
1256 ok( hr == E_INVALIDARG, "got %#lx\n", hr );
1257
1258 memset( &f, 0, sizeof(f) );
1259 f.mapping = WS_ELEMENT_FIELD_MAPPING;
1260 f.localName = &val;
1261 f.ns = &ns;
1262 f.type = WS_UINT32_TYPE;
1263 fields[0] = &f;
1264
1265 memset( &s, 0, sizeof(s) );
1266 s.size = sizeof(struct test);
1267 s.alignment = TYPE_ALIGNMENT(struct test);
1268 s.fields = fields;
1269 s.fieldCount = 1;
1270 s.typeLocalName = &localname;
1271 s.typeNs = &ns;
1272
1273 desc.elementLocalName = &localname2;
1274 desc.elementNs = &ns;
1275 desc.type = WS_STRUCT_TYPE;
1276 desc.typeDescription = &s;
1277
1278 memset( &test, 0, sizeof(test) );
1279 hr = WsReadBody( msg2, &desc, WS_READ_REQUIRED_VALUE, heap, &test, sizeof(test), NULL );
1280 ok( hr == S_OK, "got %#lx\n", hr );
1281 ok( test.val == 1, "got %u\n", test.val );
1282
1283 state = 0xdeadbeef;
1284 hr = WsGetMessageProperty( msg2, WS_MESSAGE_PROPERTY_STATE, &state, sizeof(state), NULL );
1285 ok( hr == S_OK, "got %#lx\n", hr );
1286 ok( state == WS_MESSAGE_STATE_READING, "got %u\n", state );
1287
1288 hr = WsReadEnvelopeEnd( msg2, NULL );
1289 ok( hr == S_OK, "got %#lx\n", hr );
1290
1291 hr = WsCreateMessage( WS_ENVELOPE_VERSION_SOAP_1_1, WS_ADDRESSING_VERSION_0_9, NULL, 0, &msg3, NULL );
1292 ok( hr == S_OK, "got %#lx\n", hr );
1293
1294 hr = set_input( reader, faultxml, strlen(faultxml) );
1295 ok( hr == S_OK, "got %#lx\n", hr );
1296
1297 hr = WsReadEnvelopeStart( msg3, reader, NULL, NULL, NULL );
1298 ok( hr == S_OK, "got %#lx\n", hr );
1299
1300 isfault = FALSE;
1301 hr = WsGetMessageProperty( msg3, WS_MESSAGE_PROPERTY_IS_FAULT, &isfault, sizeof(isfault), NULL );
1302 ok( hr == S_OK, "got %#lx\n", hr );
1303 ok( isfault, "isfault == FALSE\n" );
1304
1305 faultdesc.elementLocalName = NULL;
1306 faultdesc.elementNs = NULL;
1307 faultdesc.type = WS_FAULT_TYPE;
1308 faultdesc.typeDescription = NULL;
1309
1310 memset( &fault, 0, sizeof(fault) );
1311 hr = WsReadBody( msg3, &faultdesc, WS_READ_REQUIRED_VALUE, heap, &fault, sizeof(fault), NULL );
1312 ok( hr == S_OK, "got %#lx\n", hr );
1313 ok( fault.code->value.localName.length == faultcode.length, "got %lu\n", fault.code->value.localName.length );
1314 ok( !memcmp( fault.code->value.localName.bytes, faultcode.bytes, faultcode.length ), "wrong fault code\n" );
1315 ok( !fault.code->subCode, "subcode is not NULL\n" );
1316 ok( fault.reasonCount == 1, "got %lu\n", fault.reasonCount );
1317 ok( fault.reasons[0].text.length == faultstring.length, "got %lu\n", fault.reasons[0].text.length );
1318 ok( !memcmp( fault.reasons[0].text.chars, faultstring.chars, faultstring.length * sizeof(WCHAR) ),
1319 "wrong fault string\n" );
1320
1321 hr = WsReadEnvelopeEnd( msg3, NULL );
1322 ok( hr == S_OK, "got %#lx\n", hr );
1323
1324
1325 WsFreeMessage( msg );
1326 WsFreeMessage( msg2 );
1327 WsFreeMessage( msg3 );
1328 WsFreeReader( reader );
1329 WsFreeHeap( heap );
1330 }
1331
1332 static void test_WsResetMessage(void)
1333 {
1334 WS_MESSAGE *msg;
1335 WS_MESSAGE_STATE state;
1336 WS_ENVELOPE_VERSION env_version;
1337 WS_ADDRESSING_VERSION addr_version;
1338 HRESULT hr;
1339
1340 hr = WsCreateMessage( WS_ENVELOPE_VERSION_SOAP_1_1, WS_ADDRESSING_VERSION_0_9, NULL, 0, &msg, NULL );
1341 ok( hr == S_OK, "got %#lx\n", hr );
1342
1343 state = 0xdeadbeef;
1344 hr = WsGetMessageProperty( msg, WS_MESSAGE_PROPERTY_STATE, &state, sizeof(state), NULL );
1345 ok( hr == S_OK, "got %#lx\n", hr );
1346 ok( state == WS_MESSAGE_STATE_EMPTY, "got %u\n", state );
1347
1348 hr = WsInitializeMessage( msg, WS_REQUEST_MESSAGE, NULL, NULL );
1349 ok( hr == S_OK, "got %#lx\n", hr );
1350
1351 state = 0xdeadbeef;
1352 hr = WsGetMessageProperty( msg, WS_MESSAGE_PROPERTY_STATE, &state, sizeof(state), NULL );
1353 ok( hr == S_OK, "got %#lx\n", hr );
1354 ok( state == WS_MESSAGE_STATE_INITIALIZED, "got %u\n", state );
1355
1356 hr = WsResetMessage( msg, NULL );
1357 ok( hr == S_OK, "got %#lx\n", hr );
1358
1359 state = 0xdeadbeef;
1360 hr = WsGetMessageProperty( msg, WS_MESSAGE_PROPERTY_STATE, &state, sizeof(state), NULL );
1361 ok( hr == S_OK, "got %#lx\n", hr );
1362 ok( state == WS_MESSAGE_STATE_EMPTY, "got %u\n", state );
1363
1364 env_version = 0xdeadbeef;
1365 hr = WsGetMessageProperty( msg, WS_MESSAGE_PROPERTY_ENVELOPE_VERSION, &env_version,
1366 sizeof(env_version), NULL );
1367 ok( hr == S_OK, "got %#lx\n", hr );
1368 ok( env_version == WS_ENVELOPE_VERSION_SOAP_1_1, "got %u\n", env_version );
1369
1370 addr_version = 0xdeadbeef;
1371 hr = WsGetMessageProperty( msg, WS_MESSAGE_PROPERTY_ADDRESSING_VERSION, &addr_version,
1372 sizeof(addr_version), NULL );
1373 ok( hr == S_OK, "got %#lx\n", hr );
1374 ok( addr_version == WS_ADDRESSING_VERSION_0_9, "got %u\n", addr_version );
1375
1376 WsFreeMessage( msg );
1377 }
1378
1379 static void test_WsGetHeader(void)
1380 {
1381 static char expected[] =
1382 "<s:Envelope xmlns:a=\"http://www.w3.org/2005/08/addressing\" "
1383 "xmlns:s=\"http://www.w3.org/2003/05/soap-envelope\"><s:Header>"
1384 "<a:MessageID>urn:uuid:00000000-0000-0000-0000-000000000000</a:MessageID>"
1385 "<a:Action s:mustUnderstand=\"1\">action</a:Action></s:Header><s:Body/></s:Envelope>";
1386 static char expected2[] =
1387 "<Envelope><Header><Action mustUnderstand=\"1\" "
1388 "xmlns=\"http://schemas.microsoft.com/ws/2005/05/addressing/none\">action</Action>"
1389 "</Header><Body/></Envelope>";
1390 static char expected3[] =
1391 "<s:Envelope xmlns:s=\"http://www.w3.org/2003/05/soap-envelope\"><s:Header>"
1392 "<Action s:mustUnderstand=\"1\" "
1393 "xmlns=\"http://schemas.microsoft.com/ws/2005/05/addressing/none\">action</Action>"
1394 "</s:Header><s:Body/></s:Envelope>";
1395 WS_MESSAGE *msg;
1396 const WCHAR *ptr;
1397 HRESULT hr;
1398
1399 hr = WsGetHeader( NULL, 0, 0, 0, NULL, NULL, 0, NULL );
1400 ok( hr == E_INVALIDARG, "got %#lx\n", hr );
1401
1402 hr = WsCreateMessage( WS_ENVELOPE_VERSION_SOAP_1_2, WS_ADDRESSING_VERSION_1_0, NULL, 0, &msg, NULL );
1403 ok( hr == S_OK, "got %#lx\n", hr );
1404
1405 hr = WsGetHeader( msg, 0, 0, 0, NULL, NULL, 0, NULL );
1406 ok( hr == E_INVALIDARG, "got %#lx\n", hr );
1407
1408 hr = WsInitializeMessage( msg, WS_REQUEST_MESSAGE, NULL, NULL );
1409 ok( hr == S_OK, "got %#lx\n", hr );
1410
1411 hr = WsGetHeader( msg, 0, 0, 0, NULL, NULL, 0, NULL );
1412 ok( hr == E_INVALIDARG, "got %#lx\n", hr );
1413
1414 hr = WsGetHeader( msg, WS_ACTION_HEADER, 0, 0, NULL, NULL, 0, NULL );
1415 ok( hr == E_INVALIDARG, "got %#lx\n", hr );
1416
1417 hr = WsGetHeader( msg, WS_ACTION_HEADER, WS_WSZ_TYPE, 0, NULL, NULL, 0, NULL );
1418 ok( hr == E_INVALIDARG, "got %#lx\n", hr );
1419
1420 hr = WsGetHeader( msg, WS_ACTION_HEADER, WS_WSZ_TYPE, WS_READ_NILLABLE_POINTER, NULL, NULL, 0, NULL );
1421 ok( hr == E_INVALIDARG, "got %#lx\n", hr );
1422
1423 hr = WsGetHeader( msg, WS_ACTION_HEADER, WS_WSZ_TYPE, WS_READ_REQUIRED_POINTER, NULL, NULL, 0, NULL );
1424 ok( hr == WS_E_INVALID_FORMAT, "got %#lx\n", hr );
1425
1426 ptr = L"action";
1427 hr = WsSetHeader( msg, WS_ACTION_HEADER, WS_WSZ_TYPE, WS_WRITE_REQUIRED_POINTER, &ptr, sizeof(ptr), NULL );
1428 ok( hr == S_OK, "got %#lx\n", hr );
1429 check_output_header( msg, expected, -1, strstr(expected, "urn:uuid:") - expected, 46, __LINE__ );
1430
1431 hr = WsGetHeader( msg, WS_ACTION_HEADER, WS_WSZ_TYPE, WS_READ_REQUIRED_POINTER, NULL, NULL, 0, NULL );
1432 ok( hr == E_INVALIDARG, "got %#lx\n", hr );
1433
1434 ptr = NULL;
1435 hr = WsGetHeader( msg, WS_ACTION_HEADER, WS_WSZ_TYPE, WS_READ_REQUIRED_POINTER, NULL, &ptr, 0, NULL );
1436 ok( hr == E_INVALIDARG, "got %#lx\n", hr );
1437
1438 ptr = NULL;
1439 hr = WsGetHeader( msg, WS_ACTION_HEADER, WS_WSZ_TYPE, WS_READ_REQUIRED_POINTER, NULL, &ptr, sizeof(ptr), NULL );
1440 ok( hr == S_OK, "got %#lx\n", hr );
1441 ok( ptr != NULL, "ptr not set\n" );
1442 ok( !memcmp( ptr, L"action", sizeof(L"action") ), "wrong data\n" );
1443 WsFreeMessage( msg );
1444
1445 hr = WsCreateMessage( WS_ENVELOPE_VERSION_NONE, WS_ADDRESSING_VERSION_TRANSPORT, NULL, 0, &msg, NULL );
1446 ok( hr == S_OK, "got %#lx\n", hr );
1447
1448 hr = WsInitializeMessage( msg, WS_REQUEST_MESSAGE, NULL, NULL );
1449 ok( hr == S_OK, "got %#lx\n", hr );
1450
1451 ptr = L"action";
1452 hr = WsSetHeader( msg, WS_ACTION_HEADER, WS_WSZ_TYPE, WS_WRITE_REQUIRED_POINTER, &ptr, sizeof(ptr), NULL );
1453 ok( hr == S_OK, "got %#lx\n", hr );
1454 if (hr == S_OK) check_output_header( msg, expected2, -1, 0, 0, __LINE__ );
1455
1456 ptr = NULL;
1457 hr = WsGetHeader( msg, WS_ACTION_HEADER, WS_WSZ_TYPE, WS_READ_REQUIRED_POINTER, NULL, &ptr, sizeof(ptr), NULL );
1458 ok( hr == S_OK, "got %#lx\n", hr );
1459 ok( ptr != NULL, "ptr not set\n" );
1460 ok( !memcmp( ptr, L"action", sizeof(L"action") ), "wrong data\n" );
1461 WsFreeMessage( msg );
1462
1463 hr = WsCreateMessage( WS_ENVELOPE_VERSION_SOAP_1_2, WS_ADDRESSING_VERSION_TRANSPORT, NULL, 0, &msg, NULL );
1464 ok( hr == S_OK, "got %#lx\n", hr );
1465
1466 hr = WsInitializeMessage( msg, WS_REQUEST_MESSAGE, NULL, NULL );
1467 ok( hr == S_OK, "got %#lx\n", hr );
1468
1469 ptr = L"action";
1470 hr = WsSetHeader( msg, WS_ACTION_HEADER, WS_WSZ_TYPE, WS_WRITE_REQUIRED_POINTER, &ptr, sizeof(ptr), NULL );
1471 ok( hr == S_OK, "got %#lx\n", hr );
1472 if (hr == S_OK) check_output_header( msg, expected3, -1, 0, 0, __LINE__ );
1473
1474 ptr = NULL;
1475 hr = WsGetHeader( msg, WS_ACTION_HEADER, WS_WSZ_TYPE, WS_READ_REQUIRED_POINTER, NULL, &ptr, sizeof(ptr), NULL );
1476 ok( hr == S_OK, "got %#lx\n", hr );
1477 ok( ptr != NULL, "ptr not set\n" );
1478 ok( !memcmp( ptr, L"action", sizeof(L"action") ), "wrong data\n" );
1479 WsFreeMessage( msg );
1480 }
1481
1482 static void test_WsGetCustomHeader(void)
1483 {
1484 static char expected[] =
1485 "<Envelope><Header><Custom xmlns=\"ns\">value</Custom></Header><Body/></Envelope>";
1486 static WS_XML_STRING custom = {6, (BYTE *)"Custom"}, ns = {2, (BYTE *)"ns"};
1487 WS_ELEMENT_DESCRIPTION desc;
1488 WS_STRUCT_DESCRIPTION s;
1489 WS_FIELD_DESCRIPTION f, *fields[1];
1490 WS_MESSAGE *msg;
1491 HRESULT hr;
1492 struct header
1493 {
1494 const WCHAR *value;
1495 } test;
1496
1497 hr = WsGetCustomHeader( NULL, NULL, 0, 0, 0, NULL, NULL, 0, NULL, NULL );
1498 ok( hr == E_INVALIDARG, "got %#lx\n", hr );
1499
1500 hr = WsCreateMessage( WS_ENVELOPE_VERSION_NONE, WS_ADDRESSING_VERSION_TRANSPORT, NULL, 0, &msg, NULL );
1501 ok( hr == S_OK, "got %#lx\n", hr );
1502
1503 hr = WsGetCustomHeader( msg, NULL, 0, 0, 0, NULL, NULL, 0, NULL, NULL );
1504 ok( hr == E_INVALIDARG, "got %#lx\n", hr );
1505
1506 hr = WsInitializeMessage( msg, WS_REQUEST_MESSAGE, NULL, NULL );
1507 ok( hr == S_OK, "got %#lx\n", hr );
1508
1509 memset( &f, 0, sizeof(f) );
1510 f.mapping = WS_TEXT_FIELD_MAPPING;
1511 f.type = WS_WSZ_TYPE;
1512 fields[0] = &f;
1513
1514 memset( &s, 0, sizeof(s) );
1515 s.size = sizeof(struct header);
1516 s.alignment = TYPE_ALIGNMENT(struct header);
1517 s.fields = fields;
1518 s.fieldCount = 1;
1519
1520 desc.elementLocalName = &custom;
1521 desc.elementNs = &ns;
1522 desc.type = WS_STRUCT_TYPE;
1523 desc.typeDescription = &s;
1524
1525 test.value = L"value";
1526 hr = WsAddCustomHeader( msg, &desc, WS_WRITE_REQUIRED_VALUE, &test, sizeof(test), 0, NULL );
1527 ok( hr == S_OK, "got %#lx\n", hr );
1528 check_output_header( msg, expected, -1, 0, 0, __LINE__ );
1529
1530 hr = WsGetCustomHeader( msg, &desc, 0, 0, 0, NULL, NULL, 0, NULL, NULL );
1531 ok( hr == E_INVALIDARG, "got %#lx\n", hr );
1532
1533 hr = WsGetCustomHeader( msg, &desc, WS_SINGLETON_HEADER, 1, 0, NULL, NULL, 0, NULL, NULL );
1534 ok( hr == E_INVALIDARG, "got %#lx\n", hr );
1535
1536 hr = WsGetCustomHeader( msg, &desc, WS_SINGLETON_HEADER, 0, WS_READ_REQUIRED_VALUE, NULL, NULL, 0, NULL, NULL );
1537 ok( hr == E_INVALIDARG, "got %#lx\n", hr );
1538
1539 memset( &test, 0, sizeof(test) );
1540 hr = WsGetCustomHeader( msg, &desc, WS_SINGLETON_HEADER, 0, WS_READ_REQUIRED_VALUE, NULL, &test, sizeof(test),
1541 NULL, NULL );
1542 ok( hr == S_OK, "got %#lx\n", hr );
1543 ok( test.value != NULL, "value not set\n" );
1544 ok( !memcmp( test.value, L"value", sizeof(L"value") ), "wrong value\n" );
1545 WsFreeMessage( msg );
1546 }
1547
1548 START_TEST(msg)
1549 {
1550 test_WsCreateMessage();
1551 test_WsCreateMessageForChannel();
1552 test_WsInitializeMessage();
1553 test_WsAddressMessage();
1554 test_WsWriteEnvelopeStart();
1555 test_WsWriteEnvelopeEnd();
1556 test_WsWriteBody();
1557 test_WsSetHeader();
1558 test_WsRemoveHeader();
1559 test_WsAddMappedHeader();
1560 test_WsRemoveMappedHeader();
1561 test_WsAddCustomHeader();
1562 test_WsRemoveCustomHeader();
1563 test_WsReadEnvelopeStart();
1564 test_WsReadEnvelopeEnd();
1565 test_WsReadBody();
1566 test_WsResetMessage();
1567 test_WsGetHeader();
1568 test_WsGetCustomHeader();
1569 }
Windows API implementation