2 * Copyright 2015 Hans Leidekker for CodeWeavers
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.
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.
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
21 #include "webservices.h"
22 #include "wine/test.h"
24 static const char data1
[] =
25 "<?xml version=\"1.0\" encoding=\"utf-8\"?>";
27 static const char data2
[] =
28 {0xef,0xbb,0xbf,'<','t','e','x','t','>','t','e','s','t','<','/','t','e','x','t','>',0};
30 static const char data3
[] =
31 "<?xml version=\"1.0\" encoding=\"utf-8\"?>"
34 static const char data4
[] =
35 "<?xml version=\"1.0\" encoding=\"utf-8\"?>\r\n"
36 "<o:OfficeConfig xmlns:o=\"urn:schemas-microsoft-com:office:office\">\r\n"
37 " <o:services o:GenerationTime=\"2015-09-03T18:47:54\">\r\n"
38 " <!--Build: 16.0.6202.6852-->\r\n"
40 " <o:ticket o:headerName=\"Authorization\" o:headerValue=\"{}\" />\r\n"
42 " <o:service o:name=\"LiveOAuthLoginStart\">\r\n"
43 " <o:url>https://login.[Live.WebHost]/oauth20_authorize.srf</o:url>\r\n"
46 "</o:OfficeConfig>\r\n";
48 static const char data5
[] =
51 static const char data6
[] =
52 "<?xml version=\"1.0\" encoding=\"utf-8\"?>"
53 "<text attr= \"value\" attr2='value2'>test</text>";
55 static const char data7
[] =
58 static const char data8
[] =
59 "<node1><node2>test</node2></node1>";
61 static const char data9
[] =
62 "<text xml:attr=\"value\">test</text>";
64 static const char data10
[] =
67 static void test_WsCreateError(void)
71 WS_ERROR_PROPERTY prop
;
72 ULONG size
, code
, count
;
75 hr
= WsCreateError( NULL
, 0, NULL
);
76 ok( hr
== E_INVALIDARG
, "got %08x\n", hr
);
79 hr
= WsCreateError( NULL
, 0, &error
);
80 ok( hr
== S_OK
, "got %08x\n", hr
);
81 ok( error
!= NULL
, "error not set\n" );
85 hr
= WsGetErrorProperty( error
, WS_ERROR_PROPERTY_STRING_COUNT
, &count
, size
);
86 ok( hr
== S_OK
, "got %08x\n", hr
);
87 ok( !count
, "got %u\n", count
);
89 hr
= WsSetErrorProperty( error
, WS_ERROR_PROPERTY_STRING_COUNT
, &count
, size
);
90 ok( hr
== E_INVALIDARG
, "got %08x\n", hr
);
94 hr
= WsGetErrorProperty( error
, WS_ERROR_PROPERTY_ORIGINAL_ERROR_CODE
, &code
, size
);
95 ok( hr
== S_OK
, "got %08x\n", hr
);
96 ok( !code
, "got %u\n", code
);
99 hr
= WsSetErrorProperty( error
, WS_ERROR_PROPERTY_ORIGINAL_ERROR_CODE
, &code
, size
);
100 ok( hr
== S_OK
, "got %08x\n", hr
);
101 hr
= WsGetErrorProperty( error
, WS_ERROR_PROPERTY_ORIGINAL_ERROR_CODE
, &code
, size
);
102 ok( hr
== S_OK
, "got %08x\n", hr
);
103 ok( code
== 0xdeadbeef, "got %u\n", code
);
106 size
= sizeof(langid
);
107 hr
= WsGetErrorProperty( error
, WS_ERROR_PROPERTY_LANGID
, &langid
, size
);
108 ok( hr
== S_OK
, "got %08x\n", hr
);
109 ok( langid
== GetUserDefaultUILanguage(), "got %u\n", langid
);
111 langid
= MAKELANGID( LANG_DUTCH
, SUBLANG_DEFAULT
);
112 hr
= WsSetErrorProperty( error
, WS_ERROR_PROPERTY_LANGID
, &langid
, size
);
113 ok( hr
== WS_E_INVALID_OPERATION
, "got %08x\n", hr
);
116 size
= sizeof(count
);
117 hr
= WsGetErrorProperty( error
, WS_ERROR_PROPERTY_LANGID
+ 1, &count
, size
);
118 ok( hr
== E_INVALIDARG
, "got %08x\n", hr
);
119 ok( count
== 0xdeadbeef, "got %u\n", count
);
120 WsFreeError( error
);
123 prop
.id
= WS_ERROR_PROPERTY_STRING_COUNT
;
125 prop
.valueSize
= sizeof(count
);
126 hr
= WsCreateError( &prop
, 1, &error
);
127 ok( hr
== E_INVALIDARG
, "got %08x\n", hr
);
130 prop
.id
= WS_ERROR_PROPERTY_ORIGINAL_ERROR_CODE
;
132 prop
.valueSize
= sizeof(code
);
133 hr
= WsCreateError( &prop
, 1, &error
);
134 ok( hr
== E_INVALIDARG
, "got %08x\n", hr
);
136 langid
= MAKELANGID( LANG_DUTCH
, SUBLANG_DEFAULT
);
137 prop
.id
= WS_ERROR_PROPERTY_LANGID
;
138 prop
.value
= &langid
;
139 prop
.valueSize
= sizeof(langid
);
140 hr
= WsCreateError( &prop
, 1, &error
);
141 ok( hr
== S_OK
, "got %08x\n", hr
);
144 size
= sizeof(langid
);
145 hr
= WsGetErrorProperty( error
, WS_ERROR_PROPERTY_LANGID
, &langid
, size
);
146 ok( hr
== S_OK
, "got %08x\n", hr
);
147 ok( langid
== MAKELANGID( LANG_DUTCH
, SUBLANG_DEFAULT
), "got %u\n", langid
);
148 WsFreeError( error
);
151 prop
.id
= WS_ERROR_PROPERTY_LANGID
+ 1;
153 prop
.valueSize
= sizeof(count
);
154 hr
= WsCreateError( &prop
, 1, &error
);
155 ok( hr
== E_INVALIDARG
, "got %08x\n", hr
);
158 static void test_WsCreateHeap(void)
162 WS_HEAP_PROPERTY prop
;
163 SIZE_T max
, trim
, requested
, actual
;
166 hr
= WsCreateHeap( 0, 0, NULL
, 0, NULL
, NULL
);
167 ok( hr
== E_INVALIDARG
, "got %08x\n", hr
);
170 hr
= WsCreateHeap( 0, 0, NULL
, 0, &heap
, NULL
);
171 ok( hr
== S_OK
, "got %08x\n", hr
);
172 ok( heap
!= NULL
, "heap not set\n" );
175 hr
= WsCreateHeap( 1 << 16, 1 << 6, NULL
, 0, NULL
, NULL
);
176 ok( hr
== E_INVALIDARG
, "got %08x\n", hr
);
179 hr
= WsCreateHeap( 1 << 16, 0, NULL
, 0, &heap
, NULL
);
180 ok( hr
== S_OK
, "got %08x\n", hr
);
181 ok( heap
!= NULL
, "heap not set\n" );
184 hr
= WsCreateHeap( 1 << 16, 1 << 6, NULL
, 0, &heap
, NULL
);
185 ok( hr
== S_OK
, "got %08x\n", hr
);
189 hr
= WsGetHeapProperty( heap
, WS_HEAP_PROPERTY_MAX_SIZE
, &max
, size
, NULL
);
190 ok( hr
== S_OK
, "got %08x\n", hr
);
191 ok( max
== 1 << 16, "got %u\n", (ULONG
)max
);
195 hr
= WsGetHeapProperty( heap
, WS_HEAP_PROPERTY_TRIM_SIZE
, &trim
, size
, NULL
);
196 ok( hr
== S_OK
, "got %08x\n", hr
);
197 ok( trim
== 1 << 6, "got %u\n", (ULONG
)trim
);
199 requested
= 0xdeadbeef;
200 size
= sizeof(requested
);
201 hr
= WsGetHeapProperty( heap
, WS_HEAP_PROPERTY_REQUESTED_SIZE
, &requested
, size
, NULL
);
202 ok( hr
== S_OK
, "got %08x\n", hr
);
203 ok( !requested
, "got %u\n", (ULONG
)requested
);
206 size
= sizeof(actual
);
207 hr
= WsGetHeapProperty( heap
, WS_HEAP_PROPERTY_ACTUAL_SIZE
, &actual
, size
, NULL
);
208 ok( hr
== S_OK
, "got %08x\n", hr
);
209 ok( !actual
, "got %u\n", (ULONG
)actual
);
212 size
= sizeof(actual
);
213 hr
= WsGetHeapProperty( heap
, WS_HEAP_PROPERTY_ACTUAL_SIZE
+ 1, &actual
, size
, NULL
);
214 ok( hr
== E_INVALIDARG
, "got %08x\n", hr
);
215 ok( actual
== 0xdeadbeef, "got %u\n", (ULONG
)actual
);
219 prop
.id
= WS_HEAP_PROPERTY_MAX_SIZE
;
221 prop
.valueSize
= sizeof(max
);
222 hr
= WsCreateHeap( 1 << 16, 1 << 6, &prop
, 1, &heap
, NULL
);
223 ok( hr
== E_INVALIDARG
, "got %08x\n", hr
);
225 hr
= WsCreateHeap( 1 << 16, 1 << 6, NULL
, 1, &heap
, NULL
);
226 ok( hr
== E_INVALIDARG
, "got %08x\n", hr
);
229 static HRESULT
set_input( WS_XML_READER
*reader
, const char *data
, ULONG size
)
231 WS_XML_READER_TEXT_ENCODING encoding
;
232 WS_XML_READER_BUFFER_INPUT input
;
234 encoding
.encoding
.encodingType
= WS_XML_READER_ENCODING_TYPE_TEXT
;
235 encoding
.charSet
= WS_CHARSET_AUTO
;
237 input
.input
.inputType
= WS_XML_READER_INPUT_TYPE_BUFFER
;
238 input
.encodedData
= (void *)data
;
239 input
.encodedDataSize
= size
;
241 return WsSetInput( reader
, &encoding
.encoding
, &input
.input
, NULL
, 0, NULL
);
244 static void test_WsCreateReader(void)
247 WS_XML_READER
*reader
;
248 WS_XML_READER_PROPERTY prop
;
249 ULONG size
, max_depth
, max_attrs
, trim_size
, buffer_size
, max_ns
;
250 BOOL allow_fragment
, read_decl
, in_attr
;
251 ULONGLONG row
, column
;
254 hr
= WsCreateReader( NULL
, 0, NULL
, NULL
) ;
255 ok( hr
== E_INVALIDARG
, "got %08x\n", hr
);
258 hr
= WsCreateReader( NULL
, 0, &reader
, NULL
) ;
259 ok( hr
== S_OK
, "got %08x\n", hr
);
260 ok( reader
!= NULL
, "reader not set\n" );
262 /* can't retrieve properties before input is set */
263 max_depth
= 0xdeadbeef;
264 size
= sizeof(max_depth
);
265 hr
= WsGetReaderProperty( reader
, WS_XML_READER_PROPERTY_MAX_DEPTH
, &max_depth
, size
, NULL
);
266 ok( hr
== WS_E_INVALID_OPERATION
, "got %08x\n", hr
);
267 ok( max_depth
== 0xdeadbeef, "max_depth set\n" );
269 hr
= set_input( reader
, data1
, sizeof(data1
) - 1 );
270 ok( hr
== S_OK
, "got %08x\n", hr
);
272 /* check some defaults */
273 max_depth
= 0xdeadbeef;
274 size
= sizeof(max_depth
);
275 hr
= WsGetReaderProperty( reader
, WS_XML_READER_PROPERTY_MAX_DEPTH
, &max_depth
, size
, NULL
);
276 ok( hr
== S_OK
, "got %08x\n", hr
);
277 ok( max_depth
== 32, "got %u\n", max_depth
);
279 allow_fragment
= TRUE
;
280 size
= sizeof(allow_fragment
);
281 hr
= WsGetReaderProperty( reader
, WS_XML_READER_PROPERTY_ALLOW_FRAGMENT
, &allow_fragment
, size
, NULL
);
282 ok( hr
== S_OK
, "got %08x\n", hr
);
283 ok( !allow_fragment
, "got %d\n", allow_fragment
);
285 max_attrs
= 0xdeadbeef;
286 size
= sizeof(max_attrs
);
287 hr
= WsGetReaderProperty( reader
, WS_XML_READER_PROPERTY_MAX_ATTRIBUTES
, &max_attrs
, size
, NULL
);
288 ok( hr
== S_OK
, "got %08x\n", hr
);
289 ok( max_attrs
== 128, "got %u\n", max_attrs
);
292 size
= sizeof(read_decl
);
293 hr
= WsGetReaderProperty( reader
, WS_XML_READER_PROPERTY_READ_DECLARATION
, &read_decl
, size
, NULL
);
294 ok( hr
== S_OK
, "got %08x\n", hr
);
295 ok( read_decl
, "got %u\n", read_decl
);
297 charset
= 0xdeadbeef;
298 size
= sizeof(charset
);
299 hr
= WsGetReaderProperty( reader
, WS_XML_READER_PROPERTY_CHARSET
, &charset
, size
, NULL
);
300 ok( hr
== S_OK
, "got %08x\n", hr
);
301 ok( charset
== WS_CHARSET_UTF8
, "got %u\n", charset
);
303 size
= sizeof(trim_size
);
304 hr
= WsGetReaderProperty( reader
, WS_XML_READER_PROPERTY_UTF8_TRIM_SIZE
, &trim_size
, size
, NULL
);
305 todo_wine
ok( hr
== E_INVALIDARG
, "got %08x\n", hr
);
306 WsFreeReader( reader
);
308 hr
= WsCreateReader( NULL
, 0, &reader
, NULL
) ;
309 ok( hr
== S_OK
, "got %08x\n", hr
);
311 hr
= set_input( reader
, data1
, sizeof(data1
) - 1 );
312 ok( hr
== S_OK
, "got %08x\n", hr
);
314 size
= sizeof(buffer_size
);
315 hr
= WsGetReaderProperty( reader
, WS_XML_READER_PROPERTY_STREAM_BUFFER_SIZE
, &buffer_size
, size
, NULL
);
316 todo_wine
ok( hr
== E_INVALIDARG
, "got %08x\n", hr
);
317 WsFreeReader( reader
);
319 hr
= WsCreateReader( NULL
, 0, &reader
, NULL
) ;
320 ok( hr
== S_OK
, "got %08x\n", hr
);
322 hr
= set_input( reader
, data1
, sizeof(data1
) - 1 );
323 ok( hr
== S_OK
, "got %08x\n", hr
);
326 size
= sizeof(max_ns
);
327 hr
= WsGetReaderProperty( reader
, WS_XML_READER_PROPERTY_MAX_NAMESPACES
, &max_ns
, size
, NULL
);
328 ok( hr
== S_OK
, "got %08x\n", hr
);
329 ok( max_ns
== 32, "got %u\n", max_ns
);
330 WsFreeReader( reader
);
332 /* change a property */
334 prop
.id
= WS_XML_READER_PROPERTY_MAX_DEPTH
;
335 prop
.value
= &max_depth
;
336 prop
.valueSize
= sizeof(max_depth
);
337 hr
= WsCreateReader( &prop
, 1, &reader
, NULL
) ;
338 ok( hr
== S_OK
, "got %08x\n", hr
);
340 hr
= set_input( reader
, data1
, sizeof(data1
) - 1 );
341 ok( hr
== S_OK
, "got %08x\n", hr
);
343 max_depth
= 0xdeadbeef;
344 size
= sizeof(max_depth
);
345 hr
= WsGetReaderProperty( reader
, WS_XML_READER_PROPERTY_MAX_DEPTH
, &max_depth
, size
, NULL
);
346 ok( hr
== S_OK
, "got %08x\n", hr
);
347 ok( max_depth
== 16, "got %u\n", max_depth
);
348 WsFreeReader( reader
);
350 /* show that some properties are read-only */
352 prop
.id
= WS_XML_READER_PROPERTY_ROW
;
354 prop
.valueSize
= sizeof(row
);
355 hr
= WsCreateReader( &prop
, 1, &reader
, NULL
) ;
356 ok( hr
== E_INVALIDARG
, "got %08x\n", hr
);
359 prop
.id
= WS_XML_READER_PROPERTY_COLUMN
;
360 prop
.value
= &column
;
361 prop
.valueSize
= sizeof(column
);
362 hr
= WsCreateReader( &prop
, 1, &reader
, NULL
) ;
363 ok( hr
== E_INVALIDARG
, "got %08x\n", hr
);
366 prop
.id
= WS_XML_READER_PROPERTY_IN_ATTRIBUTE
;
367 prop
.value
= &in_attr
;
368 prop
.valueSize
= sizeof(in_attr
);
369 hr
= WsCreateReader( &prop
, 1, &reader
, NULL
) ;
370 ok( hr
== E_INVALIDARG
, "got %08x\n", hr
);
373 static void test_WsSetInput(void)
375 static char test1
[] = {0xef,0xbb,0xbf,'<','a','/','>'};
376 static char test2
[] = {'<','a','/','>'};
377 static char test3
[] = {'<','!','-','-'};
378 static char test4
[] = {'<','?','x','m','l',' ','v','e','r','s','i','o','n','=','"','1','.','0','"',
379 ' ','e','n','c','o','d','i','n','g','=','"','u','t','f','-','8','"','?','>'};
380 static char test5
[] = {'<','?','x','m','l',' ','e','n','c','o','d','i','n','g','=',
381 '"','u','t','f','-','8','"','?','>'};
382 static char test6
[] = {'<','?','x','m','l'};
383 static char test7
[] = {'<','?','y','m','l'};
384 static char test8
[] = {'<','?'};
385 static char test9
[] = {'<','!'};
386 static char test10
[] = {0xff,0xfe,'<',0,'a',0,'/',0,'>',0};
387 static char test11
[] = {'<',0,'a',0,'/',0,'>',0};
388 static char test12
[] = {'<',0,'!',0,'-',0,'-',0};
389 static char test13
[] = {'<',0,'?',0};
390 static char test14
[] = {'a','b'};
391 static char test15
[] = {'a','b','c'};
392 static char test16
[] = {'a',0};
393 static char test17
[] = {'a',0,'b',0};
394 static char test18
[] = {'<',0,'a',0,'b',0};
395 static char test19
[] = {'<',0,'a',0};
396 static char test20
[] = {0,'a','b'};
397 static char test21
[] = {0,0};
398 static char test22
[] = {0,0,0};
399 static char test23
[] = {'<',0,'?',0,'x',0,'m',0,'l',0};
401 WS_XML_READER
*reader
;
402 WS_XML_READER_PROPERTY prop
;
403 WS_XML_READER_TEXT_ENCODING enc
;
404 WS_XML_READER_BUFFER_INPUT input
;
406 const WS_XML_NODE
*node
;
407 ULONG i
, size
, max_depth
;
418 { test1
, sizeof(test1
), S_OK
, WS_CHARSET_UTF8
},
419 { test2
, sizeof(test2
), S_OK
, WS_CHARSET_UTF8
},
420 { test3
, sizeof(test3
), S_OK
, WS_CHARSET_UTF8
},
421 { test4
, sizeof(test4
), S_OK
, WS_CHARSET_UTF8
},
422 { test5
, sizeof(test5
), WS_E_INVALID_FORMAT
, 0, 1 },
423 { test6
, sizeof(test6
), WS_E_INVALID_FORMAT
, 0, 1 },
424 { test7
, sizeof(test7
), WS_E_INVALID_FORMAT
, 0, 1 },
425 { test8
, sizeof(test8
), WS_E_INVALID_FORMAT
, 0 },
426 { test9
, sizeof(test9
), WS_E_INVALID_FORMAT
, 0 },
427 { test10
, sizeof(test10
), S_OK
, WS_CHARSET_UTF16LE
},
428 { test11
, sizeof(test11
), S_OK
, WS_CHARSET_UTF16LE
},
429 { test12
, sizeof(test12
), S_OK
, WS_CHARSET_UTF16LE
},
430 { test13
, sizeof(test13
), WS_E_INVALID_FORMAT
, 0, 1 },
431 { test14
, sizeof(test14
), WS_E_INVALID_FORMAT
, 0 },
432 { test15
, sizeof(test15
), S_OK
, WS_CHARSET_UTF8
},
433 { test16
, sizeof(test16
), WS_E_INVALID_FORMAT
, 0 },
434 { test17
, sizeof(test17
), S_OK
, WS_CHARSET_UTF8
},
435 { test18
, sizeof(test18
), S_OK
, WS_CHARSET_UTF16LE
},
436 { test19
, sizeof(test19
), S_OK
, WS_CHARSET_UTF16LE
},
437 { test20
, sizeof(test20
), S_OK
, WS_CHARSET_UTF8
},
438 { test21
, sizeof(test21
), WS_E_INVALID_FORMAT
, 0 },
439 { test22
, sizeof(test22
), S_OK
, WS_CHARSET_UTF8
},
440 { test23
, sizeof(test23
), WS_E_INVALID_FORMAT
, 0, 1 },
443 hr
= WsCreateReader( NULL
, 0, &reader
, NULL
) ;
444 ok( hr
== S_OK
, "got %08x\n", hr
);
446 hr
= WsSetInput( NULL
, NULL
, NULL
, NULL
, 0, NULL
);
447 ok( hr
== E_INVALIDARG
, "got %08x\n", hr
);
450 hr
= WsGetReaderNode( reader
, &node
, NULL
);
451 ok( hr
== S_OK
, "got %08x\n", hr
);
452 ok( node
!= NULL
, "node not set\n" );
453 if (node
) ok( node
->nodeType
== WS_XML_NODE_TYPE_EOF
, "got %u\n", node
->nodeType
);
455 enc
.encoding
.encodingType
= WS_XML_READER_ENCODING_TYPE_TEXT
;
456 enc
.charSet
= WS_CHARSET_UTF8
;
458 input
.input
.inputType
= WS_XML_READER_INPUT_TYPE_BUFFER
;
459 input
.encodedData
= (void *)data1
;
460 input
.encodedDataSize
= sizeof(data1
) - 1;
462 hr
= WsSetInput( reader
, &enc
.encoding
, &input
.input
, NULL
, 0, NULL
);
463 ok( hr
== S_OK
, "got %08x\n", hr
);
466 hr
= WsGetReaderNode( reader
, &node
, NULL
);
467 ok( hr
== S_OK
, "got %08x\n", hr
);
468 ok( node
!= NULL
, "node not set\n" );
469 if (node
) ok( node
->nodeType
== WS_XML_NODE_TYPE_BOF
, "got %u\n", node
->nodeType
);
471 /* multiple calls are allowed */
472 hr
= WsSetInput( reader
, &enc
.encoding
, &input
.input
, NULL
, 0, NULL
);
473 ok( hr
== S_OK
, "got %08x\n", hr
);
475 /* charset is detected by WsSetInput */
476 enc
.encoding
.encodingType
= WS_XML_READER_ENCODING_TYPE_TEXT
;
477 enc
.charSet
= WS_CHARSET_AUTO
;
479 for (i
= 0; i
< sizeof(tests
)/sizeof(tests
[0]); i
++)
481 input
.encodedData
= tests
[i
].data
;
482 input
.encodedDataSize
= tests
[i
].size
;
483 hr
= WsSetInput( reader
, &enc
.encoding
, &input
.input
, NULL
, 0, NULL
);
484 ok( hr
== S_OK
, "%u: got %08x\n", i
, hr
);
486 charset
= 0xdeadbeef;
487 size
= sizeof(charset
);
488 hr
= WsGetReaderProperty( reader
, WS_XML_READER_PROPERTY_CHARSET
, &charset
, size
, NULL
);
489 todo_wine_if (tests
[i
].todo
)
491 ok( hr
== tests
[i
].hr
, "%u: got %08x expected %08x\n", i
, hr
, tests
[i
].hr
);
493 ok( charset
== tests
[i
].charset
, "%u: got %u expected %u\n", i
, charset
, tests
[i
].charset
);
497 enc
.encoding
.encodingType
= WS_XML_READER_ENCODING_TYPE_TEXT
;
498 enc
.charSet
= WS_CHARSET_UTF8
;
500 /* reader properties can be set with WsSetInput */
502 prop
.id
= WS_XML_READER_PROPERTY_MAX_DEPTH
;
503 prop
.value
= &max_depth
;
504 prop
.valueSize
= sizeof(max_depth
);
505 hr
= WsSetInput( reader
, &enc
.encoding
, &input
.input
, &prop
, 1, NULL
);
506 ok( hr
== S_OK
, "got %08x\n", hr
);
508 max_depth
= 0xdeadbeef;
509 size
= sizeof(max_depth
);
510 hr
= WsGetReaderProperty( reader
, WS_XML_READER_PROPERTY_MAX_DEPTH
, &max_depth
, size
, NULL
);
511 ok( hr
== S_OK
, "got %08x\n", hr
);
512 ok( max_depth
== 16, "got %u\n", max_depth
);
513 WsFreeReader( reader
);
516 static void test_WsSetInputToBuffer(void)
520 WS_XML_BUFFER
*buffer
;
521 WS_XML_READER
*reader
;
522 WS_XML_READER_PROPERTY prop
;
523 const WS_XML_NODE
*node
;
524 ULONG size
, max_depth
;
526 hr
= WsCreateReader( NULL
, 0, &reader
, NULL
) ;
527 ok( hr
== S_OK
, "got %08x\n", hr
);
529 hr
= WsCreateHeap( 1 << 16, 0, NULL
, 0, &heap
, NULL
);
530 ok( hr
== S_OK
, "got %08x\n", hr
);
532 hr
= WsCreateXmlBuffer( heap
, NULL
, 0, &buffer
, NULL
);
533 ok( hr
== S_OK
, "got %08x\n", hr
);
535 hr
= WsSetInputToBuffer( NULL
, NULL
, NULL
, 0, NULL
);
536 ok( hr
== E_INVALIDARG
, "got %08x\n", hr
);
538 hr
= WsSetInputToBuffer( reader
, NULL
, NULL
, 0, NULL
);
539 ok( hr
== E_INVALIDARG
, "got %08x\n", hr
);
542 hr
= WsGetReaderNode( reader
, &node
, NULL
);
543 ok( hr
== S_OK
, "got %08x\n", hr
);
544 ok( node
!= NULL
, "node not set\n" );
545 if (node
) ok( node
->nodeType
== WS_XML_NODE_TYPE_EOF
, "got %u\n", node
->nodeType
);
547 hr
= WsSetInputToBuffer( reader
, buffer
, NULL
, 0, NULL
);
548 ok( hr
== S_OK
, "got %08x\n", hr
);
551 hr
= WsGetReaderNode( reader
, &node
, NULL
);
552 ok( hr
== S_OK
, "got %08x\n", hr
);
553 ok( node
!= NULL
, "node not set\n" );
554 if (node
) ok( node
->nodeType
== WS_XML_NODE_TYPE_BOF
, "got %u\n", node
->nodeType
);
556 /* multiple calls are allowed */
557 hr
= WsSetInputToBuffer( reader
, buffer
, NULL
, 0, NULL
);
558 ok( hr
== S_OK
, "got %08x\n", hr
);
560 /* reader properties can be set with WsSetInputToBuffer */
562 prop
.id
= WS_XML_READER_PROPERTY_MAX_DEPTH
;
563 prop
.value
= &max_depth
;
564 prop
.valueSize
= sizeof(max_depth
);
565 hr
= WsSetInputToBuffer( reader
, buffer
, &prop
, 1, NULL
);
566 ok( hr
== S_OK
, "got %08x\n", hr
);
568 max_depth
= 0xdeadbeef;
569 size
= sizeof(max_depth
);
570 hr
= WsGetReaderProperty( reader
, WS_XML_READER_PROPERTY_MAX_DEPTH
, &max_depth
, size
, NULL
);
571 ok( hr
== S_OK
, "got %08x\n", hr
);
572 ok( max_depth
== 16, "got %u\n", max_depth
);
574 WsFreeReader( reader
);
578 static void test_WsFillReader(void)
581 WS_XML_READER
*reader
;
582 const WS_XML_NODE
*node
;
584 /* what happens of we don't call WsFillReader? */
585 hr
= WsCreateReader( NULL
, 0, &reader
, NULL
) ;
586 ok( hr
== S_OK
, "got %08x\n", hr
);
589 hr
= WsGetReaderNode( reader
, &node
, NULL
);
590 ok( hr
== S_OK
, "got %08x\n", hr
);
591 if (node
) ok( node
->nodeType
== WS_XML_NODE_TYPE_EOF
, "got %u\n", node
->nodeType
);
593 hr
= set_input( reader
, data1
, sizeof(data1
) - 1 );
594 ok( hr
== S_OK
, "got %08x\n", hr
);
597 hr
= WsGetReaderNode( reader
, &node
, NULL
);
598 ok( hr
== S_OK
, "got %08x\n", hr
);
599 if (node
) ok( node
->nodeType
== WS_XML_NODE_TYPE_BOF
, "got %u\n", node
->nodeType
);
601 hr
= WsReadNode( reader
, NULL
);
602 ok( hr
== S_OK
, "got %08x\n", hr
);
605 hr
= WsGetReaderNode( reader
, &node
, NULL
);
606 ok( hr
== S_OK
, "got %08x\n", hr
);
607 if (node
) ok( node
->nodeType
== WS_XML_NODE_TYPE_EOF
, "got %u\n", node
->nodeType
);
608 WsFreeReader( reader
);
610 hr
= WsCreateReader( NULL
, 0, &reader
, NULL
) ;
611 ok( hr
== S_OK
, "got %08x\n", hr
);
613 hr
= set_input( reader
, data1
, sizeof(data1
) - 1 );
614 ok( hr
== S_OK
, "got %08x\n", hr
);
616 hr
= WsFillReader( reader
, sizeof(data1
) - 1, NULL
, NULL
);
617 ok( hr
== S_OK
, "got %08x\n", hr
);
619 hr
= set_input( reader
, data1
, sizeof(data1
) - 1 );
620 ok( hr
== S_OK
, "got %08x\n", hr
);
623 hr
= WsGetReaderNode( reader
, &node
, NULL
);
624 ok( hr
== S_OK
, "got %08x\n", hr
);
625 ok( node
!= NULL
, "node not set\n" );
626 if (node
) ok( node
->nodeType
== WS_XML_NODE_TYPE_BOF
, "got %u\n", node
->nodeType
);
628 hr
= WsFillReader( NULL
, sizeof(data1
) - 1, NULL
, NULL
);
629 ok( hr
== E_INVALIDARG
, "got %08x\n", hr
);
631 hr
= WsFillReader( reader
, sizeof(data1
) - 1, NULL
, NULL
);
632 ok( hr
== S_OK
, "got %08x\n", hr
);
635 hr
= WsGetReaderNode( reader
, &node
, NULL
);
636 ok( hr
== S_OK
, "got %08x\n", hr
);
637 ok( node
!= NULL
, "node not set\n" );
638 if (node
) ok( node
->nodeType
== WS_XML_NODE_TYPE_BOF
, "got %u\n", node
->nodeType
);
640 hr
= WsFillReader( reader
, sizeof(data1
) - 1, NULL
, NULL
);
641 ok( hr
== S_OK
, "got %08x\n", hr
);
643 /* min_size larger than input size */
644 hr
= WsFillReader( reader
, sizeof(data1
), NULL
, NULL
);
645 ok( hr
== S_OK
, "got %08x\n", hr
);
646 WsFreeReader( reader
);
649 static void test_WsReadToStartElement(void)
652 WS_XML_READER
*reader
;
653 const WS_XML_NODE
*node
, *node2
;
656 hr
= WsCreateReader( NULL
, 0, &reader
, NULL
) ;
657 ok( hr
== S_OK
, "got %08x\n", hr
);
659 hr
= set_input( reader
, data1
, sizeof(data1
) - 1 );
660 ok( hr
== S_OK
, "got %08x\n", hr
);
662 hr
= WsFillReader( reader
, sizeof(data1
) - 1, NULL
, NULL
);
663 ok( hr
== S_OK
, "got %08x\n", hr
);
665 hr
= WsGetReaderNode( reader
, &node
, NULL
);
666 ok( hr
== S_OK
, "got %08x\n", hr
);
667 if (node
) ok( node
->nodeType
== WS_XML_NODE_TYPE_BOF
, "got %u\n", node
->nodeType
);
669 hr
= WsFillReader( reader
, sizeof(data1
) - 1, NULL
, NULL
);
670 ok( hr
== S_OK
, "got %08x\n", hr
);
672 hr
= WsReadToStartElement( NULL
, NULL
, NULL
, NULL
, NULL
);
673 ok( hr
== E_INVALIDARG
, "got %08x\n", hr
);
676 hr
= WsReadToStartElement( reader
, NULL
, NULL
, &found
, NULL
);
677 ok( hr
== S_OK
, "got %08x\n", hr
);
678 ok( found
== FALSE
, "got %d\n", found
);
680 hr
= WsGetReaderNode( reader
, &node
, NULL
);
681 ok( hr
== S_OK
, "got %08x\n", hr
);
682 if (node
) ok( node
->nodeType
== WS_XML_NODE_TYPE_EOF
, "got %u\n", node
->nodeType
);
684 hr
= set_input( reader
, data2
, sizeof(data2
) - 1 );
685 ok( hr
== S_OK
, "got %08x\n", hr
);
687 hr
= WsFillReader( reader
, sizeof(data2
) - 1, NULL
, NULL
);
688 ok( hr
== S_OK
, "got %08x\n", hr
);
690 hr
= WsGetReaderNode( reader
, &node
, NULL
);
691 ok( hr
== S_OK
, "got %08x\n", hr
);
692 if (node
) ok( node
->nodeType
== WS_XML_NODE_TYPE_BOF
, "got %u\n", node
->nodeType
);
695 hr
= WsReadToStartElement( reader
, NULL
, NULL
, &found
, NULL
);
696 ok( hr
== S_OK
, "got %08x\n", hr
);
697 ok( found
== TRUE
, "got %d\n", found
);
699 hr
= WsGetReaderNode( reader
, &node
, NULL
);
700 ok( hr
== S_OK
, "got %08x\n", hr
);
703 WS_XML_ELEMENT_NODE
*elem
= (WS_XML_ELEMENT_NODE
*)node
;
705 ok( elem
->node
.nodeType
== WS_XML_NODE_TYPE_ELEMENT
, "got %u\n", elem
->node
.nodeType
);
706 ok( elem
->prefix
!= NULL
, "prefix not set\n" );
709 ok( !elem
->prefix
->length
, "got %u\n", elem
->prefix
->length
);
711 ok( elem
->localName
!= NULL
, "localName not set\n" );
714 ok( elem
->localName
->length
== 4, "got %u\n", elem
->localName
->length
);
715 ok( !memcmp( elem
->localName
->bytes
, "text", 4 ), "wrong data\n" );
717 ok( elem
->ns
!= NULL
, "ns not set\n" );
720 ok( !elem
->ns
->length
, "got %u\n", elem
->ns
->length
);
722 ok( !elem
->attributeCount
, "got %u\n", elem
->attributeCount
);
723 ok( elem
->attributes
== NULL
, "attributes set\n" );
724 ok( !elem
->isEmpty
, "isEmpty not zero\n" );
728 hr
= WsReadToStartElement( reader
, NULL
, NULL
, &found
, NULL
);
729 ok( hr
== S_OK
, "got %08x\n", hr
);
730 ok( found
== TRUE
, "got %d\n", found
);
733 hr
= WsGetReaderNode( reader
, &node2
, NULL
);
734 ok( hr
== S_OK
, "got %08x\n", hr
);
735 ok( node2
== node
, "different node\n" );
737 hr
= set_input( reader
, data3
, sizeof(data3
) - 1 );
738 ok( hr
== S_OK
, "got %08x\n", hr
);
740 hr
= WsFillReader( reader
, sizeof(data3
) - 1, NULL
, NULL
);
741 ok( hr
== S_OK
, "got %08x\n", hr
);
744 hr
= WsReadToStartElement( reader
, NULL
, NULL
, &found
, NULL
);
745 ok( hr
== S_OK
, "got %08x\n", hr
);
746 ok( found
== TRUE
, "got %d\n", found
);
748 hr
= WsGetReaderNode( reader
, &node
, NULL
);
749 ok( hr
== S_OK
, "got %08x\n", hr
);
752 WS_XML_ELEMENT_NODE
*elem
= (WS_XML_ELEMENT_NODE
*)node
;
754 ok( elem
->node
.nodeType
== WS_XML_NODE_TYPE_ELEMENT
, "got %u\n", elem
->node
.nodeType
);
755 ok( elem
->localName
!= NULL
, "localName not set\n" );
758 ok( elem
->localName
->length
== 4, "got %u\n", elem
->localName
->length
);
759 ok( !memcmp( elem
->localName
->bytes
, "text", 4 ), "wrong data\n" );
763 hr
= set_input( reader
, data4
, sizeof(data4
) - 1 );
764 ok( hr
== S_OK
, "got %08x\n", hr
);
766 hr
= WsFillReader( reader
, sizeof(data4
) - 1, NULL
, NULL
);
767 ok( hr
== S_OK
, "got %08x\n", hr
);
770 hr
= WsReadToStartElement( reader
, NULL
, NULL
, &found
, NULL
);
771 ok( hr
== S_OK
, "got %08x\n", hr
);
772 ok( found
== TRUE
, "got %d\n", found
);
773 WsFreeReader( reader
);
776 static void test_WsReadStartElement(void)
779 WS_XML_READER
*reader
;
780 const WS_XML_NODE
*node
, *node2
;
783 hr
= WsCreateReader( NULL
, 0, &reader
, NULL
) ;
784 ok( hr
== S_OK
, "got %08x\n", hr
);
786 hr
= set_input( reader
, data2
, sizeof(data2
) - 1 );
787 ok( hr
== S_OK
, "got %08x\n", hr
);
789 hr
= WsFillReader( reader
, sizeof(data2
) - 1, NULL
, NULL
);
790 ok( hr
== S_OK
, "got %08x\n", hr
);
793 hr
= WsReadToStartElement( reader
, NULL
, NULL
, &found
, NULL
);
794 ok( hr
== S_OK
, "got %08x\n", hr
);
795 ok( found
== TRUE
, "got %d\n", found
);
797 hr
= WsReadStartElement( NULL
, NULL
);
798 ok( hr
== E_INVALIDARG
, "got %08x\n", hr
);
800 hr
= WsGetReaderNode( reader
, &node
, NULL
);
801 ok( hr
== S_OK
, "got %08x\n", hr
);
802 if (node
) ok( node
->nodeType
== WS_XML_NODE_TYPE_ELEMENT
, "got %u\n", node
->nodeType
);
804 hr
= WsReadStartElement( reader
, NULL
);
805 ok( hr
== S_OK
, "got %08x\n", hr
);
807 hr
= WsGetReaderNode( reader
, &node
, NULL
);
808 ok( hr
== S_OK
, "got %08x\n", hr
);
811 WS_XML_TEXT_NODE
*text
= (WS_XML_TEXT_NODE
*)node
;
812 ok( text
->node
.nodeType
== WS_XML_NODE_TYPE_TEXT
, "got %u\n", text
->node
.nodeType
);
813 ok( text
->text
!= NULL
, "text not set\n" );
816 WS_XML_UTF8_TEXT
*utf8
= (WS_XML_UTF8_TEXT
*)text
->text
;
817 ok( text
->text
->textType
== WS_XML_TEXT_TYPE_UTF8
, "got %u\n", text
->text
->textType
);
818 ok( utf8
->value
.length
== 4, "got %u\n", utf8
->value
.length
);
819 ok( !memcmp( utf8
->value
.bytes
, "test", 4 ), "wrong data\n" );
823 hr
= WsReadStartElement( reader
, NULL
);
824 ok( hr
== WS_E_INVALID_FORMAT
, "got %08x\n", hr
);
827 hr
= WsGetReaderNode( reader
, &node2
, NULL
);
828 ok( hr
== S_OK
, "got %08x\n", hr
);
829 ok( node2
== node
, "different node\n" );
831 hr
= set_input( reader
, data8
, sizeof(data8
) - 1 );
832 ok( hr
== S_OK
, "got %08x\n", hr
);
834 hr
= WsFillReader( reader
, sizeof(data8
) - 1, NULL
, NULL
);
835 ok( hr
== S_OK
, "got %08x\n", hr
);
838 hr
= WsReadToStartElement( reader
, NULL
, NULL
, &found
, NULL
);
839 ok( hr
== S_OK
, "got %08x\n", hr
);
840 ok( found
== TRUE
, "got %d\n", found
);
842 hr
= WsGetReaderNode( reader
, &node
, NULL
);
843 ok( hr
== S_OK
, "got %08x\n", hr
);
844 if (node
) ok( node
->nodeType
== WS_XML_NODE_TYPE_ELEMENT
, "got %u\n", node
->nodeType
);
846 hr
= WsGetReaderNode( reader
, &node
, NULL
);
847 ok( hr
== S_OK
, "got %08x\n", hr
);
850 WS_XML_ELEMENT_NODE
*elem
= (WS_XML_ELEMENT_NODE
*)node
;
851 ok( node
->nodeType
== WS_XML_NODE_TYPE_ELEMENT
, "got %u\n", node
->nodeType
);
852 ok( !memcmp( elem
->localName
->bytes
, "node1", 5), "wrong name\n" );
855 hr
= WsReadStartElement( reader
, NULL
);
856 ok( hr
== S_OK
, "got %08x\n", hr
);
858 hr
= WsGetReaderNode( reader
, &node
, NULL
);
859 ok( hr
== S_OK
, "got %08x\n", hr
);
862 WS_XML_ELEMENT_NODE
*elem
= (WS_XML_ELEMENT_NODE
*)node
;
863 ok( node
->nodeType
== WS_XML_NODE_TYPE_ELEMENT
, "got %u\n", node
->nodeType
);
864 ok( !memcmp( elem
->localName
->bytes
, "node2", 5), "wrong name\n" );
867 hr
= WsReadNode( reader
, NULL
);
868 ok( hr
== S_OK
, "got %08x\n", hr
);
870 hr
= WsGetReaderNode( reader
, &node
, NULL
);
871 ok( hr
== S_OK
, "got %08x\n", hr
);
872 if (node
) ok( node
->nodeType
== WS_XML_NODE_TYPE_TEXT
, "got %u\n", node
->nodeType
);
874 hr
= WsReadNode( reader
, NULL
);
875 ok( hr
== S_OK
, "got %08x\n", hr
);
877 hr
= WsGetReaderNode( reader
, &node
, NULL
);
878 ok( hr
== S_OK
, "got %08x\n", hr
);
879 if (node
) ok( node
->nodeType
== WS_XML_NODE_TYPE_END_ELEMENT
, "got %u\n", node
->nodeType
);
881 hr
= WsReadEndElement( reader
, NULL
);
882 ok( hr
== S_OK
, "got %08x\n", hr
);
884 hr
= WsGetReaderNode( reader
, &node
, NULL
);
885 ok( hr
== S_OK
, "got %08x\n", hr
);
886 if (node
) ok( node
->nodeType
== WS_XML_NODE_TYPE_END_ELEMENT
, "got %u\n", node
->nodeType
);
888 /* WsReadEndElement advances reader to EOF */
889 hr
= WsReadEndElement( reader
, NULL
);
890 todo_wine
ok( hr
== S_OK
, "got %08x\n", hr
);
892 hr
= WsGetReaderNode( reader
, &node
, NULL
);
893 ok( hr
== S_OK
, "got %08x\n", hr
);
894 todo_wine
if (node
) ok( node
->nodeType
== WS_XML_NODE_TYPE_EOF
, "got %u\n", node
->nodeType
);
896 hr
= WsReadEndElement( reader
, NULL
);
897 ok( hr
== WS_E_INVALID_FORMAT
, "got %08x\n", hr
);
899 WsFreeReader( reader
);
902 static void test_WsReadEndElement(void)
905 WS_XML_READER
*reader
;
906 const WS_XML_NODE
*node
;
908 hr
= WsCreateReader( NULL
, 0, &reader
, NULL
) ;
909 ok( hr
== S_OK
, "got %08x\n", hr
);
911 hr
= set_input( reader
, data2
, sizeof(data2
) - 1 );
912 ok( hr
== S_OK
, "got %08x\n", hr
);
914 hr
= WsFillReader( reader
, sizeof(data2
) - 1, NULL
, NULL
);
915 ok( hr
== S_OK
, "got %08x\n", hr
);
917 hr
= WsReadEndElement( reader
, NULL
);
918 ok( hr
== WS_E_INVALID_FORMAT
, "got %08x\n", hr
);
920 hr
= set_input( reader
, data2
, sizeof(data2
) - 1 );
921 ok( hr
== S_OK
, "got %08x\n", hr
);
923 hr
= WsFillReader( reader
, sizeof(data2
) - 1, NULL
, NULL
);
924 ok( hr
== S_OK
, "got %08x\n", hr
);
926 hr
= WsReadNode( reader
, NULL
);
927 ok( hr
== S_OK
, "got %08x\n", hr
);
929 hr
= WsGetReaderNode( reader
, &node
, NULL
);
930 ok( hr
== S_OK
, "got %08x\n", hr
);
931 if (node
) ok( node
->nodeType
== WS_XML_NODE_TYPE_ELEMENT
, "got %u\n", node
->nodeType
);
933 hr
= WsReadNode( reader
, NULL
);
934 ok( hr
== S_OK
, "got %08x\n", hr
);
936 hr
= WsGetReaderNode( reader
, &node
, NULL
);
937 ok( hr
== S_OK
, "got %08x\n", hr
);
938 if (node
) ok( node
->nodeType
== WS_XML_NODE_TYPE_TEXT
, "got %u\n", node
->nodeType
);
940 hr
= WsReadNode( reader
, NULL
);
941 ok( hr
== S_OK
, "got %08x\n", hr
);
943 hr
= WsGetReaderNode( reader
, &node
, NULL
);
944 ok( hr
== S_OK
, "got %08x\n", hr
);
945 if (node
) ok( node
->nodeType
== WS_XML_NODE_TYPE_END_ELEMENT
, "got %u\n", node
->nodeType
);
947 hr
= WsReadNode( reader
, NULL
);
948 ok( hr
== S_OK
, "got %08x\n", hr
);
950 hr
= WsGetReaderNode( reader
, &node
, NULL
);
951 ok( hr
== S_OK
, "got %08x\n", hr
);
952 if (node
) ok( node
->nodeType
== WS_XML_NODE_TYPE_EOF
, "got %u\n", node
->nodeType
);
954 hr
= set_input( reader
, data2
, sizeof(data2
) - 1 );
955 ok( hr
== S_OK
, "got %08x\n", hr
);
957 hr
= WsFillReader( reader
, sizeof(data2
) - 1, NULL
, NULL
);
958 ok( hr
== S_OK
, "got %08x\n", hr
);
960 hr
= WsReadToStartElement( reader
, NULL
, NULL
, NULL
, NULL
);
961 ok( hr
== S_OK
, "got %08x\n", hr
);
963 hr
= WsReadStartElement( reader
, NULL
);
964 ok( hr
== S_OK
, "got %08x\n", hr
);
966 hr
= WsGetReaderNode( reader
, &node
, NULL
);
967 ok( hr
== S_OK
, "got %08x\n", hr
);
968 if (node
) ok( node
->nodeType
== WS_XML_NODE_TYPE_TEXT
, "got %u\n", node
->nodeType
);
970 hr
= WsReadNode( reader
, NULL
);
971 ok( hr
== S_OK
, "got %08x\n", hr
);
973 hr
= WsGetReaderNode( reader
, &node
, NULL
);
974 ok( hr
== S_OK
, "got %08x\n", hr
);
975 if (node
) ok( node
->nodeType
== WS_XML_NODE_TYPE_END_ELEMENT
, "got %u\n", node
->nodeType
);
977 /* WsReadEndElement advances reader to EOF */
978 hr
= WsReadEndElement( reader
, NULL
);
979 todo_wine
ok( hr
== S_OK
, "got %08x\n", hr
);
981 hr
= WsGetReaderNode( reader
, &node
, NULL
);
982 ok( hr
== S_OK
, "got %08x\n", hr
);
983 todo_wine
if (node
) ok( node
->nodeType
== WS_XML_NODE_TYPE_EOF
, "got %u\n", node
->nodeType
);
985 hr
= WsReadEndElement( reader
, NULL
);
986 ok( hr
== WS_E_INVALID_FORMAT
, "got %08x\n", hr
);
988 hr
= set_input( reader
, data5
, sizeof(data5
) - 1 );
989 ok( hr
== S_OK
, "got %08x\n", hr
);
991 hr
= WsFillReader( reader
, sizeof(data5
) - 1, NULL
, NULL
);
992 ok( hr
== S_OK
, "got %08x\n", hr
);
994 hr
= WsReadEndElement( reader
, NULL
);
995 ok( hr
== WS_E_INVALID_FORMAT
, "got %08x\n", hr
);
997 hr
= set_input( reader
, data10
, sizeof(data10
) - 1 );
998 ok( hr
== S_OK
, "got %08x\n", hr
);
1000 hr
= WsFillReader( reader
, sizeof(data10
) - 1, NULL
, NULL
);
1001 ok( hr
== S_OK
, "got %08x\n", hr
);
1003 hr
= WsReadNode( reader
, NULL
);
1004 ok( hr
== S_OK
, "got %08x\n", hr
);
1006 hr
= WsGetReaderNode( reader
, &node
, NULL
);
1007 ok( hr
== S_OK
, "got %08x\n", hr
);
1008 if (node
) ok( node
->nodeType
== WS_XML_NODE_TYPE_ELEMENT
, "got %u\n", node
->nodeType
);
1010 hr
= WsReadEndElement( reader
, NULL
);
1011 ok( hr
== WS_E_INVALID_FORMAT
, "got %08x\n", hr
);
1012 WsFreeReader( reader
);
1015 static void test_WsReadNode(void)
1017 static const char str1
[] = "<a>";
1018 static const char str2
[] = "< a>";
1019 static const char str3
[] = "<a >";
1020 static const char str4
[] = "<<a>>";
1021 static const char str5
[] = "<>";
1022 static const char str6
[] = "</a>";
1023 static const char str7
[] = " <a>";
1024 static const char str8
[] = "<?xml>";
1025 static const char str9
[] = "<?xml?>";
1026 static const char str10
[] = "<?xml ?>";
1027 static const char str11
[] = "<?xml version=\"1.0\"?>";
1028 static const char str12
[] = "<text>test</text>";
1029 static const char str13
[] = "<?xml version=\"1.0\"?><text>test</text>";
1030 static const char str14
[] = "";
1031 static const char str15
[] = "<!--";
1032 static const char str16
[] = "<!---->";
1033 static const char str17
[] = "<!--comment-->";
1035 WS_XML_READER
*reader
;
1036 const WS_XML_NODE
*node
;
1043 WS_XML_NODE_TYPE type
;
1048 { str1
, S_OK
, WS_XML_NODE_TYPE_ELEMENT
},
1049 { str2
, WS_E_INVALID_FORMAT
, 0 },
1050 { str3
, S_OK
, WS_XML_NODE_TYPE_ELEMENT
},
1051 { str4
, WS_E_INVALID_FORMAT
, 0 },
1052 { str5
, WS_E_INVALID_FORMAT
, 0 },
1053 { str6
, WS_E_INVALID_FORMAT
, 0 },
1054 { str7
, S_OK
, WS_XML_NODE_TYPE_TEXT
},
1055 { str8
, WS_E_INVALID_FORMAT
, 0 },
1056 { str9
, WS_E_INVALID_FORMAT
, 0 },
1057 { str10
, WS_E_INVALID_FORMAT
, 0, 1 },
1058 { str11
, S_OK
, WS_XML_NODE_TYPE_EOF
},
1059 { str12
, S_OK
, WS_XML_NODE_TYPE_ELEMENT
},
1060 { str13
, S_OK
, WS_XML_NODE_TYPE_ELEMENT
},
1061 { str14
, WS_E_INVALID_FORMAT
, 0, 1 },
1062 { str15
, WS_E_INVALID_FORMAT
, 0 },
1063 { str16
, S_OK
, WS_XML_NODE_TYPE_COMMENT
},
1064 { str17
, S_OK
, WS_XML_NODE_TYPE_COMMENT
},
1067 hr
= WsCreateReader( NULL
, 0, &reader
, NULL
) ;
1068 ok( hr
== S_OK
, "got %08x\n", hr
);
1070 for (i
= 0; i
< sizeof(tests
)/sizeof(tests
[0]); i
++)
1072 hr
= set_input( reader
, tests
[i
].text
, strlen(tests
[i
].text
) );
1073 ok( hr
== S_OK
, "got %08x\n", hr
);
1075 hr
= WsFillReader( reader
, strlen(tests
[i
].text
), NULL
, NULL
);
1076 ok( hr
== S_OK
, "%u: got %08x\n", i
, hr
);
1078 hr
= WsReadNode( reader
, NULL
);
1079 todo_wine_if (tests
[i
].todo
)
1080 ok( hr
== tests
[i
].hr
, "%u: got %08x\n", i
, hr
);
1084 hr
= WsGetReaderNode( reader
, &node
, NULL
);
1085 ok( hr
== S_OK
, "%u: got %08x\n", i
, hr
);
1086 ok( node
!= NULL
, "%u: node not set\n", i
);
1089 todo_wine_if (tests
[i
].todo
)
1090 ok( node
->nodeType
== tests
[i
].type
, "%u: got %u\n", i
, node
->nodeType
);
1095 hr
= set_input( reader
, data6
, sizeof(data6
) - 1 );
1096 ok( hr
== S_OK
, "got %08x\n", hr
);
1098 hr
= WsFillReader( reader
, sizeof(data6
) - 1, NULL
, NULL
);
1099 ok( hr
== S_OK
, "got %08x\n", hr
);
1102 hr
= WsReadToStartElement( reader
, NULL
, NULL
, &found
, NULL
);
1103 ok( hr
== S_OK
, "got %08x\n", hr
);
1104 ok( found
== TRUE
, "got %d\n", found
);
1106 hr
= WsGetReaderNode( reader
, &node
, NULL
);
1107 ok( hr
== S_OK
, "got %08x\n", hr
);
1110 WS_XML_ELEMENT_NODE
*elem
= (WS_XML_ELEMENT_NODE
*)node
;
1111 WS_XML_ATTRIBUTE
*attr
;
1112 WS_XML_UTF8_TEXT
*text
;
1114 ok( elem
->node
.nodeType
== WS_XML_NODE_TYPE_ELEMENT
, "got %u\n", elem
->node
.nodeType
);
1115 ok( elem
->prefix
!= NULL
, "prefix not set\n" );
1116 ok( !elem
->prefix
->length
, "got %u\n", elem
->prefix
->length
);
1117 ok( elem
->prefix
->bytes
== NULL
, "bytes set\n" );
1118 ok( elem
->localName
!= NULL
, "localName not set\n" );
1119 ok( elem
->localName
->length
== 4, "got %u\n", elem
->localName
->length
);
1120 ok( !memcmp( elem
->localName
->bytes
, "text", 4 ), "wrong data\n" );
1121 ok( elem
->ns
!= NULL
, "ns not set\n" );
1122 ok( !elem
->ns
->length
, "got %u\n", elem
->ns
->length
);
1123 ok( elem
->ns
->bytes
!= NULL
, "bytes not set\n" );
1124 ok( elem
->attributeCount
== 2, "got %u\n", elem
->attributeCount
);
1125 ok( elem
->attributes
!= NULL
, "attributes not set\n" );
1126 ok( !elem
->isEmpty
, "isEmpty not zero\n" );
1128 attr
= elem
->attributes
[0];
1129 ok( !attr
->singleQuote
, "got %u\n", attr
->singleQuote
);
1130 ok( !attr
->isXmlNs
, "got %u\n", attr
->isXmlNs
);
1131 ok( attr
->prefix
!= NULL
, "prefix not set\n" );
1132 ok( !attr
->prefix
->length
, "got %u\n", attr
->prefix
->length
);
1133 ok( attr
->prefix
->bytes
== NULL
, "bytes set\n" );
1134 ok( attr
->localName
!= NULL
, "localName not set\n" );
1135 ok( attr
->localName
->length
== 4, "got %u\n", attr
->localName
->length
);
1136 ok( !memcmp( attr
->localName
->bytes
, "attr", 4 ), "wrong data\n" );
1137 ok( attr
->ns
!= NULL
, "ns not set\n" );
1138 ok( !attr
->ns
->length
, "got %u\n", attr
->ns
->length
);
1139 ok( attr
->ns
->bytes
== NULL
, "bytes set\n" );
1140 ok( attr
->value
!= NULL
, "value not set\n" );
1142 text
= (WS_XML_UTF8_TEXT
*)attr
->value
;
1143 ok( attr
->value
->textType
== WS_XML_TEXT_TYPE_UTF8
, "got %u\n", attr
->value
->textType
);
1144 ok( text
->value
.length
== 5, "got %u\n", text
->value
.length
);
1145 ok( !memcmp( text
->value
.bytes
, "value", 5 ), "wrong data\n" );
1147 attr
= elem
->attributes
[1];
1148 ok( attr
->singleQuote
== 1, "got %u\n", attr
->singleQuote
);
1149 ok( !attr
->isXmlNs
, "got %u\n", attr
->isXmlNs
);
1150 ok( attr
->prefix
!= NULL
, "prefix not set\n" );
1151 ok( !attr
->prefix
->length
, "got %u\n", attr
->prefix
->length
);
1152 ok( attr
->prefix
->bytes
== NULL
, "bytes set\n" );
1153 ok( attr
->localName
!= NULL
, "localName not set\n" );
1154 ok( attr
->localName
->length
== 5, "got %u\n", attr
->localName
->length
);
1155 ok( !memcmp( attr
->localName
->bytes
, "attr2", 5 ), "wrong data\n" );
1156 ok( attr
->ns
!= NULL
, "ns not set\n" );
1157 ok( !attr
->ns
->length
, "got %u\n", attr
->ns
->length
);
1158 ok( attr
->ns
->bytes
== NULL
, "bytes set\n" );
1159 ok( attr
->value
!= NULL
, "value not set\n" );
1161 text
= (WS_XML_UTF8_TEXT
*)attr
->value
;
1162 ok( attr
->value
->textType
== WS_XML_TEXT_TYPE_UTF8
, "got %u\n", attr
->value
->textType
);
1163 ok( text
->value
.length
== 6, "got %u\n", text
->value
.length
);
1164 ok( !memcmp( text
->value
.bytes
, "value2", 6 ), "wrong data\n" );
1167 hr
= set_input( reader
, data7
, sizeof(data7
) - 1 );
1168 ok( hr
== S_OK
, "got %08x\n", hr
);
1170 hr
= WsFillReader( reader
, sizeof(data7
) - 1, NULL
, NULL
);
1171 ok( hr
== S_OK
, "got %08x\n", hr
);
1173 hr
= WsReadNode( reader
, NULL
);
1174 ok( hr
== S_OK
, "got %08x\n", hr
);
1176 hr
= WsGetReaderNode( reader
, &node
, NULL
);
1177 ok( hr
== S_OK
, "got %08x\n", hr
);
1180 WS_XML_COMMENT_NODE
*comment
= (WS_XML_COMMENT_NODE
*)node
;
1182 ok( comment
->node
.nodeType
== WS_XML_NODE_TYPE_COMMENT
, "got %u\n", comment
->node
.nodeType
);
1183 ok( comment
->value
.length
== 9, "got %u\n", comment
->value
.length
);
1184 ok( !memcmp( comment
->value
.bytes
, " comment ", 9 ), "wrong data\n" );
1187 WsFreeReader( reader
);
1190 static void prepare_type_test( WS_XML_READER
*reader
, const char *data
, ULONG size
)
1194 hr
= set_input( reader
, data
, size
);
1195 ok( hr
== S_OK
, "got %08x\n", hr
);
1197 hr
= WsFillReader( reader
, size
, NULL
, NULL
);
1198 ok( hr
== S_OK
, "got %08x\n", hr
);
1200 hr
= WsReadToStartElement( reader
, NULL
, NULL
, NULL
, NULL
);
1201 ok( hr
== S_OK
, "got %08x\n", hr
);
1203 hr
= WsReadStartElement( reader
, NULL
);
1204 ok( hr
== S_OK
, "got %08x\n", hr
);
1207 static void test_WsReadType(void)
1209 static const WCHAR testW
[] = {'t','e','s','t',0};
1211 WS_XML_READER
*reader
;
1224 hr
= WsCreateHeap( 1 << 16, 0, NULL
, 0, &heap
, NULL
);
1225 ok( hr
== S_OK
, "got %08x\n", hr
);
1227 hr
= WsCreateReader( NULL
, 0, &reader
, NULL
) ;
1228 ok( hr
== S_OK
, "got %08x\n", hr
);
1230 prepare_type_test( reader
, data2
, sizeof(data2
) - 1 );
1231 hr
= WsReadType( NULL
, WS_ELEMENT_CONTENT_TYPE_MAPPING
, WS_WSZ_TYPE
, NULL
,
1232 WS_READ_REQUIRED_POINTER
, heap
, &val_str
, sizeof(val_str
), NULL
);
1233 ok( hr
== E_INVALIDARG
, "got %08x\n", hr
);
1235 hr
= WsReadType( reader
, WS_ELEMENT_CONTENT_TYPE_MAPPING
, WS_WSZ_TYPE
, NULL
,
1236 WS_READ_REQUIRED_POINTER
, heap
, &val_str
, 0, NULL
);
1237 ok( hr
== E_INVALIDARG
, "got %08x\n", hr
);
1239 hr
= WsReadType( reader
, WS_ELEMENT_CONTENT_TYPE_MAPPING
, WS_WSZ_TYPE
, NULL
,
1240 WS_READ_REQUIRED_POINTER
, heap
, NULL
, sizeof(val_str
), NULL
);
1241 ok( hr
== E_INVALIDARG
, "got %08x\n", hr
);
1243 hr
= WsReadType( reader
, WS_ELEMENT_CONTENT_TYPE_MAPPING
, WS_WSZ_TYPE
, NULL
,
1244 WS_READ_REQUIRED_POINTER
, heap
, &val_str
, sizeof(val_str
) + 1, NULL
);
1245 ok( hr
== E_INVALIDARG
, "got %08x\n", hr
);
1248 hr
= WsReadType( reader
, WS_ELEMENT_CONTENT_TYPE_MAPPING
, WS_WSZ_TYPE
, NULL
,
1249 WS_READ_REQUIRED_POINTER
, heap
, &val_str
, sizeof(val_str
), NULL
);
1250 ok( hr
== S_OK
, "got %08x\n", hr
);
1251 ok( val_str
!= NULL
, "pointer not set\n" );
1252 if (val_str
) ok( !lstrcmpW( val_str
, testW
), "wrong data\n" );
1255 prepare_type_test( reader
, "<t>true</t>", sizeof("<t>true</t>") - 1 );
1256 hr
= WsReadType( reader
, WS_ELEMENT_CONTENT_TYPE_MAPPING
, WS_BOOL_TYPE
, NULL
,
1257 WS_READ_REQUIRED_VALUE
, heap
, &val_bool
, sizeof(BOOL
), NULL
);
1258 ok( hr
== S_OK
, "got %08x\n", hr
);
1259 ok( val_bool
== TRUE
, "got %d\n", val_bool
);
1262 prepare_type_test( reader
, "<t>false</t>", sizeof("<t>false</t>") - 1 );
1263 hr
= WsReadType( reader
, WS_ELEMENT_CONTENT_TYPE_MAPPING
, WS_BOOL_TYPE
, NULL
,
1264 WS_READ_REQUIRED_VALUE
, heap
, &val_bool
, sizeof(BOOL
), NULL
);
1265 ok( hr
== S_OK
, "got %08x\n", hr
);
1266 ok( val_bool
== FALSE
, "got %d\n", val_bool
);
1269 prepare_type_test( reader
, "<t>FALSE</t>", sizeof("<t>FALSE</t>") - 1 );
1270 hr
= WsReadType( reader
, WS_ELEMENT_CONTENT_TYPE_MAPPING
, WS_BOOL_TYPE
, NULL
,
1271 WS_READ_REQUIRED_VALUE
, heap
, &val_bool
, sizeof(val_bool
), NULL
);
1272 ok( hr
== WS_E_INVALID_FORMAT
, "got %08x\n", hr
);
1273 ok( val_bool
== -1, "got %d\n", val_bool
);
1276 prepare_type_test( reader
, "<t>1</t>", sizeof("<t>1</t>") - 1 );
1277 hr
= WsReadType( reader
, WS_ELEMENT_CONTENT_TYPE_MAPPING
, WS_BOOL_TYPE
, NULL
,
1278 WS_READ_REQUIRED_VALUE
, heap
, &val_bool
, sizeof(val_bool
), NULL
);
1279 ok( hr
== S_OK
, "got %08x\n", hr
);
1280 ok( val_bool
== TRUE
, "got %d\n", val_bool
);
1283 prepare_type_test( reader
, "<t>2</t>", sizeof("<t>2</t>") - 1 );
1284 hr
= WsReadType( reader
, WS_ELEMENT_CONTENT_TYPE_MAPPING
, WS_BOOL_TYPE
, NULL
,
1285 WS_READ_REQUIRED_VALUE
, heap
, &val_bool
, sizeof(val_bool
), NULL
);
1286 ok( hr
== WS_E_INVALID_FORMAT
, "got %08x\n", hr
);
1287 ok( val_bool
== -1, "got %d\n", val_bool
);
1290 prepare_type_test( reader
, "<t>0</t>", sizeof("<t>0</t>") - 1 );
1291 hr
= WsReadType( reader
, WS_ELEMENT_CONTENT_TYPE_MAPPING
, WS_BOOL_TYPE
, NULL
,
1292 WS_READ_REQUIRED_VALUE
, heap
, &val_bool
, sizeof(val_bool
), NULL
);
1293 ok( hr
== S_OK
, "got %08x\n", hr
);
1294 ok( val_bool
== FALSE
, "got %d\n", val_bool
);
1297 prepare_type_test( reader
, "<t>-128</t>", sizeof("<t>-128</t>") - 1 );
1298 hr
= WsReadType( reader
, WS_ELEMENT_CONTENT_TYPE_MAPPING
, WS_INT8_TYPE
, NULL
,
1299 WS_READ_REQUIRED_VALUE
, heap
, &val_int8
, sizeof(val_int8
), NULL
);
1300 ok( hr
== S_OK
, "got %08x\n", hr
);
1301 ok( val_int8
== -128, "got %d\n", val_int8
);
1304 prepare_type_test( reader
, "<t> </t>", sizeof("<t> </t>") - 1 );
1305 hr
= WsReadType( reader
, WS_ELEMENT_CONTENT_TYPE_MAPPING
, WS_INT8_TYPE
, NULL
,
1306 WS_READ_REQUIRED_VALUE
, heap
, &val_int8
, sizeof(val_int8
), NULL
);
1307 ok( hr
== WS_E_INVALID_FORMAT
, "got %08x\n", hr
);
1308 ok( !val_int8
, "got %d\n", val_int8
);
1311 prepare_type_test( reader
, "<t>-</t>", sizeof("<t>-</t>") - 1 );
1312 hr
= WsReadType( reader
, WS_ELEMENT_CONTENT_TYPE_MAPPING
, WS_INT8_TYPE
, NULL
,
1313 WS_READ_REQUIRED_VALUE
, heap
, &val_int8
, sizeof(val_int8
), NULL
);
1314 ok( hr
== WS_E_INVALID_FORMAT
, "got %08x\n", hr
);
1315 ok( !val_int8
, "got %d\n", val_int8
);
1318 prepare_type_test( reader
, "<t>-0</t>", sizeof("<t>-0</t>") - 1 );
1319 hr
= WsReadType( reader
, WS_ELEMENT_CONTENT_TYPE_MAPPING
, WS_INT8_TYPE
, NULL
,
1320 WS_READ_REQUIRED_VALUE
, heap
, &val_int8
, sizeof(val_int8
), NULL
);
1321 ok( hr
== S_OK
, "got %08x\n", hr
);
1322 ok( !val_int8
, "got %d\n", val_int8
);
1325 prepare_type_test( reader
, "<t>-129</t>", sizeof("<t>-129</t>") - 1 );
1326 hr
= WsReadType( reader
, WS_ELEMENT_CONTENT_TYPE_MAPPING
, WS_INT8_TYPE
, NULL
,
1327 WS_READ_REQUIRED_VALUE
, heap
, &val_int8
, sizeof(val_int8
), NULL
);
1328 ok( hr
== WS_E_NUMERIC_OVERFLOW
, "got %08x\n", hr
);
1329 ok( !val_int8
, "got %d\n", val_int8
);
1332 prepare_type_test( reader
, "<t>-32768</t>", sizeof("<t>-32768</t>") - 1 );
1333 hr
= WsReadType( reader
, WS_ELEMENT_CONTENT_TYPE_MAPPING
, WS_INT16_TYPE
, NULL
,
1334 WS_READ_REQUIRED_VALUE
, heap
, &val_int16
, sizeof(val_int16
), NULL
);
1335 ok( hr
== S_OK
, "got %08x\n", hr
);
1336 ok( val_int16
== -32768, "got %d\n", val_int16
);
1339 prepare_type_test( reader
, "<t>-32769</t>", sizeof("<t>-32769</t>") - 1 );
1340 hr
= WsReadType( reader
, WS_ELEMENT_CONTENT_TYPE_MAPPING
, WS_INT16_TYPE
, NULL
,
1341 WS_READ_REQUIRED_VALUE
, heap
, &val_int16
, sizeof(val_int16
), NULL
);
1342 ok( hr
== WS_E_NUMERIC_OVERFLOW
, "got %08x\n", hr
);
1343 ok( !val_int16
, "got %d\n", val_int16
);
1346 prepare_type_test( reader
, "<t>-2147483648</t>", sizeof("<t>-2147483648</t>") - 1 );
1347 hr
= WsReadType( reader
, WS_ELEMENT_CONTENT_TYPE_MAPPING
, WS_INT32_TYPE
, NULL
,
1348 WS_READ_REQUIRED_VALUE
, heap
, &val_int32
, sizeof(val_int32
), NULL
);
1349 ok( hr
== S_OK
, "got %08x\n", hr
);
1350 ok( val_int32
== -2147483647 - 1, "got %d\n", val_int32
);
1353 prepare_type_test( reader
, "<t>-2147483649</t>", sizeof("<t>-2147483649</t>") - 1 );
1354 hr
= WsReadType( reader
, WS_ELEMENT_CONTENT_TYPE_MAPPING
, WS_INT32_TYPE
, NULL
,
1355 WS_READ_REQUIRED_VALUE
, heap
, &val_int32
, sizeof(val_int32
), NULL
);
1356 todo_wine
ok( hr
== WS_E_INVALID_FORMAT
, "got %08x\n", hr
);
1357 ok( !val_int32
, "got %d\n", val_int32
);
1360 prepare_type_test( reader
, "<t>-9223372036854775808</t>", sizeof("<t>-9223372036854775808</t>") - 1 );
1361 hr
= WsReadType( reader
, WS_ELEMENT_CONTENT_TYPE_MAPPING
, WS_INT64_TYPE
, NULL
,
1362 WS_READ_REQUIRED_VALUE
, heap
, &val_int64
, sizeof(val_int64
), NULL
);
1363 ok( hr
== S_OK
, "got %08x\n", hr
);
1364 ok( val_int64
== -9223372036854775807 - 1, "wrong value\n" );
1367 prepare_type_test( reader
, "<t>-9223372036854775809</t>", sizeof("<t>-9223372036854775809</t>") - 1 );
1368 hr
= WsReadType( reader
, WS_ELEMENT_CONTENT_TYPE_MAPPING
, WS_INT64_TYPE
, NULL
,
1369 WS_READ_REQUIRED_VALUE
, heap
, &val_int64
, sizeof(val_int64
), NULL
);
1370 todo_wine
ok( hr
== WS_E_INVALID_FORMAT
, "got %08x\n", hr
);
1371 ok( !val_int64
, "wrong value\n" );
1374 prepare_type_test( reader
, "<t> 255 </t>", sizeof("<t> 255 </t>") - 1 );
1375 hr
= WsReadType( reader
, WS_ELEMENT_CONTENT_TYPE_MAPPING
, WS_UINT8_TYPE
, NULL
,
1376 WS_READ_REQUIRED_VALUE
, heap
, &val_uint8
, sizeof(val_uint8
), NULL
);
1377 ok( hr
== S_OK
, "got %08x\n", hr
);
1378 ok( val_uint8
== 255, "got %u\n", val_uint8
);
1381 prepare_type_test( reader
, "<t>+255</t>", sizeof("<t>+255</t>") - 1 );
1382 hr
= WsReadType( reader
, WS_ELEMENT_CONTENT_TYPE_MAPPING
, WS_UINT8_TYPE
, NULL
,
1383 WS_READ_REQUIRED_VALUE
, heap
, &val_uint8
, sizeof(val_uint8
), NULL
);
1384 ok( hr
== WS_E_INVALID_FORMAT
, "got %08x\n", hr
);
1385 ok( !val_uint8
, "got %u\n", val_uint8
);
1388 prepare_type_test( reader
, "<t>-255</t>", sizeof("<t>-255</t>") - 1 );
1389 hr
= WsReadType( reader
, WS_ELEMENT_CONTENT_TYPE_MAPPING
, WS_UINT8_TYPE
, NULL
,
1390 WS_READ_REQUIRED_VALUE
, heap
, &val_uint8
, sizeof(val_uint8
), NULL
);
1391 todo_wine
ok( hr
== WS_E_NUMERIC_OVERFLOW
, "got %08x\n", hr
);
1392 ok( !val_uint8
, "got %u\n", val_uint8
);
1395 prepare_type_test( reader
, "<t>0xff</t>", sizeof("<t>0xff</t>") - 1 );
1396 hr
= WsReadType( reader
, WS_ELEMENT_CONTENT_TYPE_MAPPING
, WS_UINT8_TYPE
, NULL
,
1397 WS_READ_REQUIRED_VALUE
, heap
, &val_uint8
, sizeof(val_uint8
), NULL
);
1398 ok( hr
== WS_E_INVALID_FORMAT
, "got %08x\n", hr
);
1399 ok( !val_uint8
, "got %u\n", val_uint8
);
1402 prepare_type_test( reader
, "<t>256</t>", sizeof("<t>256</t>") - 1 );
1403 hr
= WsReadType( reader
, WS_ELEMENT_CONTENT_TYPE_MAPPING
, WS_UINT8_TYPE
, NULL
,
1404 WS_READ_REQUIRED_VALUE
, heap
, &val_uint8
, sizeof(val_uint8
), NULL
);
1405 ok( hr
== WS_E_NUMERIC_OVERFLOW
, "got %08x\n", hr
);
1406 ok( !val_uint8
, "got %u\n", val_uint8
);
1409 prepare_type_test( reader
, "<t>65535</t>", sizeof("<t>65535</t>") - 1 );
1410 hr
= WsReadType( reader
, WS_ELEMENT_CONTENT_TYPE_MAPPING
, WS_UINT16_TYPE
, NULL
,
1411 WS_READ_REQUIRED_VALUE
, heap
, &val_uint16
, sizeof(val_uint16
), NULL
);
1412 ok( hr
== S_OK
, "got %08x\n", hr
);
1413 ok( val_uint16
== 65535, "got %u\n", val_uint16
);
1416 prepare_type_test( reader
, "<t>65536</t>", sizeof("<t>65536</t>") - 1 );
1417 hr
= WsReadType( reader
, WS_ELEMENT_CONTENT_TYPE_MAPPING
, WS_UINT16_TYPE
, NULL
,
1418 WS_READ_REQUIRED_VALUE
, heap
, &val_uint16
, sizeof(val_uint16
), NULL
);
1419 ok( hr
== WS_E_NUMERIC_OVERFLOW
, "got %08x\n", hr
);
1420 ok( !val_uint16
, "got %u\n", val_uint16
);
1423 prepare_type_test( reader
, "<t>4294967295</t>", sizeof("<t>4294967295</t>") - 1 );
1424 hr
= WsReadType( reader
, WS_ELEMENT_CONTENT_TYPE_MAPPING
, WS_UINT32_TYPE
, NULL
,
1425 WS_READ_REQUIRED_VALUE
, heap
, &val_uint32
, sizeof(val_uint32
), NULL
);
1426 ok( hr
== S_OK
, "got %08x\n", hr
);
1427 ok( val_uint32
== ~0, "got %u\n", val_uint32
);
1430 prepare_type_test( reader
, "<t>4294967296</t>", sizeof("<t>4294967296</t>") - 1 );
1431 hr
= WsReadType( reader
, WS_ELEMENT_CONTENT_TYPE_MAPPING
, WS_UINT32_TYPE
, NULL
,
1432 WS_READ_REQUIRED_VALUE
, heap
, &val_uint32
, sizeof(val_uint32
), NULL
);
1433 ok( hr
== WS_E_NUMERIC_OVERFLOW
, "got %08x\n", hr
);
1434 ok( !val_uint32
, "got %u\n", val_uint32
);
1437 prepare_type_test( reader
, "<t>18446744073709551615</t>", sizeof("<t>18446744073709551615</t>") - 1 );
1438 hr
= WsReadType( reader
, WS_ELEMENT_CONTENT_TYPE_MAPPING
, WS_UINT64_TYPE
, NULL
,
1439 WS_READ_REQUIRED_VALUE
, heap
, &val_uint64
, sizeof(val_uint64
), NULL
);
1440 ok( hr
== S_OK
, "got %08x\n", hr
);
1441 ok( val_uint64
== ~0, "wrong value\n" );
1444 prepare_type_test( reader
, "<t>18446744073709551616</t>", sizeof("<t>18446744073709551616</t>") - 1 );
1445 hr
= WsReadType( reader
, WS_ELEMENT_CONTENT_TYPE_MAPPING
, WS_UINT64_TYPE
, NULL
,
1446 WS_READ_REQUIRED_VALUE
, heap
, &val_uint64
, sizeof(val_uint64
), NULL
);
1447 todo_wine
ok( hr
== WS_E_INVALID_FORMAT
, "got %08x\n", hr
);
1448 ok( !val_uint64
, "wrong value\n" );
1450 WsFreeReader( reader
);
1454 static void test_WsGetXmlAttribute(void)
1456 static const WCHAR valueW
[] = {'v','a','l','u','e',0};
1458 WS_XML_READER
*reader
;
1459 WS_XML_STRING xmlstr
;
1465 hr
= WsCreateHeap( 1 << 16, 0, NULL
, 0, &heap
, NULL
);
1466 ok( hr
== S_OK
, "got %08x\n", hr
);
1468 hr
= WsCreateReader( NULL
, 0, &reader
, NULL
) ;
1469 ok( hr
== S_OK
, "got %08x\n", hr
);
1471 hr
= set_input( reader
, data9
, sizeof(data9
) - 1 );
1472 ok( hr
== S_OK
, "got %08x\n", hr
);
1474 hr
= WsFillReader( reader
, sizeof(data9
) - 1, NULL
, NULL
);
1475 ok( hr
== S_OK
, "got %08x\n", hr
);
1478 hr
= WsReadToStartElement( reader
, NULL
, NULL
, &found
, NULL
);
1479 ok( hr
== S_OK
, "got %08x\n", hr
);
1480 ok( found
== TRUE
, "got %d\n", found
);
1482 xmlstr
.bytes
= (BYTE
*)"attr";
1483 xmlstr
.length
= sizeof("attr") - 1;
1484 xmlstr
.dictionary
= NULL
;
1488 hr
= WsGetXmlAttribute( reader
, &xmlstr
, heap
, &str
, &count
, NULL
);
1489 todo_wine
ok( hr
== S_OK
, "got %08x\n", hr
);
1490 todo_wine
ok( str
!= NULL
, "str not set\n" );
1491 todo_wine
ok( count
== 5, "got %u\n", count
);
1492 /* string is not null-terminated */
1493 if (str
) ok( !memcmp( str
, valueW
, count
* sizeof(WCHAR
) ), "wrong data\n" );
1495 xmlstr
.bytes
= (BYTE
*)"none";
1496 xmlstr
.length
= sizeof("none") - 1;
1497 xmlstr
.dictionary
= NULL
;
1499 str
= (WCHAR
*)0xdeadbeef;
1501 hr
= WsGetXmlAttribute( reader
, &xmlstr
, heap
, &str
, &count
, NULL
);
1502 todo_wine
ok( hr
== S_FALSE
, "got %08x\n", hr
);
1503 todo_wine
ok( str
== NULL
, "str not set\n" );
1504 todo_wine
ok( !count
, "got %u\n", count
);
1506 WsFreeReader( reader
);
1510 static void test_WsXmlStringEquals(void)
1512 BYTE bom
[] = {0xef,0xbb,0xbf};
1513 WS_XML_STRING str1
= {0, NULL
}, str2
= {0, NULL
};
1516 hr
= WsXmlStringEquals( NULL
, NULL
, NULL
);
1517 ok( hr
== E_INVALIDARG
, "got %08x\n", hr
);
1519 hr
= WsXmlStringEquals( &str1
, NULL
, NULL
);
1520 ok( hr
== E_INVALIDARG
, "got %08x\n", hr
);
1522 hr
= WsXmlStringEquals( NULL
, &str2
, NULL
);
1523 ok( hr
== E_INVALIDARG
, "got %08x\n", hr
);
1525 hr
= WsXmlStringEquals( &str1
, &str2
, NULL
);
1526 ok( hr
== S_OK
, "got %08x\n", hr
);
1529 str1
.bytes
= (BYTE
*)"a";
1530 hr
= WsXmlStringEquals( &str1
, &str1
, NULL
);
1531 ok( hr
== S_OK
, "got %08x\n", hr
);
1534 str2
.bytes
= (BYTE
*)"b";
1535 hr
= WsXmlStringEquals( &str1
, &str2
, NULL
);
1536 ok( hr
== S_FALSE
, "got %08x\n", hr
);
1540 hr
= WsXmlStringEquals( &str1
, &str2
, NULL
);
1541 ok( hr
== S_FALSE
, "got %08x\n", hr
);
1544 hr
= WsXmlStringEquals( &str1
, &str2
, NULL
);
1545 ok( hr
== S_FALSE
, "got %08x\n", hr
);
1548 hr
= WsXmlStringEquals( &str1
, &str2
, NULL
);
1549 ok( hr
== S_FALSE
, "got %08x\n", hr
);
1553 hr
= WsXmlStringEquals( &str1
, &str2
, NULL
);
1554 ok( hr
== S_OK
, "got %08x\n", hr
);
1557 static void test_WsAlloc(void)
1563 hr
= WsCreateHeap( 256, 0, NULL
, 0, &heap
, NULL
);
1564 ok( hr
== S_OK
, "got %08x\n", hr
);
1567 hr
= WsAlloc( NULL
, 16, &ptr
, NULL
);
1568 ok( hr
== E_INVALIDARG
, "got %08x\n", hr
);
1569 ok( ptr
== NULL
, "ptr set\n" );
1572 hr
= WsAlloc( heap
, 512, &ptr
, NULL
);
1573 todo_wine
ok( hr
== WS_E_QUOTA_EXCEEDED
, "got %08x\n", hr
);
1574 todo_wine
ok( ptr
== NULL
, "ptr not set\n" );
1577 hr
= WsAlloc( heap
, 16, &ptr
, NULL
);
1578 ok( hr
== S_OK
, "got %08x\n", hr
);
1579 ok( ptr
!= NULL
, "ptr not set\n" );
1583 static void test_WsMoveReader(void)
1587 WS_XML_READER
*reader
;
1588 WS_XML_WRITER
*writer
;
1589 WS_XML_BUFFER
*buffer
;
1590 WS_XML_STRING localname
= {1, (BYTE
*)"a"}, localname2
= {1, (BYTE
*)"b"}, ns
= {0, NULL
};
1591 const WS_XML_NODE
*node
;
1592 WS_XML_ELEMENT_NODE
*elem
;
1594 hr
= WsCreateReader( NULL
, 0, &reader
, NULL
) ;
1595 ok( hr
== S_OK
, "got %08x\n", hr
);
1597 hr
= WsMoveReader( NULL
, WS_MOVE_TO_EOF
, NULL
, NULL
);
1598 ok( hr
== E_INVALIDARG
, "got %08x\n", hr
);
1600 /* reader must be set to an XML buffer */
1601 hr
= WsMoveReader( reader
, WS_MOVE_TO_EOF
, NULL
, NULL
);
1602 ok( hr
== WS_E_INVALID_OPERATION
, "got %08x\n", hr
);
1604 hr
= set_input( reader
, data8
, sizeof(data8
) - 1 );
1605 ok( hr
== S_OK
, "got %08x\n", hr
);
1607 hr
= WsMoveReader( reader
, WS_MOVE_TO_EOF
, NULL
, NULL
);
1608 todo_wine
ok( hr
== WS_E_INVALID_OPERATION
, "got %08x\n", hr
);
1609 WsFreeReader( reader
);
1611 hr
= WsCreateHeap( 1 << 16, 0, NULL
, 0, &heap
, NULL
);
1612 ok( hr
== S_OK
, "got %08x\n", hr
);
1614 hr
= WsCreateXmlBuffer( heap
, NULL
, 0, &buffer
, NULL
);
1615 ok( hr
== S_OK
, "got %08x\n", hr
);
1617 hr
= WsCreateWriter( NULL
, 0, &writer
, NULL
) ;
1618 ok( hr
== S_OK
, "got %08x\n", hr
);
1620 hr
= WsSetOutputToBuffer( writer
, buffer
, NULL
, 0, NULL
);
1621 ok( hr
== S_OK
, "got %08x\n", hr
);
1624 hr
= WsWriteStartElement( writer
, NULL
, &localname
, &ns
, NULL
);
1625 ok( hr
== S_OK
, "got %08x\n", hr
);
1627 hr
= WsWriteStartElement( writer
, NULL
, &localname2
, &ns
, NULL
);
1628 ok( hr
== S_OK
, "got %08x\n", hr
);
1630 hr
= WsWriteEndElement( writer
, NULL
);
1631 ok( hr
== S_OK
, "got %08x\n", hr
);
1633 hr
= WsWriteEndElement( writer
, NULL
);
1634 ok( hr
== S_OK
, "got %08x\n", hr
);
1636 hr
= WsCreateReader( NULL
, 0, &reader
, NULL
) ;
1637 ok( hr
== S_OK
, "got %08x\n", hr
);
1639 hr
= WsMoveReader( reader
, WS_MOVE_TO_EOF
, NULL
, NULL
);
1640 ok( hr
== WS_E_INVALID_OPERATION
, "got %08x\n", hr
);
1642 hr
= WsSetInputToBuffer( reader
, buffer
, NULL
, 0, NULL
);
1643 ok( hr
== S_OK
, "got %08x\n", hr
);
1645 /* first element is child node of BOF node */
1646 hr
= WsMoveReader( reader
, WS_MOVE_TO_BOF
, NULL
, NULL
);
1647 ok( hr
== S_OK
, "got %08x\n", hr
);
1649 hr
= WsMoveReader( reader
, WS_MOVE_TO_CHILD_NODE
, NULL
, NULL
);
1650 ok( hr
== S_OK
, "got %08x\n", hr
);
1652 hr
= WsGetReaderNode( reader
, &node
, NULL
);
1653 ok( hr
== S_OK
, "got %08x\n", hr
);
1654 elem
= (WS_XML_ELEMENT_NODE
*)node
;
1655 ok( elem
->node
.nodeType
== WS_XML_NODE_TYPE_ELEMENT
, "got %u\n", elem
->node
.nodeType
);
1656 ok( elem
->localName
->length
== 1, "got %u\n", elem
->localName
->length
);
1657 ok( !memcmp( elem
->localName
->bytes
, "a", 1 ), "wrong data\n" );
1659 hr
= WsMoveReader( reader
, WS_MOVE_TO_CHILD_NODE
, NULL
, NULL
);
1660 ok( hr
== S_OK
, "got %08x\n", hr
);
1662 hr
= WsGetReaderNode( reader
, &node
, NULL
);
1663 ok( hr
== S_OK
, "got %08x\n", hr
);
1664 elem
= (WS_XML_ELEMENT_NODE
*)node
;
1665 ok( elem
->node
.nodeType
== WS_XML_NODE_TYPE_ELEMENT
, "got %u\n", elem
->node
.nodeType
);
1666 ok( elem
->localName
->length
== 1, "got %u\n", elem
->localName
->length
);
1667 ok( !memcmp( elem
->localName
->bytes
, "b", 1 ), "wrong data\n" );
1669 hr
= WsMoveReader( reader
, WS_MOVE_TO_NEXT_NODE
, NULL
, NULL
);
1670 ok( hr
== S_OK
, "got %08x\n", hr
);
1672 hr
= WsGetReaderNode( reader
, &node
, NULL
);
1673 ok( hr
== S_OK
, "got %08x\n", hr
);
1674 ok( node
->nodeType
== WS_XML_NODE_TYPE_END_ELEMENT
, "got %u\n", elem
->node
.nodeType
);
1676 /* EOF node is last child of BOF node */
1677 hr
= WsMoveReader( reader
, WS_MOVE_TO_BOF
, NULL
, NULL
);
1678 ok( hr
== S_OK
, "got %08x\n", hr
);
1680 hr
= WsMoveReader( reader
, WS_MOVE_TO_CHILD_NODE
, NULL
, NULL
);
1681 ok( hr
== S_OK
, "got %08x\n", hr
);
1683 hr
= WsGetReaderNode( reader
, &node
, NULL
);
1684 ok( hr
== S_OK
, "got %08x\n", hr
);
1685 ok( node
->nodeType
== WS_XML_NODE_TYPE_ELEMENT
, "got %u\n", elem
->node
.nodeType
);
1687 hr
= WsMoveReader( reader
, WS_MOVE_TO_NEXT_NODE
, NULL
, NULL
);
1688 ok( hr
== S_OK
, "got %08x\n", hr
);
1690 hr
= WsGetReaderNode( reader
, &node
, NULL
);
1691 ok( hr
== S_OK
, "got %08x\n", hr
);
1692 ok( node
->nodeType
== WS_XML_NODE_TYPE_EOF
, "got %u\n", elem
->node
.nodeType
);
1694 hr
= WsMoveReader( reader
, WS_MOVE_TO_ROOT_ELEMENT
, NULL
, NULL
);
1695 ok( hr
== S_OK
, "got %08x\n", hr
);
1697 hr
= WsGetReaderNode( reader
, &node
, NULL
);
1698 ok( hr
== S_OK
, "got %08x\n", hr
);
1699 elem
= (WS_XML_ELEMENT_NODE
*)node
;
1700 ok( elem
->node
.nodeType
== WS_XML_NODE_TYPE_ELEMENT
, "got %u\n", elem
->node
.nodeType
);
1701 ok( elem
->localName
->length
== 1, "got %u\n", elem
->localName
->length
);
1702 ok( !memcmp( elem
->localName
->bytes
, "a", 1 ), "wrong data\n" );
1704 hr
= WsMoveReader( reader
, WS_MOVE_TO_CHILD_ELEMENT
, NULL
, NULL
);
1705 ok( hr
== S_OK
, "got %08x\n", hr
);
1707 hr
= WsGetReaderNode( reader
, &node
, NULL
);
1708 ok( hr
== S_OK
, "got %08x\n", hr
);
1709 elem
= (WS_XML_ELEMENT_NODE
*)node
;
1710 ok( elem
->node
.nodeType
== WS_XML_NODE_TYPE_ELEMENT
, "got %u\n", elem
->node
.nodeType
);
1711 ok( elem
->localName
->length
== 1, "got %u\n", elem
->localName
->length
);
1712 ok( !memcmp( elem
->localName
->bytes
, "b", 1 ), "wrong data\n" );
1714 hr
= WsMoveReader( reader
, WS_MOVE_TO_END_ELEMENT
, NULL
, NULL
);
1715 ok( hr
== S_OK
, "got %08x\n", hr
);
1717 hr
= WsGetReaderNode( reader
, &node
, NULL
);
1718 ok( hr
== S_OK
, "got %08x\n", hr
);
1719 ok( node
->nodeType
== WS_XML_NODE_TYPE_END_ELEMENT
, "got %u\n", elem
->node
.nodeType
);
1721 hr
= WsMoveReader( reader
, WS_MOVE_TO_PARENT_ELEMENT
, NULL
, NULL
);
1722 ok( hr
== S_OK
, "got %08x\n", hr
);
1724 hr
= WsGetReaderNode( reader
, &node
, NULL
);
1725 ok( hr
== S_OK
, "got %08x\n", hr
);
1726 elem
= (WS_XML_ELEMENT_NODE
*)node
;
1727 ok( elem
->node
.nodeType
== WS_XML_NODE_TYPE_ELEMENT
, "got %u\n", elem
->node
.nodeType
);
1728 ok( elem
->localName
->length
== 1, "got %u\n", elem
->localName
->length
);
1729 ok( !memcmp( elem
->localName
->bytes
, "b", 1 ), "wrong data\n" );
1731 hr
= WsMoveReader( reader
, WS_MOVE_TO_PARENT_ELEMENT
, NULL
, NULL
);
1732 ok( hr
== S_OK
, "got %08x\n", hr
);
1734 hr
= WsGetReaderNode( reader
, &node
, NULL
);
1735 ok( hr
== S_OK
, "got %08x\n", hr
);
1736 elem
= (WS_XML_ELEMENT_NODE
*)node
;
1737 ok( elem
->node
.nodeType
== WS_XML_NODE_TYPE_ELEMENT
, "got %u\n", elem
->node
.nodeType
);
1738 ok( elem
->localName
->length
== 1, "got %u\n", elem
->localName
->length
);
1739 ok( !memcmp( elem
->localName
->bytes
, "a", 1 ), "wrong data\n" );
1741 hr
= WsMoveReader( reader
, WS_MOVE_TO_PARENT_ELEMENT
, NULL
, NULL
);
1742 ok( hr
== S_OK
, "got %08x\n", hr
);
1744 hr
= WsGetReaderNode( reader
, &node
, NULL
);
1745 ok( hr
== S_OK
, "got %08x\n", hr
);
1746 ok( node
->nodeType
== WS_XML_NODE_TYPE_BOF
, "got %u\n", elem
->node
.nodeType
);
1748 hr
= WsMoveReader( reader
, WS_MOVE_TO_PARENT_ELEMENT
, NULL
, NULL
);
1749 ok( hr
== WS_E_INVALID_FORMAT
, "got %08x\n", hr
);
1751 WsFreeReader( reader
);
1752 WsFreeWriter( writer
);
1756 static void prepare_struct_type_test( WS_XML_READER
*reader
, const char *data
)
1759 ULONG size
= strlen( data
);
1761 hr
= set_input( reader
, data
, size
);
1762 ok( hr
== S_OK
, "got %08x\n", hr
);
1764 hr
= WsFillReader( reader
, size
, NULL
, NULL
);
1765 ok( hr
== S_OK
, "got %08x\n", hr
);
1768 static void test_simple_struct_type(void)
1770 static const WCHAR testW
[] = {'t','e','s','t',0};
1772 WS_XML_READER
*reader
;
1774 WS_STRUCT_DESCRIPTION s
;
1775 WS_FIELD_DESCRIPTION f
, *fields
[1];
1776 WS_XML_STRING ns
= {0, NULL
}, localname
= {3, (BYTE
*)"str"};
1777 WS_XML_STRING localname2
= {4, (BYTE
*)"test"};
1778 const WS_XML_NODE
*node
;
1779 struct test
{ WCHAR
*str
; } *test
;
1781 hr
= WsCreateHeap( 1 << 16, 0, NULL
, 0, &heap
, NULL
);
1782 ok( hr
== S_OK
, "got %08x\n", hr
);
1784 hr
= WsCreateReader( NULL
, 0, &reader
, NULL
) ;
1785 ok( hr
== S_OK
, "got %08x\n", hr
);
1787 prepare_struct_type_test( reader
, "<str>test</str>" );
1788 hr
= WsReadType( reader
, WS_ELEMENT_CONTENT_TYPE_MAPPING
, WS_STRUCT_TYPE
, NULL
,
1789 WS_READ_REQUIRED_POINTER
, heap
, &test
, sizeof(test
), NULL
);
1790 ok( hr
== E_INVALIDARG
, "got %08x\n", hr
);
1792 hr
= WsGetReaderNode( reader
, &node
, NULL
);
1793 ok( hr
== S_OK
, "got %08x\n", hr
);
1794 ok( node
->nodeType
== WS_XML_NODE_TYPE_BOF
, "got %u\n", node
->nodeType
);
1796 /* element field mapping */
1797 memset( &f
, 0, sizeof(f
) );
1798 f
.mapping
= WS_ELEMENT_FIELD_MAPPING
;
1799 f
.localName
= &localname
;
1801 f
.type
= WS_WSZ_TYPE
;
1804 memset( &s
, 0, sizeof(s
) );
1805 s
.size
= sizeof(struct test
);
1806 s
.alignment
= TYPE_ALIGNMENT(struct test
);
1809 s
.typeLocalName
= &localname2
;
1813 prepare_struct_type_test( reader
, "<?xml version=\"1.0\" encoding=\"utf-8\"?><str>test</str><str>test2</str>" );
1814 hr
= WsReadType( reader
, WS_ELEMENT_CONTENT_TYPE_MAPPING
, WS_STRUCT_TYPE
, &s
,
1815 WS_READ_REQUIRED_POINTER
, heap
, &test
, sizeof(test
), NULL
);
1816 ok( hr
== WS_E_INVALID_FORMAT
, "got %08x\n", hr
);
1819 prepare_struct_type_test( reader
, "<?xml version=\"1.0\" encoding=\"utf-8\"?><str>test</str>" );
1820 hr
= WsReadType( reader
, WS_ELEMENT_CONTENT_TYPE_MAPPING
, WS_STRUCT_TYPE
, &s
,
1821 WS_READ_REQUIRED_POINTER
, heap
, &test
, sizeof(test
), NULL
);
1822 ok( hr
== S_OK
, "got %08x\n", hr
);
1823 ok( test
!= NULL
, "test not set\n" );
1826 ok( test
->str
!= NULL
, "str not set\n" );
1827 if (test
->str
) ok( !lstrcmpW( test
->str
, testW
), "wrong data\n" );
1830 hr
= WsGetReaderNode( reader
, &node
, NULL
);
1831 ok( hr
== S_OK
, "got %08x\n", hr
);
1832 ok( node
->nodeType
== WS_XML_NODE_TYPE_EOF
, "got %u\n", node
->nodeType
);
1835 prepare_struct_type_test( reader
, "<str>test</str>" );
1836 hr
= WsReadType( reader
, WS_ELEMENT_CONTENT_TYPE_MAPPING
, WS_STRUCT_TYPE
, &s
,
1837 WS_READ_REQUIRED_POINTER
, heap
, &test
, sizeof(test
), NULL
);
1838 ok( hr
== S_OK
, "got %08x\n", hr
);
1839 ok( test
!= NULL
, "test not set\n" );
1842 ok( test
->str
!= NULL
, "str not set\n" );
1843 if (test
->str
) ok( !lstrcmpW( test
->str
, testW
), "wrong data\n" );
1846 hr
= WsGetReaderNode( reader
, &node
, NULL
);
1847 ok( hr
== S_OK
, "got %08x\n", hr
);
1848 ok( node
->nodeType
== WS_XML_NODE_TYPE_EOF
, "got %u\n", node
->nodeType
);
1850 WsFreeReader( reader
);
1854 static void test_cdata(void)
1856 static const char test
[] = "<t><![CDATA[<data>]]></t>";
1858 WS_XML_READER
*reader
;
1859 const WS_XML_NODE
*node
;
1861 hr
= WsCreateReader( NULL
, 0, &reader
, NULL
) ;
1862 ok( hr
== S_OK
, "got %08x\n", hr
);
1864 hr
= set_input( reader
, test
, sizeof(test
) - 1 );
1865 ok( hr
== S_OK
, "got %08x\n", hr
);
1867 hr
= WsFillReader( reader
, sizeof(test
) - 1, NULL
, NULL
);
1868 ok( hr
== S_OK
, "got %08x\n", hr
);
1870 hr
= WsReadNode( reader
, NULL
);
1871 ok( hr
== S_OK
, "got %08x\n", hr
);
1873 hr
= WsGetReaderNode( reader
, &node
, NULL
);
1874 ok( hr
== S_OK
, "got %08x\n", hr
);
1875 if (node
) ok( node
->nodeType
== WS_XML_NODE_TYPE_ELEMENT
, "got %u\n", node
->nodeType
);
1877 hr
= WsReadNode( reader
, NULL
);
1878 ok( hr
== S_OK
, "got %08x\n", hr
);
1880 hr
= WsGetReaderNode( reader
, &node
, NULL
);
1881 ok( hr
== S_OK
, "got %08x\n", hr
);
1882 if (node
) ok( node
->nodeType
== WS_XML_NODE_TYPE_CDATA
, "got %u\n", node
->nodeType
);
1884 hr
= WsReadNode( reader
, NULL
);
1885 ok( hr
== S_OK
, "got %08x\n", hr
);
1887 hr
= WsGetReaderNode( reader
, &node
, NULL
);
1888 ok( hr
== S_OK
, "got %08x\n", hr
);
1891 WS_XML_TEXT_NODE
*text
= (WS_XML_TEXT_NODE
*)node
;
1892 ok( node
->nodeType
== WS_XML_NODE_TYPE_TEXT
, "got %u\n", node
->nodeType
);
1893 ok( text
->text
!= NULL
, "text not set\n" );
1896 WS_XML_UTF8_TEXT
*utf8
= (WS_XML_UTF8_TEXT
*)text
->text
;
1897 ok( utf8
->text
.textType
== WS_XML_TEXT_TYPE_UTF8
, "got %u\n", utf8
->text
.textType
);
1898 ok( utf8
->value
.length
== 6, "got %u\n", utf8
->value
.length
);
1899 ok( !memcmp( utf8
->value
.bytes
, "<data>", 6 ), "wrong data\n" );
1903 hr
= WsReadNode( reader
, NULL
);
1904 ok( hr
== S_OK
, "got %08x\n", hr
);
1906 hr
= WsGetReaderNode( reader
, &node
, NULL
);
1907 ok( hr
== S_OK
, "got %08x\n", hr
);
1908 if (node
) ok( node
->nodeType
== WS_XML_NODE_TYPE_END_CDATA
, "got %u\n", node
->nodeType
);
1910 hr
= WsReadNode( reader
, NULL
);
1911 ok( hr
== S_OK
, "got %08x\n", hr
);
1913 hr
= WsGetReaderNode( reader
, &node
, NULL
);
1914 ok( hr
== S_OK
, "got %08x\n", hr
);
1915 if (node
) ok( node
->nodeType
== WS_XML_NODE_TYPE_END_ELEMENT
, "got %u\n", node
->nodeType
);
1917 WsFreeReader( reader
);
1920 static void test_WsFindAttribute(void)
1922 static const char test
[] = "<t attr='value' attr2='value2'></t>";
1923 WS_XML_STRING ns
= {0, NULL
}, localname
= {4, (BYTE
*)"attr"};
1924 WS_XML_STRING localname2
= {5, (BYTE
*)"attr2"}, localname3
= {5, (BYTE
*)"attr3"};
1925 WS_XML_READER
*reader
;
1929 hr
= WsCreateReader( NULL
, 0, &reader
, NULL
) ;
1930 ok( hr
== S_OK
, "got %08x\n", hr
);
1932 hr
= set_input( reader
, test
, sizeof(test
) - 1 );
1933 ok( hr
== S_OK
, "got %08x\n", hr
);
1935 hr
= WsReadNode( reader
, NULL
);
1936 ok( hr
== S_OK
, "got %08x\n", hr
);
1938 hr
= WsFindAttribute( reader
, &localname
, &ns
, TRUE
, NULL
, NULL
);
1939 ok( hr
== E_INVALIDARG
, "got %08x\n", hr
);
1941 hr
= set_input( reader
, test
, sizeof(test
) - 1 );
1942 ok( hr
== S_OK
, "got %08x\n", hr
);
1944 hr
= WsReadNode( reader
, NULL
);
1945 ok( hr
== S_OK
, "got %08x\n", hr
);
1947 hr
= WsFindAttribute( reader
, &localname
, NULL
, TRUE
, &index
, NULL
);
1948 ok( hr
== E_INVALIDARG
, "got %08x\n", hr
);
1950 hr
= set_input( reader
, test
, sizeof(test
) - 1 );
1951 ok( hr
== S_OK
, "got %08x\n", hr
);
1953 hr
= WsReadNode( reader
, NULL
);
1954 ok( hr
== S_OK
, "got %08x\n", hr
);
1956 hr
= WsFindAttribute( reader
, NULL
, &ns
, TRUE
, &index
, NULL
);
1957 ok( hr
== E_INVALIDARG
, "got %08x\n", hr
);
1959 hr
= set_input( reader
, test
, sizeof(test
) - 1 );
1960 ok( hr
== S_OK
, "got %08x\n", hr
);
1962 hr
= WsReadNode( reader
, NULL
);
1963 ok( hr
== S_OK
, "got %08x\n", hr
);
1966 hr
= WsFindAttribute( reader
, &localname
, &ns
, TRUE
, &index
, NULL
);
1967 ok( hr
== S_OK
, "got %08x\n", hr
);
1968 ok( !index
, "got %u\n", index
);
1971 hr
= WsFindAttribute( reader
, &localname2
, &ns
, TRUE
, &index
, NULL
);
1972 ok( hr
== S_OK
, "got %08x\n", hr
);
1973 ok( index
== 1, "got %u\n", index
);
1975 hr
= WsReadNode( reader
, NULL
);
1976 ok( hr
== S_OK
, "got %08x\n", hr
);
1979 hr
= WsFindAttribute( reader
, &localname
, &ns
, TRUE
, &index
, NULL
);
1980 ok( hr
== WS_E_INVALID_OPERATION
, "got %08x\n", hr
);
1981 ok( index
== 0xdeadbeef, "got %u\n", index
);
1983 hr
= set_input( reader
, test
, sizeof(test
) - 1 );
1984 ok( hr
== S_OK
, "got %08x\n", hr
);
1986 hr
= WsReadNode( reader
, NULL
);
1987 ok( hr
== S_OK
, "got %08x\n", hr
);
1990 hr
= WsFindAttribute( reader
, &localname3
, &ns
, TRUE
, &index
, NULL
);
1991 ok( hr
== WS_E_INVALID_FORMAT
, "got %08x\n", hr
);
1992 ok( index
== 0xdeadbeef, "got %u\n", index
);
1994 hr
= set_input( reader
, test
, sizeof(test
) - 1 );
1995 ok( hr
== S_OK
, "got %08x\n", hr
);
1997 hr
= WsReadNode( reader
, NULL
);
1998 ok( hr
== S_OK
, "got %08x\n", hr
);
2001 hr
= WsFindAttribute( reader
, &localname3
, &ns
, FALSE
, &index
, NULL
);
2002 ok( hr
== S_FALSE
, "got %08x\n", hr
);
2003 ok( index
== ~0u, "got %u\n", index
);
2005 WsFreeReader( reader
);
2010 test_WsCreateError();
2011 test_WsCreateHeap();
2012 test_WsCreateReader();
2014 test_WsSetInputToBuffer();
2015 test_WsFillReader();
2016 test_WsReadToStartElement();
2017 test_WsReadStartElement();
2018 test_WsReadEndElement();
2021 test_WsGetXmlAttribute();
2022 test_WsXmlStringEquals();
2024 test_WsMoveReader();
2025 test_simple_struct_type();
2027 test_WsFindAttribute();