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