projects / reactos.git / blob
? search:


54138e95d7b7a5b52fcfc39a627864e1a3ff96e0
[reactos.git] / rostests / winetests / xmllite / reader.c
1 /*
2 * IXmlReader tests
3 *
4 * Copyright 2010, 2012-2013 Nikolay Sivov
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19 */
20
21 #define WIN32_NO_STATUS
22 #define _INC_WINDOWS
23 #define COM_NO_WINDOWS_H
24
25 #define COBJMACROS
26 #define CONST_VTABLE
27
28 //#include <stdarg.h>
29 #include <stdio.h>
30
31 #include <windef.h>
32 #include <winbase.h>
33 #include <winnls.h>
34 #include <initguid.h>
35 #include <ole2.h>
36 #include <xmllite.h>
37 #include <wine/test.h>
38
39 DEFINE_GUID(IID_IXmlReaderInput, 0x0b3ccc9b, 0x9214, 0x428b, 0xa2, 0xae, 0xef, 0x3a, 0xa8, 0x71, 0xaf, 0xda);
40
41 static HRESULT (WINAPI *pCreateXmlReader)(REFIID riid, void **ppvObject, IMalloc *pMalloc);
42 static HRESULT (WINAPI *pCreateXmlReaderInputWithEncodingName)(IUnknown *stream,
43 IMalloc *pMalloc,
44 LPCWSTR encoding,
45 BOOL hint,
46 LPCWSTR base_uri,
47 IXmlReaderInput **ppInput);
48
49 static WCHAR *a2w(const char *str)
50 {
51 int len = MultiByteToWideChar(CP_ACP, 0, str, -1, NULL, 0);
52 WCHAR *ret = HeapAlloc(GetProcessHeap(), 0, len*sizeof(WCHAR));
53 MultiByteToWideChar(CP_ACP, 0, str, -1, ret, len);
54 return ret;
55 }
56
57 static void free_str(WCHAR *str)
58 {
59 HeapFree(GetProcessHeap(), 0, str);
60 }
61
62 static const char xmldecl_full[] = "\xef\xbb\xbf<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>\n";
63 static const char xmldecl_short[] = "<?xml version=\"1.0\"?><RegistrationInfo/>";
64
65 static IStream *create_stream_on_data(const char *data, int size)
66 {
67 IStream *stream = NULL;
68 HGLOBAL hglobal;
69 void *ptr;
70 HRESULT hr;
71
72 hglobal = GlobalAlloc(GHND, size);
73 ptr = GlobalLock(hglobal);
74
75 memcpy(ptr, data, size);
76
77 hr = CreateStreamOnHGlobal(hglobal, TRUE, &stream);
78 ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
79 ok(stream != NULL, "Expected non-NULL stream\n");
80
81 GlobalUnlock(hglobal);
82
83 return stream;
84 }
85
86 static void ok_pos_(IXmlReader *reader, int line, int pos, int line_broken,
87 int pos_broken, BOOL todo, int _line_)
88 {
89 UINT l, p;
90 HRESULT hr;
91 BOOL broken_state;
92
93 hr = IXmlReader_GetLineNumber(reader, &l);
94 ok_(__FILE__, _line_)(hr == S_OK, "Expected S_OK, got %08x\n", hr);
95 hr = IXmlReader_GetLinePosition(reader, &p);
96 ok_(__FILE__, _line_)(hr == S_OK, "Expected S_OK, got %08x\n", hr);
97
98 if (line_broken == -1 && pos_broken == -1)
99 broken_state = FALSE;
100 else
101 broken_state = broken((line_broken == -1 ? line : line_broken) == l &&
102 (pos_broken == -1 ? pos : pos_broken) == p);
103
104 if (todo)
105 todo_wine
106 ok_(__FILE__, _line_)((l == line && pos == p) || broken_state,
107 "Expected (%d,%d), got (%d,%d)\n", line, pos, l, p);
108 else
109 {
110 ok_(__FILE__, _line_)((l == line && pos == p) || broken_state,
111 "Expected (%d,%d), got (%d,%d)\n", line, pos, l, p);
112 }
113 }
114 #define ok_pos(reader, l, p, l_brk, p_brk, todo) ok_pos_(reader, l, p, l_brk, p_brk, todo, __LINE__)
115
116 typedef struct input_iids_t {
117 IID iids[10];
118 int count;
119 } input_iids_t;
120
121 static const IID *setinput_full[] = {
122 &IID_IXmlReaderInput,
123 &IID_IStream,
124 &IID_ISequentialStream,
125 NULL
126 };
127
128 /* this applies to early xmllite versions */
129 static const IID *setinput_full_old[] = {
130 &IID_IXmlReaderInput,
131 &IID_ISequentialStream,
132 &IID_IStream,
133 NULL
134 };
135
136 /* after ::SetInput(IXmlReaderInput*) */
137 static const IID *setinput_readerinput[] = {
138 &IID_IStream,
139 &IID_ISequentialStream,
140 NULL
141 };
142
143 static const IID *empty_seq[] = {
144 NULL
145 };
146
147 static input_iids_t input_iids;
148
149 static void ok_iids_(const input_iids_t *iids, const IID **expected, const IID **exp_broken, BOOL todo, int line)
150 {
151 int i = 0, size = 0;
152
153 while (expected[i++]) size++;
154
155 if (todo) {
156 todo_wine
157 ok_(__FILE__, line)(iids->count == size, "Sequence size mismatch (%d), got (%d)\n", size, iids->count);
158 }
159 else
160 ok_(__FILE__, line)(iids->count == size, "Sequence size mismatch (%d), got (%d)\n", size, iids->count);
161
162 if (iids->count != size) return;
163
164 for (i = 0; i < size; i++) {
165 ok_(__FILE__, line)(IsEqualGUID(&iids->iids[i], expected[i]) ||
166 (exp_broken ? broken(IsEqualGUID(&iids->iids[i], exp_broken[i])) : FALSE),
167 "Wrong IID(%d), got %s\n", i, wine_dbgstr_guid(&iids->iids[i]));
168 }
169 }
170 #define ok_iids(got, exp, brk, todo) ok_iids_(got, exp, brk, todo, __LINE__)
171
172 static const char *state_to_str(XmlReadState state)
173 {
174 static const char* state_names[] = {
175 "XmlReadState_Initial",
176 "XmlReadState_Interactive",
177 "XmlReadState_Error",
178 "XmlReadState_EndOfFile",
179 "XmlReadState_Closed"
180 };
181
182 static const char unknown[] = "unknown";
183
184 switch (state)
185 {
186 case XmlReadState_Initial:
187 case XmlReadState_Interactive:
188 case XmlReadState_Error:
189 case XmlReadState_EndOfFile:
190 case XmlReadState_Closed:
191 return state_names[state];
192 default:
193 return unknown;
194 }
195 }
196
197 static const char *type_to_str(XmlNodeType type)
198 {
199 static const char* type_names[] = {
200 "XmlNodeType_None",
201 "XmlNodeType_Element",
202 "XmlNodeType_Attribute",
203 "XmlNodeType_Text",
204 "XmlNodeType_CDATA",
205 "", "",
206 "XmlNodeType_ProcessingInstruction",
207 "XmlNodeType_Comment",
208 "",
209 "XmlNodeType_DocumentType",
210 "", "",
211 "XmlNodeType_Whitespace",
212 "",
213 "XmlNodeType_EndElement",
214 "",
215 "XmlNodeType_XmlDeclaration"
216 };
217
218 static const char unknown[] = "unknown";
219
220 switch (type)
221 {
222 case XmlNodeType_None:
223 case XmlNodeType_Element:
224 case XmlNodeType_Attribute:
225 case XmlNodeType_Text:
226 case XmlNodeType_CDATA:
227 case XmlNodeType_ProcessingInstruction:
228 case XmlNodeType_Comment:
229 case XmlNodeType_DocumentType:
230 case XmlNodeType_Whitespace:
231 case XmlNodeType_EndElement:
232 case XmlNodeType_XmlDeclaration:
233 return type_names[type];
234 default:
235 return unknown;
236 }
237 }
238
239 static void test_read_state_(IXmlReader *reader, XmlReadState expected,
240 XmlReadState exp_broken, BOOL todo, int line)
241 {
242 LONG_PTR state;
243 HRESULT hr;
244 BOOL broken_state;
245
246 state = -1; /* invalid value */
247 hr = IXmlReader_GetProperty(reader, XmlReaderProperty_ReadState, &state);
248 ok_(__FILE__, line)(hr == S_OK, "Expected S_OK, got %08x\n", hr);
249
250 if (exp_broken == -1)
251 broken_state = FALSE;
252 else
253 broken_state = broken(exp_broken == state);
254
255 if (todo)
256 {
257 todo_wine
258 ok_(__FILE__, line)(state == expected || broken_state, "Expected (%s), got (%s)\n",
259 state_to_str(expected), state_to_str(state));
260 }
261 else
262 ok_(__FILE__, line)(state == expected || broken_state, "Expected (%s), got (%s)\n",
263 state_to_str(expected), state_to_str(state));
264 }
265
266 #define test_read_state(reader, exp, brk, todo) test_read_state_(reader, exp, brk, todo, __LINE__)
267
268 typedef struct _testinput
269 {
270 IUnknown IUnknown_iface;
271 LONG ref;
272 } testinput;
273
274 static inline testinput *impl_from_IUnknown(IUnknown *iface)
275 {
276 return CONTAINING_RECORD(iface, testinput, IUnknown_iface);
277 }
278
279 static HRESULT WINAPI testinput_QueryInterface(IUnknown *iface, REFIID riid, void** ppvObj)
280 {
281 if (IsEqualGUID( riid, &IID_IUnknown ))
282 {
283 *ppvObj = iface;
284 IUnknown_AddRef(iface);
285 return S_OK;
286 }
287
288 input_iids.iids[input_iids.count++] = *riid;
289
290 *ppvObj = NULL;
291
292 return E_NOINTERFACE;
293 }
294
295 static ULONG WINAPI testinput_AddRef(IUnknown *iface)
296 {
297 testinput *This = impl_from_IUnknown(iface);
298 return InterlockedIncrement(&This->ref);
299 }
300
301 static ULONG WINAPI testinput_Release(IUnknown *iface)
302 {
303 testinput *This = impl_from_IUnknown(iface);
304 LONG ref;
305
306 ref = InterlockedDecrement(&This->ref);
307 if (ref == 0)
308 {
309 HeapFree(GetProcessHeap(), 0, This);
310 }
311
312 return ref;
313 }
314
315 static const struct IUnknownVtbl testinput_vtbl =
316 {
317 testinput_QueryInterface,
318 testinput_AddRef,
319 testinput_Release
320 };
321
322 static HRESULT testinput_createinstance(void **ppObj)
323 {
324 testinput *input;
325
326 input = HeapAlloc(GetProcessHeap(), 0, sizeof (*input));
327 if(!input) return E_OUTOFMEMORY;
328
329 input->IUnknown_iface.lpVtbl = &testinput_vtbl;
330 input->ref = 1;
331
332 *ppObj = &input->IUnknown_iface;
333
334 return S_OK;
335 }
336
337 static HRESULT WINAPI teststream_QueryInterface(ISequentialStream *iface, REFIID riid, void **obj)
338 {
339 if (IsEqualIID(riid, &IID_IUnknown) || IsEqualIID(riid, &IID_ISequentialStream))
340 {
341 *obj = iface;
342 return S_OK;
343 }
344
345 *obj = NULL;
346 return E_NOINTERFACE;
347 }
348
349 static ULONG WINAPI teststream_AddRef(ISequentialStream *iface)
350 {
351 return 2;
352 }
353
354 static ULONG WINAPI teststream_Release(ISequentialStream *iface)
355 {
356 return 1;
357 }
358
359 static int stream_readcall;
360
361 static HRESULT WINAPI teststream_Read(ISequentialStream *iface, void *pv, ULONG cb, ULONG *pread)
362 {
363 static const char xml[] = "<!-- comment -->";
364
365 if (stream_readcall++)
366 {
367 *pread = 0;
368 return E_PENDING;
369 }
370
371 *pread = sizeof(xml) / 2;
372 memcpy(pv, xml, *pread);
373 return S_OK;
374 }
375
376 static HRESULT WINAPI teststream_Write(ISequentialStream *iface, const void *pv, ULONG cb, ULONG *written)
377 {
378 ok(0, "unexpected call\n");
379 return E_NOTIMPL;
380 }
381
382 static const ISequentialStreamVtbl teststreamvtbl =
383 {
384 teststream_QueryInterface,
385 teststream_AddRef,
386 teststream_Release,
387 teststream_Read,
388 teststream_Write
389 };
390
391 static BOOL init_pointers(void)
392 {
393 /* don't free module here, it's to be unloaded on exit */
394 HMODULE mod = LoadLibraryA("xmllite.dll");
395
396 if (!mod)
397 {
398 win_skip("xmllite library not available\n");
399 return FALSE;
400 }
401
402 #define MAKEFUNC(f) if (!(p##f = (void*)GetProcAddress(mod, #f))) return FALSE;
403 MAKEFUNC(CreateXmlReader);
404 MAKEFUNC(CreateXmlReaderInputWithEncodingName);
405 #undef MAKEFUNC
406
407 return TRUE;
408 }
409
410 static void test_reader_create(void)
411 {
412 HRESULT hr;
413 IXmlReader *reader;
414 IUnknown *input;
415 DtdProcessing dtd;
416 XmlNodeType nodetype;
417
418 /* crashes native */
419 if (0)
420 {
421 pCreateXmlReader(&IID_IXmlReader, NULL, NULL);
422 pCreateXmlReader(NULL, (void**)&reader, NULL);
423 }
424
425 hr = pCreateXmlReader(&IID_IXmlReader, (void**)&reader, NULL);
426 ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
427
428 test_read_state(reader, XmlReadState_Closed, -1, FALSE);
429
430 nodetype = XmlNodeType_Element;
431 hr = IXmlReader_GetNodeType(reader, &nodetype);
432 ok(hr == S_FALSE, "got %08x\n", hr);
433 ok(nodetype == XmlNodeType_None, "got %d\n", nodetype);
434
435 dtd = 2;
436 hr = IXmlReader_GetProperty(reader, XmlReaderProperty_DtdProcessing, (LONG_PTR*)&dtd);
437 ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
438 ok(dtd == DtdProcessing_Prohibit, "got %d\n", dtd);
439
440 dtd = 2;
441 hr = IXmlReader_SetProperty(reader, XmlReaderProperty_DtdProcessing, dtd);
442 ok(hr == E_INVALIDARG, "Expected E_INVALIDARG, got %08x\n", hr);
443
444 hr = IXmlReader_SetProperty(reader, XmlReaderProperty_DtdProcessing, -1);
445 ok(hr == E_INVALIDARG, "Expected E_INVALIDARG, got %08x\n", hr);
446
447 /* Null input pointer, releases previous input */
448 hr = IXmlReader_SetInput(reader, NULL);
449 ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
450
451 test_read_state(reader, XmlReadState_Initial, XmlReadState_Closed, FALSE);
452
453 /* test input interface selection sequence */
454 hr = testinput_createinstance((void**)&input);
455 ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
456
457 if (hr == S_OK)
458 {
459 input_iids.count = 0;
460 hr = IXmlReader_SetInput(reader, input);
461 ok(hr == E_NOINTERFACE, "Expected E_NOINTERFACE, got %08x\n", hr);
462 ok_iids(&input_iids, setinput_full, setinput_full_old, FALSE);
463 IUnknown_Release(input);
464 }
465 IXmlReader_Release(reader);
466 }
467
468 static void test_readerinput(void)
469 {
470 IXmlReaderInput *reader_input;
471 IXmlReader *reader, *reader2;
472 IUnknown *obj, *input;
473 IStream *stream, *stream2;
474 XmlNodeType nodetype;
475 HRESULT hr;
476 LONG ref;
477
478 hr = pCreateXmlReaderInputWithEncodingName(NULL, NULL, NULL, FALSE, NULL, NULL);
479 ok(hr == E_INVALIDARG, "Expected E_INVALIDARG, got %08x\n", hr);
480 hr = pCreateXmlReaderInputWithEncodingName(NULL, NULL, NULL, FALSE, NULL, &reader_input);
481 ok(hr == E_INVALIDARG, "Expected E_INVALIDARG, got %08x\n", hr);
482
483 hr = CreateStreamOnHGlobal(NULL, TRUE, &stream);
484 ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
485
486 ref = IStream_AddRef(stream);
487 ok(ref == 2, "Expected 2, got %d\n", ref);
488 IStream_Release(stream);
489 hr = pCreateXmlReaderInputWithEncodingName((IUnknown*)stream, NULL, NULL, FALSE, NULL, &reader_input);
490 ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
491
492 hr = IUnknown_QueryInterface(reader_input, &IID_IStream, (void**)&stream2);
493 ok(hr == E_NOINTERFACE, "Expected S_OK, got %08x\n", hr);
494
495 hr = IUnknown_QueryInterface(reader_input, &IID_ISequentialStream, (void**)&stream2);
496 ok(hr == E_NOINTERFACE, "Expected S_OK, got %08x\n", hr);
497
498 /* IXmlReaderInput grabs a stream reference */
499 ref = IStream_AddRef(stream);
500 ok(ref == 3, "Expected 3, got %d\n", ref);
501 IStream_Release(stream);
502
503 /* try ::SetInput() with valid IXmlReaderInput */
504 hr = pCreateXmlReader(&IID_IXmlReader, (void**)&reader, NULL);
505 ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
506
507 ref = IUnknown_AddRef(reader_input);
508 ok(ref == 2, "Expected 2, got %d\n", ref);
509 IUnknown_Release(reader_input);
510
511 hr = IXmlReader_SetInput(reader, reader_input);
512 ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
513
514 test_read_state(reader, XmlReadState_Initial, -1, FALSE);
515
516 nodetype = XmlNodeType_Element;
517 hr = IXmlReader_GetNodeType(reader, &nodetype);
518 ok(hr == S_OK, "got %08x\n", hr);
519 ok(nodetype == XmlNodeType_None, "got %d\n", nodetype);
520
521 /* IXmlReader grabs a IXmlReaderInput reference */
522 ref = IUnknown_AddRef(reader_input);
523 ok(ref == 3, "Expected 3, got %d\n", ref);
524 IUnknown_Release(reader_input);
525
526 ref = IStream_AddRef(stream);
527 ok(ref == 4, "Expected 4, got %d\n", ref);
528 IStream_Release(stream);
529
530 /* reset input and check state */
531 hr = IXmlReader_SetInput(reader, NULL);
532 ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
533
534 test_read_state(reader, XmlReadState_Initial, XmlReadState_Closed, FALSE);
535
536 IXmlReader_Release(reader);
537
538 ref = IStream_AddRef(stream);
539 ok(ref == 3, "Expected 3, got %d\n", ref);
540 IStream_Release(stream);
541
542 ref = IUnknown_AddRef(reader_input);
543 ok(ref == 2, "Expected 2, got %d\n", ref);
544 IUnknown_Release(reader_input);
545
546 /* IID_IXmlReaderInput */
547 /* it returns a kind of private undocumented vtable incompatible with IUnknown,
548 so it's not a COM interface actually.
549 Such query will be used only to check if input is really IXmlReaderInput */
550 obj = (IUnknown*)0xdeadbeef;
551 hr = IUnknown_QueryInterface(reader_input, &IID_IXmlReaderInput, (void**)&obj);
552 ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
553 ref = IUnknown_AddRef(reader_input);
554 ok(ref == 3, "Expected 3, got %d\n", ref);
555 IUnknown_Release(reader_input);
556
557 IUnknown_Release(reader_input);
558 IUnknown_Release(reader_input);
559 IStream_Release(stream);
560
561 /* test input interface selection sequence */
562 input = NULL;
563 hr = testinput_createinstance((void**)&input);
564 ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
565
566 input_iids.count = 0;
567 ref = IUnknown_AddRef(input);
568 ok(ref == 2, "Expected 2, got %d\n", ref);
569 IUnknown_Release(input);
570 hr = pCreateXmlReaderInputWithEncodingName(input, NULL, NULL, FALSE, NULL, &reader_input);
571 ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
572 ok_iids(&input_iids, empty_seq, NULL, FALSE);
573 /* IXmlReaderInput stores stream interface as IUnknown */
574 ref = IUnknown_AddRef(input);
575 ok(ref == 3, "Expected 3, got %d\n", ref);
576 IUnknown_Release(input);
577
578 hr = pCreateXmlReader(&IID_IXmlReader, (LPVOID*)&reader, NULL);
579 ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
580
581 input_iids.count = 0;
582 ref = IUnknown_AddRef(reader_input);
583 ok(ref == 2, "Expected 2, got %d\n", ref);
584 IUnknown_Release(reader_input);
585 ref = IUnknown_AddRef(input);
586 ok(ref == 3, "Expected 3, got %d\n", ref);
587 IUnknown_Release(input);
588 hr = IXmlReader_SetInput(reader, reader_input);
589 ok(hr == E_NOINTERFACE, "Expected E_NOINTERFACE, got %08x\n", hr);
590 ok_iids(&input_iids, setinput_readerinput, NULL, FALSE);
591
592 test_read_state(reader, XmlReadState_Closed, -1, FALSE);
593
594 ref = IUnknown_AddRef(input);
595 ok(ref == 3, "Expected 3, got %d\n", ref);
596 IUnknown_Release(input);
597
598 ref = IUnknown_AddRef(reader_input);
599 ok(ref == 3 || broken(ref == 2) /* versions 1.0.x and 1.1.x - XP, Vista */,
600 "Expected 3, got %d\n", ref);
601 IUnknown_Release(reader_input);
602 /* repeat another time, no check or caching here */
603 input_iids.count = 0;
604 hr = IXmlReader_SetInput(reader, reader_input);
605 ok(hr == E_NOINTERFACE, "Expected E_NOINTERFACE, got %08x\n", hr);
606 ok_iids(&input_iids, setinput_readerinput, NULL, FALSE);
607
608 /* another reader */
609 hr = pCreateXmlReader(&IID_IXmlReader, (LPVOID*)&reader2, NULL);
610 ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
611
612 /* resolving from IXmlReaderInput to IStream/ISequentialStream is done at
613 ::SetInput() level, each time it's called */
614 input_iids.count = 0;
615 hr = IXmlReader_SetInput(reader2, reader_input);
616 ok(hr == E_NOINTERFACE, "Expected E_NOINTERFACE, got %08x\n", hr);
617 ok_iids(&input_iids, setinput_readerinput, NULL, FALSE);
618
619 IXmlReader_Release(reader2);
620 IXmlReader_Release(reader);
621
622 IUnknown_Release(reader_input);
623 IUnknown_Release(input);
624 }
625
626 static void test_reader_state(void)
627 {
628 IXmlReader *reader;
629 XmlNodeType nodetype;
630 HRESULT hr;
631
632 hr = pCreateXmlReader(&IID_IXmlReader, (void**)&reader, NULL);
633 ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
634
635 /* invalid arguments */
636 hr = IXmlReader_GetProperty(reader, XmlReaderProperty_ReadState, NULL);
637 ok(hr == E_INVALIDARG, "Expected E_INVALIDARG, got %08x\n", hr);
638
639 /* attempt to read on closed reader */
640 test_read_state(reader, XmlReadState_Closed, -1, FALSE);
641 if (0)
642 {
643 /* newer versions crash here, probably cause no input was set */
644 hr = IXmlReader_Read(reader, &nodetype);
645 ok(hr == S_FALSE, "got %08x\n", hr);
646 }
647 IXmlReader_Release(reader);
648 }
649
650 static void test_read_xmldeclaration(void)
651 {
652 static const WCHAR xmlW[] = {'x','m','l',0};
653 static const WCHAR RegistrationInfoW[] = {'R','e','g','i','s','t','r','a','t','i','o','n','I','n','f','o',0};
654 static const struct
655 {
656 WCHAR name[12];
657 WCHAR val[12];
658 } name_val[] =
659 {
660 { {'v','e','r','s','i','o','n',0}, {'1','.','0',0} },
661 { {'e','n','c','o','d','i','n','g',0}, {'U','T','F','-','8',0} },
662 { {'s','t','a','n','d','a','l','o','n','e',0}, {'y','e','s',0} }
663 };
664 IXmlReader *reader;
665 IStream *stream;
666 HRESULT hr;
667 XmlNodeType type;
668 UINT count = 0, len, i;
669 BOOL ret;
670 const WCHAR *val;
671
672 hr = pCreateXmlReader(&IID_IXmlReader, (LPVOID*)&reader, NULL);
673 ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
674
675 /* position methods with Null args */
676 hr = IXmlReader_GetLineNumber(reader, NULL);
677 ok(hr == E_INVALIDARG, "Expected E_INVALIDARG, got %08x\n", hr);
678
679 hr = IXmlReader_GetLinePosition(reader, NULL);
680 ok(hr == E_INVALIDARG, "Expected E_INVALIDARG, got %08x\n", hr);
681
682 stream = create_stream_on_data(xmldecl_full, sizeof(xmldecl_full));
683
684 hr = IXmlReader_SetInput(reader, (IUnknown*)stream);
685 ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
686
687 hr = IXmlReader_GetAttributeCount(reader, &count);
688 ok(hr == S_OK, "got %08x\n", hr);
689 ok(count == 0, "got %d\n", count);
690
691 /* try to move without attributes */
692 hr = IXmlReader_MoveToElement(reader);
693 ok(hr == S_FALSE, "got %08x\n", hr);
694
695 hr = IXmlReader_MoveToNextAttribute(reader);
696 ok(hr == S_FALSE, "got %08x\n", hr);
697
698 hr = IXmlReader_MoveToFirstAttribute(reader);
699 ok(hr == S_FALSE, "got %08x\n", hr);
700
701 ok_pos(reader, 0, 0, -1, -1, FALSE);
702
703 type = -1;
704 hr = IXmlReader_Read(reader, &type);
705 ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
706 ok(type == XmlNodeType_XmlDeclaration,
707 "Expected XmlNodeType_XmlDeclaration, got %s\n", type_to_str(type));
708 /* new version 1.2.x and 1.3.x properly update position for <?xml ?> */
709 ok_pos(reader, 1, 3, -1, 55, TRUE);
710 test_read_state(reader, XmlReadState_Interactive, -1, FALSE);
711
712 hr = IXmlReader_GetValue(reader, &val, NULL);
713 ok(hr == S_OK, "got %08x\n", hr);
714 ok(*val == 0, "got %s\n", wine_dbgstr_w(val));
715
716 /* check attributes */
717 hr = IXmlReader_MoveToNextAttribute(reader);
718 ok(hr == S_OK, "got %08x\n", hr);
719
720 type = XmlNodeType_None;
721 hr = IXmlReader_GetNodeType(reader, &type);
722 ok(hr == S_OK, "got %08x\n", hr);
723 ok(type == XmlNodeType_Attribute, "got %d\n", type);
724
725 ok_pos(reader, 1, 7, -1, 55, TRUE);
726
727 /* try to move from last attribute */
728 hr = IXmlReader_MoveToNextAttribute(reader);
729 ok(hr == S_OK, "got %08x\n", hr);
730 hr = IXmlReader_MoveToNextAttribute(reader);
731 ok(hr == S_OK, "got %08x\n", hr);
732 hr = IXmlReader_MoveToNextAttribute(reader);
733 ok(hr == S_FALSE, "got %08x\n", hr);
734
735 type = XmlNodeType_None;
736 hr = IXmlReader_GetNodeType(reader, &type);
737 ok(hr == S_OK, "got %08x\n", hr);
738 ok(type == XmlNodeType_Attribute, "got %d\n", type);
739
740 hr = IXmlReader_MoveToFirstAttribute(reader);
741 ok(hr == S_OK, "got %08x\n", hr);
742 ok_pos(reader, 1, 7, -1, 55, TRUE);
743
744 hr = IXmlReader_GetAttributeCount(reader, NULL);
745 ok(hr == E_INVALIDARG, "got %08x\n", hr);
746
747 hr = IXmlReader_GetAttributeCount(reader, &count);
748 ok(hr == S_OK, "got %08x\n", hr);
749 ok(count == 3, "Expected 3, got %d\n", count);
750
751 for (i = 0; i < count; i++)
752 {
753 len = 0;
754 hr = IXmlReader_GetLocalName(reader, &val, &len);
755 ok(hr == S_OK, "got %08x\n", hr);
756 ok(len == lstrlenW(name_val[i].name), "expected %u, got %u\n", lstrlenW(name_val[i].name), len);
757 ok(!lstrcmpW(name_val[i].name, val), "expected %s, got %s\n", wine_dbgstr_w(name_val[i].name), wine_dbgstr_w(val));
758
759 len = 0;
760 hr = IXmlReader_GetValue(reader, &val, &len);
761 ok(hr == S_OK, "got %08x\n", hr);
762 ok(len == lstrlenW(name_val[i].val), "expected %u, got %u\n", lstrlenW(name_val[i].val), len);
763 ok(!lstrcmpW(name_val[i].val, val), "expected %s, got %s\n", wine_dbgstr_w(name_val[i].val), wine_dbgstr_w(val));
764
765 hr = IXmlReader_MoveToNextAttribute(reader);
766 ok(hr == ((i < count - 1) ? S_OK : S_FALSE), "got %08x\n", hr);
767 }
768
769 hr = IXmlReader_GetDepth(reader, &count);
770 ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
771 ok(count == 1, "Expected 1, got %d\n", count);
772
773 hr = IXmlReader_MoveToElement(reader);
774 ok(hr == S_OK, "got %08x\n", hr);
775
776 type = XmlNodeType_None;
777 hr = IXmlReader_GetNodeType(reader, &type);
778 ok(hr == S_OK, "got %08x\n", hr);
779 ok(type == XmlNodeType_XmlDeclaration, "got %d\n", type);
780
781 type = XmlNodeType_XmlDeclaration;
782 hr = IXmlReader_Read(reader, &type);
783 /* newer versions return syntax error here cause document is incomplete,
784 it makes more sense than invalid char error */
785 todo_wine {
786 ok(hr == WC_E_SYNTAX || broken(hr == WC_E_XMLCHARACTER), "got 0x%08x\n", hr);
787 ok(type == XmlNodeType_None, "got %d\n", type);
788 }
789 IStream_Release(stream);
790
791 /* test short variant */
792 stream = create_stream_on_data(xmldecl_short, sizeof(xmldecl_short));
793
794 hr = IXmlReader_SetInput(reader, (IUnknown *)stream);
795 ok(hr == S_OK, "expected S_OK, got %08x\n", hr);
796
797 type = -1;
798 hr = IXmlReader_Read(reader, &type);
799 ok(hr == S_OK, "expected S_OK, got %08x\n", hr);
800 ok(type == XmlNodeType_XmlDeclaration, "expected XmlDeclaration, got %s\n", type_to_str(type));
801 ok_pos(reader, 1, 3, 1, 21, TRUE);
802 test_read_state(reader, XmlReadState_Interactive, -1, TRUE);
803
804 hr = IXmlReader_GetAttributeCount(reader, &count);
805 ok(hr == S_OK, "expected S_OK, got %08x\n", hr);
806 ok(count == 1, "expected 1, got %d\n", count);
807
808 ret = IXmlReader_IsEmptyElement(reader);
809 ok(!ret, "element should not be empty\n");
810
811 hr = IXmlReader_GetValue(reader, &val, NULL);
812 ok(hr == S_OK, "expected S_OK, got %08x\n", hr);
813 ok(*val == 0, "got %s\n", wine_dbgstr_w(val));
814
815 hr = IXmlReader_GetLocalName(reader, &val, NULL);
816 ok(hr == S_OK, "expected S_OK, got %08x\n", hr);
817 todo_wine
818 ok(!lstrcmpW(val, xmlW), "got %s\n", wine_dbgstr_w(val));
819
820 /* check attributes */
821 hr = IXmlReader_MoveToNextAttribute(reader);
822 ok(hr == S_OK, "expected S_OK, got %08x\n", hr);
823
824 type = -1;
825 hr = IXmlReader_GetNodeType(reader, &type);
826 ok(hr == S_OK, "expected S_OK, got %08x\n", hr);
827 ok(type == XmlNodeType_Attribute, "got %d\n", type);
828 ok_pos(reader, 1, 7, 1, 21, TRUE);
829
830 /* try to move from last attribute */
831 hr = IXmlReader_MoveToNextAttribute(reader);
832 ok(hr == S_FALSE, "expected S_FALSE, got %08x\n", hr);
833
834 type = -1;
835 hr = IXmlReader_Read(reader, &type);
836 ok(hr == S_OK, "expected S_OK, got %08x\n", hr);
837 ok(type == XmlNodeType_Element, "expected Element, got %s\n", type_to_str(type));
838 ok_pos(reader, 1, 23, 1, 40, TRUE);
839 test_read_state(reader, XmlReadState_Interactive, -1, TRUE);
840
841 hr = IXmlReader_GetAttributeCount(reader, &count);
842 ok(hr == S_OK, "expected S_OK, got %08x\n", hr);
843 ok(count == 0, "expected 0, got %d\n", count);
844
845 ret = IXmlReader_IsEmptyElement(reader);
846 ok(ret, "element should be empty\n");
847
848 hr = IXmlReader_GetValue(reader, &val, NULL);
849 ok(hr == S_OK, "expected S_OK, got %08x\n", hr);
850 todo_wine
851 ok(*val == 0, "got %s\n", wine_dbgstr_w(val));
852
853 hr = IXmlReader_GetLocalName(reader, &val, NULL);
854 ok(hr == S_OK, "expected S_OK, got %08x\n", hr);
855 ok(!lstrcmpW(val, RegistrationInfoW), "got %s\n", wine_dbgstr_w(val));
856
857 type = -1;
858 hr = IXmlReader_Read(reader, &type);
859 todo_wine
860 ok(hr == WC_E_SYNTAX || hr == WC_E_XMLCHARACTER /* XP */, "expected WC_E_SYNTAX, got %08x\n", hr);
861 todo_wine
862 ok(type == XmlNodeType_None, "expected None, got %s\n", type_to_str(type));
863 ok_pos(reader, 1, 41, -1, -1, TRUE);
864 test_read_state(reader, XmlReadState_Error, -1, TRUE);
865
866 IStream_Release(stream);
867 IXmlReader_Release(reader);
868 }
869
870 struct test_entry {
871 const char *xml;
872 const char *name;
873 const char *value;
874 HRESULT hr;
875 HRESULT hr_broken; /* this is set to older version results */
876 BOOL todo;
877 };
878
879 static struct test_entry comment_tests[] = {
880 { "<!-- comment -->", "", " comment ", S_OK },
881 { "<!-- - comment-->", "", " - comment", S_OK },
882 { "<!-- -- comment-->", NULL, NULL, WC_E_COMMENT, WC_E_GREATERTHAN },
883 { "<!-- -- comment--->", NULL, NULL, WC_E_COMMENT, WC_E_GREATERTHAN },
884 { NULL }
885 };
886
887 static void test_read_comment(void)
888 {
889 struct test_entry *test = comment_tests;
890 IXmlReader *reader;
891 HRESULT hr;
892
893 hr = pCreateXmlReader(&IID_IXmlReader, (void**)&reader, NULL);
894 ok(hr == S_OK, "S_OK, got %08x\n", hr);
895
896 while (test->xml)
897 {
898 XmlNodeType type;
899 IStream *stream;
900
901 stream = create_stream_on_data(test->xml, strlen(test->xml)+1);
902 hr = IXmlReader_SetInput(reader, (IUnknown*)stream);
903 ok(hr == S_OK, "got %08x\n", hr);
904
905 type = XmlNodeType_None;
906 hr = IXmlReader_Read(reader, &type);
907 if (test->hr_broken)
908 ok(hr == test->hr || broken(hr == test->hr_broken), "got %08x for %s\n", hr, test->xml);
909 else
910 ok(hr == test->hr, "got %08x for %s\n", hr, test->xml);
911 if (hr == S_OK)
912 {
913 const WCHAR *str;
914 WCHAR *str_exp;
915 UINT len;
916
917 ok(type == XmlNodeType_Comment, "got %d for %s\n", type, test->xml);
918
919 len = 1;
920 str = NULL;
921 hr = IXmlReader_GetLocalName(reader, &str, &len);
922 ok(hr == S_OK, "got 0x%08x\n", hr);
923 ok(len == strlen(test->name), "got %u\n", len);
924 str_exp = a2w(test->name);
925 ok(!lstrcmpW(str, str_exp), "got %s\n", wine_dbgstr_w(str));
926 free_str(str_exp);
927
928 len = 1;
929 str = NULL;
930 hr = IXmlReader_GetQualifiedName(reader, &str, &len);
931 ok(hr == S_OK, "got 0x%08x\n", hr);
932 ok(len == strlen(test->name), "got %u\n", len);
933 str_exp = a2w(test->name);
934 ok(!lstrcmpW(str, str_exp), "got %s\n", wine_dbgstr_w(str));
935 free_str(str_exp);
936
937 /* value */
938 len = 1;
939 str = NULL;
940 hr = IXmlReader_GetValue(reader, &str, &len);
941 ok(hr == S_OK, "got 0x%08x\n", hr);
942 ok(len == strlen(test->value), "got %u\n", len);
943 str_exp = a2w(test->value);
944 ok(!lstrcmpW(str, str_exp), "got %s\n", wine_dbgstr_w(str));
945 free_str(str_exp);
946 }
947
948 IStream_Release(stream);
949 test++;
950 }
951
952 IXmlReader_Release(reader);
953 }
954
955 static struct test_entry pi_tests[] = {
956 { "<?pi?>", "pi", "", S_OK },
957 { "<?pi ?>", "pi", "", S_OK },
958 { "<?pi ?>", "pi", "", S_OK },
959 { "<?pi pi data?>", "pi", "pi data", S_OK },
960 { "<?pi pi data ?>", "pi", "pi data ", S_OK },
961 { "<?pi data ?>", "pi", "data ", S_OK },
962 { "<?pi:pi?>", NULL, NULL, NC_E_NAMECOLON, WC_E_NAMECHARACTER },
963 { "<?:pi ?>", NULL, NULL, WC_E_PI, WC_E_NAMECHARACTER },
964 { "<?-pi ?>", NULL, NULL, WC_E_PI, WC_E_NAMECHARACTER },
965 { "<?xml-stylesheet ?>", "xml-stylesheet", "", S_OK },
966 { NULL }
967 };
968
969 static void test_read_pi(void)
970 {
971 struct test_entry *test = pi_tests;
972 IXmlReader *reader;
973 HRESULT hr;
974
975 hr = pCreateXmlReader(&IID_IXmlReader, (void**)&reader, NULL);
976 ok(hr == S_OK, "S_OK, got %08x\n", hr);
977
978 while (test->xml)
979 {
980 XmlNodeType type;
981 IStream *stream;
982
983 stream = create_stream_on_data(test->xml, strlen(test->xml)+1);
984 hr = IXmlReader_SetInput(reader, (IUnknown*)stream);
985 ok(hr == S_OK, "got %08x\n", hr);
986
987 type = XmlNodeType_None;
988 hr = IXmlReader_Read(reader, &type);
989 if (test->hr_broken)
990 ok(hr == test->hr || broken(hr == test->hr_broken), "got %08x for %s\n", hr, test->xml);
991 else
992 ok(hr == test->hr, "got %08x for %s\n", hr, test->xml);
993 if (hr == S_OK)
994 {
995 const WCHAR *str;
996 WCHAR *str_exp;
997 UINT len;
998
999 ok(type == XmlNodeType_ProcessingInstruction, "got %d for %s\n", type, test->xml);
1000
1001 len = 0;
1002 str = NULL;
1003 hr = IXmlReader_GetLocalName(reader, &str, &len);
1004 ok(hr == S_OK, "got 0x%08x\n", hr);
1005 ok(len == strlen(test->name), "got %u\n", len);
1006 str_exp = a2w(test->name);
1007 ok(!lstrcmpW(str, str_exp), "got %s\n", wine_dbgstr_w(str));
1008 free_str(str_exp);
1009
1010 len = 0;
1011 str = NULL;
1012 hr = IXmlReader_GetQualifiedName(reader, &str, &len);
1013 ok(hr == S_OK, "got 0x%08x\n", hr);
1014 ok(len == strlen(test->name), "got %u\n", len);
1015 str_exp = a2w(test->name);
1016 ok(!lstrcmpW(str, str_exp), "got %s\n", wine_dbgstr_w(str));
1017 free_str(str_exp);
1018
1019 /* value */
1020 len = !strlen(test->value);
1021 str = NULL;
1022 hr = IXmlReader_GetValue(reader, &str, &len);
1023 ok(hr == S_OK, "got 0x%08x\n", hr);
1024 ok(len == strlen(test->value), "got %u\n", len);
1025 str_exp = a2w(test->value);
1026 ok(!lstrcmpW(str, str_exp), "got %s\n", wine_dbgstr_w(str));
1027 free_str(str_exp);
1028 }
1029
1030 IStream_Release(stream);
1031 test++;
1032 }
1033
1034 IXmlReader_Release(reader);
1035 }
1036
1037 struct nodes_test {
1038 const char *xml;
1039 XmlNodeType types[20];
1040 };
1041
1042 static const char misc_test_xml[] =
1043 "<!-- comment1 -->"
1044 "<!-- comment2 -->"
1045 "<?pi1 pi1body ?>"
1046 "<!-- comment3 -->"
1047 " \t \r \n"
1048 "<!-- comment4 -->"
1049 "<a>"
1050 "\r\n\t"
1051 "<b/>"
1052 "text"
1053 "<!-- comment -->"
1054 "text2"
1055 "<?pi pibody ?>"
1056 "\r\n"
1057 "</a>"
1058 ;
1059
1060 static struct nodes_test misc_test = {
1061 misc_test_xml,
1062 {
1063 XmlNodeType_Comment,
1064 XmlNodeType_Comment,
1065 XmlNodeType_ProcessingInstruction,
1066 XmlNodeType_Comment,
1067 XmlNodeType_Whitespace,
1068 XmlNodeType_Comment,
1069 XmlNodeType_Element,
1070 XmlNodeType_Whitespace,
1071 XmlNodeType_Element,
1072 XmlNodeType_Text,
1073 XmlNodeType_Comment,
1074 XmlNodeType_Text,
1075 XmlNodeType_ProcessingInstruction,
1076 XmlNodeType_Whitespace,
1077 XmlNodeType_EndElement,
1078 XmlNodeType_None
1079 }
1080 };
1081
1082 static void test_read_full(void)
1083 {
1084 struct nodes_test *test = &misc_test;
1085 IXmlReader *reader;
1086 XmlNodeType type;
1087 IStream *stream;
1088 HRESULT hr;
1089 int i;
1090
1091 hr = pCreateXmlReader(&IID_IXmlReader, (void**)&reader, NULL);
1092 ok(hr == S_OK, "S_OK, got %08x\n", hr);
1093
1094 stream = create_stream_on_data(test->xml, strlen(test->xml)+1);
1095 hr = IXmlReader_SetInput(reader, (IUnknown*)stream);
1096 ok(hr == S_OK, "got %08x\n", hr);
1097
1098 i = 0;
1099 type = XmlNodeType_None;
1100 hr = IXmlReader_Read(reader, &type);
1101 while (hr == S_OK)
1102 {
1103 ok(test->types[i] != XmlNodeType_None, "%d: unexpected end of test data\n", i);
1104 if (test->types[i] == XmlNodeType_None) break;
1105 ok(type == test->types[i], "%d: got wrong type %d, expected %d\n", i, type, test->types[i]);
1106 if (type == XmlNodeType_Whitespace)
1107 {
1108 const WCHAR *ptr;
1109 UINT len = 0;
1110
1111 hr = IXmlReader_GetValue(reader, &ptr, &len);
1112 ok(hr == S_OK, "%d: GetValue failed 0x%08x\n", i, hr);
1113 ok(len > 0, "%d: wrong value length %d\n", i, len);
1114 }
1115 hr = IXmlReader_Read(reader, &type);
1116 i++;
1117 }
1118 ok(test->types[i] == XmlNodeType_None, "incomplete sequence, got %d\n", test->types[i]);
1119
1120 IStream_Release(stream);
1121 IXmlReader_Release(reader);
1122 }
1123
1124 static const char test_dtd[] =
1125 "<!DOCTYPE testdtd SYSTEM \"externalid uri\" >"
1126 "<!-- comment -->";
1127
1128 static void test_read_dtd(void)
1129 {
1130 static const WCHAR sysvalW[] = {'e','x','t','e','r','n','a','l','i','d',' ','u','r','i',0};
1131 static const WCHAR dtdnameW[] = {'t','e','s','t','d','t','d',0};
1132 static const WCHAR sysW[] = {'S','Y','S','T','E','M',0};
1133 IXmlReader *reader;
1134 const WCHAR *str;
1135 XmlNodeType type;
1136 IStream *stream;
1137 UINT len, count;
1138 HRESULT hr;
1139
1140 hr = pCreateXmlReader(&IID_IXmlReader, (void**)&reader, NULL);
1141 ok(hr == S_OK, "S_OK, got %08x\n", hr);
1142
1143 hr = IXmlReader_SetProperty(reader, XmlReaderProperty_DtdProcessing, DtdProcessing_Parse);
1144 ok(hr == S_OK, "got 0x%8x\n", hr);
1145
1146 stream = create_stream_on_data(test_dtd, sizeof(test_dtd));
1147 hr = IXmlReader_SetInput(reader, (IUnknown*)stream);
1148 ok(hr == S_OK, "got %08x\n", hr);
1149
1150 type = XmlNodeType_None;
1151 hr = IXmlReader_Read(reader, &type);
1152 ok(hr == S_OK, "got 0x%8x\n", hr);
1153 ok(type == XmlNodeType_DocumentType, "got type %d\n", type);
1154
1155 count = 0;
1156 hr = IXmlReader_GetAttributeCount(reader, &count);
1157 ok(hr == S_OK, "got %08x\n", hr);
1158 ok(count == 1, "got %d\n", count);
1159
1160 hr = IXmlReader_MoveToFirstAttribute(reader);
1161 ok(hr == S_OK, "got %08x\n", hr);
1162
1163 type = XmlNodeType_None;
1164 hr = IXmlReader_GetNodeType(reader, &type);
1165 ok(hr == S_OK, "got %08x\n", hr);
1166 ok(type == XmlNodeType_Attribute, "got %d\n", type);
1167
1168 len = 0;
1169 str = NULL;
1170 hr = IXmlReader_GetLocalName(reader, &str, &len);
1171 ok(hr == S_OK, "got 0x%08x\n", hr);
1172 ok(len == lstrlenW(sysW), "got %u\n", len);
1173 ok(!lstrcmpW(str, sysW), "got %s\n", wine_dbgstr_w(str));
1174
1175 len = 0;
1176 str = NULL;
1177 hr = IXmlReader_GetValue(reader, &str, &len);
1178 ok(hr == S_OK, "got 0x%08x\n", hr);
1179 ok(len == lstrlenW(sysvalW), "got %u\n", len);
1180 ok(!lstrcmpW(str, sysvalW), "got %s\n", wine_dbgstr_w(str));
1181
1182 hr = IXmlReader_MoveToElement(reader);
1183 ok(hr == S_OK, "got 0x%08x\n", hr);
1184
1185 len = 0;
1186 str = NULL;
1187 hr = IXmlReader_GetLocalName(reader, &str, &len);
1188 ok(hr == S_OK, "got 0x%08x\n", hr);
1189 todo_wine {
1190 ok(len == lstrlenW(dtdnameW), "got %u\n", len);
1191 ok(!lstrcmpW(str, dtdnameW), "got %s\n", wine_dbgstr_w(str));
1192 }
1193 len = 0;
1194 str = NULL;
1195 hr = IXmlReader_GetQualifiedName(reader, &str, &len);
1196 ok(hr == S_OK, "got 0x%08x\n", hr);
1197 ok(len == lstrlenW(dtdnameW), "got %u\n", len);
1198 ok(!lstrcmpW(str, dtdnameW), "got %s\n", wine_dbgstr_w(str));
1199
1200 type = XmlNodeType_None;
1201 hr = IXmlReader_Read(reader, &type);
1202 ok(hr == S_OK, "got 0x%8x\n", hr);
1203 ok(type == XmlNodeType_Comment, "got type %d\n", type);
1204
1205 IStream_Release(stream);
1206 IXmlReader_Release(reader);
1207 }
1208
1209 static struct test_entry element_tests[] = {
1210 { "<a/>", "a", "", S_OK },
1211 { "<a />", "a", "", S_OK },
1212 { "<a:b/>", "a:b", "", NC_E_UNDECLAREDPREFIX },
1213 { "<:a/>", NULL, NULL, NC_E_QNAMECHARACTER },
1214 { "< a/>", NULL, NULL, NC_E_QNAMECHARACTER },
1215 { "<a>", "a", "", S_OK },
1216 { "<a >", "a", "", S_OK },
1217 { "<a \r \t\n>", "a", "", S_OK },
1218 { "</a>", NULL, NULL, NC_E_QNAMECHARACTER },
1219 { NULL }
1220 };
1221
1222 static void test_read_element(void)
1223 {
1224 struct test_entry *test = element_tests;
1225 static const char stag[] = "<a><b></b></a>";
1226 static const char mismatch[] = "<a></b>";
1227 IXmlReader *reader;
1228 XmlNodeType type;
1229 IStream *stream;
1230 UINT depth;
1231 HRESULT hr;
1232
1233 hr = pCreateXmlReader(&IID_IXmlReader, (void**)&reader, NULL);
1234 ok(hr == S_OK, "S_OK, got %08x\n", hr);
1235
1236 while (test->xml)
1237 {
1238 stream = create_stream_on_data(test->xml, strlen(test->xml)+1);
1239 hr = IXmlReader_SetInput(reader, (IUnknown*)stream);
1240 ok(hr == S_OK, "got %08x\n", hr);
1241
1242 type = XmlNodeType_None;
1243 hr = IXmlReader_Read(reader, &type);
1244 if (test->hr_broken)
1245 ok(hr == test->hr || broken(hr == test->hr_broken), "got %08x for %s\n", hr, test->xml);
1246 else
1247 ok(hr == test->hr, "got %08x for %s\n", hr, test->xml);
1248 if (hr == S_OK)
1249 {
1250 const WCHAR *str;
1251 WCHAR *str_exp;
1252 UINT len;
1253
1254 ok(type == XmlNodeType_Element, "got %d for %s\n", type, test->xml);
1255
1256 len = 0;
1257 str = NULL;
1258 hr = IXmlReader_GetQualifiedName(reader, &str, &len);
1259 ok(hr == S_OK, "got 0x%08x\n", hr);
1260 ok(len == strlen(test->name), "got %u\n", len);
1261 str_exp = a2w(test->name);
1262 ok(!lstrcmpW(str, str_exp), "got %s\n", wine_dbgstr_w(str));
1263 free_str(str_exp);
1264
1265 /* value */
1266 len = 1;
1267 str = NULL;
1268 hr = IXmlReader_GetValue(reader, &str, &len);
1269 ok(hr == S_OK, "got 0x%08x\n", hr);
1270 ok(len == 0, "got %u\n", len);
1271 ok(*str == 0, "got %s\n", wine_dbgstr_w(str));
1272 }
1273
1274 IStream_Release(stream);
1275 test++;
1276 }
1277
1278 /* test reader depth increment */
1279 stream = create_stream_on_data(stag, sizeof(stag));
1280 hr = IXmlReader_SetInput(reader, (IUnknown*)stream);
1281 ok(hr == S_OK, "got %08x\n", hr);
1282
1283 depth = 1;
1284 hr = IXmlReader_GetDepth(reader, &depth);
1285 ok(hr == S_OK, "got %08x\n", hr);
1286 ok(depth == 0, "got %d\n", depth);
1287
1288 type = XmlNodeType_None;
1289 hr = IXmlReader_Read(reader, &type);
1290 ok(hr == S_OK, "got %08x\n", hr);
1291 ok(type == XmlNodeType_Element, "got %d\n", type);
1292
1293 depth = 1;
1294 hr = IXmlReader_GetDepth(reader, &depth);
1295 ok(hr == S_OK, "got %08x\n", hr);
1296 ok(depth == 0, "got %d\n", depth);
1297
1298 type = XmlNodeType_None;
1299 hr = IXmlReader_Read(reader, &type);
1300 ok(hr == S_OK, "got %08x\n", hr);
1301 ok(type == XmlNodeType_Element, "got %d\n", type);
1302
1303 depth = 0;
1304 hr = IXmlReader_GetDepth(reader, &depth);
1305 ok(hr == S_OK, "got %08x\n", hr);
1306 ok(depth == 1, "got %d\n", depth);
1307
1308 /* read end tag for inner element */
1309 type = XmlNodeType_None;
1310 hr = IXmlReader_Read(reader, &type);
1311 ok(hr == S_OK, "got %08x\n", hr);
1312 ok(type == XmlNodeType_EndElement, "got %d\n", type);
1313
1314 depth = 0;
1315 hr = IXmlReader_GetDepth(reader, &depth);
1316 ok(hr == S_OK, "got %08x\n", hr);
1317 todo_wine
1318 ok(depth == 2, "got %d\n", depth);
1319
1320 /* read end tag for container element */
1321 type = XmlNodeType_None;
1322 hr = IXmlReader_Read(reader, &type);
1323 ok(hr == S_OK, "got %08x\n", hr);
1324 ok(type == XmlNodeType_EndElement, "got %d\n", type);
1325
1326 depth = 0;
1327 hr = IXmlReader_GetDepth(reader, &depth);
1328 ok(hr == S_OK, "got %08x\n", hr);
1329 ok(depth == 1, "got %d\n", depth);
1330
1331 IStream_Release(stream);
1332
1333 /* start/end tag mismatch */
1334 stream = create_stream_on_data(mismatch, sizeof(mismatch));
1335 hr = IXmlReader_SetInput(reader, (IUnknown*)stream);
1336 ok(hr == S_OK, "got %08x\n", hr);
1337
1338 type = XmlNodeType_None;
1339 hr = IXmlReader_Read(reader, &type);
1340 ok(hr == S_OK, "got %08x\n", hr);
1341 ok(type == XmlNodeType_Element, "got %d\n", type);
1342
1343 type = XmlNodeType_Element;
1344 hr = IXmlReader_Read(reader, &type);
1345 ok(hr == WC_E_ELEMENTMATCH, "got %08x\n", hr);
1346 todo_wine
1347 ok(type == XmlNodeType_None, "got %d\n", type);
1348
1349 IStream_Release(stream);
1350
1351 IXmlReader_Release(reader);
1352 }
1353
1354 static ISequentialStream teststream = { &teststreamvtbl };
1355
1356 static void test_read_pending(void)
1357 {
1358 IXmlReader *reader;
1359 const WCHAR *value;
1360 XmlNodeType type;
1361 HRESULT hr;
1362 int c;
1363
1364 hr = pCreateXmlReader(&IID_IXmlReader, (void**)&reader, NULL);
1365 ok(hr == S_OK, "S_OK, got 0x%08x\n", hr);
1366
1367 hr = IXmlReader_SetInput(reader, (IUnknown*)&teststream);
1368 ok(hr == S_OK, "got 0x%08x\n", hr);
1369
1370 /* first read call returns incomplete node, second attempt fails with E_PENDING */
1371 stream_readcall = 0;
1372 type = XmlNodeType_Element;
1373 hr = IXmlReader_Read(reader, &type);
1374 ok(hr == S_OK || broken(hr == E_PENDING), "got 0x%08x\n", hr);
1375 /* newer versions are happy when it's enough data to detect node type,
1376 older versions keep reading until it fails to read more */
1377 ok(stream_readcall == 1 || broken(stream_readcall > 1), "got %d\n", stream_readcall);
1378 ok(type == XmlNodeType_Comment || broken(type == XmlNodeType_None), "got %d\n", type);
1379
1380 /* newer versions' GetValue() makes an attempt to read more */
1381 c = stream_readcall;
1382 value = (void*)0xdeadbeef;
1383 hr = IXmlReader_GetValue(reader, &value, NULL);
1384 ok(hr == E_PENDING, "got 0x%08x\n", hr);
1385 ok(value == NULL || broken(value == (void*)0xdeadbeef) /* Win8 sets it to NULL */, "got %p\n", value);
1386 ok(c < stream_readcall || broken(c == stream_readcall), "got %d, expected %d\n", stream_readcall, c+1);
1387
1388 IXmlReader_Release(reader);
1389 }
1390
1391 static void test_readvaluechunk(void)
1392 {
1393 static const char testA[] = "<!-- comment1 -->";
1394 IXmlReader *reader;
1395 XmlNodeType type;
1396 IStream *stream;
1397 const WCHAR *value;
1398 WCHAR b;
1399 HRESULT hr;
1400 UINT c;
1401
1402 hr = pCreateXmlReader(&IID_IXmlReader, (void**)&reader, NULL);
1403 ok(hr == S_OK, "S_OK, got %08x\n", hr);
1404
1405 stream = create_stream_on_data(testA, sizeof(testA));
1406 hr = IXmlReader_SetInput(reader, (IUnknown*)stream);
1407 ok(hr == S_OK, "got %08x\n", hr);
1408
1409 hr = IXmlReader_Read(reader, &type);
1410 ok(hr == S_OK, "got %08x\n", hr);
1411
1412 c = 0;
1413 b = 0;
1414 hr = IXmlReader_ReadValueChunk(reader, &b, 1, &c);
1415 ok(hr == S_OK, "got %08x\n", hr);
1416 ok(c == 1, "got %u\n", c);
1417 ok(b == ' ', "got %x\n", b);
1418
1419 /* portion read as chunk is skipped from resulting node value */
1420 value = NULL;
1421 hr = IXmlReader_GetValue(reader, &value, NULL);
1422 ok(hr == S_OK, "got %08x\n", hr);
1423 ok(value[0] == 'c', "got %s\n", wine_dbgstr_w(value));
1424
1425 /* once value is returned/allocated it's not possible to read by chunk */
1426 c = 0;
1427 b = 0;
1428 hr = IXmlReader_ReadValueChunk(reader, &b, 1, &c);
1429 ok(hr == S_FALSE, "got %08x\n", hr);
1430 ok(c == 0, "got %u\n", c);
1431 ok(b == 0, "got %x\n", b);
1432
1433 value = NULL;
1434 hr = IXmlReader_GetValue(reader, &value, NULL);
1435 ok(hr == S_OK, "got %08x\n", hr);
1436 ok(value[0] == 'c', "got %s\n", wine_dbgstr_w(value));
1437
1438 IXmlReader_Release(reader);
1439 }
1440
1441 static struct test_entry cdata_tests[] = {
1442 { "<a><![CDATA[ ]]data ]]></a>", "", " ]]data ", S_OK },
1443 { "<a><![CDATA[<![CDATA[ data ]]]]></a>", "", "<![CDATA[ data ]]", S_OK },
1444 { "<a><![CDATA[\n \r\n \n\n ]]></a>", "", "\n \n \n\n ", S_OK, S_OK, TRUE },
1445 { "<a><![CDATA[\r \r\r\n \n\n ]]></a>", "", "\n \n\n \n\n ", S_OK, S_OK, TRUE },
1446 { "<a><![CDATA[\r\r \n\r \r \n\n ]]></a>", "", "\n\n \n\n \n \n\n ", S_OK },
1447 { NULL }
1448 };
1449
1450 static void test_read_cdata(void)
1451 {
1452 struct test_entry *test = cdata_tests;
1453 IXmlReader *reader;
1454 HRESULT hr;
1455
1456 hr = pCreateXmlReader(&IID_IXmlReader, (void**)&reader, NULL);
1457 ok(hr == S_OK, "S_OK, got %08x\n", hr);
1458
1459 while (test->xml)
1460 {
1461 XmlNodeType type;
1462 IStream *stream;
1463
1464 stream = create_stream_on_data(test->xml, strlen(test->xml)+1);
1465 hr = IXmlReader_SetInput(reader, (IUnknown*)stream);
1466 ok(hr == S_OK, "got %08x\n", hr);
1467
1468 type = XmlNodeType_None;
1469 hr = IXmlReader_Read(reader, &type);
1470
1471 /* read one more to get to CDATA */
1472 if (type == XmlNodeType_Element)
1473 {
1474 type = XmlNodeType_None;
1475 hr = IXmlReader_Read(reader, &type);
1476 }
1477
1478 if (test->hr_broken)
1479 ok(hr == test->hr || broken(hr == test->hr_broken), "got %08x for %s\n", hr, test->xml);
1480 else
1481 ok(hr == test->hr, "got %08x for %s\n", hr, test->xml);
1482 if (hr == S_OK)
1483 {
1484 const WCHAR *str;
1485 WCHAR *str_exp;
1486 UINT len;
1487
1488 ok(type == XmlNodeType_CDATA, "got %d for %s\n", type, test->xml);
1489
1490 str_exp = a2w(test->name);
1491
1492 len = 1;
1493 str = NULL;
1494 hr = IXmlReader_GetLocalName(reader, &str, &len);
1495 ok(hr == S_OK, "got 0x%08x\n", hr);
1496 ok(len == strlen(test->name), "got %u\n", len);
1497 ok(!lstrcmpW(str, str_exp), "got %s\n", wine_dbgstr_w(str));
1498
1499 str = NULL;
1500 hr = IXmlReader_GetLocalName(reader, &str, NULL);
1501 ok(hr == S_OK, "got 0x%08x\n", hr);
1502 ok(!lstrcmpW(str, str_exp), "got %s\n", wine_dbgstr_w(str));
1503
1504 free_str(str_exp);
1505
1506 len = 1;
1507 str = NULL;
1508 hr = IXmlReader_GetQualifiedName(reader, &str, &len);
1509 ok(hr == S_OK, "got 0x%08x\n", hr);
1510 ok(len == strlen(test->name), "got %u\n", len);
1511 str_exp = a2w(test->name);
1512 ok(!lstrcmpW(str, str_exp), "got %s\n", wine_dbgstr_w(str));
1513 free_str(str_exp);
1514
1515 /* value */
1516 len = 1;
1517 str = NULL;
1518 hr = IXmlReader_GetValue(reader, &str, &len);
1519 ok(hr == S_OK, "got 0x%08x\n", hr);
1520
1521 str_exp = a2w(test->value);
1522 if (test->todo)
1523 {
1524 todo_wine {
1525 ok(len == strlen(test->value), "got %u\n", len);
1526 ok(!lstrcmpW(str, str_exp), "got %s\n", wine_dbgstr_w(str));
1527 }
1528 }
1529 else
1530 {
1531 ok(len == strlen(test->value), "got %u\n", len);
1532 ok(!lstrcmpW(str, str_exp), "got %s\n", wine_dbgstr_w(str));
1533 }
1534 free_str(str_exp);
1535 }
1536
1537 IStream_Release(stream);
1538 test++;
1539 }
1540
1541 IXmlReader_Release(reader);
1542 }
1543
1544 static struct test_entry text_tests[] = {
1545 { "<a>simple text</a>", "", "simple text", S_OK },
1546 { "<a>text ]]> text</a>", "", "", WC_E_CDSECTEND },
1547 { NULL }
1548 };
1549
1550 static void test_read_text(void)
1551 {
1552 struct test_entry *test = text_tests;
1553 IXmlReader *reader;
1554 HRESULT hr;
1555
1556 hr = pCreateXmlReader(&IID_IXmlReader, (void**)&reader, NULL);
1557 ok(hr == S_OK, "S_OK, got %08x\n", hr);
1558
1559 while (test->xml)
1560 {
1561 XmlNodeType type;
1562 IStream *stream;
1563
1564 stream = create_stream_on_data(test->xml, strlen(test->xml)+1);
1565 hr = IXmlReader_SetInput(reader, (IUnknown*)stream);
1566 ok(hr == S_OK, "got %08x\n", hr);
1567
1568 type = XmlNodeType_None;
1569 hr = IXmlReader_Read(reader, &type);
1570
1571 /* read one more to get to CDATA */
1572 if (type == XmlNodeType_Element)
1573 {
1574 type = XmlNodeType_None;
1575 hr = IXmlReader_Read(reader, &type);
1576 }
1577
1578 if (test->hr_broken)
1579 ok(hr == test->hr || broken(hr == test->hr_broken), "got %08x for %s\n", hr, test->xml);
1580 else
1581 ok(hr == test->hr, "got %08x for %s\n", hr, test->xml);
1582 if (hr == S_OK)
1583 {
1584 const WCHAR *str;
1585 WCHAR *str_exp;
1586 UINT len;
1587
1588 ok(type == XmlNodeType_Text, "got %d for %s\n", type, test->xml);
1589
1590 str_exp = a2w(test->name);
1591
1592 len = 1;
1593 str = NULL;
1594 hr = IXmlReader_GetLocalName(reader, &str, &len);
1595 ok(hr == S_OK, "got 0x%08x\n", hr);
1596 ok(len == strlen(test->name), "got %u\n", len);
1597 ok(!lstrcmpW(str, str_exp), "got %s\n", wine_dbgstr_w(str));
1598
1599 str = NULL;
1600 hr = IXmlReader_GetLocalName(reader, &str, NULL);
1601 ok(hr == S_OK, "got 0x%08x\n", hr);
1602 ok(!lstrcmpW(str, str_exp), "got %s\n", wine_dbgstr_w(str));
1603
1604 free_str(str_exp);
1605
1606 len = 1;
1607 str = NULL;
1608 hr = IXmlReader_GetQualifiedName(reader, &str, &len);
1609 ok(hr == S_OK, "got 0x%08x\n", hr);
1610 ok(len == strlen(test->name), "got %u\n", len);
1611 str_exp = a2w(test->name);
1612 ok(!lstrcmpW(str, str_exp), "got %s\n", wine_dbgstr_w(str));
1613 free_str(str_exp);
1614
1615 /* value */
1616 len = 1;
1617 str = NULL;
1618 hr = IXmlReader_GetValue(reader, &str, &len);
1619 ok(hr == S_OK, "got 0x%08x\n", hr);
1620
1621 str_exp = a2w(test->value);
1622 if (test->todo)
1623 {
1624 todo_wine {
1625 ok(len == strlen(test->value), "got %u\n", len);
1626 ok(!lstrcmpW(str, str_exp), "got %s\n", wine_dbgstr_w(str));
1627 }
1628 }
1629 else
1630 {
1631 ok(len == strlen(test->value), "got %u\n", len);
1632 ok(!lstrcmpW(str, str_exp), "got %s\n", wine_dbgstr_w(str));
1633 }
1634 free_str(str_exp);
1635 }
1636
1637 IStream_Release(stream);
1638 test++;
1639 }
1640
1641 IXmlReader_Release(reader);
1642 }
1643
1644 struct test_entry_empty {
1645 const char *xml;
1646 BOOL empty;
1647 };
1648
1649 static struct test_entry_empty empty_element_tests[] = {
1650 { "<a></a>", FALSE },
1651 { "<a/>", TRUE },
1652 { NULL }
1653 };
1654
1655 static void test_isemptyelement(void)
1656 {
1657 struct test_entry_empty *test = empty_element_tests;
1658 IXmlReader *reader;
1659 HRESULT hr;
1660
1661 hr = pCreateXmlReader(&IID_IXmlReader, (void**)&reader, NULL);
1662 ok(hr == S_OK, "S_OK, got %08x\n", hr);
1663
1664 while (test->xml)
1665 {
1666 XmlNodeType type;
1667 IStream *stream;
1668 BOOL ret;
1669
1670 stream = create_stream_on_data(test->xml, strlen(test->xml)+1);
1671 hr = IXmlReader_SetInput(reader, (IUnknown*)stream);
1672 ok(hr == S_OK, "got %08x\n", hr);
1673
1674 type = XmlNodeType_None;
1675 hr = IXmlReader_Read(reader, &type);
1676 ok(hr == S_OK, "got 0x%08x\n", hr);
1677 ok(type == XmlNodeType_Element, "got %d\n", type);
1678
1679 ret = IXmlReader_IsEmptyElement(reader);
1680 ok(ret == test->empty, "got %d, expected %d. xml=%s\n", ret, test->empty, test->xml);
1681
1682 IStream_Release(stream);
1683 test++;
1684 }
1685
1686 IXmlReader_Release(reader);
1687 }
1688
1689 static struct test_entry attributes_tests[] = {
1690 { "<a attr1=\"attrvalue\"/>", "attr1", "attrvalue", S_OK },
1691 { "<a attr1=\"a\'\'ttrvalue\"/>", "attr1", "a\'\'ttrvalue", S_OK },
1692 { "<a attr1=\'a\"ttrvalue\'/>", "attr1", "a\"ttrvalue", S_OK },
1693 { "<a attr1=\' \'/>", "attr1", " ", S_OK },
1694 { "<a attr1=\" \"/>", "attr1", " ", S_OK },
1695 { "<a attr1=\"\r\n \r \n \t\n\r\"/>", "attr1", " ", S_OK },
1696 { "<a attr1=\" val \"/>", "attr1", " val ", S_OK },
1697 { "<a attr1=\"\r\n\tval\n\"/>", "attr1", " val ", S_OK },
1698 { "<a attr1=\"val&#32;\"/>", "attr1", "val ", S_OK },
1699 { "<a attr1=\"val&#x20;\"/>", "attr1", "val ", S_OK },
1700 { "<a attr1=\"&lt;&gt;&amp;&apos;&quot;\"/>", "attr1", "<>&\'\"", S_OK },
1701 { "<a attr1=\"&entname;\"/>", NULL, NULL, WC_E_UNDECLAREDENTITY },
1702 { "<a attr1=\"val&#xfffe;\"/>", NULL, NULL, WC_E_XMLCHARACTER },
1703 { "<a attr1=\"val &#a;\"/>", NULL, NULL, WC_E_DIGIT, WC_E_SEMICOLON },
1704 { "<a attr1=\"val &#12a;\"/>", NULL, NULL, WC_E_SEMICOLON },
1705 { "<a attr1=\"val &#x12g;\"/>", NULL, NULL, WC_E_SEMICOLON },
1706 { "<a attr1=\"val &#xg;\"/>", NULL, NULL, WC_E_HEXDIGIT, WC_E_SEMICOLON },
1707 { "<a attr1=attrvalue/>", NULL, NULL, WC_E_QUOTE },
1708 { "<a attr1=\"attr<value\"/>", NULL, NULL, WC_E_LESSTHAN },
1709 { "<a attr1=\"&entname\"/>", NULL, NULL, WC_E_SEMICOLON },
1710 { NULL }
1711 };
1712
1713 static void test_read_attribute(void)
1714 {
1715 struct test_entry *test = attributes_tests;
1716 IXmlReader *reader;
1717 HRESULT hr;
1718
1719 hr = pCreateXmlReader(&IID_IXmlReader, (void**)&reader, NULL);
1720 ok(hr == S_OK, "S_OK, got %08x\n", hr);
1721
1722 while (test->xml)
1723 {
1724 XmlNodeType type;
1725 IStream *stream;
1726
1727 stream = create_stream_on_data(test->xml, strlen(test->xml)+1);
1728 hr = IXmlReader_SetInput(reader, (IUnknown*)stream);
1729 ok(hr == S_OK, "got %08x\n", hr);
1730
1731 type = XmlNodeType_None;
1732 hr = IXmlReader_Read(reader, &type);
1733
1734 if (test->hr_broken)
1735 ok(hr == test->hr || broken(hr == test->hr_broken), "got %08x for %s\n", hr, test->xml);
1736 else
1737 ok(hr == test->hr, "got %08x for %s\n", hr, test->xml);
1738 if (hr == S_OK)
1739 {
1740 const WCHAR *str;
1741 WCHAR *str_exp;
1742 UINT len;
1743
1744 ok(type == XmlNodeType_Element, "got %d for %s\n", type, test->xml);
1745
1746 hr = IXmlReader_MoveToFirstAttribute(reader);
1747 ok(hr == S_OK, "got 0x%08x\n", hr);
1748
1749 len = 1;
1750 str = NULL;
1751 hr = IXmlReader_GetLocalName(reader, &str, &len);
1752 ok(hr == S_OK, "got 0x%08x\n", hr);
1753 ok(len == strlen(test->name), "got %u\n", len);
1754 str_exp = a2w(test->name);
1755 ok(!lstrcmpW(str, str_exp), "got %s\n", wine_dbgstr_w(str));
1756 free_str(str_exp);
1757
1758 len = 1;
1759 str = NULL;
1760 hr = IXmlReader_GetQualifiedName(reader, &str, &len);
1761 ok(hr == S_OK, "got 0x%08x\n", hr);
1762 todo_wine {
1763 ok(len == strlen(test->name), "got %u\n", len);
1764 str_exp = a2w(test->name);
1765 ok(!lstrcmpW(str, str_exp), "got %s\n", wine_dbgstr_w(str));
1766 free_str(str_exp);
1767 }
1768 /* value */
1769 len = 1;
1770 str = NULL;
1771 hr = IXmlReader_GetValue(reader, &str, &len);
1772 ok(hr == S_OK, "got 0x%08x\n", hr);
1773 ok(len == strlen(test->value), "got %u\n", len);
1774 str_exp = a2w(test->value);
1775 ok(!lstrcmpW(str, str_exp), "got %s\n", wine_dbgstr_w(str));
1776 free_str(str_exp);
1777 }
1778
1779 IStream_Release(stream);
1780 test++;
1781 }
1782
1783 IXmlReader_Release(reader);
1784 }
1785
1786 START_TEST(reader)
1787 {
1788 if (!init_pointers())
1789 return;
1790
1791 test_reader_create();
1792 test_readerinput();
1793 test_reader_state();
1794 test_read_attribute();
1795 test_read_cdata();
1796 test_read_comment();
1797 test_read_pi();
1798 test_read_dtd();
1799 test_read_element();
1800 test_isemptyelement();
1801 test_read_text();
1802 test_read_full();
1803 test_read_pending();
1804 test_readvaluechunk();
1805 test_read_xmldeclaration();
1806 }
A free Windows-compatible Operating System