dlls/xmllite/tests/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 COBJMACROS
  22 #define CONST_VTABLE
  23
  24 #include <stdarg.h>
  25 #include <stdio.h>
  26
  27 #include "windef.h"
  28 #include "winbase.h"
  29 #include "initguid.h"
  30 #include "ole2.h"
  31 #include "xmllite.h"
  32 #include "wine/test.h"
  33
  34 DEFINE_GUID(IID_IXmlReaderInput, 0x0b3ccc9b, 0x9214, 0x428b, 0xa2, 0xae, 0xef, 0x3a, 0xa8, 0x71, 0xaf, 0xda);
  35
  36 static WCHAR *a2w(const char *str)
  37 {
  38     int len = MultiByteToWideChar(CP_ACP, 0, str, -1, NULL, 0);
  39     WCHAR *ret = HeapAlloc(GetProcessHeap(), 0, len*sizeof(WCHAR));
  40     MultiByteToWideChar(CP_ACP, 0, str, -1, ret, len);
  41     return ret;
  42 }
  43
  44 static void free_str(WCHAR *str)
  45 {
  46     HeapFree(GetProcessHeap(), 0, str);
  47 }
  48
  49 static const char xmldecl_full[] = "\xef\xbb\xbf<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>\n";
  50 static const char xmldecl_short[] = "<?xml version=\"1.0\"?><RegistrationInfo/>";
  51
  52 static IStream *create_stream_on_data(const void *data, unsigned int size)
  53 {
  54     IStream *stream = NULL;
  55     HGLOBAL hglobal;
  56     void *ptr;
  57     HRESULT hr;
  58
  59     hglobal = GlobalAlloc(GHND, size);
  60     ptr = GlobalLock(hglobal);
  61
  62     memcpy(ptr, data, size);
  63
  64     hr = CreateStreamOnHGlobal(hglobal, TRUE, &stream);
  65     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
  66     ok(stream != NULL, "Expected non-NULL stream\n");
  67
  68     GlobalUnlock(hglobal);
  69
  70     return stream;
  71 }
  72
  73 static void ok_pos_(IXmlReader *reader, int line, int pos, int line_broken,
  74                                         int pos_broken, BOOL todo, int _line_)
  75 {
  76     UINT l, p;
  77     HRESULT hr;
  78     BOOL broken_state;
  79
  80     hr = IXmlReader_GetLineNumber(reader, &l);
  81     ok_(__FILE__, _line_)(hr == S_OK, "Expected S_OK, got %08x\n", hr);
  82     hr = IXmlReader_GetLinePosition(reader, &p);
  83     ok_(__FILE__, _line_)(hr == S_OK, "Expected S_OK, got %08x\n", hr);
  84
  85     if (line_broken == -1 && pos_broken == -1)
  86         broken_state = FALSE;
  87     else
  88         broken_state = broken((line_broken == -1 ? line : line_broken) == l &&
  89                               (pos_broken == -1 ? pos : pos_broken) == p);
  90
  91     todo_wine_if (todo)
  92         ok_(__FILE__, _line_)((l == line && pos == p) || broken_state,
  93                             "Expected (%d,%d), got (%d,%d)\n", line, pos, l, p);
  94 }
  95 #define ok_pos(reader, l, p, l_brk, p_brk, todo) ok_pos_(reader, l, p, l_brk, p_brk, todo, __LINE__)
  96
  97 typedef struct input_iids_t {
  98     IID iids[10];
  99     int count;
 100 } input_iids_t;
 101
 102 static const IID *setinput_full[] = {
 103     &IID_IXmlReaderInput,
 104     &IID_IStream,
 105     &IID_ISequentialStream,
 106     NULL
 107 };
 108
 109 /* this applies to early xmllite versions */
 110 static const IID *setinput_full_old[] = {
 111     &IID_IXmlReaderInput,
 112     &IID_ISequentialStream,
 113     &IID_IStream,
 114     NULL
 115 };
 116
 117 /* after ::SetInput(IXmlReaderInput*) */
 118 static const IID *setinput_readerinput[] = {
 119     &IID_IStream,
 120     &IID_ISequentialStream,
 121     NULL
 122 };
 123
 124 static const IID *empty_seq[] = {
 125     NULL
 126 };
 127
 128 static input_iids_t input_iids;
 129
 130 static void ok_iids_(const input_iids_t *iids, const IID **expected, const IID **exp_broken, BOOL todo, int line)
 131 {
 132     int i = 0, size = 0;
 133
 134     while (expected[i++]) size++;
 135
 136     todo_wine_if (todo)
 137         ok_(__FILE__, line)(iids->count == size, "Sequence size mismatch (%d), got (%d)\n", size, iids->count);
 138
 139     if (iids->count != size) return;
 140
 141     for (i = 0; i < size; i++) {
 142         ok_(__FILE__, line)(IsEqualGUID(&iids->iids[i], expected[i]) ||
 143             (exp_broken ? broken(IsEqualGUID(&iids->iids[i], exp_broken[i])) : FALSE),
 144             "Wrong IID(%d), got %s\n", i, wine_dbgstr_guid(&iids->iids[i]));
 145     }
 146 }
 147 #define ok_iids(got, exp, brk, todo) ok_iids_(got, exp, brk, todo, __LINE__)
 148
 149 static const char *state_to_str(XmlReadState state)
 150 {
 151     static const char* state_names[] = {
 152         "XmlReadState_Initial",
 153         "XmlReadState_Interactive",
 154         "XmlReadState_Error",
 155         "XmlReadState_EndOfFile",
 156         "XmlReadState_Closed"
 157     };
 158
 159     static const char unknown[] = "unknown";
 160
 161     switch (state)
 162     {
 163     case XmlReadState_Initial:
 164     case XmlReadState_Interactive:
 165     case XmlReadState_Error:
 166     case XmlReadState_EndOfFile:
 167     case XmlReadState_Closed:
 168         return state_names[state];
 169     default:
 170         return unknown;
 171     }
 172 }
 173
 174 static const char *type_to_str(XmlNodeType type)
 175 {
 176     static const char* type_names[] = {
 177         "XmlNodeType_None",
 178         "XmlNodeType_Element",
 179         "XmlNodeType_Attribute",
 180         "XmlNodeType_Text",
 181         "XmlNodeType_CDATA",
 182         "", "",
 183         "XmlNodeType_ProcessingInstruction",
 184         "XmlNodeType_Comment",
 185         "",
 186         "XmlNodeType_DocumentType",
 187         "", "",
 188         "XmlNodeType_Whitespace",
 189         "",
 190         "XmlNodeType_EndElement",
 191         "",
 192         "XmlNodeType_XmlDeclaration"
 193     };
 194
 195     static const char unknown[] = "unknown";
 196
 197     switch (type)
 198     {
 199     case XmlNodeType_None:
 200     case XmlNodeType_Element:
 201     case XmlNodeType_Attribute:
 202     case XmlNodeType_Text:
 203     case XmlNodeType_CDATA:
 204     case XmlNodeType_ProcessingInstruction:
 205     case XmlNodeType_Comment:
 206     case XmlNodeType_DocumentType:
 207     case XmlNodeType_Whitespace:
 208     case XmlNodeType_EndElement:
 209     case XmlNodeType_XmlDeclaration:
 210         return type_names[type];
 211     default:
 212         return unknown;
 213     }
 214 }
 215
 216 static void test_read_state_(IXmlReader *reader, XmlReadState expected,
 217                              XmlReadState exp_broken, BOOL todo, int line)
 218 {
 219     LONG_PTR state;
 220     HRESULT hr;
 221     BOOL broken_state;
 222
 223     state = -1; /* invalid value */
 224     hr = IXmlReader_GetProperty(reader, XmlReaderProperty_ReadState, &state);
 225     ok_(__FILE__, line)(hr == S_OK, "Expected S_OK, got %08x\n", hr);
 226
 227     if (exp_broken == -1)
 228         broken_state = FALSE;
 229     else
 230         broken_state = broken(exp_broken == state);
 231
 232     todo_wine_if (todo)
 233         ok_(__FILE__, line)(state == expected || broken_state, "Expected (%s), got (%s)\n",
 234                                    state_to_str(expected), state_to_str(state));
 235 }
 236
 237 #define test_read_state(reader, exp, brk, todo) test_read_state_(reader, exp, brk, todo, __LINE__)
 238
 239 typedef struct _testinput
 240 {
 241     IUnknown IUnknown_iface;
 242     LONG ref;
 243 } testinput;
 244
 245 static inline testinput *impl_from_IUnknown(IUnknown *iface)
 246 {
 247     return CONTAINING_RECORD(iface, testinput, IUnknown_iface);
 248 }
 249
 250 static HRESULT WINAPI testinput_QueryInterface(IUnknown *iface, REFIID riid, void** ppvObj)
 251 {
 252     if (IsEqualGUID( riid, &IID_IUnknown ))
 253     {
 254         *ppvObj = iface;
 255         IUnknown_AddRef(iface);
 256         return S_OK;
 257     }
 258
 259     input_iids.iids[input_iids.count++] = *riid;
 260
 261     *ppvObj = NULL;
 262
 263     return E_NOINTERFACE;
 264 }
 265
 266 static ULONG WINAPI testinput_AddRef(IUnknown *iface)
 267 {
 268     testinput *This = impl_from_IUnknown(iface);
 269     return InterlockedIncrement(&This->ref);
 270 }
 271
 272 static ULONG WINAPI testinput_Release(IUnknown *iface)
 273 {
 274     testinput *This = impl_from_IUnknown(iface);
 275     LONG ref;
 276
 277     ref = InterlockedDecrement(&This->ref);
 278     if (ref == 0)
 279     {
 280         HeapFree(GetProcessHeap(), 0, This);
 281     }
 282
 283     return ref;
 284 }
 285
 286 static const struct IUnknownVtbl testinput_vtbl =
 287 {
 288     testinput_QueryInterface,
 289     testinput_AddRef,
 290     testinput_Release
 291 };
 292
 293 static HRESULT testinput_createinstance(void **ppObj)
 294 {
 295     testinput *input;
 296
 297     input = HeapAlloc(GetProcessHeap(), 0, sizeof (*input));
 298     if(!input) return E_OUTOFMEMORY;
 299
 300     input->IUnknown_iface.lpVtbl = &testinput_vtbl;
 301     input->ref = 1;
 302
 303     *ppObj = &input->IUnknown_iface;
 304
 305     return S_OK;
 306 }
 307
 308 static HRESULT WINAPI teststream_QueryInterface(ISequentialStream *iface, REFIID riid, void **obj)
 309 {
 310     if (IsEqualIID(riid, &IID_IUnknown) || IsEqualIID(riid, &IID_ISequentialStream))
 311     {
 312         *obj = iface;
 313         return S_OK;
 314     }
 315
 316     *obj = NULL;
 317     return E_NOINTERFACE;
 318 }
 319
 320 static ULONG WINAPI teststream_AddRef(ISequentialStream *iface)
 321 {
 322     return 2;
 323 }
 324
 325 static ULONG WINAPI teststream_Release(ISequentialStream *iface)
 326 {
 327     return 1;
 328 }
 329
 330 static int stream_readcall;
 331
 332 static HRESULT WINAPI teststream_Read(ISequentialStream *iface, void *pv, ULONG cb, ULONG *pread)
 333 {
 334     static const char xml[] = "<!-- comment -->";
 335
 336     if (stream_readcall++)
 337     {
 338         *pread = 0;
 339         return E_PENDING;
 340     }
 341
 342     *pread = sizeof(xml) / 2;
 343     memcpy(pv, xml, *pread);
 344     return S_OK;
 345 }
 346
 347 static HRESULT WINAPI teststream_Write(ISequentialStream *iface, const void *pv, ULONG cb, ULONG *written)
 348 {
 349     ok(0, "unexpected call\n");
 350     return E_NOTIMPL;
 351 }
 352
 353 static const ISequentialStreamVtbl teststreamvtbl =
 354 {
 355     teststream_QueryInterface,
 356     teststream_AddRef,
 357     teststream_Release,
 358     teststream_Read,
 359     teststream_Write
 360 };
 361
 362 static HRESULT WINAPI resolver_QI(IXmlResolver *iface, REFIID riid, void **obj)
 363 {
 364     ok(0, "unexpected call, riid %s\n", wine_dbgstr_guid(riid));
 365
 366     if (IsEqualIID(riid, &IID_IXmlResolver) || IsEqualIID(riid, &IID_IUnknown))
 367     {
 368         *obj = iface;
 369         IXmlResolver_AddRef(iface);
 370         return S_OK;
 371     }
 372
 373     *obj = NULL;
 374     return E_NOINTERFACE;
 375 }
 376
 377 static ULONG WINAPI resolver_AddRef(IXmlResolver *iface)
 378 {
 379     return 2;
 380 }
 381
 382 static ULONG WINAPI resolver_Release(IXmlResolver *iface)
 383 {
 384     return 1;
 385 }
 386
 387 static HRESULT WINAPI resolver_ResolveUri(IXmlResolver *iface, const WCHAR *base_uri,
 388     const WCHAR *public_id, const WCHAR *system_id, IUnknown **input)
 389 {
 390     ok(0, "unexpected call\n");
 391     return E_NOTIMPL;
 392 }
 393
 394 static const IXmlResolverVtbl resolvervtbl =
 395 {
 396     resolver_QI,
 397     resolver_AddRef,
 398     resolver_Release,
 399     resolver_ResolveUri
 400 };
 401
 402 static IXmlResolver testresolver = { &resolvervtbl };
 403
 404 static void test_reader_create(void)
 405 {
 406     IXmlResolver *resolver;
 407     HRESULT hr;
 408     IXmlReader *reader;
 409     IUnknown *input;
 410     DtdProcessing dtd;
 411     XmlNodeType nodetype;
 412
 413     /* crashes native */
 414     if (0)
 415     {
 416         CreateXmlReader(&IID_IXmlReader, NULL, NULL);
 417         CreateXmlReader(NULL, (void**)&reader, NULL);
 418     }
 419
 420     hr = CreateXmlReader(&IID_IXmlReader, (void**)&reader, NULL);
 421     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
 422
 423     test_read_state(reader, XmlReadState_Closed, -1, FALSE);
 424
 425     nodetype = XmlNodeType_Element;
 426     hr = IXmlReader_GetNodeType(reader, &nodetype);
 427     ok(hr == S_FALSE, "got %08x\n", hr);
 428     ok(nodetype == XmlNodeType_None, "got %d\n", nodetype);
 429
 430     /* crashes on XP, 2k3, works on newer versions */
 431     if (0)
 432     {
 433         hr = IXmlReader_GetNodeType(reader, NULL);
 434         ok(hr == E_INVALIDARG, "got %08x\n", hr);
 435     }
 436
 437     resolver = (void*)0xdeadbeef;
 438     hr = IXmlReader_GetProperty(reader, XmlReaderProperty_XmlResolver, (LONG_PTR*)&resolver);
 439     ok(hr == S_OK, "got 0x%08x\n", hr);
 440     ok(resolver == NULL, "got %p\n", resolver);
 441
 442     hr = IXmlReader_SetProperty(reader, XmlReaderProperty_XmlResolver, 0);
 443     ok(hr == S_OK, "got 0x%08x\n", hr);
 444
 445     hr = IXmlReader_SetProperty(reader, XmlReaderProperty_XmlResolver, (LONG_PTR)&testresolver);
 446     ok(hr == S_OK, "got 0x%08x\n", hr);
 447
 448     resolver = NULL;
 449     hr = IXmlReader_GetProperty(reader, XmlReaderProperty_XmlResolver, (LONG_PTR*)&resolver);
 450     ok(hr == S_OK, "got 0x%08x\n", hr);
 451     ok(resolver == &testresolver, "got %p\n", resolver);
 452     IXmlResolver_Release(resolver);
 453
 454     hr = IXmlReader_SetProperty(reader, XmlReaderProperty_XmlResolver, 0);
 455     ok(hr == S_OK, "got 0x%08x\n", hr);
 456
 457     dtd = 2;
 458     hr = IXmlReader_GetProperty(reader, XmlReaderProperty_DtdProcessing, (LONG_PTR*)&dtd);
 459     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
 460     ok(dtd == DtdProcessing_Prohibit, "got %d\n", dtd);
 461
 462     dtd = 2;
 463     hr = IXmlReader_SetProperty(reader, XmlReaderProperty_DtdProcessing, dtd);
 464     ok(hr == E_INVALIDARG, "Expected E_INVALIDARG, got %08x\n", hr);
 465
 466     hr = IXmlReader_SetProperty(reader, XmlReaderProperty_DtdProcessing, -1);
 467     ok(hr == E_INVALIDARG, "Expected E_INVALIDARG, got %08x\n", hr);
 468
 469     /* Null input pointer, releases previous input */
 470     hr = IXmlReader_SetInput(reader, NULL);
 471     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
 472
 473     test_read_state(reader, XmlReadState_Initial, XmlReadState_Closed, FALSE);
 474
 475     /* test input interface selection sequence */
 476     hr = testinput_createinstance((void**)&input);
 477     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
 478
 479     if (hr == S_OK)
 480     {
 481         input_iids.count = 0;
 482         hr = IXmlReader_SetInput(reader, input);
 483         ok(hr == E_NOINTERFACE, "Expected E_NOINTERFACE, got %08x\n", hr);
 484         ok_iids(&input_iids, setinput_full, setinput_full_old, FALSE);
 485         IUnknown_Release(input);
 486     }
 487     IXmlReader_Release(reader);
 488 }
 489
 490 static void test_readerinput(void)
 491 {
 492     IXmlReaderInput *reader_input;
 493     IXmlReader *reader, *reader2;
 494     IUnknown *obj, *input;
 495     IStream *stream, *stream2;
 496     XmlNodeType nodetype;
 497     HRESULT hr;
 498     LONG ref;
 499
 500     hr = CreateXmlReaderInputWithEncodingName(NULL, NULL, NULL, FALSE, NULL, NULL);
 501     ok(hr == E_INVALIDARG, "Expected E_INVALIDARG, got %08x\n", hr);
 502     hr = CreateXmlReaderInputWithEncodingName(NULL, NULL, NULL, FALSE, NULL, &reader_input);
 503     ok(hr == E_INVALIDARG, "Expected E_INVALIDARG, got %08x\n", hr);
 504
 505     hr = CreateStreamOnHGlobal(NULL, TRUE, &stream);
 506     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
 507
 508     ref = IStream_AddRef(stream);
 509     ok(ref == 2, "Expected 2, got %d\n", ref);
 510     IStream_Release(stream);
 511     hr = CreateXmlReaderInputWithEncodingName((IUnknown*)stream, NULL, NULL, FALSE, NULL, &reader_input);
 512     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
 513
 514     hr = IUnknown_QueryInterface(reader_input, &IID_IStream, (void**)&stream2);
 515     ok(hr == E_NOINTERFACE, "Expected S_OK, got %08x\n", hr);
 516
 517     hr = IUnknown_QueryInterface(reader_input, &IID_ISequentialStream, (void**)&stream2);
 518     ok(hr == E_NOINTERFACE, "Expected S_OK, got %08x\n", hr);
 519
 520     /* IXmlReaderInput grabs a stream reference */
 521     ref = IStream_AddRef(stream);
 522     ok(ref == 3, "Expected 3, got %d\n", ref);
 523     IStream_Release(stream);
 524
 525     /* try ::SetInput() with valid IXmlReaderInput */
 526     hr = CreateXmlReader(&IID_IXmlReader, (void**)&reader, NULL);
 527     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
 528
 529     ref = IUnknown_AddRef(reader_input);
 530     ok(ref == 2, "Expected 2, got %d\n", ref);
 531     IUnknown_Release(reader_input);
 532
 533     hr = IXmlReader_SetInput(reader, reader_input);
 534     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
 535
 536     test_read_state(reader, XmlReadState_Initial, -1, FALSE);
 537
 538     nodetype = XmlNodeType_Element;
 539     hr = IXmlReader_GetNodeType(reader, &nodetype);
 540     ok(hr == S_OK, "got %08x\n", hr);
 541     ok(nodetype == XmlNodeType_None, "got %d\n", nodetype);
 542
 543     /* IXmlReader grabs a IXmlReaderInput reference */
 544     ref = IUnknown_AddRef(reader_input);
 545     ok(ref == 3, "Expected 3, got %d\n", ref);
 546     IUnknown_Release(reader_input);
 547
 548     ref = IStream_AddRef(stream);
 549     ok(ref == 4, "Expected 4, got %d\n", ref);
 550     IStream_Release(stream);
 551
 552     /* reset input and check state */
 553     hr = IXmlReader_SetInput(reader, NULL);
 554     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
 555
 556     test_read_state(reader, XmlReadState_Initial, XmlReadState_Closed, FALSE);
 557
 558     IXmlReader_Release(reader);
 559
 560     ref = IStream_AddRef(stream);
 561     ok(ref == 3, "Expected 3, got %d\n", ref);
 562     IStream_Release(stream);
 563
 564     ref = IUnknown_AddRef(reader_input);
 565     ok(ref == 2, "Expected 2, got %d\n", ref);
 566     IUnknown_Release(reader_input);
 567
 568     /* IID_IXmlReaderInput */
 569     /* it returns a kind of private undocumented vtable incompatible with IUnknown,
 570        so it's not a COM interface actually.
 571        Such query will be used only to check if input is really IXmlReaderInput */
 572     obj = (IUnknown*)0xdeadbeef;
 573     hr = IUnknown_QueryInterface(reader_input, &IID_IXmlReaderInput, (void**)&obj);
 574     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
 575     ref = IUnknown_AddRef(reader_input);
 576     ok(ref == 3, "Expected 3, got %d\n", ref);
 577     IUnknown_Release(reader_input);
 578
 579     IUnknown_Release(reader_input);
 580     IUnknown_Release(reader_input);
 581     IStream_Release(stream);
 582
 583     /* test input interface selection sequence */
 584     input = NULL;
 585     hr = testinput_createinstance((void**)&input);
 586     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
 587
 588     input_iids.count = 0;
 589     ref = IUnknown_AddRef(input);
 590     ok(ref == 2, "Expected 2, got %d\n", ref);
 591     IUnknown_Release(input);
 592     hr = CreateXmlReaderInputWithEncodingName(input, NULL, NULL, FALSE, NULL, &reader_input);
 593     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
 594     ok_iids(&input_iids, empty_seq, NULL, FALSE);
 595     /* IXmlReaderInput stores stream interface as IUnknown */
 596     ref = IUnknown_AddRef(input);
 597     ok(ref == 3, "Expected 3, got %d\n", ref);
 598     IUnknown_Release(input);
 599
 600     hr = CreateXmlReader(&IID_IXmlReader, (LPVOID*)&reader, NULL);
 601     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
 602
 603     input_iids.count = 0;
 604     ref = IUnknown_AddRef(reader_input);
 605     ok(ref == 2, "Expected 2, got %d\n", ref);
 606     IUnknown_Release(reader_input);
 607     ref = IUnknown_AddRef(input);
 608     ok(ref == 3, "Expected 3, got %d\n", ref);
 609     IUnknown_Release(input);
 610     hr = IXmlReader_SetInput(reader, reader_input);
 611     ok(hr == E_NOINTERFACE, "Expected E_NOINTERFACE, got %08x\n", hr);
 612     ok_iids(&input_iids, setinput_readerinput, NULL, FALSE);
 613
 614     test_read_state(reader, XmlReadState_Closed, -1, FALSE);
 615
 616     ref = IUnknown_AddRef(input);
 617     ok(ref == 3, "Expected 3, got %d\n", ref);
 618     IUnknown_Release(input);
 619
 620     ref = IUnknown_AddRef(reader_input);
 621     ok(ref == 3 || broken(ref == 2) /* versions 1.0.x and 1.1.x - XP, Vista */,
 622           "Expected 3, got %d\n", ref);
 623     IUnknown_Release(reader_input);
 624     /* repeat another time, no check or caching here */
 625     input_iids.count = 0;
 626     hr = IXmlReader_SetInput(reader, reader_input);
 627     ok(hr == E_NOINTERFACE, "Expected E_NOINTERFACE, got %08x\n", hr);
 628     ok_iids(&input_iids, setinput_readerinput, NULL, FALSE);
 629
 630     /* another reader */
 631     hr = CreateXmlReader(&IID_IXmlReader, (LPVOID*)&reader2, NULL);
 632     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
 633
 634     /* resolving from IXmlReaderInput to IStream/ISequentialStream is done at
 635        ::SetInput() level, each time it's called */
 636     input_iids.count = 0;
 637     hr = IXmlReader_SetInput(reader2, reader_input);
 638     ok(hr == E_NOINTERFACE, "Expected E_NOINTERFACE, got %08x\n", hr);
 639     ok_iids(&input_iids, setinput_readerinput, NULL, FALSE);
 640
 641     IXmlReader_Release(reader2);
 642     IXmlReader_Release(reader);
 643
 644     IUnknown_Release(reader_input);
 645     IUnknown_Release(input);
 646 }
 647
 648 static void test_reader_state(void)
 649 {
 650     XmlNodeType nodetype;
 651     IXmlReader *reader;
 652     IStream *stream;
 653     HRESULT hr;
 654
 655     hr = CreateXmlReader(&IID_IXmlReader, (void**)&reader, NULL);
 656     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
 657
 658     /* invalid arguments */
 659     hr = IXmlReader_GetProperty(reader, XmlReaderProperty_ReadState, NULL);
 660     ok(hr == E_INVALIDARG, "Expected E_INVALIDARG, got %08x\n", hr);
 661
 662     /* attempt to read on closed reader */
 663     test_read_state(reader, XmlReadState_Closed, -1, FALSE);
 664 if (0)
 665 {
 666     /* newer versions crash here, probably because no input was set */
 667     hr = IXmlReader_Read(reader, &nodetype);
 668     ok(hr == S_FALSE, "got %08x\n", hr);
 669 }
 670
 671     stream = create_stream_on_data("xml", sizeof("xml"));
 672
 673     hr = IXmlReader_SetInput(reader, (IUnknown *)stream);
 674     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
 675
 676     test_read_state(reader, XmlReadState_Initial, -1, FALSE);
 677
 678     nodetype = XmlNodeType_Element;
 679     hr = IXmlReader_Read(reader, &nodetype);
 680 todo_wine
 681     ok(FAILED(hr), "got %08x\n", hr);
 682     ok(nodetype == XmlNodeType_None, "Unexpected node type %d\n", nodetype);
 683
 684     test_read_state(reader, XmlReadState_Error, -1, TRUE);
 685
 686     nodetype = XmlNodeType_Element;
 687     hr = IXmlReader_Read(reader, &nodetype);
 688 todo_wine
 689     ok(FAILED(hr), "got %08x\n", hr);
 690     ok(nodetype == XmlNodeType_None, "Unexpected node type %d\n", nodetype);
 691
 692     IStream_Release(stream);
 693     IXmlReader_Release(reader);
 694 }
 695
 696 static void test_read_xmldeclaration(void)
 697 {
 698     static const WCHAR xmlW[] = {'x','m','l',0};
 699     static const WCHAR RegistrationInfoW[] = {'R','e','g','i','s','t','r','a','t','i','o','n','I','n','f','o',0};
 700     static const struct
 701     {
 702         WCHAR name[12];
 703         WCHAR val[12];
 704     } name_val[] =
 705     {
 706         { {'v','e','r','s','i','o','n',0}, {'1','.','0',0} },
 707         { {'e','n','c','o','d','i','n','g',0}, {'U','T','F','-','8',0} },
 708         { {'s','t','a','n','d','a','l','o','n','e',0}, {'y','e','s',0} }
 709     };
 710     IXmlReader *reader;
 711     IStream *stream;
 712     HRESULT hr;
 713     XmlNodeType type;
 714     UINT count = 0, len, i;
 715     BOOL ret;
 716     const WCHAR *val;
 717
 718     hr = CreateXmlReader(&IID_IXmlReader, (LPVOID*)&reader, NULL);
 719     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
 720
 721     /* position methods with Null args */
 722     hr = IXmlReader_GetLineNumber(reader, NULL);
 723     ok(hr == E_INVALIDARG, "Expected E_INVALIDARG, got %08x\n", hr);
 724
 725     hr = IXmlReader_GetLinePosition(reader, NULL);
 726     ok(hr == E_INVALIDARG, "Expected E_INVALIDARG, got %08x\n", hr);
 727
 728     stream = create_stream_on_data(xmldecl_full, sizeof(xmldecl_full));
 729
 730     hr = IXmlReader_SetInput(reader, (IUnknown*)stream);
 731     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
 732
 733     hr = IXmlReader_GetAttributeCount(reader, &count);
 734     ok(hr == S_OK, "got %08x\n", hr);
 735     ok(count == 0, "got %d\n", count);
 736
 737     /* try to move without attributes */
 738     hr = IXmlReader_MoveToElement(reader);
 739     ok(hr == S_FALSE, "got %08x\n", hr);
 740
 741     hr = IXmlReader_MoveToNextAttribute(reader);
 742     ok(hr == S_FALSE, "got %08x\n", hr);
 743
 744     hr = IXmlReader_MoveToFirstAttribute(reader);
 745     ok(hr == S_FALSE, "got %08x\n", hr);
 746
 747     ok_pos(reader, 0, 0, -1, -1, FALSE);
 748
 749     type = -1;
 750     hr = IXmlReader_Read(reader, &type);
 751     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
 752     ok(type == XmlNodeType_XmlDeclaration,
 753                      "Expected XmlNodeType_XmlDeclaration, got %s\n", type_to_str(type));
 754     /* new version 1.2.x and 1.3.x properly update position for <?xml ?> */
 755     ok_pos(reader, 1, 3, -1, 55, TRUE);
 756     test_read_state(reader, XmlReadState_Interactive, -1, FALSE);
 757
 758     count = 1;
 759     hr = IXmlReader_GetDepth(reader, &count);
 760     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
 761     ok(count == 0, "Expected 1, got %d\n", count);
 762
 763     hr = IXmlReader_GetValue(reader, &val, NULL);
 764     ok(hr == S_OK, "got %08x\n", hr);
 765     ok(*val == 0, "got %s\n", wine_dbgstr_w(val));
 766
 767     /* check attributes */
 768     hr = IXmlReader_MoveToNextAttribute(reader);
 769     ok(hr == S_OK, "got %08x\n", hr);
 770
 771     count = 0;
 772     hr = IXmlReader_GetDepth(reader, &count);
 773     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
 774     ok(count == 1, "Expected 1, got %d\n", count);
 775
 776     type = XmlNodeType_None;
 777     hr = IXmlReader_GetNodeType(reader, &type);
 778     ok(hr == S_OK, "got %08x\n", hr);
 779     ok(type == XmlNodeType_Attribute, "got %d\n", type);
 780
 781     ok_pos(reader, 1, 7, -1, 55, TRUE);
 782
 783     /* try to move from last attribute */
 784     hr = IXmlReader_MoveToNextAttribute(reader);
 785     ok(hr == S_OK, "got %08x\n", hr);
 786     hr = IXmlReader_MoveToNextAttribute(reader);
 787     ok(hr == S_OK, "got %08x\n", hr);
 788     hr = IXmlReader_MoveToNextAttribute(reader);
 789     ok(hr == S_FALSE, "got %08x\n", hr);
 790
 791     type = XmlNodeType_None;
 792     hr = IXmlReader_GetNodeType(reader, &type);
 793     ok(hr == S_OK, "got %08x\n", hr);
 794     ok(type == XmlNodeType_Attribute, "got %d\n", type);
 795
 796     hr = IXmlReader_MoveToFirstAttribute(reader);
 797     ok(hr == S_OK, "got %08x\n", hr);
 798     ok_pos(reader, 1, 7, -1, 55, TRUE);
 799
 800     hr = IXmlReader_GetAttributeCount(reader, NULL);
 801     ok(hr == E_INVALIDARG, "got %08x\n", hr);
 802
 803     hr = IXmlReader_GetAttributeCount(reader, &count);
 804     ok(hr == S_OK, "got %08x\n", hr);
 805     ok(count == 3, "Expected 3, got %d\n", count);
 806
 807     for (i = 0; i < count; i++)
 808     {
 809         len = 0;
 810         hr = IXmlReader_GetLocalName(reader, &val, &len);
 811         ok(hr == S_OK, "got %08x\n", hr);
 812         ok(len == lstrlenW(name_val[i].name), "expected %u, got %u\n", lstrlenW(name_val[i].name), len);
 813         ok(!lstrcmpW(name_val[i].name, val), "expected %s, got %s\n", wine_dbgstr_w(name_val[i].name), wine_dbgstr_w(val));
 814
 815         len = 0;
 816         hr = IXmlReader_GetValue(reader, &val, &len);
 817         ok(hr == S_OK, "got %08x\n", hr);
 818         ok(len == lstrlenW(name_val[i].val), "expected %u, got %u\n", lstrlenW(name_val[i].val), len);
 819         ok(!lstrcmpW(name_val[i].val, val), "expected %s, got %s\n", wine_dbgstr_w(name_val[i].val), wine_dbgstr_w(val));
 820
 821         hr = IXmlReader_MoveToNextAttribute(reader);
 822         ok(hr == ((i < count - 1) ? S_OK : S_FALSE), "got %08x\n", hr);
 823     }
 824
 825     count = 0;
 826     hr = IXmlReader_GetDepth(reader, &count);
 827     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
 828     ok(count == 1, "Expected 1, got %d\n", count);
 829
 830     hr = IXmlReader_MoveToElement(reader);
 831     ok(hr == S_OK, "got %08x\n", hr);
 832
 833     type = XmlNodeType_None;
 834     hr = IXmlReader_GetNodeType(reader, &type);
 835     ok(hr == S_OK, "got %08x\n", hr);
 836     ok(type == XmlNodeType_XmlDeclaration, "got %d\n", type);
 837
 838     type = XmlNodeType_XmlDeclaration;
 839     hr = IXmlReader_Read(reader, &type);
 840     /* newer versions return syntax error here cause document is incomplete,
 841        it makes more sense than invalid char error */
 842 todo_wine {
 843     ok(hr == WC_E_SYNTAX || broken(hr == WC_E_XMLCHARACTER), "got 0x%08x\n", hr);
 844     ok(type == XmlNodeType_None, "got %d\n", type);
 845 }
 846     IStream_Release(stream);
 847
 848     /* test short variant */
 849     stream = create_stream_on_data(xmldecl_short, sizeof(xmldecl_short));
 850
 851     hr = IXmlReader_SetInput(reader, (IUnknown *)stream);
 852     ok(hr == S_OK, "expected S_OK, got %08x\n", hr);
 853
 854     type = -1;
 855     hr = IXmlReader_Read(reader, &type);
 856     ok(hr == S_OK, "expected S_OK, got %08x\n", hr);
 857     ok(type == XmlNodeType_XmlDeclaration, "expected XmlDeclaration, got %s\n", type_to_str(type));
 858     ok_pos(reader, 1, 3, 1, 21, TRUE);
 859     test_read_state(reader, XmlReadState_Interactive, -1, FALSE);
 860
 861     hr = IXmlReader_GetAttributeCount(reader, &count);
 862     ok(hr == S_OK, "expected S_OK, got %08x\n", hr);
 863     ok(count == 1, "expected 1, got %d\n", count);
 864
 865     ret = IXmlReader_IsEmptyElement(reader);
 866     ok(!ret, "element should not be empty\n");
 867
 868     hr = IXmlReader_GetValue(reader, &val, NULL);
 869     ok(hr == S_OK, "expected S_OK, got %08x\n", hr);
 870     ok(*val == 0, "got %s\n", wine_dbgstr_w(val));
 871
 872     val = NULL;
 873     hr = IXmlReader_GetLocalName(reader, &val, NULL);
 874     ok(hr == S_OK, "expected S_OK, got %08x\n", hr);
 875     ok(!lstrcmpW(val, xmlW), "got %s\n", wine_dbgstr_w(val));
 876
 877     val = NULL;
 878     hr = IXmlReader_GetQualifiedName(reader, &val, NULL);
 879     ok(hr == S_OK, "expected S_OK, got %08x\n", hr);
 880     ok(!lstrcmpW(val, xmlW), "got %s\n", wine_dbgstr_w(val));
 881
 882     /* check attributes */
 883     hr = IXmlReader_MoveToNextAttribute(reader);
 884     ok(hr == S_OK, "expected S_OK, got %08x\n", hr);
 885
 886     type = -1;
 887     hr = IXmlReader_GetNodeType(reader, &type);
 888     ok(hr == S_OK, "expected S_OK, got %08x\n", hr);
 889     ok(type == XmlNodeType_Attribute, "got %d\n", type);
 890     ok_pos(reader, 1, 7, 1, 21, TRUE);
 891
 892     /* try to move from last attribute */
 893     hr = IXmlReader_MoveToNextAttribute(reader);
 894     ok(hr == S_FALSE, "expected S_FALSE, got %08x\n", hr);
 895
 896     type = -1;
 897     hr = IXmlReader_Read(reader, &type);
 898     ok(hr == S_OK, "expected S_OK, got %08x\n", hr);
 899     ok(type == XmlNodeType_Element, "expected Element, got %s\n", type_to_str(type));
 900     ok_pos(reader, 1, 23, 1, 40, TRUE);
 901     test_read_state(reader, XmlReadState_Interactive, -1, FALSE);
 902
 903     hr = IXmlReader_GetAttributeCount(reader, &count);
 904     ok(hr == S_OK, "expected S_OK, got %08x\n", hr);
 905     ok(count == 0, "expected 0, got %d\n", count);
 906
 907     ret = IXmlReader_IsEmptyElement(reader);
 908     ok(ret, "element should be empty\n");
 909
 910     hr = IXmlReader_GetValue(reader, &val, NULL);
 911     ok(hr == S_OK, "expected S_OK, got %08x\n", hr);
 912     ok(*val == 0, "got %s\n", wine_dbgstr_w(val));
 913
 914     hr = IXmlReader_GetLocalName(reader, &val, NULL);
 915     ok(hr == S_OK, "expected S_OK, got %08x\n", hr);
 916     ok(!lstrcmpW(val, RegistrationInfoW), "got %s\n", wine_dbgstr_w(val));
 917
 918     type = -1;
 919     hr = IXmlReader_Read(reader, &type);
 920 todo_wine
 921     ok(hr == WC_E_SYNTAX || hr == WC_E_XMLCHARACTER /* XP */, "expected WC_E_SYNTAX, got %08x\n", hr);
 922     ok(type == XmlNodeType_None, "expected XmlNodeType_None, got %s\n", type_to_str(type));
 923     ok_pos(reader, 1, 41, -1, -1, TRUE);
 924     test_read_state(reader, XmlReadState_Error, -1, TRUE);
 925
 926     IStream_Release(stream);
 927     IXmlReader_Release(reader);
 928 }
 929
 930 struct test_entry {
 931     const char *xml;
 932     const char *name;
 933     const char *value;
 934     HRESULT hr;
 935     HRESULT hr_broken; /* this is set to older version results */
 936     BOOL todo;
 937 };
 938
 939 static struct test_entry comment_tests[] = {
 940     { "<!-- comment -->", "", " comment ", S_OK },
 941     { "<!-- - comment-->", "", " - comment", S_OK },
 942     { "<!-- -- comment-->", NULL, NULL, WC_E_COMMENT, WC_E_GREATERTHAN },
 943     { "<!-- -- comment--->", NULL, NULL, WC_E_COMMENT, WC_E_GREATERTHAN },
 944     { NULL }
 945 };
 946
 947 static void test_read_comment(void)
 948 {
 949     struct test_entry *test = comment_tests;
 950     IXmlReader *reader;
 951     HRESULT hr;
 952
 953     hr = CreateXmlReader(&IID_IXmlReader, (void**)&reader, NULL);
 954     ok(hr == S_OK, "S_OK, got %08x\n", hr);
 955
 956     while (test->xml)
 957     {
 958         XmlNodeType type;
 959         IStream *stream;
 960
 961         stream = create_stream_on_data(test->xml, strlen(test->xml)+1);
 962         hr = IXmlReader_SetInput(reader, (IUnknown*)stream);
 963         ok(hr == S_OK, "got %08x\n", hr);
 964
 965         type = XmlNodeType_None;
 966         hr = IXmlReader_Read(reader, &type);
 967         if (test->hr_broken)
 968             ok(hr == test->hr || broken(hr == test->hr_broken), "got %08x for %s\n", hr, test->xml);
 969         else
 970             ok(hr == test->hr, "got %08x for %s\n", hr, test->xml);
 971         if (hr == S_OK)
 972         {
 973             const WCHAR *str;
 974             WCHAR *str_exp;
 975             UINT len;
 976
 977             ok(type == XmlNodeType_Comment, "got %d for %s\n", type, test->xml);
 978
 979             len = 1;
 980             str = NULL;
 981             hr = IXmlReader_GetLocalName(reader, &str, &len);
 982             ok(hr == S_OK, "got 0x%08x\n", hr);
 983             ok(len == strlen(test->name), "got %u\n", len);
 984             str_exp = a2w(test->name);
 985             ok(!lstrcmpW(str, str_exp), "got %s\n", wine_dbgstr_w(str));
 986             free_str(str_exp);
 987
 988             len = 1;
 989             str = NULL;
 990             hr = IXmlReader_GetQualifiedName(reader, &str, &len);
 991             ok(hr == S_OK, "got 0x%08x\n", hr);
 992             ok(len == strlen(test->name), "got %u\n", len);
 993             str_exp = a2w(test->name);
 994             ok(!lstrcmpW(str, str_exp), "got %s\n", wine_dbgstr_w(str));
 995             free_str(str_exp);
 996
 997             /* value */
 998             len = 1;
 999             str = NULL;
1000             hr = IXmlReader_GetValue(reader, &str, &len);
1001             ok(hr == S_OK, "got 0x%08x\n", hr);
1002             ok(len == strlen(test->value), "got %u\n", len);
1003             str_exp = a2w(test->value);
1004             ok(!lstrcmpW(str, str_exp), "got %s\n", wine_dbgstr_w(str));
1005             free_str(str_exp);
1006         }
1007
1008         IStream_Release(stream);
1009         test++;
1010     }
1011
1012     IXmlReader_Release(reader);
1013 }
1014
1015 static struct test_entry pi_tests[] = {
1016     { "<?pi?>", "pi", "", S_OK },
1017     { "<?pi ?>", "pi", "", S_OK },
1018     { "<?pi  ?>", "pi", "", S_OK },
1019     { "<?pi pi data?>", "pi", "pi data", S_OK },
1020     { "<?pi pi data  ?>", "pi", "pi data  ", S_OK },
1021     { "<?pi    data  ?>", "pi", "data  ", S_OK },
1022     { "<?pi:pi?>", NULL, NULL, NC_E_NAMECOLON, WC_E_NAMECHARACTER },
1023     { "<?:pi ?>", NULL, NULL, WC_E_PI, WC_E_NAMECHARACTER },
1024     { "<?-pi ?>", NULL, NULL, WC_E_PI, WC_E_NAMECHARACTER },
1025     { "<?xml-stylesheet ?>", "xml-stylesheet", "", S_OK },
1026     { NULL }
1027 };
1028
1029 static void test_read_pi(void)
1030 {
1031     struct test_entry *test = pi_tests;
1032     IXmlReader *reader;
1033     HRESULT hr;
1034
1035     hr = CreateXmlReader(&IID_IXmlReader, (void**)&reader, NULL);
1036     ok(hr == S_OK, "S_OK, got %08x\n", hr);
1037
1038     while (test->xml)
1039     {
1040         XmlNodeType type;
1041         IStream *stream;
1042
1043         stream = create_stream_on_data(test->xml, strlen(test->xml)+1);
1044         hr = IXmlReader_SetInput(reader, (IUnknown*)stream);
1045         ok(hr == S_OK, "got %08x\n", hr);
1046
1047         type = XmlNodeType_None;
1048         hr = IXmlReader_Read(reader, &type);
1049         if (test->hr_broken)
1050             ok(hr == test->hr || broken(hr == test->hr_broken), "got %08x for %s\n", hr, test->xml);
1051         else
1052             ok(hr == test->hr, "got %08x for %s\n", hr, test->xml);
1053         if (hr == S_OK)
1054         {
1055             const WCHAR *str;
1056             WCHAR *str_exp;
1057             UINT len;
1058
1059             ok(type == XmlNodeType_ProcessingInstruction, "got %d for %s\n", type, test->xml);
1060
1061             len = 0;
1062             str = NULL;
1063             hr = IXmlReader_GetLocalName(reader, &str, &len);
1064             ok(hr == S_OK, "got 0x%08x\n", hr);
1065             ok(len == strlen(test->name), "got %u\n", len);
1066             str_exp = a2w(test->name);
1067             ok(!lstrcmpW(str, str_exp), "got %s\n", wine_dbgstr_w(str));
1068             free_str(str_exp);
1069
1070             len = 0;
1071             str = NULL;
1072             hr = IXmlReader_GetQualifiedName(reader, &str, &len);
1073             ok(hr == S_OK, "got 0x%08x\n", hr);
1074             ok(len == strlen(test->name), "got %u\n", len);
1075             str_exp = a2w(test->name);
1076             ok(!lstrcmpW(str, str_exp), "got %s\n", wine_dbgstr_w(str));
1077             free_str(str_exp);
1078
1079             /* value */
1080             len = !strlen(test->value);
1081             str = NULL;
1082             hr = IXmlReader_GetValue(reader, &str, &len);
1083             ok(hr == S_OK, "got 0x%08x\n", hr);
1084             ok(len == strlen(test->value), "got %u\n", len);
1085             str_exp = a2w(test->value);
1086             ok(!lstrcmpW(str, str_exp), "got %s\n", wine_dbgstr_w(str));
1087             free_str(str_exp);
1088         }
1089
1090         IStream_Release(stream);
1091         test++;
1092     }
1093
1094     IXmlReader_Release(reader);
1095 }
1096
1097 struct nodes_test {
1098     const char *xml;
1099     XmlNodeType types[20];
1100 };
1101
1102 static const char misc_test_xml[] =
1103     "<!-- comment1 -->"
1104     "<!-- comment2 -->"
1105     "<?pi1 pi1body ?>"
1106     "<!-- comment3 -->"
1107     " \t \r \n"
1108     "<!-- comment4 -->"
1109     "<a>"
1110     "\r\n\t"
1111     "<b/>"
1112     "text"
1113     "<!-- comment -->"
1114     "text2"
1115     "<?pi pibody ?>"
1116     "\r\n"
1117     "</a>"
1118 ;
1119
1120 static struct nodes_test misc_test = {
1121     misc_test_xml,
1122     {
1123         XmlNodeType_Comment,
1124         XmlNodeType_Comment,
1125         XmlNodeType_ProcessingInstruction,
1126         XmlNodeType_Comment,
1127         XmlNodeType_Whitespace,
1128         XmlNodeType_Comment,
1129         XmlNodeType_Element,
1130         XmlNodeType_Whitespace,
1131         XmlNodeType_Element,
1132         XmlNodeType_Text,
1133         XmlNodeType_Comment,
1134         XmlNodeType_Text,
1135         XmlNodeType_ProcessingInstruction,
1136         XmlNodeType_Whitespace,
1137         XmlNodeType_EndElement,
1138         XmlNodeType_None
1139     }
1140 };
1141
1142 static void test_read_full(void)
1143 {
1144     struct nodes_test *test = &misc_test;
1145     IXmlReader *reader;
1146     XmlNodeType type;
1147     IStream *stream;
1148     HRESULT hr;
1149     int i;
1150
1151     hr = CreateXmlReader(&IID_IXmlReader, (void**)&reader, NULL);
1152     ok(hr == S_OK, "S_OK, got %08x\n", hr);
1153
1154     stream = create_stream_on_data(test->xml, strlen(test->xml)+1);
1155     hr = IXmlReader_SetInput(reader, (IUnknown*)stream);
1156     ok(hr == S_OK, "got %08x\n", hr);
1157
1158     i = 0;
1159     type = ~0u;
1160     while (IXmlReader_Read(reader, &type) == S_OK)
1161     {
1162         ok(test->types[i] != XmlNodeType_None, "%d: unexpected end of test data\n", i);
1163         if (test->types[i] == XmlNodeType_None) break;
1164         ok(type == test->types[i], "%d: got wrong type %d, expected %d\n", i, type, test->types[i]);
1165         if (type == XmlNodeType_Whitespace)
1166         {
1167             const WCHAR *ptr;
1168             UINT len = 0;
1169
1170             hr = IXmlReader_GetValue(reader, &ptr, &len);
1171             ok(hr == S_OK, "%d: GetValue failed 0x%08x\n", i, hr);
1172             ok(len > 0, "%d: wrong value length %d\n", i, len);
1173         }
1174         i++;
1175     }
1176     ok(test->types[i] == XmlNodeType_None, "incomplete sequence, got %d\n", test->types[i]);
1177
1178     IStream_Release(stream);
1179     IXmlReader_Release(reader);
1180 }
1181
1182 static const char test_public_dtd[] =
1183     "<!DOCTYPE testdtd PUBLIC \"pubid\" \"externalid uri\" >";
1184
1185 static void test_read_public_dtd(void)
1186 {
1187     static const WCHAR sysvalW[] = {'e','x','t','e','r','n','a','l','i','d',' ','u','r','i',0};
1188     static const WCHAR pubvalW[] = {'p','u','b','i','d',0};
1189     static const WCHAR dtdnameW[] = {'t','e','s','t','d','t','d',0};
1190     static const WCHAR sysW[] = {'S','Y','S','T','E','M',0};
1191     static const WCHAR pubW[] = {'P','U','B','L','I','C',0};
1192     IXmlReader *reader;
1193     const WCHAR *str;
1194     XmlNodeType type;
1195     IStream *stream;
1196     UINT len, count;
1197     HRESULT hr;
1198
1199     hr = CreateXmlReader(&IID_IXmlReader, (void**)&reader, NULL);
1200     ok(hr == S_OK, "S_OK, got %08x\n", hr);
1201
1202     hr = IXmlReader_SetProperty(reader, XmlReaderProperty_DtdProcessing, DtdProcessing_Parse);
1203     ok(hr == S_OK, "got 0x%8x\n", hr);
1204
1205     stream = create_stream_on_data(test_public_dtd, sizeof(test_public_dtd));
1206     hr = IXmlReader_SetInput(reader, (IUnknown*)stream);
1207     ok(hr == S_OK, "got %08x\n", hr);
1208
1209     type = XmlNodeType_None;
1210     hr = IXmlReader_Read(reader, &type);
1211     ok(hr == S_OK, "got 0x%8x\n", hr);
1212     ok(type == XmlNodeType_DocumentType, "got type %d\n", type);
1213
1214     count = 0;
1215     hr = IXmlReader_GetAttributeCount(reader, &count);
1216     ok(hr == S_OK, "got %08x\n", hr);
1217     ok(count == 2, "got %d\n", count);
1218
1219     hr = IXmlReader_MoveToFirstAttribute(reader);
1220     ok(hr == S_OK, "got %08x\n", hr);
1221
1222     type = XmlNodeType_None;
1223     hr = IXmlReader_GetNodeType(reader, &type);
1224     ok(hr == S_OK, "got %08x\n", hr);
1225     ok(type == XmlNodeType_Attribute, "got %d\n", type);
1226
1227     len = 0;
1228     str = NULL;
1229     hr = IXmlReader_GetLocalName(reader, &str, &len);
1230     ok(hr == S_OK, "got 0x%08x\n", hr);
1231     ok(len == lstrlenW(pubW), "got %u\n", len);
1232     ok(!lstrcmpW(str, pubW), "got %s\n", wine_dbgstr_w(str));
1233
1234     len = 0;
1235     str = NULL;
1236     hr = IXmlReader_GetValue(reader, &str, &len);
1237     ok(hr == S_OK, "got 0x%08x\n", hr);
1238     ok(len == lstrlenW(pubvalW), "got %u\n", len);
1239     ok(!lstrcmpW(str, pubvalW), "got %s\n", wine_dbgstr_w(str));
1240
1241     hr = IXmlReader_MoveToNextAttribute(reader);
1242     ok(hr == S_OK, "got %08x\n", hr);
1243
1244     type = XmlNodeType_None;
1245     hr = IXmlReader_GetNodeType(reader, &type);
1246     ok(hr == S_OK, "got %08x\n", hr);
1247     ok(type == XmlNodeType_Attribute, "got %d\n", type);
1248
1249     len = 0;
1250     str = NULL;
1251     hr = IXmlReader_GetLocalName(reader, &str, &len);
1252     ok(hr == S_OK, "got 0x%08x\n", hr);
1253     ok(len == lstrlenW(sysW), "got %u\n", len);
1254     ok(!lstrcmpW(str, sysW), "got %s\n", wine_dbgstr_w(str));
1255
1256     len = 0;
1257     str = NULL;
1258     hr = IXmlReader_GetValue(reader, &str, &len);
1259     ok(hr == S_OK, "got 0x%08x\n", hr);
1260     ok(len == lstrlenW(sysvalW), "got %u\n", len);
1261     ok(!lstrcmpW(str, sysvalW), "got %s\n", wine_dbgstr_w(str));
1262
1263     hr = IXmlReader_MoveToElement(reader);
1264     ok(hr == S_OK, "got 0x%08x\n", hr);
1265
1266     len = 0;
1267     str = NULL;
1268     hr = IXmlReader_GetLocalName(reader, &str, &len);
1269     ok(hr == S_OK, "got 0x%08x\n", hr);
1270 todo_wine {
1271     ok(len == lstrlenW(dtdnameW), "got %u\n", len);
1272     ok(!lstrcmpW(str, dtdnameW), "got %s\n", wine_dbgstr_w(str));
1273 }
1274     len = 0;
1275     str = NULL;
1276     hr = IXmlReader_GetQualifiedName(reader, &str, &len);
1277     ok(hr == S_OK, "got 0x%08x\n", hr);
1278     ok(len == lstrlenW(dtdnameW), "got %u\n", len);
1279     ok(!lstrcmpW(str, dtdnameW), "got %s\n", wine_dbgstr_w(str));
1280
1281     IStream_Release(stream);
1282     IXmlReader_Release(reader);
1283 }
1284
1285 static const char test_system_dtd[] =
1286     "<!DOCTYPE testdtd SYSTEM \"externalid uri\" >"
1287     "<!-- comment -->";
1288
1289 static void test_read_system_dtd(void)
1290 {
1291     static const WCHAR sysvalW[] = {'e','x','t','e','r','n','a','l','i','d',' ','u','r','i',0};
1292     static const WCHAR dtdnameW[] = {'t','e','s','t','d','t','d',0};
1293     static const WCHAR sysW[] = {'S','Y','S','T','E','M',0};
1294     IXmlReader *reader;
1295     const WCHAR *str;
1296     XmlNodeType type;
1297     IStream *stream;
1298     UINT len, count;
1299     HRESULT hr;
1300
1301     hr = CreateXmlReader(&IID_IXmlReader, (void**)&reader, NULL);
1302     ok(hr == S_OK, "S_OK, got %08x\n", hr);
1303
1304     hr = IXmlReader_SetProperty(reader, XmlReaderProperty_DtdProcessing, DtdProcessing_Parse);
1305     ok(hr == S_OK, "got 0x%8x\n", hr);
1306
1307     stream = create_stream_on_data(test_system_dtd, sizeof(test_system_dtd));
1308     hr = IXmlReader_SetInput(reader, (IUnknown*)stream);
1309     ok(hr == S_OK, "got %08x\n", hr);
1310
1311     type = XmlNodeType_None;
1312     hr = IXmlReader_Read(reader, &type);
1313     ok(hr == S_OK, "got 0x%8x\n", hr);
1314     ok(type == XmlNodeType_DocumentType, "got type %d\n", type);
1315
1316     count = 0;
1317     hr = IXmlReader_GetAttributeCount(reader, &count);
1318     ok(hr == S_OK, "got %08x\n", hr);
1319     ok(count == 1, "got %d\n", count);
1320
1321     hr = IXmlReader_MoveToFirstAttribute(reader);
1322     ok(hr == S_OK, "got %08x\n", hr);
1323
1324     type = XmlNodeType_None;
1325     hr = IXmlReader_GetNodeType(reader, &type);
1326     ok(hr == S_OK, "got %08x\n", hr);
1327     ok(type == XmlNodeType_Attribute, "got %d\n", type);
1328
1329     len = 0;
1330     str = NULL;
1331     hr = IXmlReader_GetLocalName(reader, &str, &len);
1332     ok(hr == S_OK, "got 0x%08x\n", hr);
1333     ok(len == lstrlenW(sysW), "got %u\n", len);
1334     ok(!lstrcmpW(str, sysW), "got %s\n", wine_dbgstr_w(str));
1335
1336     len = 0;
1337     str = NULL;
1338     hr = IXmlReader_GetValue(reader, &str, &len);
1339     ok(hr == S_OK, "got 0x%08x\n", hr);
1340     ok(len == lstrlenW(sysvalW), "got %u\n", len);
1341     ok(!lstrcmpW(str, sysvalW), "got %s\n", wine_dbgstr_w(str));
1342
1343     hr = IXmlReader_MoveToElement(reader);
1344     ok(hr == S_OK, "got 0x%08x\n", hr);
1345
1346     len = 0;
1347     str = NULL;
1348     hr = IXmlReader_GetLocalName(reader, &str, &len);
1349     ok(hr == S_OK, "got 0x%08x\n", hr);
1350 todo_wine {
1351     ok(len == lstrlenW(dtdnameW), "got %u\n", len);
1352     ok(!lstrcmpW(str, dtdnameW), "got %s\n", wine_dbgstr_w(str));
1353 }
1354     len = 0;
1355     str = NULL;
1356     hr = IXmlReader_GetQualifiedName(reader, &str, &len);
1357     ok(hr == S_OK, "got 0x%08x\n", hr);
1358     ok(len == lstrlenW(dtdnameW), "got %u\n", len);
1359     ok(!lstrcmpW(str, dtdnameW), "got %s\n", wine_dbgstr_w(str));
1360
1361     type = XmlNodeType_None;
1362     hr = IXmlReader_Read(reader, &type);
1363     ok(hr == S_OK, "got 0x%8x\n", hr);
1364     ok(type == XmlNodeType_Comment, "got type %d\n", type);
1365
1366     IStream_Release(stream);
1367     IXmlReader_Release(reader);
1368 }
1369
1370 static struct test_entry element_tests[] = {
1371     { "<a/>", "a", "", S_OK },
1372     { "<a />", "a", "", S_OK },
1373     { "<a:b/>", "a:b", "", NC_E_UNDECLAREDPREFIX },
1374     { "<:a/>", NULL, NULL, NC_E_QNAMECHARACTER },
1375     { "< a/>", NULL, NULL, NC_E_QNAMECHARACTER },
1376     { "<a>", "a", "", S_OK },
1377     { "<a >", "a", "", S_OK },
1378     { "<a \r \t\n>", "a", "", S_OK },
1379     { "</a>", NULL, NULL, NC_E_QNAMECHARACTER },
1380     { NULL }
1381 };
1382
1383 static void test_read_element(void)
1384 {
1385     struct test_entry *test = element_tests;
1386     static const char stag[] =
1387          "<a attr1=\"_a\">"
1388              "<b attr2=\"_b\">"
1389                  "text"
1390                  "<c attr3=\"_c\"/>"
1391                  "<d attr4=\"_d\"></d>"
1392              "</b>"
1393          "</a>";
1394     static const UINT depths[] = { 0, 1, 2, 2, 2, 3, 2, 1 };
1395     static const char mismatch[] = "<a></b>";
1396     IXmlReader *reader;
1397     XmlNodeType type;
1398     IStream *stream;
1399     unsigned int i;
1400     UINT depth;
1401     HRESULT hr;
1402
1403     hr = CreateXmlReader(&IID_IXmlReader, (void**)&reader, NULL);
1404     ok(hr == S_OK, "S_OK, got %08x\n", hr);
1405
1406     while (test->xml)
1407     {
1408         stream = create_stream_on_data(test->xml, strlen(test->xml)+1);
1409         hr = IXmlReader_SetInput(reader, (IUnknown*)stream);
1410         ok(hr == S_OK, "got %08x\n", hr);
1411
1412         type = XmlNodeType_None;
1413         hr = IXmlReader_Read(reader, &type);
1414         if (test->hr_broken)
1415             ok(hr == test->hr || broken(hr == test->hr_broken), "got %08x for %s\n", hr, test->xml);
1416         else
1417             todo_wine_if(test->hr == NC_E_UNDECLAREDPREFIX)
1418                 ok(hr == test->hr, "got %08x for %s\n", hr, test->xml);
1419         if (hr == S_OK)
1420         {
1421             const WCHAR *str;
1422             WCHAR *str_exp;
1423             UINT len;
1424
1425             ok(type == XmlNodeType_Element, "got %d for %s\n", type, test->xml);
1426
1427             len = 0;
1428             str = NULL;
1429             hr = IXmlReader_GetQualifiedName(reader, &str, &len);
1430             ok(hr == S_OK, "got 0x%08x\n", hr);
1431             ok(len == strlen(test->name), "got %u\n", len);
1432             str_exp = a2w(test->name);
1433             ok(!lstrcmpW(str, str_exp), "got %s\n", wine_dbgstr_w(str));
1434             free_str(str_exp);
1435
1436             /* value */
1437             len = 1;
1438             str = NULL;
1439             hr = IXmlReader_GetValue(reader, &str, &len);
1440             ok(hr == S_OK, "got 0x%08x\n", hr);
1441             ok(len == 0, "got %u\n", len);
1442             ok(*str == 0, "got %s\n", wine_dbgstr_w(str));
1443         }
1444
1445         IStream_Release(stream);
1446         test++;
1447     }
1448
1449     /* test reader depth increment */
1450     stream = create_stream_on_data(stag, sizeof(stag));
1451     hr = IXmlReader_SetInput(reader, (IUnknown *)stream);
1452     ok(hr == S_OK, "got %08x\n", hr);
1453
1454     i = 0;
1455     while (IXmlReader_Read(reader, &type) == S_OK)
1456     {
1457         ok(type == XmlNodeType_Element || type == XmlNodeType_EndElement ||
1458                 type == XmlNodeType_Text, "Unexpected node type %d\n", type);
1459
1460         depth = 123;
1461         hr = IXmlReader_GetDepth(reader, &depth);
1462         ok(hr == S_OK, "got %08x\n", hr);
1463         ok(depth == depths[i], "%u: got depth %u, expected %u\n", i, depth, depths[i]);
1464
1465         if (type == XmlNodeType_Element)
1466         {
1467             UINT count = 0;
1468
1469             hr = IXmlReader_GetAttributeCount(reader, &count);
1470             ok(hr == S_OK, "got %08x\n", hr);
1471
1472             /* moving to attributes increases depth */
1473             if (count)
1474             {
1475                 const WCHAR *value;
1476
1477                 hr = IXmlReader_GetValue(reader, &value, NULL);
1478                 ok(*value == 0, "Unexpected value %s\n", wine_dbgstr_w(value));
1479
1480                 hr = IXmlReader_MoveToFirstAttribute(reader);
1481                 ok(hr == S_OK, "got %08x\n", hr);
1482
1483                 hr = IXmlReader_GetValue(reader, &value, NULL);
1484                 ok(*value != 0, "Unexpected value %s\n", wine_dbgstr_w(value));
1485
1486                 depth = 123;
1487                 hr = IXmlReader_GetDepth(reader, &depth);
1488                 ok(hr == S_OK, "got %08x\n", hr);
1489                 ok(depth == depths[i] + 1, "%u: got depth %u, expected %u\n", i, depth, depths[i] + 1);
1490
1491                 hr = IXmlReader_MoveToElement(reader);
1492                 ok(hr == S_OK, "got %08x\n", hr);
1493
1494                 hr = IXmlReader_GetValue(reader, &value, NULL);
1495                 ok(*value == 0, "Unexpected value %s\n", wine_dbgstr_w(value));
1496
1497                 depth = 123;
1498                 hr = IXmlReader_GetDepth(reader, &depth);
1499                 ok(hr == S_OK, "got %08x\n", hr);
1500                 ok(depth == depths[i], "%u: got depth %u, expected %u\n", i, depth, depths[i]);
1501             }
1502         }
1503
1504         i++;
1505     }
1506
1507     IStream_Release(stream);
1508
1509     /* start/end tag mismatch */
1510     stream = create_stream_on_data(mismatch, sizeof(mismatch));
1511     hr = IXmlReader_SetInput(reader, (IUnknown*)stream);
1512     ok(hr == S_OK, "got %08x\n", hr);
1513
1514     type = XmlNodeType_None;
1515     hr = IXmlReader_Read(reader, &type);
1516     ok(hr == S_OK, "got %08x\n", hr);
1517     ok(type == XmlNodeType_Element, "got %d\n", type);
1518
1519     type = XmlNodeType_Element;
1520     hr = IXmlReader_Read(reader, &type);
1521     ok(hr == WC_E_ELEMENTMATCH, "got %08x\n", hr);
1522 todo_wine
1523     ok(type == XmlNodeType_None, "got %d\n", type);
1524
1525     IStream_Release(stream);
1526
1527     IXmlReader_Release(reader);
1528 }
1529
1530 static ISequentialStream teststream = { &teststreamvtbl };
1531
1532 static void test_read_pending(void)
1533 {
1534     IXmlReader *reader;
1535     const WCHAR *value;
1536     XmlNodeType type;
1537     HRESULT hr;
1538     int c;
1539
1540     hr = CreateXmlReader(&IID_IXmlReader, (void**)&reader, NULL);
1541     ok(hr == S_OK, "S_OK, got 0x%08x\n", hr);
1542
1543     hr = IXmlReader_SetInput(reader, (IUnknown*)&teststream);
1544     ok(hr == S_OK, "got 0x%08x\n", hr);
1545
1546     /* first read call returns incomplete node, second attempt fails with E_PENDING */
1547     stream_readcall = 0;
1548     type = XmlNodeType_Element;
1549     hr = IXmlReader_Read(reader, &type);
1550     ok(hr == S_OK || broken(hr == E_PENDING), "got 0x%08x\n", hr);
1551     /* newer versions are happy when it's enough data to detect node type,
1552        older versions keep reading until it fails to read more */
1553     ok(stream_readcall == 1 || broken(stream_readcall > 1), "got %d\n", stream_readcall);
1554     ok(type == XmlNodeType_Comment || broken(type == XmlNodeType_None), "got %d\n", type);
1555
1556     /* newer versions' GetValue() makes an attempt to read more */
1557     c = stream_readcall;
1558     value = (void*)0xdeadbeef;
1559     hr = IXmlReader_GetValue(reader, &value, NULL);
1560     ok(hr == E_PENDING, "got 0x%08x\n", hr);
1561     ok(value == NULL || broken(value == (void*)0xdeadbeef) /* Win8 sets it to NULL */, "got %p\n", value);
1562     ok(c < stream_readcall || broken(c == stream_readcall), "got %d, expected %d\n", stream_readcall, c+1);
1563
1564     IXmlReader_Release(reader);
1565 }
1566
1567 static void test_readvaluechunk(void)
1568 {
1569     static const char testA[] = "<!-- comment1 -->";
1570     IXmlReader *reader;
1571     XmlNodeType type;
1572     IStream *stream;
1573     const WCHAR *value;
1574     WCHAR b;
1575     HRESULT hr;
1576     UINT c;
1577
1578     hr = CreateXmlReader(&IID_IXmlReader, (void**)&reader, NULL);
1579     ok(hr == S_OK, "S_OK, got %08x\n", hr);
1580
1581     stream = create_stream_on_data(testA, sizeof(testA));
1582     hr = IXmlReader_SetInput(reader, (IUnknown*)stream);
1583     ok(hr == S_OK, "got %08x\n", hr);
1584
1585     hr = IXmlReader_Read(reader, &type);
1586     ok(hr == S_OK, "got %08x\n", hr);
1587
1588     c = 0;
1589     b = 0;
1590     hr = IXmlReader_ReadValueChunk(reader, &b, 1, &c);
1591     ok(hr == S_OK, "got %08x\n", hr);
1592     ok(c == 1, "got %u\n", c);
1593     ok(b == ' ', "got %x\n", b);
1594
1595     /* portion read as chunk is skipped from resulting node value */
1596     value = NULL;
1597     hr = IXmlReader_GetValue(reader, &value, NULL);
1598     ok(hr == S_OK, "got %08x\n", hr);
1599     ok(value[0] == 'c', "got %s\n", wine_dbgstr_w(value));
1600
1601     /* once value is returned/allocated it's not possible to read by chunk */
1602     c = 0;
1603     b = 0;
1604     hr = IXmlReader_ReadValueChunk(reader, &b, 1, &c);
1605     ok(hr == S_FALSE, "got %08x\n", hr);
1606     ok(c == 0, "got %u\n", c);
1607     ok(b == 0, "got %x\n", b);
1608
1609     value = NULL;
1610     hr = IXmlReader_GetValue(reader, &value, NULL);
1611     ok(hr == S_OK, "got %08x\n", hr);
1612     ok(value[0] == 'c', "got %s\n", wine_dbgstr_w(value));
1613
1614     IXmlReader_Release(reader);
1615     IStream_Release(stream);
1616 }
1617
1618 static struct test_entry cdata_tests[] = {
1619     { "<a><![CDATA[ ]]data ]]></a>", "", " ]]data ", S_OK },
1620     { "<a><![CDATA[<![CDATA[ data ]]]]></a>", "", "<![CDATA[ data ]]", S_OK },
1621     { "<a><![CDATA[\n \r\n \n\n ]]></a>", "", "\n \n \n\n ", S_OK, S_OK, TRUE },
1622     { "<a><![CDATA[\r \r\r\n \n\n ]]></a>", "", "\n \n\n \n\n ", S_OK, S_OK, TRUE },
1623     { "<a><![CDATA[\r\r \n\r \r \n\n ]]></a>", "", "\n\n \n\n \n \n\n ", S_OK },
1624     { NULL }
1625 };
1626
1627 static void test_read_cdata(void)
1628 {
1629     struct test_entry *test = cdata_tests;
1630     IXmlReader *reader;
1631     HRESULT hr;
1632
1633     hr = CreateXmlReader(&IID_IXmlReader, (void**)&reader, NULL);
1634     ok(hr == S_OK, "S_OK, got %08x\n", hr);
1635
1636     while (test->xml)
1637     {
1638         XmlNodeType type;
1639         IStream *stream;
1640
1641         stream = create_stream_on_data(test->xml, strlen(test->xml)+1);
1642         hr = IXmlReader_SetInput(reader, (IUnknown*)stream);
1643         ok(hr == S_OK, "got %08x\n", hr);
1644
1645         type = XmlNodeType_None;
1646         hr = IXmlReader_Read(reader, &type);
1647
1648         /* read one more to get to CDATA */
1649         if (type == XmlNodeType_Element)
1650         {
1651             type = XmlNodeType_None;
1652             hr = IXmlReader_Read(reader, &type);
1653         }
1654
1655         if (test->hr_broken)
1656             ok(hr == test->hr || broken(hr == test->hr_broken), "got %08x for %s\n", hr, test->xml);
1657         else
1658             ok(hr == test->hr, "got %08x for %s\n", hr, test->xml);
1659         if (hr == S_OK)
1660         {
1661             const WCHAR *str;
1662             WCHAR *str_exp;
1663             UINT len;
1664
1665             ok(type == XmlNodeType_CDATA, "got %d for %s\n", type, test->xml);
1666
1667             str_exp = a2w(test->name);
1668
1669             len = 1;
1670             str = NULL;
1671             hr = IXmlReader_GetLocalName(reader, &str, &len);
1672             ok(hr == S_OK, "got 0x%08x\n", hr);
1673             ok(len == strlen(test->name), "got %u\n", len);
1674             ok(!lstrcmpW(str, str_exp), "got %s\n", wine_dbgstr_w(str));
1675
1676             str = NULL;
1677             hr = IXmlReader_GetLocalName(reader, &str, NULL);
1678             ok(hr == S_OK, "got 0x%08x\n", hr);
1679             ok(!lstrcmpW(str, str_exp), "got %s\n", wine_dbgstr_w(str));
1680
1681             free_str(str_exp);
1682
1683             len = 1;
1684             str = NULL;
1685             hr = IXmlReader_GetQualifiedName(reader, &str, &len);
1686             ok(hr == S_OK, "got 0x%08x\n", hr);
1687             ok(len == strlen(test->name), "got %u\n", len);
1688             str_exp = a2w(test->name);
1689             ok(!lstrcmpW(str, str_exp), "got %s\n", wine_dbgstr_w(str));
1690             free_str(str_exp);
1691
1692             /* value */
1693             len = 1;
1694             str = NULL;
1695             hr = IXmlReader_GetValue(reader, &str, &len);
1696             ok(hr == S_OK, "got 0x%08x\n", hr);
1697
1698             str_exp = a2w(test->value);
1699             todo_wine_if (test->todo)
1700             {
1701                 ok(len == strlen(test->value), "got %u\n", len);
1702                 ok(!lstrcmpW(str, str_exp), "got %s\n", wine_dbgstr_w(str));
1703             }
1704             free_str(str_exp);
1705         }
1706
1707         IStream_Release(stream);
1708         test++;
1709     }
1710
1711     IXmlReader_Release(reader);
1712 }
1713
1714 static struct test_entry text_tests[] = {
1715     { "<a>simple text</a>", "", "simple text", S_OK },
1716     { "<a>text ]]> text</a>", "", "", WC_E_CDSECTEND },
1717     { NULL }
1718 };
1719
1720 static void test_read_text(void)
1721 {
1722     struct test_entry *test = text_tests;
1723     IXmlReader *reader;
1724     HRESULT hr;
1725
1726     hr = CreateXmlReader(&IID_IXmlReader, (void**)&reader, NULL);
1727     ok(hr == S_OK, "S_OK, got %08x\n", hr);
1728
1729     while (test->xml)
1730     {
1731         XmlNodeType type;
1732         IStream *stream;
1733
1734         stream = create_stream_on_data(test->xml, strlen(test->xml)+1);
1735         hr = IXmlReader_SetInput(reader, (IUnknown*)stream);
1736         ok(hr == S_OK, "got %08x\n", hr);
1737
1738         type = XmlNodeType_None;
1739         hr = IXmlReader_Read(reader, &type);
1740
1741         /* read one more to get to CDATA */
1742         if (type == XmlNodeType_Element)
1743         {
1744             type = XmlNodeType_None;
1745             hr = IXmlReader_Read(reader, &type);
1746         }
1747
1748         if (test->hr_broken)
1749             ok(hr == test->hr || broken(hr == test->hr_broken), "got %08x for %s\n", hr, test->xml);
1750         else
1751             ok(hr == test->hr, "got %08x for %s\n", hr, test->xml);
1752         if (hr == S_OK)
1753         {
1754             const WCHAR *str;
1755             WCHAR *str_exp;
1756             UINT len;
1757
1758             ok(type == XmlNodeType_Text, "got %d for %s\n", type, test->xml);
1759
1760             str_exp = a2w(test->name);
1761
1762             len = 1;
1763             str = NULL;
1764             hr = IXmlReader_GetLocalName(reader, &str, &len);
1765             ok(hr == S_OK, "got 0x%08x\n", hr);
1766             ok(len == strlen(test->name), "got %u\n", len);
1767             ok(!lstrcmpW(str, str_exp), "got %s\n", wine_dbgstr_w(str));
1768
1769             str = NULL;
1770             hr = IXmlReader_GetLocalName(reader, &str, NULL);
1771             ok(hr == S_OK, "got 0x%08x\n", hr);
1772             ok(!lstrcmpW(str, str_exp), "got %s\n", wine_dbgstr_w(str));
1773
1774             free_str(str_exp);
1775
1776             len = 1;
1777             str = NULL;
1778             hr = IXmlReader_GetQualifiedName(reader, &str, &len);
1779             ok(hr == S_OK, "got 0x%08x\n", hr);
1780             ok(len == strlen(test->name), "got %u\n", len);
1781             str_exp = a2w(test->name);
1782             ok(!lstrcmpW(str, str_exp), "got %s\n", wine_dbgstr_w(str));
1783             free_str(str_exp);
1784
1785             /* value */
1786             len = 1;
1787             str = NULL;
1788             hr = IXmlReader_GetValue(reader, &str, &len);
1789             ok(hr == S_OK, "got 0x%08x\n", hr);
1790
1791             str_exp = a2w(test->value);
1792             todo_wine_if (test->todo)
1793             {
1794                 ok(len == strlen(test->value), "got %u\n", len);
1795                 ok(!lstrcmpW(str, str_exp), "got %s\n", wine_dbgstr_w(str));
1796             }
1797             free_str(str_exp);
1798         }
1799
1800         IStream_Release(stream);
1801         test++;
1802     }
1803
1804     IXmlReader_Release(reader);
1805 }
1806
1807 struct test_entry_empty {
1808     const char *xml;
1809     BOOL empty;
1810 };
1811
1812 static struct test_entry_empty empty_element_tests[] = {
1813     { "<a></a>", FALSE },
1814     { "<a/>", TRUE },
1815     { NULL }
1816 };
1817
1818 static void test_isemptyelement(void)
1819 {
1820     struct test_entry_empty *test = empty_element_tests;
1821     IXmlReader *reader;
1822     HRESULT hr;
1823
1824     hr = CreateXmlReader(&IID_IXmlReader, (void**)&reader, NULL);
1825     ok(hr == S_OK, "S_OK, got %08x\n", hr);
1826
1827     while (test->xml)
1828     {
1829         XmlNodeType type;
1830         IStream *stream;
1831         BOOL ret;
1832
1833         stream = create_stream_on_data(test->xml, strlen(test->xml)+1);
1834         hr = IXmlReader_SetInput(reader, (IUnknown*)stream);
1835         ok(hr == S_OK, "got %08x\n", hr);
1836
1837         type = XmlNodeType_None;
1838         hr = IXmlReader_Read(reader, &type);
1839         ok(hr == S_OK, "got 0x%08x\n", hr);
1840         ok(type == XmlNodeType_Element, "got %d\n", type);
1841
1842         ret = IXmlReader_IsEmptyElement(reader);
1843         ok(ret == test->empty, "got %d, expected %d. xml=%s\n", ret, test->empty, test->xml);
1844
1845         IStream_Release(stream);
1846         test++;
1847     }
1848
1849     IXmlReader_Release(reader);
1850 }
1851
1852 static struct test_entry attributes_tests[] = {
1853     { "<a attr1=\"attrvalue\"/>", "attr1", "attrvalue", S_OK },
1854     { "<a attr1=\"a\'\'ttrvalue\"/>", "attr1", "a\'\'ttrvalue", S_OK },
1855     { "<a attr1=\'a\"ttrvalue\'/>", "attr1", "a\"ttrvalue", S_OK },
1856     { "<a attr1=\' \'/>", "attr1", " ", S_OK },
1857     { "<a attr1=\" \"/>", "attr1", " ", S_OK },
1858     { "<a attr1=\"\r\n \r \n \t\n\r\"/>", "attr1", "         ", S_OK },
1859     { "<a attr1=\" val \"/>", "attr1", " val ", S_OK },
1860     { "<a attr1=\"\r\n\tval\n\"/>", "attr1", "  val ", S_OK },
1861     { "<a attr1=\"val&#32;\"/>", "attr1", "val ", S_OK },
1862     { "<a attr1=\"val&#x20;\"/>", "attr1", "val ", S_OK },
1863     { "<a attr1=\"&lt;&gt;&amp;&apos;&quot;\"/>", "attr1", "<>&\'\"", S_OK },
1864     { "<a attr1=\"&entname;\"/>", NULL, NULL, WC_E_UNDECLAREDENTITY },
1865     { "<a attr1=\"val&#xfffe;\"/>", NULL, NULL, WC_E_XMLCHARACTER },
1866     { "<a attr1=\"val &#a;\"/>", NULL, NULL, WC_E_DIGIT, WC_E_SEMICOLON },
1867     { "<a attr1=\"val &#12a;\"/>", NULL, NULL, WC_E_SEMICOLON },
1868     { "<a attr1=\"val &#x12g;\"/>", NULL, NULL, WC_E_SEMICOLON },
1869     { "<a attr1=\"val &#xg;\"/>", NULL, NULL, WC_E_HEXDIGIT, WC_E_SEMICOLON },
1870     { "<a attr1=attrvalue/>", NULL, NULL, WC_E_QUOTE },
1871     { "<a attr1=\"attr<value\"/>", NULL, NULL, WC_E_LESSTHAN },
1872     { "<a attr1=\"&entname\"/>", NULL, NULL, WC_E_SEMICOLON },
1873     { NULL }
1874 };
1875
1876 static void test_read_attribute(void)
1877 {
1878     struct test_entry *test = attributes_tests;
1879     IXmlReader *reader;
1880     HRESULT hr;
1881
1882     hr = CreateXmlReader(&IID_IXmlReader, (void**)&reader, NULL);
1883     ok(hr == S_OK, "S_OK, got %08x\n", hr);
1884
1885     while (test->xml)
1886     {
1887         XmlNodeType type;
1888         IStream *stream;
1889
1890         stream = create_stream_on_data(test->xml, strlen(test->xml)+1);
1891         hr = IXmlReader_SetInput(reader, (IUnknown*)stream);
1892         ok(hr == S_OK, "got %08x\n", hr);
1893
1894         hr = IXmlReader_Read(reader, NULL);
1895
1896         if (test->hr_broken)
1897             ok(hr == test->hr || broken(hr == test->hr_broken), "got %08x for %s\n", hr, test->xml);
1898         else
1899             ok(hr == test->hr, "got %08x for %s\n", hr, test->xml);
1900         if (hr == S_OK)
1901         {
1902             const WCHAR *str;
1903             WCHAR *str_exp;
1904             UINT len;
1905
1906             type = XmlNodeType_None;
1907             hr = IXmlReader_GetNodeType(reader, &type);
1908             ok(hr == S_OK, "Failed to get node type, %#x\n", hr);
1909
1910             ok(type == XmlNodeType_Element, "got %d for %s\n", type, test->xml);
1911
1912             hr = IXmlReader_MoveToFirstAttribute(reader);
1913             ok(hr == S_OK, "got 0x%08x\n", hr);
1914
1915             len = 1;
1916             str = NULL;
1917             hr = IXmlReader_GetLocalName(reader, &str, &len);
1918             ok(hr == S_OK, "got 0x%08x\n", hr);
1919             ok(len == strlen(test->name), "got %u\n", len);
1920             str_exp = a2w(test->name);
1921             ok(!lstrcmpW(str, str_exp), "got %s\n", wine_dbgstr_w(str));
1922             free_str(str_exp);
1923
1924             len = 1;
1925             str = NULL;
1926             hr = IXmlReader_GetQualifiedName(reader, &str, &len);
1927             ok(hr == S_OK, "got 0x%08x\n", hr);
1928         todo_wine {
1929             ok(len == strlen(test->name), "got %u\n", len);
1930             str_exp = a2w(test->name);
1931             ok(!lstrcmpW(str, str_exp), "got %s\n", wine_dbgstr_w(str));
1932             free_str(str_exp);
1933         }
1934             /* value */
1935             len = 1;
1936             str = NULL;
1937             hr = IXmlReader_GetValue(reader, &str, &len);
1938             ok(hr == S_OK, "got 0x%08x\n", hr);
1939             ok(len == strlen(test->value), "got %u\n", len);
1940             str_exp = a2w(test->value);
1941             ok(!lstrcmpW(str, str_exp), "got %s\n", wine_dbgstr_w(str));
1942             free_str(str_exp);
1943         }
1944
1945         IStream_Release(stream);
1946         test++;
1947     }
1948
1949     IXmlReader_Release(reader);
1950 }
1951
1952 static void test_reader_properties(void)
1953 {
1954     IXmlReader *reader;
1955     HRESULT hr;
1956
1957     hr = CreateXmlReader(&IID_IXmlReader, (void**)&reader, NULL);
1958     ok(hr == S_OK, "S_OK, got %08x\n", hr);
1959
1960     hr = IXmlReader_SetProperty(reader, XmlReaderProperty_MultiLanguage, 0);
1961     ok(hr == S_OK, "SetProperty failed: %08x\n", hr);
1962
1963     hr = IXmlReader_SetProperty(reader, XmlReaderProperty_MaxElementDepth, 0);
1964     ok(hr == S_OK, "SetProperty failed: %08x\n", hr);
1965
1966     IXmlReader_Release(reader);
1967 }
1968
1969 static void test_prefix(void)
1970 {
1971     static const struct
1972     {
1973         const char *xml;
1974         const char *prefix1;
1975         const char *prefix2;
1976         const char *prefix3;
1977     } prefix_tests[] =
1978     {
1979         { "<b xmlns=\"defns\" xml:a=\"a ns\"/>", "", "", "xml" },
1980     };
1981     IXmlReader *reader;
1982     unsigned int i;
1983     HRESULT hr;
1984
1985     hr = CreateXmlReader(&IID_IXmlReader, (void**)&reader, NULL);
1986     ok(hr == S_OK, "S_OK, got %08x\n", hr);
1987
1988     for (i = 0; i < sizeof(prefix_tests)/sizeof(prefix_tests[0]); i++) {
1989         const WCHAR *prefix;
1990         XmlNodeType type;
1991         WCHAR *expected;
1992         IStream *stream;
1993
1994         stream = create_stream_on_data(prefix_tests[i].xml, strlen(prefix_tests[i].xml) + 1);
1995         hr = IXmlReader_SetInput(reader, (IUnknown *)stream);
1996         ok(hr == S_OK, "got %08x\n", hr);
1997
1998         hr = IXmlReader_Read(reader, &type);
1999         ok(hr == S_OK, "Read() failed, %#x\n", hr);
2000         ok(type == XmlNodeType_Element, "Unexpected node type %d.\n", type);
2001
2002         expected = a2w(prefix_tests[i].prefix1);
2003         hr = IXmlReader_GetPrefix(reader, &prefix, NULL);
2004         ok(hr == S_OK, "GetPrefix() failed, %#x.\n", hr);
2005         ok(!lstrcmpW(prefix, expected), "Unexpected prefix %s, expected %s.\n", wine_dbgstr_w(prefix),
2006             wine_dbgstr_w(expected));
2007         free_str(expected);
2008
2009         hr = IXmlReader_MoveToFirstAttribute(reader);
2010         ok(hr == S_OK, "MoveToFirstAttribute() failed, %#x.\n", hr);
2011
2012         hr = IXmlReader_GetNodeType(reader, &type);
2013         ok(hr == S_OK, "GetNodeType() failed, %#x.\n", hr);
2014         ok(type == XmlNodeType_Attribute, "Unexpected node type %d.\n", type);
2015
2016         expected = a2w(prefix_tests[i].prefix2);
2017         hr = IXmlReader_GetPrefix(reader, &prefix, NULL);
2018         ok(hr == S_OK, "GetPrefix() failed, %#x.\n", hr);
2019         ok(!lstrcmpW(prefix, expected), "Unexpected prefix %s, expected %s.\n", wine_dbgstr_w(prefix),
2020             wine_dbgstr_w(expected));
2021         free_str(expected);
2022
2023         hr = IXmlReader_MoveToNextAttribute(reader);
2024         ok(hr == S_OK, "MoveToNextAttribute() failed, %#x.\n", hr);
2025
2026         hr = IXmlReader_GetNodeType(reader, &type);
2027         ok(hr == S_OK, "GetNodeType() failed, %#x.\n", hr);
2028         ok(type == XmlNodeType_Attribute, "Unexpected node type %d.\n", type);
2029
2030         expected = a2w(prefix_tests[i].prefix3);
2031         hr = IXmlReader_GetPrefix(reader, &prefix, NULL);
2032         ok(hr == S_OK, "GetPrefix() failed, %#x.\n", hr);
2033         ok(!lstrcmpW(prefix, expected), "Unexpected prefix %s, expected %s.\n", wine_dbgstr_w(prefix),
2034             wine_dbgstr_w(expected));
2035         free_str(expected);
2036
2037         /* back to the element, check prefix */
2038         hr = IXmlReader_MoveToElement(reader);
2039         ok(hr == S_OK, "MoveToElement() failed, %#x.\n", hr);
2040
2041         expected = a2w(prefix_tests[i].prefix1);
2042         hr = IXmlReader_GetPrefix(reader, &prefix, NULL);
2043         ok(hr == S_OK, "GetPrefix() failed, %#x.\n", hr);
2044         ok(!lstrcmpW(prefix, expected), "Unexpected prefix %s, expected %s.\n", wine_dbgstr_w(prefix),
2045             wine_dbgstr_w(expected));
2046         free_str(expected);
2047
2048         IStream_Release(stream);
2049     }
2050
2051     IXmlReader_Release(reader);
2052 }
2053
2054 static void test_namespaceuri(void)
2055 {
2056     struct uri_test
2057     {
2058         const char *xml;
2059         const char *uri[5];
2060     } uri_tests[] =
2061     {
2062         { "<a xmlns=\"defns a\"><b xmlns=\"defns b\"><c xmlns=\"defns c\"/></b></a>",
2063                 { "defns a", "defns b", "defns c", "defns b", "defns a" }},
2064         { "<r:a xmlns=\"defns a\" xmlns:r=\"ns r\"/>",
2065                 { "ns r" }},
2066         { "<r:a xmlns=\"defns a\" xmlns:r=\"ns r\"><b/></r:a>",
2067                 { "ns r", "defns a", "ns r" }},
2068         { "<a xmlns=\"defns a\" xmlns:r=\"ns r\"><r:b/></a>",
2069                 { "defns a", "ns r", "defns a" }},
2070         { "<a><b><c/></b></a>",
2071                 { "", "", "", "", "" }},
2072     };
2073     IXmlReader *reader;
2074     XmlNodeType type;
2075     unsigned int i;
2076     HRESULT hr;
2077
2078     hr = CreateXmlReader(&IID_IXmlReader, (void**)&reader, NULL);
2079     ok(hr == S_OK, "S_OK, got %08x\n", hr);
2080
2081     for (i = 0; i < sizeof(uri_tests)/sizeof(uri_tests[0]); i++) {
2082         IStream *stream = create_stream_on_data(uri_tests[i].xml, strlen(uri_tests[i].xml) + 1);
2083         unsigned int j = 0;
2084
2085         hr = IXmlReader_SetInput(reader, (IUnknown *)stream);
2086         ok(hr == S_OK, "got %08x\n", hr);
2087
2088         type = ~0u;
2089         while (IXmlReader_Read(reader, &type) == S_OK) {
2090             const WCHAR *uri, *local;
2091             WCHAR *uriW;
2092
2093             ok(type == XmlNodeType_Element || type == XmlNodeType_EndElement, "Unexpected node type %d.\n", type);
2094
2095             hr = IXmlReader_GetLocalName(reader, &local, NULL);
2096             ok(hr == S_OK, "S_OK, got %08x\n", hr);
2097
2098             hr = IXmlReader_GetNamespaceUri(reader, &uri, NULL);
2099             ok(hr == S_OK, "S_OK, got %08x\n", hr);
2100
2101             uriW = a2w(uri_tests[i].uri[j]);
2102             ok(!lstrcmpW(uriW, uri), "%s: uri %s\n", wine_dbgstr_w(local), wine_dbgstr_w(uri));
2103             free_str(uriW);
2104
2105             j++;
2106         }
2107         ok(type == XmlNodeType_None, "Unexpected node type %d\n", type);
2108
2109         IStream_Release(stream);
2110     }
2111
2112     IXmlReader_Release(reader);
2113 }
2114
2115 static void test_read_charref(void)
2116 {
2117     static const char testA[] = "<a b=\"c\">&#x1f3;&#x103;</a>";
2118     static const WCHAR chardataW[] = {0x01f3,0x0103,0};
2119     const WCHAR *value;
2120     IXmlReader *reader;
2121     XmlNodeType type;
2122     IStream *stream;
2123     HRESULT hr;
2124
2125     hr = CreateXmlReader(&IID_IXmlReader, (void **)&reader, NULL);
2126     ok(hr == S_OK, "S_OK, got %08x\n", hr);
2127
2128     stream = create_stream_on_data(testA, sizeof(testA));
2129     hr = IXmlReader_SetInput(reader, (IUnknown *)stream);
2130     ok(hr == S_OK, "got %08x\n", hr);
2131
2132     hr = IXmlReader_Read(reader, &type);
2133     ok(hr == S_OK, "got %08x\n", hr);
2134     ok(type == XmlNodeType_Element, "Unexpected node type %d\n", type);
2135
2136     hr = IXmlReader_Read(reader, &type);
2137     ok(hr == S_OK, "got %08x\n", hr);
2138     ok(type == XmlNodeType_Text, "Unexpected node type %d\n", type);
2139
2140     hr = IXmlReader_GetValue(reader, &value, NULL);
2141     ok(hr == S_OK, "got %08x\n", hr);
2142     ok(!lstrcmpW(value, chardataW), "Text value : %s\n", wine_dbgstr_w(value));
2143
2144     hr = IXmlReader_Read(reader, &type);
2145     ok(hr == S_OK, "got %08x\n", hr);
2146     ok(type == XmlNodeType_EndElement, "Unexpected node type %d\n", type);
2147
2148     IXmlReader_Release(reader);
2149     IStream_Release(stream);
2150 }
2151
2152 static void test_encoding_detection(void)
2153 {
2154     static const struct encoding_testW
2155     {
2156         WCHAR text[16];
2157     }
2158     encoding_testsW[] =
2159     {
2160         { { '<','?','p','i',' ','?','>',0 } },
2161         { { '<','!','-','-',' ','c','-','-','>',0 } },
2162         { { 0xfeff,'<','a','/','>',0 } },
2163         { { '<','a','/','>',0 } },
2164     };
2165     static const char *encoding_testsA[] =
2166     {
2167         "<?pi ?>",
2168         "<!-- comment -->",
2169         "\xef\xbb\xbf<a/>", /* UTF-8 BOM */
2170         "<a/>",
2171     };
2172     IXmlReader *reader;
2173     XmlNodeType type;
2174     IStream *stream;
2175     unsigned int i;
2176     HRESULT hr;
2177
2178     hr = CreateXmlReader(&IID_IXmlReader, (void **)&reader, NULL);
2179     ok(hr == S_OK, "S_OK, got %08x\n", hr);
2180
2181     /* there's no way to query detected encoding back, so just verify that document is browsable */
2182
2183     for (i = 0; i < sizeof(encoding_testsA)/sizeof(encoding_testsA[0]); i++)
2184     {
2185         stream = create_stream_on_data(encoding_testsA[i], strlen(encoding_testsA[i]));
2186
2187         hr = IXmlReader_SetInput(reader, (IUnknown *)stream);
2188         ok(hr == S_OK, "got %08x\n", hr);
2189
2190         type = XmlNodeType_None;
2191         hr = IXmlReader_Read(reader, &type);
2192         ok(hr == S_OK, "got %08x\n", hr);
2193         ok(type != XmlNodeType_None, "Unexpected node type %d\n", type);
2194
2195         IStream_Release(stream);
2196     }
2197
2198     for (i = 0; i < sizeof(encoding_testsW)/sizeof(encoding_testsW[0]); i++)
2199     {
2200         stream = create_stream_on_data(encoding_testsW[i].text, lstrlenW(encoding_testsW[i].text) * sizeof(WCHAR));
2201
2202         hr = IXmlReader_SetInput(reader, (IUnknown *)stream);
2203         ok(hr == S_OK, "got %08x\n", hr);
2204
2205         type = XmlNodeType_None;
2206         hr = IXmlReader_Read(reader, &type);
2207         ok(hr == S_OK, "%u: got %08x\n", i, hr);
2208         ok(type != XmlNodeType_None, "%u: unexpected node type %d\n", i, type);
2209
2210         IStream_Release(stream);
2211     }
2212
2213     IXmlReader_Release(reader);
2214 }
2215
2216 static void test_eof_state(IXmlReader *reader, BOOL eof)
2217 {
2218     LONG_PTR state;
2219     HRESULT hr;
2220
2221     ok(IXmlReader_IsEOF(reader) == eof, "Unexpected IsEOF() result\n");
2222     hr = IXmlReader_GetProperty(reader, XmlReaderProperty_ReadState, &state);
2223     ok(hr == S_OK, "GetProperty() failed, %#x\n", hr);
2224     ok((state == XmlReadState_EndOfFile) == eof, "Unexpected EndOfFile state %ld\n", state);
2225 }
2226
2227 static void test_endoffile(void)
2228 {
2229     static const char *xml = "<a/>";
2230     IXmlReader *reader;
2231     XmlNodeType type;
2232     IStream *stream;
2233     HRESULT hr;
2234
2235     hr = CreateXmlReader(&IID_IXmlReader, (void **)&reader, NULL);
2236     ok(hr == S_OK, "S_OK, got %08x\n", hr);
2237
2238     test_eof_state(reader, FALSE);
2239
2240     stream = create_stream_on_data(xml, strlen(xml));
2241
2242     hr = IXmlReader_SetInput(reader, (IUnknown *)stream);
2243     ok(hr == S_OK, "got %08x\n", hr);
2244
2245     test_eof_state(reader, FALSE);
2246
2247     type = XmlNodeType_None;
2248     hr = IXmlReader_Read(reader, &type);
2249     ok(hr == S_OK, "got %#x\n", hr);
2250     ok(type == XmlNodeType_Element, "Unexpected type %d\n", type);
2251
2252     test_eof_state(reader, FALSE);
2253
2254     type = XmlNodeType_Element;
2255     hr = IXmlReader_Read(reader, &type);
2256     ok(hr == S_FALSE, "got %#x\n", hr);
2257     ok(type == XmlNodeType_None, "Unexpected type %d\n", type);
2258
2259     test_eof_state(reader, TRUE);
2260
2261     hr = IXmlReader_SetInput(reader, NULL);
2262     ok(hr == S_OK, "got %08x\n", hr);
2263
2264     test_eof_state(reader, FALSE);
2265
2266     IStream_Release(stream);
2267
2268     IXmlReader_Release(reader);
2269 }
2270
2271 START_TEST(reader)
2272 {
2273     test_reader_create();
2274     test_readerinput();
2275     test_reader_state();
2276     test_read_attribute();
2277     test_read_cdata();
2278     test_read_comment();
2279     test_read_pi();
2280     test_read_system_dtd();
2281     test_read_public_dtd();
2282     test_read_element();
2283     test_isemptyelement();
2284     test_read_text();
2285     test_read_full();
2286     test_read_pending();
2287     test_readvaluechunk();
2288     test_read_xmldeclaration();
2289     test_reader_properties();
2290     test_prefix();
2291     test_namespaceuri();
2292     test_read_charref();
2293     test_encoding_detection();
2294     test_endoffile();
2295 }