[XMLLITE_WINETEST]
[reactos.git] / rostests / winetests / xmllite / reader.c
1 /*
2 * XMLLite IXmlReader tests
3 *
4 * Copyright 2010 (C) 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 COBJMACROS
22
23 #include <stdarg.h>
24 #include <stdio.h>
25
26 #include "windef.h"
27 #include "winbase.h"
28 #include "initguid.h"
29 #include "ole2.h"
30 #include "xmllite.h"
31 #include "wine/test.h"
32
33 DEFINE_GUID(IID_IXmlReaderInput, 0x0b3ccc9b, 0x9214, 0x428b, 0xa2, 0xae, 0xef, 0x3a, 0xa8, 0x71, 0xaf, 0xda);
34
35 HRESULT WINAPI (*pCreateXmlReader)(REFIID riid, void **ppvObject, IMalloc *pMalloc);
36 HRESULT WINAPI (*pCreateXmlReaderInputWithEncodingName)(IUnknown *stream,
37 IMalloc *pMalloc,
38 LPCWSTR encoding,
39 BOOL hint,
40 LPCWSTR base_uri,
41 IXmlReaderInput **ppInput);
42 static const char *debugstr_guid(REFIID riid)
43 {
44 static char buf[50];
45
46 sprintf(buf, "{%08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X}",
47 riid->Data1, riid->Data2, riid->Data3, riid->Data4[0],
48 riid->Data4[1], riid->Data4[2], riid->Data4[3], riid->Data4[4],
49 riid->Data4[5], riid->Data4[6], riid->Data4[7]);
50
51 return buf;
52 }
53
54 static const char xmldecl_full[] = "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>\n";
55
56 static IStream *create_stream_on_data(const char *data, int size)
57 {
58 IStream *stream = NULL;
59 HGLOBAL hglobal;
60 void *ptr;
61 HRESULT hr;
62
63 hglobal = GlobalAlloc(GHND, size);
64 ptr = GlobalLock(hglobal);
65
66 memcpy(ptr, data, size);
67
68 hr = CreateStreamOnHGlobal(hglobal, TRUE, &stream);
69 ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
70 ok(stream != NULL, "Expected non-NULL stream\n");
71
72 GlobalUnlock(hglobal);
73
74 return stream;
75 }
76
77 static void ok_pos_(IXmlReader *reader, int line, int pos, int line_broken,
78 int pos_broken, int todo, int _line_)
79 {
80 UINT l, p;
81 HRESULT hr;
82 int broken_state;
83
84 hr = IXmlReader_GetLineNumber(reader, &l);
85 ok_(__FILE__, _line_)(hr == S_OK, "Expected S_OK, got %08x\n", hr);
86 hr = IXmlReader_GetLinePosition(reader, &p);
87 ok_(__FILE__, _line_)(hr == S_OK, "Expected S_OK, got %08x\n", hr);
88
89 if (line_broken == -1 && pos_broken == -1)
90 broken_state = 0;
91 else
92 broken_state = broken((line_broken == -1 ? line : line_broken) == l &&
93 (pos_broken == -1 ? pos : pos_broken) == p);
94
95 if (todo)
96 todo_wine
97 ok_(__FILE__, _line_)((l == line && pos == p) || broken_state,
98 "Expected (%d,%d), got (%d,%d)\n", line, pos, l, p);
99 else
100 {
101 ok_(__FILE__, _line_)((l == line && pos == p) || broken_state,
102 "Expected (%d,%d), got (%d,%d)\n", line, pos, l, p);
103 }
104 }
105 #define ok_pos(reader, l, p, l_brk, p_brk, todo) ok_pos_(reader, l, p, l_brk, p_brk, todo, __LINE__)
106
107 typedef struct input_iids_t {
108 IID iids[10];
109 int count;
110 } input_iids_t;
111
112 static const IID *setinput_full[] = {
113 &IID_IXmlReaderInput,
114 &IID_IStream,
115 &IID_ISequentialStream,
116 NULL
117 };
118
119 /* this applies to early xmllite versions */
120 static const IID *setinput_full_old[] = {
121 &IID_IXmlReaderInput,
122 &IID_ISequentialStream,
123 &IID_IStream,
124 NULL
125 };
126
127 /* after ::SetInput(IXmlReaderInput*) */
128 static const IID *setinput_readerinput[] = {
129 &IID_IStream,
130 &IID_ISequentialStream,
131 NULL
132 };
133
134 static const IID *empty_seq[] = {
135 NULL
136 };
137
138 static input_iids_t input_iids;
139
140 static void ok_iids_(const input_iids_t *iids, const IID **expected, const IID **exp_broken, int todo, int line)
141 {
142 int i = 0, size = 0;
143
144 while (expected[i++]) size++;
145
146 if (todo) {
147 todo_wine
148 ok_(__FILE__, line)(iids->count == size, "Sequence size mismatch (%d), got (%d)\n", size, iids->count);
149 }
150 else
151 ok_(__FILE__, line)(iids->count == size, "Sequence size mismatch (%d), got (%d)\n", size, iids->count);
152
153 if (iids->count != size) return;
154
155 for (i = 0; i < size; i++) {
156 ok_(__FILE__, line)(IsEqualGUID(&iids->iids[i], expected[i]) ||
157 (exp_broken ? broken(IsEqualGUID(&iids->iids[i], exp_broken[i])) : FALSE),
158 "Wrong IID(%d), got (%s)\n", i, debugstr_guid(&iids->iids[i]));
159 }
160 }
161 #define ok_iids(got, exp, brk, todo) ok_iids_(got, exp, brk, todo, __LINE__)
162
163 static const char *state_to_str(XmlReadState state)
164 {
165 static const char* state_names[] = {
166 "XmlReadState_Initial",
167 "XmlReadState_Interactive",
168 "XmlReadState_Error",
169 "XmlReadState_EndOfFile",
170 "XmlReadState_Closed"
171 };
172
173 static const char unknown[] = "unknown";
174
175 switch (state)
176 {
177 case XmlReadState_Initial:
178 case XmlReadState_Interactive:
179 case XmlReadState_Error:
180 case XmlReadState_EndOfFile:
181 case XmlReadState_Closed:
182 return state_names[state];
183 default:
184 return unknown;
185 }
186 }
187
188 static const char *type_to_str(XmlNodeType type)
189 {
190 static const char* type_names[] = {
191 "XmlNodeType_None",
192 "XmlNodeType_Element",
193 "XmlNodeType_Attribute",
194 "XmlNodeType_Text",
195 "XmlNodeType_CDATA",
196 "", "",
197 "XmlNodeType_ProcessingInstruction",
198 "XmlNodeType_Comment",
199 "",
200 "XmlNodeType_DocumentType",
201 "", "",
202 "XmlNodeType_Whitespace",
203 "",
204 "XmlNodeType_EndElement",
205 "",
206 "XmlNodeType_XmlDeclaration"
207 };
208
209 static const char unknown[] = "unknown";
210
211 switch (type)
212 {
213 case XmlNodeType_None:
214 case XmlNodeType_Element:
215 case XmlNodeType_Attribute:
216 case XmlNodeType_Text:
217 case XmlNodeType_CDATA:
218 case XmlNodeType_ProcessingInstruction:
219 case XmlNodeType_Comment:
220 case XmlNodeType_DocumentType:
221 case XmlNodeType_Whitespace:
222 case XmlNodeType_EndElement:
223 case XmlNodeType_XmlDeclaration:
224 return type_names[type];
225 default:
226 return unknown;
227 }
228 }
229
230 static void test_read_state_(IXmlReader *reader, XmlReadState expected,
231 XmlReadState exp_broken, int todo, int line)
232 {
233 XmlReadState state;
234 HRESULT hr;
235 int broken_state;
236
237 state = -1; /* invalid value */
238 hr = IXmlReader_GetProperty(reader, XmlReaderProperty_ReadState, (LONG_PTR*)&state);
239 ok_(__FILE__, line)(hr == S_OK, "Expected S_OK, got %08x\n", hr);
240
241 if (exp_broken == -1)
242 broken_state = 0;
243 else
244 broken_state = broken(exp_broken == state);
245
246 if (todo)
247 {
248 todo_wine
249 ok_(__FILE__, line)(state == expected || broken_state, "Expected (%s), got (%s)\n",
250 state_to_str(expected), state_to_str(state));
251 }
252 else
253 ok_(__FILE__, line)(state == expected || broken_state, "Expected (%s), got (%s)\n",
254 state_to_str(expected), state_to_str(state));
255 }
256
257 #define test_read_state(reader, exp, brk, todo) test_read_state_(reader, exp, brk, todo, __LINE__)
258
259 typedef struct _testinput
260 {
261 const IUnknownVtbl *lpVtbl;
262 LONG ref;
263 } testinput;
264
265 static inline testinput *impl_from_IUnknown(IUnknown *iface)
266 {
267 return (testinput *)((char*)iface - FIELD_OFFSET(testinput, lpVtbl));
268 }
269
270 static HRESULT WINAPI testinput_QueryInterface(IUnknown *iface, REFIID riid, void** ppvObj)
271 {
272 if (IsEqualGUID( riid, &IID_IUnknown ))
273 {
274 *ppvObj = iface;
275 IUnknown_AddRef(iface);
276 return S_OK;
277 }
278
279 input_iids.iids[input_iids.count++] = *riid;
280
281 *ppvObj = NULL;
282
283 return E_NOINTERFACE;
284 }
285
286 static ULONG WINAPI testinput_AddRef(IUnknown *iface)
287 {
288 testinput *This = impl_from_IUnknown(iface);
289 return InterlockedIncrement(&This->ref);
290 }
291
292 static ULONG WINAPI testinput_Release(IUnknown *iface)
293 {
294 testinput *This = impl_from_IUnknown(iface);
295 LONG ref;
296
297 ref = InterlockedDecrement(&This->ref);
298 if (ref == 0)
299 {
300 HeapFree(GetProcessHeap(), 0, This);
301 }
302
303 return ref;
304 }
305
306 static const struct IUnknownVtbl testinput_vtbl =
307 {
308 testinput_QueryInterface,
309 testinput_AddRef,
310 testinput_Release
311 };
312
313 static HRESULT testinput_createinstance(void **ppObj)
314 {
315 testinput *input;
316
317 input = HeapAlloc(GetProcessHeap(), 0, sizeof (*input));
318 if(!input) return E_OUTOFMEMORY;
319
320 input->lpVtbl = &testinput_vtbl;
321 input->ref = 1;
322
323 *ppObj = &input->lpVtbl;
324
325 return S_OK;
326 }
327
328 static BOOL init_pointers(void)
329 {
330 /* don't free module here, it's to be unloaded on exit */
331 HMODULE mod = LoadLibraryA("xmllite.dll");
332
333 if (!mod)
334 {
335 win_skip("xmllite library not available\n");
336 return FALSE;
337 }
338
339 #define MAKEFUNC(f) if (!(p##f = (void*)GetProcAddress(mod, #f))) return FALSE;
340 MAKEFUNC(CreateXmlReader);
341 MAKEFUNC(CreateXmlReaderInputWithEncodingName);
342 #undef MAKEFUNC
343
344 return TRUE;
345 }
346
347 static void test_reader_create(void)
348 {
349 HRESULT hr;
350 IXmlReader *reader;
351 IUnknown *input;
352
353 /* crashes native */
354 if (0)
355 {
356 hr = pCreateXmlReader(&IID_IXmlReader, NULL, NULL);
357 hr = pCreateXmlReader(NULL, (LPVOID*)&reader, NULL);
358 }
359
360 hr = pCreateXmlReader(&IID_IXmlReader, (LPVOID*)&reader, NULL);
361 ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
362
363 test_read_state(reader, XmlReadState_Closed, -1, FALSE);
364
365 /* Null input pointer, releases previous input */
366 hr = IXmlReader_SetInput(reader, NULL);
367 ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
368
369 test_read_state(reader, XmlReadState_Initial, XmlReadState_Closed, FALSE);
370
371 /* test input interface selection sequence */
372 hr = testinput_createinstance((void**)&input);
373 ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
374
375 input_iids.count = 0;
376 hr = IXmlReader_SetInput(reader, input);
377 ok(hr == E_NOINTERFACE, "Expected E_NOINTERFACE, got %08x\n", hr);
378 ok_iids(&input_iids, setinput_full, setinput_full_old, FALSE);
379
380 IUnknown_Release(input);
381
382 IXmlReader_Release(reader);
383 }
384
385 static void test_readerinput(void)
386 {
387 IXmlReaderInput *reader_input;
388 IXmlReader *reader, *reader2;
389 IUnknown *obj, *input;
390 IStream *stream;
391 HRESULT hr;
392 LONG ref;
393
394 hr = pCreateXmlReaderInputWithEncodingName(NULL, NULL, NULL, FALSE, NULL, NULL);
395 ok(hr == E_INVALIDARG, "Expected E_INVALIDARG, got %08x\n", hr);
396 hr = pCreateXmlReaderInputWithEncodingName(NULL, NULL, NULL, FALSE, NULL, &reader_input);
397 ok(hr == E_INVALIDARG, "Expected E_INVALIDARG, got %08x\n", hr);
398
399 hr = CreateStreamOnHGlobal(NULL, TRUE, &stream);
400 ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
401
402 ref = IStream_AddRef(stream);
403 ok(ref == 2, "Expected 2, got %d\n", ref);
404 IStream_Release(stream);
405 hr = pCreateXmlReaderInputWithEncodingName((IUnknown*)stream, NULL, NULL, FALSE, NULL, &reader_input);
406 ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
407
408 /* IXmlReaderInput grabs a stream reference */
409 ref = IStream_AddRef(stream);
410 ok(ref == 3, "Expected 3, got %d\n", ref);
411 IStream_Release(stream);
412
413 /* try ::SetInput() with valid IXmlReaderInput */
414 hr = pCreateXmlReader(&IID_IXmlReader, (LPVOID*)&reader, NULL);
415 ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
416
417 ref = IUnknown_AddRef(reader_input);
418 ok(ref == 2, "Expected 2, got %d\n", ref);
419 IUnknown_Release(reader_input);
420
421 hr = IXmlReader_SetInput(reader, reader_input);
422 ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
423
424 test_read_state(reader, XmlReadState_Initial, -1, FALSE);
425
426 /* IXmlReader grabs a IXmlReaderInput reference */
427 ref = IUnknown_AddRef(reader_input);
428 ok(ref == 3, "Expected 3, got %d\n", ref);
429 IUnknown_Release(reader_input);
430
431 ref = IStream_AddRef(stream);
432 ok(ref == 4, "Expected 4, got %d\n", ref);
433 IStream_Release(stream);
434
435 /* reset input and check state */
436 hr = IXmlReader_SetInput(reader, NULL);
437 ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
438
439 test_read_state(reader, XmlReadState_Initial, XmlReadState_Closed, FALSE);
440
441 IXmlReader_Release(reader);
442
443 ref = IStream_AddRef(stream);
444 ok(ref == 3, "Expected 3, got %d\n", ref);
445 IStream_Release(stream);
446
447 ref = IUnknown_AddRef(reader_input);
448 ok(ref == 2, "Expected 2, got %d\n", ref);
449 IUnknown_Release(reader_input);
450
451 /* IID_IXmlReaderInput */
452 /* it returns a kind of private undocumented vtable incompatible with IUnknown,
453 so it's not a COM interface actually.
454 Such query will be used only to check if input is really IXmlReaderInput */
455 obj = (IUnknown*)0xdeadbeef;
456 hr = IUnknown_QueryInterface(reader_input, &IID_IXmlReaderInput, (void**)&obj);
457 ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
458 ref = IUnknown_AddRef(reader_input);
459 ok(ref == 3, "Expected 3, got %d\n", ref);
460 IUnknown_Release(reader_input);
461
462 IUnknown_Release(reader_input);
463 IUnknown_Release(reader_input);
464 IStream_Release(stream);
465
466 /* test input interface selection sequence */
467 hr = testinput_createinstance((void**)&input);
468 ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
469
470 input_iids.count = 0;
471 ref = IUnknown_AddRef(input);
472 ok(ref == 2, "Expected 2, got %d\n", ref);
473 IUnknown_Release(input);
474 hr = pCreateXmlReaderInputWithEncodingName(input, NULL, NULL, FALSE, NULL, &reader_input);
475 ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
476 ok_iids(&input_iids, empty_seq, NULL, FALSE);
477 /* IXmlReaderInput stores stream interface as IUnknown */
478 ref = IUnknown_AddRef(input);
479 ok(ref == 3, "Expected 3, got %d\n", ref);
480 IUnknown_Release(input);
481
482 hr = pCreateXmlReader(&IID_IXmlReader, (LPVOID*)&reader, NULL);
483 ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
484
485 input_iids.count = 0;
486 ref = IUnknown_AddRef(reader_input);
487 ok(ref == 2, "Expected 2, got %d\n", ref);
488 IUnknown_Release(reader_input);
489 ref = IUnknown_AddRef(input);
490 ok(ref == 3, "Expected 3, got %d\n", ref);
491 IUnknown_Release(input);
492 hr = IXmlReader_SetInput(reader, reader_input);
493 ok(hr == E_NOINTERFACE, "Expected E_NOINTERFACE, got %08x\n", hr);
494 ok_iids(&input_iids, setinput_readerinput, NULL, FALSE);
495
496 test_read_state(reader, XmlReadState_Closed, -1, FALSE);
497
498 ref = IUnknown_AddRef(input);
499 ok(ref == 3, "Expected 3, got %d\n", ref);
500 IUnknown_Release(input);
501
502 ref = IUnknown_AddRef(reader_input);
503 ok(ref == 3 || broken(ref == 2) /* versions 1.0.x and 1.1.x - XP, Vista */,
504 "Expected 3, got %d\n", ref);
505 IUnknown_Release(reader_input);
506 /* repeat another time, no check or caching here */
507 input_iids.count = 0;
508 hr = IXmlReader_SetInput(reader, reader_input);
509 ok(hr == E_NOINTERFACE, "Expected E_NOINTERFACE, got %08x\n", hr);
510 ok_iids(&input_iids, setinput_readerinput, NULL, FALSE);
511
512 /* another reader */
513 hr = pCreateXmlReader(&IID_IXmlReader, (LPVOID*)&reader2, NULL);
514 ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
515
516 /* resolving from IXmlReaderInput to IStream/ISequentialStream is done at
517 ::SetInput() level, each time it's called */
518 input_iids.count = 0;
519 hr = IXmlReader_SetInput(reader2, reader_input);
520 ok(hr == E_NOINTERFACE, "Expected E_NOINTERFACE, got %08x\n", hr);
521 ok_iids(&input_iids, setinput_readerinput, NULL, FALSE);
522
523 IXmlReader_Release(reader2);
524 IXmlReader_Release(reader);
525
526 IUnknown_Release(reader_input);
527 IUnknown_Release(input);
528 }
529
530 static void test_reader_state(void)
531 {
532 IXmlReader *reader;
533 HRESULT hr;
534
535 hr = pCreateXmlReader(&IID_IXmlReader, (LPVOID*)&reader, NULL);
536 ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
537
538 /* invalid arguments */
539 hr = IXmlReader_GetProperty(reader, XmlReaderProperty_ReadState, NULL);
540 ok(hr == E_INVALIDARG, "Expected E_INVALIDARG, got %08x\n", hr);
541
542 IXmlReader_Release(reader);
543 }
544
545 static void test_read_xmldeclaration(void)
546 {
547 IXmlReader *reader;
548 IStream *stream;
549 HRESULT hr;
550 XmlNodeType type;
551 UINT count = 0;
552
553 hr = pCreateXmlReader(&IID_IXmlReader, (LPVOID*)&reader, NULL);
554 ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
555
556 /* position methods with Null args */
557 hr = IXmlReader_GetLineNumber(reader, NULL);
558 ok(hr == E_INVALIDARG, "Expected E_INVALIDARG, got %08x\n", hr);
559
560 hr = IXmlReader_GetLinePosition(reader, NULL);
561 ok(hr == E_INVALIDARG, "Expected E_INVALIDARG, got %08x\n", hr);
562
563 stream = create_stream_on_data(xmldecl_full, sizeof(xmldecl_full));
564
565 hr = IXmlReader_SetInput(reader, (IUnknown*)stream);
566 ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
567
568 ok_pos(reader, 0, 0, -1, -1, FALSE);
569
570 type = -1;
571 hr = IXmlReader_Read(reader, &type);
572 todo_wine {
573 ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
574 ok(type == XmlNodeType_XmlDeclaration,
575 "Expected XmlNodeType_XmlDeclaration, got %s\n", type_to_str(type));
576 }
577 /* new version 1.2.x and 1.3.x properly update postition for <?xml ?> */
578 ok_pos(reader, 1, 3, -1, 55, TRUE);
579
580 /* check attributes */
581 hr = IXmlReader_MoveToNextAttribute(reader);
582 todo_wine ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
583 ok_pos(reader, 1, 7, -1, 55, TRUE);
584
585 hr = IXmlReader_MoveToFirstAttribute(reader);
586 todo_wine ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
587 ok_pos(reader, 1, 7, -1, 55, TRUE);
588
589 hr = IXmlReader_GetAttributeCount(reader, &count);
590 todo_wine {
591 ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
592 ok(count == 3, "Expected 3, got %d\n", count);
593 }
594 hr = IXmlReader_GetDepth(reader, &count);
595 todo_wine {
596 ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
597 ok(count == 1, "Expected 1, got %d\n", count);
598 }
599
600 IStream_Release(stream);
601 IXmlReader_Release(reader);
602 }
603
604 START_TEST(reader)
605 {
606 HRESULT r;
607
608 r = CoInitialize( NULL );
609 ok( r == S_OK, "failed to init com\n");
610
611 if (!init_pointers())
612 {
613 CoUninitialize();
614 return;
615 }
616
617 test_reader_create();
618 test_readerinput();
619 test_reader_state();
620 test_read_xmldeclaration();
621
622 CoUninitialize();
623 }