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 char *data, 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     IXmlReader *reader;
 651     XmlNodeType nodetype;
 652     HRESULT hr;
 653
 654     hr = CreateXmlReader(&IID_IXmlReader, (void**)&reader, NULL);
 655     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
 656
 657     /* invalid arguments */
 658     hr = IXmlReader_GetProperty(reader, XmlReaderProperty_ReadState, NULL);
 659     ok(hr == E_INVALIDARG, "Expected E_INVALIDARG, got %08x\n", hr);
 660
 661     /* attempt to read on closed reader */
 662     test_read_state(reader, XmlReadState_Closed, -1, FALSE);
 663 if (0)
 664 {
 665     /* newer versions crash here, probably cause no input was set */
 666     hr = IXmlReader_Read(reader, &nodetype);
 667     ok(hr == S_FALSE, "got %08x\n", hr);
 668 }
 669     IXmlReader_Release(reader);
 670 }
 671
 672 static void test_read_xmldeclaration(void)
 673 {
 674     static const WCHAR xmlW[] = {'x','m','l',0};
 675     static const WCHAR RegistrationInfoW[] = {'R','e','g','i','s','t','r','a','t','i','o','n','I','n','f','o',0};
 676     static const struct
 677     {
 678         WCHAR name[12];
 679         WCHAR val[12];
 680     } name_val[] =
 681     {
 682         { {'v','e','r','s','i','o','n',0}, {'1','.','0',0} },
 683         { {'e','n','c','o','d','i','n','g',0}, {'U','T','F','-','8',0} },
 684         { {'s','t','a','n','d','a','l','o','n','e',0}, {'y','e','s',0} }
 685     };
 686     IXmlReader *reader;
 687     IStream *stream;
 688     HRESULT hr;
 689     XmlNodeType type;
 690     UINT count = 0, len, i;
 691     BOOL ret;
 692     const WCHAR *val;
 693
 694     hr = CreateXmlReader(&IID_IXmlReader, (LPVOID*)&reader, NULL);
 695     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
 696
 697     /* position methods with Null args */
 698     hr = IXmlReader_GetLineNumber(reader, NULL);
 699     ok(hr == E_INVALIDARG, "Expected E_INVALIDARG, got %08x\n", hr);
 700
 701     hr = IXmlReader_GetLinePosition(reader, NULL);
 702     ok(hr == E_INVALIDARG, "Expected E_INVALIDARG, got %08x\n", hr);
 703
 704     stream = create_stream_on_data(xmldecl_full, sizeof(xmldecl_full));
 705
 706     hr = IXmlReader_SetInput(reader, (IUnknown*)stream);
 707     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
 708
 709     hr = IXmlReader_GetAttributeCount(reader, &count);
 710     ok(hr == S_OK, "got %08x\n", hr);
 711     ok(count == 0, "got %d\n", count);
 712
 713     /* try to move without attributes */
 714     hr = IXmlReader_MoveToElement(reader);
 715     ok(hr == S_FALSE, "got %08x\n", hr);
 716
 717     hr = IXmlReader_MoveToNextAttribute(reader);
 718     ok(hr == S_FALSE, "got %08x\n", hr);
 719
 720     hr = IXmlReader_MoveToFirstAttribute(reader);
 721     ok(hr == S_FALSE, "got %08x\n", hr);
 722
 723     ok_pos(reader, 0, 0, -1, -1, FALSE);
 724
 725     type = -1;
 726     hr = IXmlReader_Read(reader, &type);
 727     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
 728     ok(type == XmlNodeType_XmlDeclaration,
 729                      "Expected XmlNodeType_XmlDeclaration, got %s\n", type_to_str(type));
 730     /* new version 1.2.x and 1.3.x properly update position for <?xml ?> */
 731     ok_pos(reader, 1, 3, -1, 55, TRUE);
 732     test_read_state(reader, XmlReadState_Interactive, -1, FALSE);
 733
 734     hr = IXmlReader_GetValue(reader, &val, NULL);
 735     ok(hr == S_OK, "got %08x\n", hr);
 736     ok(*val == 0, "got %s\n", wine_dbgstr_w(val));
 737
 738     /* check attributes */
 739     hr = IXmlReader_MoveToNextAttribute(reader);
 740     ok(hr == S_OK, "got %08x\n", hr);
 741
 742     type = XmlNodeType_None;
 743     hr = IXmlReader_GetNodeType(reader, &type);
 744     ok(hr == S_OK, "got %08x\n", hr);
 745     ok(type == XmlNodeType_Attribute, "got %d\n", type);
 746
 747     ok_pos(reader, 1, 7, -1, 55, TRUE);
 748
 749     /* try to move from last attribute */
 750     hr = IXmlReader_MoveToNextAttribute(reader);
 751     ok(hr == S_OK, "got %08x\n", hr);
 752     hr = IXmlReader_MoveToNextAttribute(reader);
 753     ok(hr == S_OK, "got %08x\n", hr);
 754     hr = IXmlReader_MoveToNextAttribute(reader);
 755     ok(hr == S_FALSE, "got %08x\n", hr);
 756
 757     type = XmlNodeType_None;
 758     hr = IXmlReader_GetNodeType(reader, &type);
 759     ok(hr == S_OK, "got %08x\n", hr);
 760     ok(type == XmlNodeType_Attribute, "got %d\n", type);
 761
 762     hr = IXmlReader_MoveToFirstAttribute(reader);
 763     ok(hr == S_OK, "got %08x\n", hr);
 764     ok_pos(reader, 1, 7, -1, 55, TRUE);
 765
 766     hr = IXmlReader_GetAttributeCount(reader, NULL);
 767     ok(hr == E_INVALIDARG, "got %08x\n", hr);
 768
 769     hr = IXmlReader_GetAttributeCount(reader, &count);
 770     ok(hr == S_OK, "got %08x\n", hr);
 771     ok(count == 3, "Expected 3, got %d\n", count);
 772
 773     for (i = 0; i < count; i++)
 774     {
 775         len = 0;
 776         hr = IXmlReader_GetLocalName(reader, &val, &len);
 777         ok(hr == S_OK, "got %08x\n", hr);
 778         ok(len == lstrlenW(name_val[i].name), "expected %u, got %u\n", lstrlenW(name_val[i].name), len);
 779         ok(!lstrcmpW(name_val[i].name, val), "expected %s, got %s\n", wine_dbgstr_w(name_val[i].name), wine_dbgstr_w(val));
 780
 781         len = 0;
 782         hr = IXmlReader_GetValue(reader, &val, &len);
 783         ok(hr == S_OK, "got %08x\n", hr);
 784         ok(len == lstrlenW(name_val[i].val), "expected %u, got %u\n", lstrlenW(name_val[i].val), len);
 785         ok(!lstrcmpW(name_val[i].val, val), "expected %s, got %s\n", wine_dbgstr_w(name_val[i].val), wine_dbgstr_w(val));
 786
 787         hr = IXmlReader_MoveToNextAttribute(reader);
 788         ok(hr == ((i < count - 1) ? S_OK : S_FALSE), "got %08x\n", hr);
 789     }
 790
 791     hr = IXmlReader_GetDepth(reader, &count);
 792     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
 793     ok(count == 1, "Expected 1, got %d\n", count);
 794
 795     hr = IXmlReader_MoveToElement(reader);
 796     ok(hr == S_OK, "got %08x\n", hr);
 797
 798     type = XmlNodeType_None;
 799     hr = IXmlReader_GetNodeType(reader, &type);
 800     ok(hr == S_OK, "got %08x\n", hr);
 801     ok(type == XmlNodeType_XmlDeclaration, "got %d\n", type);
 802
 803     type = XmlNodeType_XmlDeclaration;
 804     hr = IXmlReader_Read(reader, &type);
 805     /* newer versions return syntax error here cause document is incomplete,
 806        it makes more sense than invalid char error */
 807 todo_wine {
 808     ok(hr == WC_E_SYNTAX || broken(hr == WC_E_XMLCHARACTER), "got 0x%08x\n", hr);
 809     ok(type == XmlNodeType_None, "got %d\n", type);
 810 }
 811     IStream_Release(stream);
 812
 813     /* test short variant */
 814     stream = create_stream_on_data(xmldecl_short, sizeof(xmldecl_short));
 815
 816     hr = IXmlReader_SetInput(reader, (IUnknown *)stream);
 817     ok(hr == S_OK, "expected S_OK, got %08x\n", hr);
 818
 819     type = -1;
 820     hr = IXmlReader_Read(reader, &type);
 821     ok(hr == S_OK, "expected S_OK, got %08x\n", hr);
 822     ok(type == XmlNodeType_XmlDeclaration, "expected XmlDeclaration, got %s\n", type_to_str(type));
 823     ok_pos(reader, 1, 3, 1, 21, TRUE);
 824     test_read_state(reader, XmlReadState_Interactive, -1, TRUE);
 825
 826     hr = IXmlReader_GetAttributeCount(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     ret = IXmlReader_IsEmptyElement(reader);
 831     ok(!ret, "element should not be empty\n");
 832
 833     hr = IXmlReader_GetValue(reader, &val, NULL);
 834     ok(hr == S_OK, "expected S_OK, got %08x\n", hr);
 835     ok(*val == 0, "got %s\n", wine_dbgstr_w(val));
 836
 837     hr = IXmlReader_GetLocalName(reader, &val, NULL);
 838     ok(hr == S_OK, "expected S_OK, got %08x\n", hr);
 839 todo_wine
 840     ok(!lstrcmpW(val, xmlW), "got %s\n", wine_dbgstr_w(val));
 841
 842     /* check attributes */
 843     hr = IXmlReader_MoveToNextAttribute(reader);
 844     ok(hr == S_OK, "expected S_OK, got %08x\n", hr);
 845
 846     type = -1;
 847     hr = IXmlReader_GetNodeType(reader, &type);
 848     ok(hr == S_OK, "expected S_OK, got %08x\n", hr);
 849     ok(type == XmlNodeType_Attribute, "got %d\n", type);
 850     ok_pos(reader, 1, 7, 1, 21, TRUE);
 851
 852     /* try to move from last attribute */
 853     hr = IXmlReader_MoveToNextAttribute(reader);
 854     ok(hr == S_FALSE, "expected S_FALSE, got %08x\n", hr);
 855
 856     type = -1;
 857     hr = IXmlReader_Read(reader, &type);
 858     ok(hr == S_OK, "expected S_OK, got %08x\n", hr);
 859     ok(type == XmlNodeType_Element, "expected Element, got %s\n", type_to_str(type));
 860     ok_pos(reader, 1, 23, 1, 40, TRUE);
 861     test_read_state(reader, XmlReadState_Interactive, -1, TRUE);
 862
 863     hr = IXmlReader_GetAttributeCount(reader, &count);
 864     ok(hr == S_OK, "expected S_OK, got %08x\n", hr);
 865     ok(count == 0, "expected 0, got %d\n", count);
 866
 867     ret = IXmlReader_IsEmptyElement(reader);
 868     ok(ret, "element should be empty\n");
 869
 870     hr = IXmlReader_GetValue(reader, &val, NULL);
 871     ok(hr == S_OK, "expected S_OK, got %08x\n", hr);
 872 todo_wine
 873     ok(*val == 0, "got %s\n", wine_dbgstr_w(val));
 874
 875     hr = IXmlReader_GetLocalName(reader, &val, NULL);
 876     ok(hr == S_OK, "expected S_OK, got %08x\n", hr);
 877     ok(!lstrcmpW(val, RegistrationInfoW), "got %s\n", wine_dbgstr_w(val));
 878
 879     type = -1;
 880     hr = IXmlReader_Read(reader, &type);
 881 todo_wine
 882     ok(hr == WC_E_SYNTAX || hr == WC_E_XMLCHARACTER /* XP */, "expected WC_E_SYNTAX, got %08x\n", hr);
 883 todo_wine
 884     ok(type == XmlNodeType_None, "expected None, got %s\n", type_to_str(type));
 885     ok_pos(reader, 1, 41, -1, -1, TRUE);
 886     test_read_state(reader, XmlReadState_Error, -1, TRUE);
 887
 888     IStream_Release(stream);
 889     IXmlReader_Release(reader);
 890 }
 891
 892 struct test_entry {
 893     const char *xml;
 894     const char *name;
 895     const char *value;
 896     HRESULT hr;
 897     HRESULT hr_broken; /* this is set to older version results */
 898     BOOL todo;
 899 };
 900
 901 static struct test_entry comment_tests[] = {
 902     { "<!-- comment -->", "", " comment ", S_OK },
 903     { "<!-- - comment-->", "", " - comment", S_OK },
 904     { "<!-- -- comment-->", NULL, NULL, WC_E_COMMENT, WC_E_GREATERTHAN },
 905     { "<!-- -- comment--->", NULL, NULL, WC_E_COMMENT, WC_E_GREATERTHAN },
 906     { NULL }
 907 };
 908
 909 static void test_read_comment(void)
 910 {
 911     struct test_entry *test = comment_tests;
 912     IXmlReader *reader;
 913     HRESULT hr;
 914
 915     hr = CreateXmlReader(&IID_IXmlReader, (void**)&reader, NULL);
 916     ok(hr == S_OK, "S_OK, got %08x\n", hr);
 917
 918     while (test->xml)
 919     {
 920         XmlNodeType type;
 921         IStream *stream;
 922
 923         stream = create_stream_on_data(test->xml, strlen(test->xml)+1);
 924         hr = IXmlReader_SetInput(reader, (IUnknown*)stream);
 925         ok(hr == S_OK, "got %08x\n", hr);
 926
 927         type = XmlNodeType_None;
 928         hr = IXmlReader_Read(reader, &type);
 929         if (test->hr_broken)
 930             ok(hr == test->hr || broken(hr == test->hr_broken), "got %08x for %s\n", hr, test->xml);
 931         else
 932             ok(hr == test->hr, "got %08x for %s\n", hr, test->xml);
 933         if (hr == S_OK)
 934         {
 935             const WCHAR *str;
 936             WCHAR *str_exp;
 937             UINT len;
 938
 939             ok(type == XmlNodeType_Comment, "got %d for %s\n", type, test->xml);
 940
 941             len = 1;
 942             str = NULL;
 943             hr = IXmlReader_GetLocalName(reader, &str, &len);
 944             ok(hr == S_OK, "got 0x%08x\n", hr);
 945             ok(len == strlen(test->name), "got %u\n", len);
 946             str_exp = a2w(test->name);
 947             ok(!lstrcmpW(str, str_exp), "got %s\n", wine_dbgstr_w(str));
 948             free_str(str_exp);
 949
 950             len = 1;
 951             str = NULL;
 952             hr = IXmlReader_GetQualifiedName(reader, &str, &len);
 953             ok(hr == S_OK, "got 0x%08x\n", hr);
 954             ok(len == strlen(test->name), "got %u\n", len);
 955             str_exp = a2w(test->name);
 956             ok(!lstrcmpW(str, str_exp), "got %s\n", wine_dbgstr_w(str));
 957             free_str(str_exp);
 958
 959             /* value */
 960             len = 1;
 961             str = NULL;
 962             hr = IXmlReader_GetValue(reader, &str, &len);
 963             ok(hr == S_OK, "got 0x%08x\n", hr);
 964             ok(len == strlen(test->value), "got %u\n", len);
 965             str_exp = a2w(test->value);
 966             ok(!lstrcmpW(str, str_exp), "got %s\n", wine_dbgstr_w(str));
 967             free_str(str_exp);
 968         }
 969
 970         IStream_Release(stream);
 971         test++;
 972     }
 973
 974     IXmlReader_Release(reader);
 975 }
 976
 977 static struct test_entry pi_tests[] = {
 978     { "<?pi?>", "pi", "", S_OK },
 979     { "<?pi ?>", "pi", "", S_OK },
 980     { "<?pi  ?>", "pi", "", S_OK },
 981     { "<?pi pi data?>", "pi", "pi data", S_OK },
 982     { "<?pi pi data  ?>", "pi", "pi data  ", S_OK },
 983     { "<?pi    data  ?>", "pi", "data  ", S_OK },
 984     { "<?pi:pi?>", NULL, NULL, NC_E_NAMECOLON, WC_E_NAMECHARACTER },
 985     { "<?:pi ?>", NULL, NULL, WC_E_PI, WC_E_NAMECHARACTER },
 986     { "<?-pi ?>", NULL, NULL, WC_E_PI, WC_E_NAMECHARACTER },
 987     { "<?xml-stylesheet ?>", "xml-stylesheet", "", S_OK },
 988     { NULL }
 989 };
 990
 991 static void test_read_pi(void)
 992 {
 993     struct test_entry *test = pi_tests;
 994     IXmlReader *reader;
 995     HRESULT hr;
 996
 997     hr = CreateXmlReader(&IID_IXmlReader, (void**)&reader, NULL);
 998     ok(hr == S_OK, "S_OK, got %08x\n", hr);
 999
1000     while (test->xml)
1001     {
1002         XmlNodeType type;
1003         IStream *stream;
1004
1005         stream = create_stream_on_data(test->xml, strlen(test->xml)+1);
1006         hr = IXmlReader_SetInput(reader, (IUnknown*)stream);
1007         ok(hr == S_OK, "got %08x\n", hr);
1008
1009         type = XmlNodeType_None;
1010         hr = IXmlReader_Read(reader, &type);
1011         if (test->hr_broken)
1012             ok(hr == test->hr || broken(hr == test->hr_broken), "got %08x for %s\n", hr, test->xml);
1013         else
1014             ok(hr == test->hr, "got %08x for %s\n", hr, test->xml);
1015         if (hr == S_OK)
1016         {
1017             const WCHAR *str;
1018             WCHAR *str_exp;
1019             UINT len;
1020
1021             ok(type == XmlNodeType_ProcessingInstruction, "got %d for %s\n", type, test->xml);
1022
1023             len = 0;
1024             str = NULL;
1025             hr = IXmlReader_GetLocalName(reader, &str, &len);
1026             ok(hr == S_OK, "got 0x%08x\n", hr);
1027             ok(len == strlen(test->name), "got %u\n", len);
1028             str_exp = a2w(test->name);
1029             ok(!lstrcmpW(str, str_exp), "got %s\n", wine_dbgstr_w(str));
1030             free_str(str_exp);
1031
1032             len = 0;
1033             str = NULL;
1034             hr = IXmlReader_GetQualifiedName(reader, &str, &len);
1035             ok(hr == S_OK, "got 0x%08x\n", hr);
1036             ok(len == strlen(test->name), "got %u\n", len);
1037             str_exp = a2w(test->name);
1038             ok(!lstrcmpW(str, str_exp), "got %s\n", wine_dbgstr_w(str));
1039             free_str(str_exp);
1040
1041             /* value */
1042             len = !strlen(test->value);
1043             str = NULL;
1044             hr = IXmlReader_GetValue(reader, &str, &len);
1045             ok(hr == S_OK, "got 0x%08x\n", hr);
1046             ok(len == strlen(test->value), "got %u\n", len);
1047             str_exp = a2w(test->value);
1048             ok(!lstrcmpW(str, str_exp), "got %s\n", wine_dbgstr_w(str));
1049             free_str(str_exp);
1050         }
1051
1052         IStream_Release(stream);
1053         test++;
1054     }
1055
1056     IXmlReader_Release(reader);
1057 }
1058
1059 struct nodes_test {
1060     const char *xml;
1061     XmlNodeType types[20];
1062 };
1063
1064 static const char misc_test_xml[] =
1065     "<!-- comment1 -->"
1066     "<!-- comment2 -->"
1067     "<?pi1 pi1body ?>"
1068     "<!-- comment3 -->"
1069     " \t \r \n"
1070     "<!-- comment4 -->"
1071     "<a>"
1072     "\r\n\t"
1073     "<b/>"
1074     "text"
1075     "<!-- comment -->"
1076     "text2"
1077     "<?pi pibody ?>"
1078     "\r\n"
1079     "</a>"
1080 ;
1081
1082 static struct nodes_test misc_test = {
1083     misc_test_xml,
1084     {
1085         XmlNodeType_Comment,
1086         XmlNodeType_Comment,
1087         XmlNodeType_ProcessingInstruction,
1088         XmlNodeType_Comment,
1089         XmlNodeType_Whitespace,
1090         XmlNodeType_Comment,
1091         XmlNodeType_Element,
1092         XmlNodeType_Whitespace,
1093         XmlNodeType_Element,
1094         XmlNodeType_Text,
1095         XmlNodeType_Comment,
1096         XmlNodeType_Text,
1097         XmlNodeType_ProcessingInstruction,
1098         XmlNodeType_Whitespace,
1099         XmlNodeType_EndElement,
1100         XmlNodeType_None
1101     }
1102 };
1103
1104 static void test_read_full(void)
1105 {
1106     struct nodes_test *test = &misc_test;
1107     IXmlReader *reader;
1108     XmlNodeType type;
1109     IStream *stream;
1110     HRESULT hr;
1111     int i;
1112
1113     hr = CreateXmlReader(&IID_IXmlReader, (void**)&reader, NULL);
1114     ok(hr == S_OK, "S_OK, got %08x\n", hr);
1115
1116     stream = create_stream_on_data(test->xml, strlen(test->xml)+1);
1117     hr = IXmlReader_SetInput(reader, (IUnknown*)stream);
1118     ok(hr == S_OK, "got %08x\n", hr);
1119
1120     i = 0;
1121     type = XmlNodeType_None;
1122     hr = IXmlReader_Read(reader, &type);
1123     while (hr == S_OK)
1124     {
1125         ok(test->types[i] != XmlNodeType_None, "%d: unexpected end of test data\n", i);
1126         if (test->types[i] == XmlNodeType_None) break;
1127         ok(type == test->types[i], "%d: got wrong type %d, expected %d\n", i, type, test->types[i]);
1128         if (type == XmlNodeType_Whitespace)
1129         {
1130             const WCHAR *ptr;
1131             UINT len = 0;
1132
1133             hr = IXmlReader_GetValue(reader, &ptr, &len);
1134             ok(hr == S_OK, "%d: GetValue failed 0x%08x\n", i, hr);
1135             ok(len > 0, "%d: wrong value length %d\n", i, len);
1136         }
1137         hr = IXmlReader_Read(reader, &type);
1138         i++;
1139     }
1140     ok(test->types[i] == XmlNodeType_None, "incomplete sequence, got %d\n", test->types[i]);
1141
1142     IStream_Release(stream);
1143     IXmlReader_Release(reader);
1144 }
1145
1146 static const char test_public_dtd[] =
1147     "<!DOCTYPE testdtd PUBLIC \"pubid\" \"externalid uri\" >";
1148
1149 static void test_read_public_dtd(void)
1150 {
1151     static const WCHAR sysvalW[] = {'e','x','t','e','r','n','a','l','i','d',' ','u','r','i',0};
1152     static const WCHAR pubvalW[] = {'p','u','b','i','d',0};
1153     static const WCHAR dtdnameW[] = {'t','e','s','t','d','t','d',0};
1154     static const WCHAR sysW[] = {'S','Y','S','T','E','M',0};
1155     static const WCHAR pubW[] = {'P','U','B','L','I','C',0};
1156     IXmlReader *reader;
1157     const WCHAR *str;
1158     XmlNodeType type;
1159     IStream *stream;
1160     UINT len, count;
1161     HRESULT hr;
1162
1163     hr = CreateXmlReader(&IID_IXmlReader, (void**)&reader, NULL);
1164     ok(hr == S_OK, "S_OK, got %08x\n", hr);
1165
1166     hr = IXmlReader_SetProperty(reader, XmlReaderProperty_DtdProcessing, DtdProcessing_Parse);
1167     ok(hr == S_OK, "got 0x%8x\n", hr);
1168
1169     stream = create_stream_on_data(test_public_dtd, sizeof(test_public_dtd));
1170     hr = IXmlReader_SetInput(reader, (IUnknown*)stream);
1171     ok(hr == S_OK, "got %08x\n", hr);
1172
1173     type = XmlNodeType_None;
1174     hr = IXmlReader_Read(reader, &type);
1175     ok(hr == S_OK, "got 0x%8x\n", hr);
1176     ok(type == XmlNodeType_DocumentType, "got type %d\n", type);
1177
1178     count = 0;
1179     hr = IXmlReader_GetAttributeCount(reader, &count);
1180     ok(hr == S_OK, "got %08x\n", hr);
1181     ok(count == 2, "got %d\n", count);
1182
1183     hr = IXmlReader_MoveToFirstAttribute(reader);
1184     ok(hr == S_OK, "got %08x\n", hr);
1185
1186     type = XmlNodeType_None;
1187     hr = IXmlReader_GetNodeType(reader, &type);
1188     ok(hr == S_OK, "got %08x\n", hr);
1189     ok(type == XmlNodeType_Attribute, "got %d\n", type);
1190
1191     len = 0;
1192     str = NULL;
1193     hr = IXmlReader_GetLocalName(reader, &str, &len);
1194     ok(hr == S_OK, "got 0x%08x\n", hr);
1195     ok(len == lstrlenW(pubW), "got %u\n", len);
1196     ok(!lstrcmpW(str, pubW), "got %s\n", wine_dbgstr_w(str));
1197
1198     len = 0;
1199     str = NULL;
1200     hr = IXmlReader_GetValue(reader, &str, &len);
1201     ok(hr == S_OK, "got 0x%08x\n", hr);
1202     ok(len == lstrlenW(pubvalW), "got %u\n", len);
1203     ok(!lstrcmpW(str, pubvalW), "got %s\n", wine_dbgstr_w(str));
1204
1205     hr = IXmlReader_MoveToNextAttribute(reader);
1206     ok(hr == S_OK, "got %08x\n", hr);
1207
1208     type = XmlNodeType_None;
1209     hr = IXmlReader_GetNodeType(reader, &type);
1210     ok(hr == S_OK, "got %08x\n", hr);
1211     ok(type == XmlNodeType_Attribute, "got %d\n", type);
1212
1213     len = 0;
1214     str = NULL;
1215     hr = IXmlReader_GetLocalName(reader, &str, &len);
1216     ok(hr == S_OK, "got 0x%08x\n", hr);
1217     ok(len == lstrlenW(sysW), "got %u\n", len);
1218     ok(!lstrcmpW(str, sysW), "got %s\n", wine_dbgstr_w(str));
1219
1220     len = 0;
1221     str = NULL;
1222     hr = IXmlReader_GetValue(reader, &str, &len);
1223     ok(hr == S_OK, "got 0x%08x\n", hr);
1224     ok(len == lstrlenW(sysvalW), "got %u\n", len);
1225     ok(!lstrcmpW(str, sysvalW), "got %s\n", wine_dbgstr_w(str));
1226
1227     hr = IXmlReader_MoveToElement(reader);
1228     ok(hr == S_OK, "got 0x%08x\n", hr);
1229
1230     len = 0;
1231     str = NULL;
1232     hr = IXmlReader_GetLocalName(reader, &str, &len);
1233     ok(hr == S_OK, "got 0x%08x\n", hr);
1234 todo_wine {
1235     ok(len == lstrlenW(dtdnameW), "got %u\n", len);
1236     ok(!lstrcmpW(str, dtdnameW), "got %s\n", wine_dbgstr_w(str));
1237 }
1238     len = 0;
1239     str = NULL;
1240     hr = IXmlReader_GetQualifiedName(reader, &str, &len);
1241     ok(hr == S_OK, "got 0x%08x\n", hr);
1242     ok(len == lstrlenW(dtdnameW), "got %u\n", len);
1243     ok(!lstrcmpW(str, dtdnameW), "got %s\n", wine_dbgstr_w(str));
1244
1245     IStream_Release(stream);
1246     IXmlReader_Release(reader);
1247 }
1248
1249 static const char test_system_dtd[] =
1250     "<!DOCTYPE testdtd SYSTEM \"externalid uri\" >"
1251     "<!-- comment -->";
1252
1253 static void test_read_system_dtd(void)
1254 {
1255     static const WCHAR sysvalW[] = {'e','x','t','e','r','n','a','l','i','d',' ','u','r','i',0};
1256     static const WCHAR dtdnameW[] = {'t','e','s','t','d','t','d',0};
1257     static const WCHAR sysW[] = {'S','Y','S','T','E','M',0};
1258     IXmlReader *reader;
1259     const WCHAR *str;
1260     XmlNodeType type;
1261     IStream *stream;
1262     UINT len, count;
1263     HRESULT hr;
1264
1265     hr = CreateXmlReader(&IID_IXmlReader, (void**)&reader, NULL);
1266     ok(hr == S_OK, "S_OK, got %08x\n", hr);
1267
1268     hr = IXmlReader_SetProperty(reader, XmlReaderProperty_DtdProcessing, DtdProcessing_Parse);
1269     ok(hr == S_OK, "got 0x%8x\n", hr);
1270
1271     stream = create_stream_on_data(test_system_dtd, sizeof(test_system_dtd));
1272     hr = IXmlReader_SetInput(reader, (IUnknown*)stream);
1273     ok(hr == S_OK, "got %08x\n", hr);
1274
1275     type = XmlNodeType_None;
1276     hr = IXmlReader_Read(reader, &type);
1277     ok(hr == S_OK, "got 0x%8x\n", hr);
1278     ok(type == XmlNodeType_DocumentType, "got type %d\n", type);
1279
1280     count = 0;
1281     hr = IXmlReader_GetAttributeCount(reader, &count);
1282     ok(hr == S_OK, "got %08x\n", hr);
1283     ok(count == 1, "got %d\n", count);
1284
1285     hr = IXmlReader_MoveToFirstAttribute(reader);
1286     ok(hr == S_OK, "got %08x\n", hr);
1287
1288     type = XmlNodeType_None;
1289     hr = IXmlReader_GetNodeType(reader, &type);
1290     ok(hr == S_OK, "got %08x\n", hr);
1291     ok(type == XmlNodeType_Attribute, "got %d\n", type);
1292
1293     len = 0;
1294     str = NULL;
1295     hr = IXmlReader_GetLocalName(reader, &str, &len);
1296     ok(hr == S_OK, "got 0x%08x\n", hr);
1297     ok(len == lstrlenW(sysW), "got %u\n", len);
1298     ok(!lstrcmpW(str, sysW), "got %s\n", wine_dbgstr_w(str));
1299
1300     len = 0;
1301     str = NULL;
1302     hr = IXmlReader_GetValue(reader, &str, &len);
1303     ok(hr == S_OK, "got 0x%08x\n", hr);
1304     ok(len == lstrlenW(sysvalW), "got %u\n", len);
1305     ok(!lstrcmpW(str, sysvalW), "got %s\n", wine_dbgstr_w(str));
1306
1307     hr = IXmlReader_MoveToElement(reader);
1308     ok(hr == S_OK, "got 0x%08x\n", hr);
1309
1310     len = 0;
1311     str = NULL;
1312     hr = IXmlReader_GetLocalName(reader, &str, &len);
1313     ok(hr == S_OK, "got 0x%08x\n", hr);
1314 todo_wine {
1315     ok(len == lstrlenW(dtdnameW), "got %u\n", len);
1316     ok(!lstrcmpW(str, dtdnameW), "got %s\n", wine_dbgstr_w(str));
1317 }
1318     len = 0;
1319     str = NULL;
1320     hr = IXmlReader_GetQualifiedName(reader, &str, &len);
1321     ok(hr == S_OK, "got 0x%08x\n", hr);
1322     ok(len == lstrlenW(dtdnameW), "got %u\n", len);
1323     ok(!lstrcmpW(str, dtdnameW), "got %s\n", wine_dbgstr_w(str));
1324
1325     type = XmlNodeType_None;
1326     hr = IXmlReader_Read(reader, &type);
1327     ok(hr == S_OK, "got 0x%8x\n", hr);
1328     ok(type == XmlNodeType_Comment, "got type %d\n", type);
1329
1330     IStream_Release(stream);
1331     IXmlReader_Release(reader);
1332 }
1333
1334 static struct test_entry element_tests[] = {
1335     { "<a/>", "a", "", S_OK },
1336     { "<a />", "a", "", S_OK },
1337     { "<a:b/>", "a:b", "", NC_E_UNDECLAREDPREFIX },
1338     { "<:a/>", NULL, NULL, NC_E_QNAMECHARACTER },
1339     { "< a/>", NULL, NULL, NC_E_QNAMECHARACTER },
1340     { "<a>", "a", "", S_OK },
1341     { "<a >", "a", "", S_OK },
1342     { "<a \r \t\n>", "a", "", S_OK },
1343     { "</a>", NULL, NULL, NC_E_QNAMECHARACTER },
1344     { NULL }
1345 };
1346
1347 static void test_read_element(void)
1348 {
1349     struct test_entry *test = element_tests;
1350     static const char stag[] = "<a><b></b></a>";
1351     static const char mismatch[] = "<a></b>";
1352     IXmlReader *reader;
1353     XmlNodeType type;
1354     IStream *stream;
1355     UINT depth;
1356     HRESULT hr;
1357
1358     hr = CreateXmlReader(&IID_IXmlReader, (void**)&reader, NULL);
1359     ok(hr == S_OK, "S_OK, got %08x\n", hr);
1360
1361     while (test->xml)
1362     {
1363         stream = create_stream_on_data(test->xml, strlen(test->xml)+1);
1364         hr = IXmlReader_SetInput(reader, (IUnknown*)stream);
1365         ok(hr == S_OK, "got %08x\n", hr);
1366
1367         type = XmlNodeType_None;
1368         hr = IXmlReader_Read(reader, &type);
1369         if (test->hr_broken)
1370             ok(hr == test->hr || broken(hr == test->hr_broken), "got %08x for %s\n", hr, test->xml);
1371         else
1372             todo_wine_if(test->hr == NC_E_UNDECLAREDPREFIX)
1373                 ok(hr == test->hr, "got %08x for %s\n", hr, test->xml);
1374         if (hr == S_OK)
1375         {
1376             const WCHAR *str;
1377             WCHAR *str_exp;
1378             UINT len;
1379
1380             ok(type == XmlNodeType_Element, "got %d for %s\n", type, test->xml);
1381
1382             len = 0;
1383             str = NULL;
1384             hr = IXmlReader_GetQualifiedName(reader, &str, &len);
1385             ok(hr == S_OK, "got 0x%08x\n", hr);
1386             ok(len == strlen(test->name), "got %u\n", len);
1387             str_exp = a2w(test->name);
1388             ok(!lstrcmpW(str, str_exp), "got %s\n", wine_dbgstr_w(str));
1389             free_str(str_exp);
1390
1391             /* value */
1392             len = 1;
1393             str = NULL;
1394             hr = IXmlReader_GetValue(reader, &str, &len);
1395             ok(hr == S_OK, "got 0x%08x\n", hr);
1396             ok(len == 0, "got %u\n", len);
1397             ok(*str == 0, "got %s\n", wine_dbgstr_w(str));
1398         }
1399
1400         IStream_Release(stream);
1401         test++;
1402     }
1403
1404     /* test reader depth increment */
1405     stream = create_stream_on_data(stag, sizeof(stag));
1406     hr = IXmlReader_SetInput(reader, (IUnknown*)stream);
1407     ok(hr == S_OK, "got %08x\n", hr);
1408
1409     depth = 1;
1410     hr = IXmlReader_GetDepth(reader, &depth);
1411     ok(hr == S_OK, "got %08x\n", hr);
1412     ok(depth == 0, "got %d\n", depth);
1413
1414     type = XmlNodeType_None;
1415     hr = IXmlReader_Read(reader, &type);
1416     ok(hr == S_OK, "got %08x\n", hr);
1417     ok(type == XmlNodeType_Element, "got %d\n", type);
1418
1419     depth = 1;
1420     hr = IXmlReader_GetDepth(reader, &depth);
1421     ok(hr == S_OK, "got %08x\n", hr);
1422     ok(depth == 0, "got %d\n", depth);
1423
1424     type = XmlNodeType_None;
1425     hr = IXmlReader_Read(reader, &type);
1426     ok(hr == S_OK, "got %08x\n", hr);
1427     ok(type == XmlNodeType_Element, "got %d\n", type);
1428
1429     depth = 0;
1430     hr = IXmlReader_GetDepth(reader, &depth);
1431     ok(hr == S_OK, "got %08x\n", hr);
1432     ok(depth == 1, "got %d\n", depth);
1433
1434     /* read end tag for inner element */
1435     type = XmlNodeType_None;
1436     hr = IXmlReader_Read(reader, &type);
1437     ok(hr == S_OK, "got %08x\n", hr);
1438     ok(type == XmlNodeType_EndElement, "got %d\n", type);
1439
1440     depth = 0;
1441     hr = IXmlReader_GetDepth(reader, &depth);
1442     ok(hr == S_OK, "got %08x\n", hr);
1443 todo_wine
1444     ok(depth == 2, "got %d\n", depth);
1445
1446     /* read end tag for container element */
1447     type = XmlNodeType_None;
1448     hr = IXmlReader_Read(reader, &type);
1449     ok(hr == S_OK, "got %08x\n", hr);
1450     ok(type == XmlNodeType_EndElement, "got %d\n", type);
1451
1452     depth = 0;
1453     hr = IXmlReader_GetDepth(reader, &depth);
1454     ok(hr == S_OK, "got %08x\n", hr);
1455     ok(depth == 1, "got %d\n", depth);
1456
1457     IStream_Release(stream);
1458
1459     /* start/end tag mismatch */
1460     stream = create_stream_on_data(mismatch, sizeof(mismatch));
1461     hr = IXmlReader_SetInput(reader, (IUnknown*)stream);
1462     ok(hr == S_OK, "got %08x\n", hr);
1463
1464     type = XmlNodeType_None;
1465     hr = IXmlReader_Read(reader, &type);
1466     ok(hr == S_OK, "got %08x\n", hr);
1467     ok(type == XmlNodeType_Element, "got %d\n", type);
1468
1469     type = XmlNodeType_Element;
1470     hr = IXmlReader_Read(reader, &type);
1471     ok(hr == WC_E_ELEMENTMATCH, "got %08x\n", hr);
1472 todo_wine
1473     ok(type == XmlNodeType_None, "got %d\n", type);
1474
1475     IStream_Release(stream);
1476
1477     IXmlReader_Release(reader);
1478 }
1479
1480 static ISequentialStream teststream = { &teststreamvtbl };
1481
1482 static void test_read_pending(void)
1483 {
1484     IXmlReader *reader;
1485     const WCHAR *value;
1486     XmlNodeType type;
1487     HRESULT hr;
1488     int c;
1489
1490     hr = CreateXmlReader(&IID_IXmlReader, (void**)&reader, NULL);
1491     ok(hr == S_OK, "S_OK, got 0x%08x\n", hr);
1492
1493     hr = IXmlReader_SetInput(reader, (IUnknown*)&teststream);
1494     ok(hr == S_OK, "got 0x%08x\n", hr);
1495
1496     /* first read call returns incomplete node, second attempt fails with E_PENDING */
1497     stream_readcall = 0;
1498     type = XmlNodeType_Element;
1499     hr = IXmlReader_Read(reader, &type);
1500     ok(hr == S_OK || broken(hr == E_PENDING), "got 0x%08x\n", hr);
1501     /* newer versions are happy when it's enough data to detect node type,
1502        older versions keep reading until it fails to read more */
1503     ok(stream_readcall == 1 || broken(stream_readcall > 1), "got %d\n", stream_readcall);
1504     ok(type == XmlNodeType_Comment || broken(type == XmlNodeType_None), "got %d\n", type);
1505
1506     /* newer versions' GetValue() makes an attempt to read more */
1507     c = stream_readcall;
1508     value = (void*)0xdeadbeef;
1509     hr = IXmlReader_GetValue(reader, &value, NULL);
1510     ok(hr == E_PENDING, "got 0x%08x\n", hr);
1511     ok(value == NULL || broken(value == (void*)0xdeadbeef) /* Win8 sets it to NULL */, "got %p\n", value);
1512     ok(c < stream_readcall || broken(c == stream_readcall), "got %d, expected %d\n", stream_readcall, c+1);
1513
1514     IXmlReader_Release(reader);
1515 }
1516
1517 static void test_readvaluechunk(void)
1518 {
1519     static const char testA[] = "<!-- comment1 -->";
1520     IXmlReader *reader;
1521     XmlNodeType type;
1522     IStream *stream;
1523     const WCHAR *value;
1524     WCHAR b;
1525     HRESULT hr;
1526     UINT c;
1527
1528     hr = CreateXmlReader(&IID_IXmlReader, (void**)&reader, NULL);
1529     ok(hr == S_OK, "S_OK, got %08x\n", hr);
1530
1531     stream = create_stream_on_data(testA, sizeof(testA));
1532     hr = IXmlReader_SetInput(reader, (IUnknown*)stream);
1533     ok(hr == S_OK, "got %08x\n", hr);
1534
1535     hr = IXmlReader_Read(reader, &type);
1536     ok(hr == S_OK, "got %08x\n", hr);
1537
1538     c = 0;
1539     b = 0;
1540     hr = IXmlReader_ReadValueChunk(reader, &b, 1, &c);
1541     ok(hr == S_OK, "got %08x\n", hr);
1542     ok(c == 1, "got %u\n", c);
1543     ok(b == ' ', "got %x\n", b);
1544
1545     /* portion read as chunk is skipped from resulting node value */
1546     value = NULL;
1547     hr = IXmlReader_GetValue(reader, &value, NULL);
1548     ok(hr == S_OK, "got %08x\n", hr);
1549     ok(value[0] == 'c', "got %s\n", wine_dbgstr_w(value));
1550
1551     /* once value is returned/allocated it's not possible to read by chunk */
1552     c = 0;
1553     b = 0;
1554     hr = IXmlReader_ReadValueChunk(reader, &b, 1, &c);
1555     ok(hr == S_FALSE, "got %08x\n", hr);
1556     ok(c == 0, "got %u\n", c);
1557     ok(b == 0, "got %x\n", b);
1558
1559     value = NULL;
1560     hr = IXmlReader_GetValue(reader, &value, NULL);
1561     ok(hr == S_OK, "got %08x\n", hr);
1562     ok(value[0] == 'c', "got %s\n", wine_dbgstr_w(value));
1563
1564     IXmlReader_Release(reader);
1565     IStream_Release(stream);
1566 }
1567
1568 static struct test_entry cdata_tests[] = {
1569     { "<a><![CDATA[ ]]data ]]></a>", "", " ]]data ", S_OK },
1570     { "<a><![CDATA[<![CDATA[ data ]]]]></a>", "", "<![CDATA[ data ]]", S_OK },
1571     { "<a><![CDATA[\n \r\n \n\n ]]></a>", "", "\n \n \n\n ", S_OK, S_OK, TRUE },
1572     { "<a><![CDATA[\r \r\r\n \n\n ]]></a>", "", "\n \n\n \n\n ", S_OK, S_OK, TRUE },
1573     { "<a><![CDATA[\r\r \n\r \r \n\n ]]></a>", "", "\n\n \n\n \n \n\n ", S_OK },
1574     { NULL }
1575 };
1576
1577 static void test_read_cdata(void)
1578 {
1579     struct test_entry *test = cdata_tests;
1580     IXmlReader *reader;
1581     HRESULT hr;
1582
1583     hr = CreateXmlReader(&IID_IXmlReader, (void**)&reader, NULL);
1584     ok(hr == S_OK, "S_OK, got %08x\n", hr);
1585
1586     while (test->xml)
1587     {
1588         XmlNodeType type;
1589         IStream *stream;
1590
1591         stream = create_stream_on_data(test->xml, strlen(test->xml)+1);
1592         hr = IXmlReader_SetInput(reader, (IUnknown*)stream);
1593         ok(hr == S_OK, "got %08x\n", hr);
1594
1595         type = XmlNodeType_None;
1596         hr = IXmlReader_Read(reader, &type);
1597
1598         /* read one more to get to CDATA */
1599         if (type == XmlNodeType_Element)
1600         {
1601             type = XmlNodeType_None;
1602             hr = IXmlReader_Read(reader, &type);
1603         }
1604
1605         if (test->hr_broken)
1606             ok(hr == test->hr || broken(hr == test->hr_broken), "got %08x for %s\n", hr, test->xml);
1607         else
1608             ok(hr == test->hr, "got %08x for %s\n", hr, test->xml);
1609         if (hr == S_OK)
1610         {
1611             const WCHAR *str;
1612             WCHAR *str_exp;
1613             UINT len;
1614
1615             ok(type == XmlNodeType_CDATA, "got %d for %s\n", type, test->xml);
1616
1617             str_exp = a2w(test->name);
1618
1619             len = 1;
1620             str = NULL;
1621             hr = IXmlReader_GetLocalName(reader, &str, &len);
1622             ok(hr == S_OK, "got 0x%08x\n", hr);
1623             ok(len == strlen(test->name), "got %u\n", len);
1624             ok(!lstrcmpW(str, str_exp), "got %s\n", wine_dbgstr_w(str));
1625
1626             str = NULL;
1627             hr = IXmlReader_GetLocalName(reader, &str, NULL);
1628             ok(hr == S_OK, "got 0x%08x\n", hr);
1629             ok(!lstrcmpW(str, str_exp), "got %s\n", wine_dbgstr_w(str));
1630
1631             free_str(str_exp);
1632
1633             len = 1;
1634             str = NULL;
1635             hr = IXmlReader_GetQualifiedName(reader, &str, &len);
1636             ok(hr == S_OK, "got 0x%08x\n", hr);
1637             ok(len == strlen(test->name), "got %u\n", len);
1638             str_exp = a2w(test->name);
1639             ok(!lstrcmpW(str, str_exp), "got %s\n", wine_dbgstr_w(str));
1640             free_str(str_exp);
1641
1642             /* value */
1643             len = 1;
1644             str = NULL;
1645             hr = IXmlReader_GetValue(reader, &str, &len);
1646             ok(hr == S_OK, "got 0x%08x\n", hr);
1647
1648             str_exp = a2w(test->value);
1649             todo_wine_if (test->todo)
1650             {
1651                 ok(len == strlen(test->value), "got %u\n", len);
1652                 ok(!lstrcmpW(str, str_exp), "got %s\n", wine_dbgstr_w(str));
1653             }
1654             free_str(str_exp);
1655         }
1656
1657         IStream_Release(stream);
1658         test++;
1659     }
1660
1661     IXmlReader_Release(reader);
1662 }
1663
1664 static struct test_entry text_tests[] = {
1665     { "<a>simple text</a>", "", "simple text", S_OK },
1666     { "<a>text ]]> text</a>", "", "", WC_E_CDSECTEND },
1667     { NULL }
1668 };
1669
1670 static void test_read_text(void)
1671 {
1672     struct test_entry *test = text_tests;
1673     IXmlReader *reader;
1674     HRESULT hr;
1675
1676     hr = CreateXmlReader(&IID_IXmlReader, (void**)&reader, NULL);
1677     ok(hr == S_OK, "S_OK, got %08x\n", hr);
1678
1679     while (test->xml)
1680     {
1681         XmlNodeType type;
1682         IStream *stream;
1683
1684         stream = create_stream_on_data(test->xml, strlen(test->xml)+1);
1685         hr = IXmlReader_SetInput(reader, (IUnknown*)stream);
1686         ok(hr == S_OK, "got %08x\n", hr);
1687
1688         type = XmlNodeType_None;
1689         hr = IXmlReader_Read(reader, &type);
1690
1691         /* read one more to get to CDATA */
1692         if (type == XmlNodeType_Element)
1693         {
1694             type = XmlNodeType_None;
1695             hr = IXmlReader_Read(reader, &type);
1696         }
1697
1698         if (test->hr_broken)
1699             ok(hr == test->hr || broken(hr == test->hr_broken), "got %08x for %s\n", hr, test->xml);
1700         else
1701             ok(hr == test->hr, "got %08x for %s\n", hr, test->xml);
1702         if (hr == S_OK)
1703         {
1704             const WCHAR *str;
1705             WCHAR *str_exp;
1706             UINT len;
1707
1708             ok(type == XmlNodeType_Text, "got %d for %s\n", type, test->xml);
1709
1710             str_exp = a2w(test->name);
1711
1712             len = 1;
1713             str = NULL;
1714             hr = IXmlReader_GetLocalName(reader, &str, &len);
1715             ok(hr == S_OK, "got 0x%08x\n", hr);
1716             ok(len == strlen(test->name), "got %u\n", len);
1717             ok(!lstrcmpW(str, str_exp), "got %s\n", wine_dbgstr_w(str));
1718
1719             str = NULL;
1720             hr = IXmlReader_GetLocalName(reader, &str, NULL);
1721             ok(hr == S_OK, "got 0x%08x\n", hr);
1722             ok(!lstrcmpW(str, str_exp), "got %s\n", wine_dbgstr_w(str));
1723
1724             free_str(str_exp);
1725
1726             len = 1;
1727             str = NULL;
1728             hr = IXmlReader_GetQualifiedName(reader, &str, &len);
1729             ok(hr == S_OK, "got 0x%08x\n", hr);
1730             ok(len == strlen(test->name), "got %u\n", len);
1731             str_exp = a2w(test->name);
1732             ok(!lstrcmpW(str, str_exp), "got %s\n", wine_dbgstr_w(str));
1733             free_str(str_exp);
1734
1735             /* value */
1736             len = 1;
1737             str = NULL;
1738             hr = IXmlReader_GetValue(reader, &str, &len);
1739             ok(hr == S_OK, "got 0x%08x\n", hr);
1740
1741             str_exp = a2w(test->value);
1742             todo_wine_if (test->todo)
1743             {
1744                 ok(len == strlen(test->value), "got %u\n", len);
1745                 ok(!lstrcmpW(str, str_exp), "got %s\n", wine_dbgstr_w(str));
1746             }
1747             free_str(str_exp);
1748         }
1749
1750         IStream_Release(stream);
1751         test++;
1752     }
1753
1754     IXmlReader_Release(reader);
1755 }
1756
1757 struct test_entry_empty {
1758     const char *xml;
1759     BOOL empty;
1760 };
1761
1762 static struct test_entry_empty empty_element_tests[] = {
1763     { "<a></a>", FALSE },
1764     { "<a/>", TRUE },
1765     { NULL }
1766 };
1767
1768 static void test_isemptyelement(void)
1769 {
1770     struct test_entry_empty *test = empty_element_tests;
1771     IXmlReader *reader;
1772     HRESULT hr;
1773
1774     hr = CreateXmlReader(&IID_IXmlReader, (void**)&reader, NULL);
1775     ok(hr == S_OK, "S_OK, got %08x\n", hr);
1776
1777     while (test->xml)
1778     {
1779         XmlNodeType type;
1780         IStream *stream;
1781         BOOL ret;
1782
1783         stream = create_stream_on_data(test->xml, strlen(test->xml)+1);
1784         hr = IXmlReader_SetInput(reader, (IUnknown*)stream);
1785         ok(hr == S_OK, "got %08x\n", hr);
1786
1787         type = XmlNodeType_None;
1788         hr = IXmlReader_Read(reader, &type);
1789         ok(hr == S_OK, "got 0x%08x\n", hr);
1790         ok(type == XmlNodeType_Element, "got %d\n", type);
1791
1792         ret = IXmlReader_IsEmptyElement(reader);
1793         ok(ret == test->empty, "got %d, expected %d. xml=%s\n", ret, test->empty, test->xml);
1794
1795         IStream_Release(stream);
1796         test++;
1797     }
1798
1799     IXmlReader_Release(reader);
1800 }
1801
1802 static struct test_entry attributes_tests[] = {
1803     { "<a attr1=\"attrvalue\"/>", "attr1", "attrvalue", S_OK },
1804     { "<a attr1=\"a\'\'ttrvalue\"/>", "attr1", "a\'\'ttrvalue", S_OK },
1805     { "<a attr1=\'a\"ttrvalue\'/>", "attr1", "a\"ttrvalue", S_OK },
1806     { "<a attr1=\' \'/>", "attr1", " ", S_OK },
1807     { "<a attr1=\" \"/>", "attr1", " ", S_OK },
1808     { "<a attr1=\"\r\n \r \n \t\n\r\"/>", "attr1", "         ", S_OK },
1809     { "<a attr1=\" val \"/>", "attr1", " val ", S_OK },
1810     { "<a attr1=\"\r\n\tval\n\"/>", "attr1", "  val ", S_OK },
1811     { "<a attr1=\"val&#32;\"/>", "attr1", "val ", S_OK },
1812     { "<a attr1=\"val&#x20;\"/>", "attr1", "val ", S_OK },
1813     { "<a attr1=\"&lt;&gt;&amp;&apos;&quot;\"/>", "attr1", "<>&\'\"", S_OK },
1814     { "<a attr1=\"&entname;\"/>", NULL, NULL, WC_E_UNDECLAREDENTITY },
1815     { "<a attr1=\"val&#xfffe;\"/>", NULL, NULL, WC_E_XMLCHARACTER },
1816     { "<a attr1=\"val &#a;\"/>", NULL, NULL, WC_E_DIGIT, WC_E_SEMICOLON },
1817     { "<a attr1=\"val &#12a;\"/>", NULL, NULL, WC_E_SEMICOLON },
1818     { "<a attr1=\"val &#x12g;\"/>", NULL, NULL, WC_E_SEMICOLON },
1819     { "<a attr1=\"val &#xg;\"/>", NULL, NULL, WC_E_HEXDIGIT, WC_E_SEMICOLON },
1820     { "<a attr1=attrvalue/>", NULL, NULL, WC_E_QUOTE },
1821     { "<a attr1=\"attr<value\"/>", NULL, NULL, WC_E_LESSTHAN },
1822     { "<a attr1=\"&entname\"/>", NULL, NULL, WC_E_SEMICOLON },
1823     { NULL }
1824 };
1825
1826 static void test_read_attribute(void)
1827 {
1828     struct test_entry *test = attributes_tests;
1829     IXmlReader *reader;
1830     HRESULT hr;
1831
1832     hr = CreateXmlReader(&IID_IXmlReader, (void**)&reader, NULL);
1833     ok(hr == S_OK, "S_OK, got %08x\n", hr);
1834
1835     while (test->xml)
1836     {
1837         XmlNodeType type;
1838         IStream *stream;
1839
1840         stream = create_stream_on_data(test->xml, strlen(test->xml)+1);
1841         hr = IXmlReader_SetInput(reader, (IUnknown*)stream);
1842         ok(hr == S_OK, "got %08x\n", hr);
1843
1844         type = XmlNodeType_None;
1845         hr = IXmlReader_Read(reader, &type);
1846
1847         if (test->hr_broken)
1848             ok(hr == test->hr || broken(hr == test->hr_broken), "got %08x for %s\n", hr, test->xml);
1849         else
1850             ok(hr == test->hr, "got %08x for %s\n", hr, test->xml);
1851         if (hr == S_OK)
1852         {
1853             const WCHAR *str;
1854             WCHAR *str_exp;
1855             UINT len;
1856
1857             ok(type == XmlNodeType_Element, "got %d for %s\n", type, test->xml);
1858
1859             hr = IXmlReader_MoveToFirstAttribute(reader);
1860             ok(hr == S_OK, "got 0x%08x\n", hr);
1861
1862             len = 1;
1863             str = NULL;
1864             hr = IXmlReader_GetLocalName(reader, &str, &len);
1865             ok(hr == S_OK, "got 0x%08x\n", hr);
1866             ok(len == strlen(test->name), "got %u\n", len);
1867             str_exp = a2w(test->name);
1868             ok(!lstrcmpW(str, str_exp), "got %s\n", wine_dbgstr_w(str));
1869             free_str(str_exp);
1870
1871             len = 1;
1872             str = NULL;
1873             hr = IXmlReader_GetQualifiedName(reader, &str, &len);
1874             ok(hr == S_OK, "got 0x%08x\n", hr);
1875         todo_wine {
1876             ok(len == strlen(test->name), "got %u\n", len);
1877             str_exp = a2w(test->name);
1878             ok(!lstrcmpW(str, str_exp), "got %s\n", wine_dbgstr_w(str));
1879             free_str(str_exp);
1880         }
1881             /* value */
1882             len = 1;
1883             str = NULL;
1884             hr = IXmlReader_GetValue(reader, &str, &len);
1885             ok(hr == S_OK, "got 0x%08x\n", hr);
1886             ok(len == strlen(test->value), "got %u\n", len);
1887             str_exp = a2w(test->value);
1888             ok(!lstrcmpW(str, str_exp), "got %s\n", wine_dbgstr_w(str));
1889             free_str(str_exp);
1890         }
1891
1892         IStream_Release(stream);
1893         test++;
1894     }
1895
1896     IXmlReader_Release(reader);
1897 }
1898
1899 static void test_reader_properties(void)
1900 {
1901     IXmlReader *reader;
1902     HRESULT hr;
1903
1904     hr = CreateXmlReader(&IID_IXmlReader, (void**)&reader, NULL);
1905     ok(hr == S_OK, "S_OK, got %08x\n", hr);
1906
1907     hr = IXmlReader_SetProperty(reader, XmlReaderProperty_MultiLanguage, 0);
1908     ok(hr == S_OK, "SetProperty failed: %08x\n", hr);
1909
1910     hr = IXmlReader_SetProperty(reader, XmlReaderProperty_MaxElementDepth, 0);
1911     ok(hr == S_OK, "SetProperty failed: %08x\n", hr);
1912
1913     IXmlReader_Release(reader);
1914 }
1915
1916 static void test_prefix(void)
1917 {
1918     static const struct
1919     {
1920         const char *xml;
1921         const char *prefix1;
1922         const char *prefix2;
1923         const char *prefix3;
1924     } prefix_tests[] =
1925     {
1926         { "<b xmlns=\"defns\" xml:a=\"a ns\"/>", "", "", "xml" },
1927     };
1928     IXmlReader *reader;
1929     unsigned int i;
1930     HRESULT hr;
1931
1932     hr = CreateXmlReader(&IID_IXmlReader, (void**)&reader, NULL);
1933     ok(hr == S_OK, "S_OK, got %08x\n", hr);
1934
1935     for (i = 0; i < sizeof(prefix_tests)/sizeof(prefix_tests[0]); i++) {
1936         const WCHAR *prefix;
1937         XmlNodeType type;
1938         WCHAR *expected;
1939         IStream *stream;
1940
1941         stream = create_stream_on_data(prefix_tests[i].xml, strlen(prefix_tests[i].xml) + 1);
1942         hr = IXmlReader_SetInput(reader, (IUnknown *)stream);
1943         ok(hr == S_OK, "got %08x\n", hr);
1944
1945         hr = IXmlReader_Read(reader, &type);
1946         ok(hr == S_OK, "Read() failed, %#x\n", hr);
1947         ok(type == XmlNodeType_Element, "Unexpected node type %d.\n", type);
1948
1949         expected = a2w(prefix_tests[i].prefix1);
1950         hr = IXmlReader_GetPrefix(reader, &prefix, NULL);
1951         ok(hr == S_OK, "GetPrefix() failed, %#x.\n", hr);
1952         ok(!lstrcmpW(prefix, expected), "Unexpected prefix %s, expected %s.\n", wine_dbgstr_w(prefix),
1953             wine_dbgstr_w(expected));
1954         free_str(expected);
1955
1956         hr = IXmlReader_MoveToFirstAttribute(reader);
1957         ok(hr == S_OK, "MoveToFirstAttribute() failed, %#x.\n", hr);
1958
1959         hr = IXmlReader_GetNodeType(reader, &type);
1960         ok(hr == S_OK, "GetNodeType() failed, %#x.\n", hr);
1961         ok(type == XmlNodeType_Attribute, "Unexpected node type %d.\n", type);
1962
1963         expected = a2w(prefix_tests[i].prefix2);
1964         hr = IXmlReader_GetPrefix(reader, &prefix, NULL);
1965         ok(hr == S_OK, "GetPrefix() failed, %#x.\n", hr);
1966         ok(!lstrcmpW(prefix, expected), "Unexpected prefix %s, expected %s.\n", wine_dbgstr_w(prefix),
1967             wine_dbgstr_w(expected));
1968         free_str(expected);
1969
1970         hr = IXmlReader_MoveToNextAttribute(reader);
1971         ok(hr == S_OK, "MoveToNextAttribute() failed, %#x.\n", hr);
1972
1973         hr = IXmlReader_GetNodeType(reader, &type);
1974         ok(hr == S_OK, "GetNodeType() failed, %#x.\n", hr);
1975         ok(type == XmlNodeType_Attribute, "Unexpected node type %d.\n", type);
1976
1977         expected = a2w(prefix_tests[i].prefix3);
1978         hr = IXmlReader_GetPrefix(reader, &prefix, NULL);
1979         ok(hr == S_OK, "GetPrefix() failed, %#x.\n", hr);
1980         ok(!lstrcmpW(prefix, expected), "Unexpected prefix %s, expected %s.\n", wine_dbgstr_w(prefix),
1981             wine_dbgstr_w(expected));
1982         free_str(expected);
1983
1984         IStream_Release(stream);
1985     }
1986
1987     IXmlReader_Release(reader);
1988 }
1989
1990 static void test_namespaceuri(void)
1991 {
1992     struct uri_test
1993     {
1994         const char *xml;
1995         const char *uri[5];
1996     } uri_tests[] =
1997     {
1998         { "<a xmlns=\"defns a\"><b xmlns=\"defns b\"><c xmlns=\"defns c\"/></b></a>",
1999                 { "defns a", "defns b", "defns c", "defns b", "defns a" }},
2000         { "<r:a xmlns=\"defns a\" xmlns:r=\"ns r\"/>",
2001                 { "ns r" }},
2002         { "<r:a xmlns=\"defns a\" xmlns:r=\"ns r\"><b/></r:a>",
2003                 { "ns r", "defns a", "ns r" }},
2004         { "<a xmlns=\"defns a\" xmlns:r=\"ns r\"><r:b/></a>",
2005                 { "defns a", "ns r", "defns a" }},
2006         { "<a><b><c/></b></a>",
2007                 { "", "", "", "", "" }},
2008     };
2009     IXmlReader *reader;
2010     XmlNodeType type;
2011     unsigned int i;
2012     HRESULT hr;
2013
2014     hr = CreateXmlReader(&IID_IXmlReader, (void**)&reader, NULL);
2015     ok(hr == S_OK, "S_OK, got %08x\n", hr);
2016
2017     for (i = 0; i < sizeof(uri_tests)/sizeof(uri_tests[0]); i++) {
2018         IStream *stream = create_stream_on_data(uri_tests[i].xml, strlen(uri_tests[i].xml) + 1);
2019         unsigned int j = 0;
2020
2021         hr = IXmlReader_SetInput(reader, (IUnknown *)stream);
2022         ok(hr == S_OK, "got %08x\n", hr);
2023
2024         while (IXmlReader_Read(reader, &type) == S_OK) {
2025             const WCHAR *uri, *local;
2026             WCHAR *uriW;
2027
2028             ok(type == XmlNodeType_Element || type == XmlNodeType_EndElement, "Unexpected node type %d.\n", type);
2029
2030             hr = IXmlReader_GetLocalName(reader, &local, NULL);
2031             ok(hr == S_OK, "S_OK, got %08x\n", hr);
2032
2033             hr = IXmlReader_GetNamespaceUri(reader, &uri, NULL);
2034             ok(hr == S_OK, "S_OK, got %08x\n", hr);
2035
2036             uriW = a2w(uri_tests[i].uri[j]);
2037             ok(!lstrcmpW(uriW, uri), "%s: uri %s\n", wine_dbgstr_w(local), wine_dbgstr_w(uri));
2038             free_str(uriW);
2039
2040             j++;
2041         }
2042
2043         IStream_Release(stream);
2044     }
2045
2046     IXmlReader_Release(reader);
2047 }
2048
2049 START_TEST(reader)
2050 {
2051     test_reader_create();
2052     test_readerinput();
2053     test_reader_state();
2054     test_read_attribute();
2055     test_read_cdata();
2056     test_read_comment();
2057     test_read_pi();
2058     test_read_system_dtd();
2059     test_read_public_dtd();
2060     test_read_element();
2061     test_isemptyelement();
2062     test_read_text();
2063     test_read_full();
2064     test_read_pending();
2065     test_readvaluechunk();
2066     test_read_xmldeclaration();
2067     test_reader_properties();
2068     test_prefix();
2069     test_namespaceuri();
2070 }