dlls/xmllite/tests/reader.c

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