rostests/winetests/msxml3/saxreader.c

   1 /*
   2  * XML test
   3  *
   4  * Copyright 2008 Piotr Caban
   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 <stdio.h>
  25 #include "windows.h"
  26 #include "ole2.h"
  27 #include "msxml2.h"
  28 #include "ocidl.h"
  29
  30 #include "wine/test.h"
  31
  32 typedef enum _CH {
  33     CH_ENDTEST,
  34     CH_PUTDOCUMENTLOCATOR,
  35     CH_STARTDOCUMENT,
  36     CH_ENDDOCUMENT,
  37     CH_STARTPREFIXMAPPING,
  38     CH_ENDPREFIXMAPPING,
  39     CH_STARTELEMENT,
  40     CH_ENDELEMENT,
  41     CH_CHARACTERS,
  42     CH_IGNORABLEWHITESPACE,
  43     CH_PROCESSINGINSTRUCTION,
  44     CH_SKIPPEDENTITY
  45 } CH;
  46
  47 static const WCHAR szSimpleXML[] = {
  48 '<','?','x','m','l',' ','v','e','r','s','i','o','n','=','\"','1','.','0','\"',' ','?','>','\n',
  49 '<','B','a','n','k','A','c','c','o','u','n','t','>','\n',
  50 ' ',' ',' ','<','N','u','m','b','e','r','>','1','2','3','4','<','/','N','u','m','b','e','r','>','\n',
  51 ' ',' ',' ','<','N','a','m','e','>','C','a','p','t','a','i','n',' ','A','h','a','b','<','/','N','a','m','e','>','\n',
  52 '<','/','B','a','n','k','A','c','c','o','u','n','t','>','\n','\0'
  53 };
  54
  55 static const WCHAR szCarriageRetTest[] = {
  56 '<','?','x','m','l',' ','v','e','r','s','i','o','n','=','"','1','.','0','"','?','>','\r','\n',
  57 '<','B','a','n','k','A','c','c','o','u','n','t','>','\r','\n',
  58 '\t','<','N','u','m','b','e','r','>','1','2','3','4','<','/','N','u','m','b','e','r','>','\r','\n',
  59 '\t','<','N','a','m','e','>','C','a','p','t','a','i','n',' ','A','h','a','b','<','/','N','a','m','e','>','\r','\n',
  60 '<','/','B','a','n','k','A','c','c','o','u','n','t','>','\0'
  61 };
  62
  63 static const CHAR szTestXML[] =
  64 "<?xml version=\"1.0\" ?>\n"
  65 "<BankAccount>\n"
  66 "   <Number>1234</Number>\n"
  67 "   <Name>Captain Ahab</Name>\n"
  68 "</BankAccount>\n";
  69
  70 typedef struct _contenthandlercheck {
  71     CH id;
  72     int line;
  73     int column;
  74     const char *arg1;
  75     const char *arg2;
  76     const char *arg3;
  77 } content_handler_test;
  78
  79 static content_handler_test contentHandlerTest1[] = {
  80     { CH_PUTDOCUMENTLOCATOR, 0, 0 },
  81     { CH_STARTDOCUMENT, 0, 0 },
  82     { CH_STARTELEMENT, 2, 14, "", "BankAccount", "BankAccount" },
  83     { CH_CHARACTERS, 2, 14, "\n   " },
  84     { CH_STARTELEMENT, 3, 12, "", "Number", "Number" },
  85     { CH_CHARACTERS, 3, 12, "1234" },
  86     { CH_ENDELEMENT, 3, 18, "", "Number", "Number" },
  87     { CH_CHARACTERS, 3, 25, "\n   " },
  88     { CH_STARTELEMENT, 4, 10, "", "Name", "Name" },
  89     { CH_CHARACTERS, 4, 10, "Captain Ahab" },
  90     { CH_ENDELEMENT, 4, 24, "", "Name", "Name" },
  91     { CH_CHARACTERS, 4, 29, "\n" },
  92     { CH_ENDELEMENT, 5, 3, "", "BankAccount", "BankAccount" },
  93     { CH_ENDDOCUMENT, 0, 0 },
  94     { CH_ENDTEST }
  95 };
  96
  97 static content_handler_test contentHandlerTest2[] = {
  98     { CH_PUTDOCUMENTLOCATOR, 0, 0 },
  99     { CH_STARTDOCUMENT, 0, 0 },
 100     { CH_STARTELEMENT, 2, 14, "", "BankAccount", "BankAccount" },
 101     { CH_CHARACTERS, 2, 14, "\n" },
 102     { CH_CHARACTERS, 2, 16, "\t" },
 103     { CH_STARTELEMENT, 3, 10, "", "Number", "Number" },
 104     { CH_CHARACTERS, 3, 10, "1234" },
 105     { CH_ENDELEMENT, 3, 16, "", "Number", "Number" },
 106     { CH_CHARACTERS, 3, 23, "\n" },
 107     { CH_CHARACTERS, 3, 25, "\t" },
 108     { CH_STARTELEMENT, 4, 8, "", "Name", "Name" },
 109     { CH_CHARACTERS, 4, 8, "Captain Ahab" },
 110     { CH_ENDELEMENT, 4, 22, "", "Name", "Name" },
 111     { CH_CHARACTERS, 4, 27, "\n" },
 112     { CH_ENDELEMENT, 5, 3, "", "BankAccount", "BankAccount" },
 113     { CH_ENDDOCUMENT, 0, 0 },
 114     { CH_ENDTEST }
 115 };
 116
 117 static content_handler_test *expectCall;
 118 static ISAXLocator *locator;
 119
 120 static void test_saxstr(unsigned line, const WCHAR *szStr, int nStr, const char *szTest)
 121 {
 122     WCHAR buf[1024];
 123     int len;
 124
 125     if(!szTest) {
 126         ok_(__FILE__,line) (szStr == NULL, "szStr != NULL\n");
 127         ok_(__FILE__,line) (nStr == 0, "nStr = %d, expected 0\n", nStr);
 128         return;
 129     }
 130
 131     len = strlen(szTest);
 132     ok_(__FILE__,line) (len == nStr, "nStr = %d, expected %d (%s)\n", nStr, len, szTest);
 133     if(len != nStr)
 134         return;
 135
 136     MultiByteToWideChar(CP_ACP, 0, szTest, -1, buf, sizeof(buf)/sizeof(WCHAR));
 137     ok_(__FILE__,line) (!memcmp(szStr, buf, len*sizeof(WCHAR)), "unexpected szStr %s, expected %s\n",
 138                         wine_dbgstr_wn(szStr, nStr), szTest);
 139 }
 140
 141 static BOOL test_expect_call(CH id)
 142 {
 143     ok(expectCall->id == id, "unexpected call %d, expected %d\n", id, expectCall->id);
 144     return expectCall->id == id;
 145 }
 146
 147 static void test_locator(unsigned line, int loc_line, int loc_column)
 148 {
 149     int rcolumn, rline;
 150     ISAXLocator_getLineNumber(locator, &rline);
 151     ISAXLocator_getColumnNumber(locator, &rcolumn);
 152
 153     ok_(__FILE__,line) (rline == loc_line,
 154             "unexpected line %d, expected %d\n", rline, loc_line);
 155     ok_(__FILE__,line) (rcolumn == loc_column,
 156             "unexpected column %d, expected %d\n", rcolumn, loc_column);
 157 }
 158
 159 static HRESULT WINAPI contentHandler_QueryInterface(
 160         ISAXContentHandler* iface,
 161         REFIID riid,
 162         void **ppvObject)
 163 {
 164     *ppvObject = NULL;
 165
 166     if(IsEqualGUID(riid, &IID_IUnknown) || IsEqualGUID(riid, &IID_ISAXContentHandler))
 167     {
 168         *ppvObject = iface;
 169     }
 170     else
 171     {
 172         return E_NOINTERFACE;
 173     }
 174
 175     return S_OK;
 176 }
 177
 178 static ULONG WINAPI contentHandler_AddRef(
 179         ISAXContentHandler* iface)
 180 {
 181     return 2;
 182 }
 183
 184 static ULONG WINAPI contentHandler_Release(
 185         ISAXContentHandler* iface)
 186 {
 187     return 1;
 188 }
 189
 190 static HRESULT WINAPI contentHandler_putDocumentLocator(
 191         ISAXContentHandler* iface,
 192         ISAXLocator *pLocator)
 193 {
 194     if(!test_expect_call(CH_PUTDOCUMENTLOCATOR))
 195         return E_FAIL;
 196
 197     locator = pLocator;
 198     test_locator(__LINE__, expectCall->line, expectCall->column);
 199
 200     expectCall++;
 201     return S_OK;
 202 }
 203
 204 static HRESULT WINAPI contentHandler_startDocument(
 205         ISAXContentHandler* iface)
 206 {
 207     if(!test_expect_call(CH_STARTDOCUMENT))
 208         return E_FAIL;
 209
 210     test_locator(__LINE__, expectCall->line, expectCall->column);
 211
 212     expectCall++;
 213     return S_OK;
 214 }
 215
 216 static HRESULT WINAPI contentHandler_endDocument(
 217         ISAXContentHandler* iface)
 218 {
 219     if(!test_expect_call(CH_ENDDOCUMENT))
 220         return E_FAIL;
 221
 222     test_locator(__LINE__, expectCall->line, expectCall->column);
 223
 224     expectCall++;
 225     return S_OK;
 226 }
 227
 228 static HRESULT WINAPI contentHandler_startPrefixMapping(
 229         ISAXContentHandler* iface,
 230         const WCHAR *pPrefix,
 231         int nPrefix,
 232         const WCHAR *pUri,
 233         int nUri)
 234 {
 235     if(!test_expect_call(CH_ENDDOCUMENT))
 236         return E_FAIL;
 237
 238     test_saxstr(__LINE__, pPrefix, nPrefix, expectCall->arg1);
 239     test_saxstr(__LINE__, pUri, nUri, expectCall->arg2);
 240     test_locator(__LINE__, expectCall->line, expectCall->column);
 241
 242     expectCall++;
 243     return S_OK;
 244 }
 245
 246 static HRESULT WINAPI contentHandler_endPrefixMapping(
 247         ISAXContentHandler* iface,
 248         const WCHAR *pPrefix,
 249         int nPrefix)
 250 {
 251     if(!test_expect_call(CH_ENDPREFIXMAPPING))
 252         return E_FAIL;
 253
 254     test_saxstr(__LINE__, pPrefix, nPrefix, expectCall->arg1);
 255     test_locator(__LINE__, expectCall->line, expectCall->column);
 256
 257     expectCall++;
 258     return S_OK;
 259 }
 260
 261 static HRESULT WINAPI contentHandler_startElement(
 262         ISAXContentHandler* iface,
 263         const WCHAR *pNamespaceUri,
 264         int nNamespaceUri,
 265         const WCHAR *pLocalName,
 266         int nLocalName,
 267         const WCHAR *pQName,
 268         int nQName,
 269         ISAXAttributes *pAttr)
 270 {
 271     if(!test_expect_call(CH_STARTELEMENT))
 272         return E_FAIL;
 273
 274     test_saxstr(__LINE__, pNamespaceUri, nNamespaceUri, expectCall->arg1);
 275     test_saxstr(__LINE__, pLocalName, nLocalName, expectCall->arg2);
 276     test_saxstr(__LINE__, pQName, nQName, expectCall->arg3);
 277     test_locator(__LINE__, expectCall->line, expectCall->column);
 278
 279     expectCall++;
 280     return S_OK;
 281 }
 282
 283 static HRESULT WINAPI contentHandler_endElement(
 284         ISAXContentHandler* iface,
 285         const WCHAR *pNamespaceUri,
 286         int nNamespaceUri,
 287         const WCHAR *pLocalName,
 288         int nLocalName,
 289         const WCHAR *pQName,
 290         int nQName)
 291 {
 292     if(!test_expect_call(CH_ENDELEMENT))
 293         return E_FAIL;
 294
 295     test_saxstr(__LINE__, pNamespaceUri, nNamespaceUri, expectCall->arg1);
 296     test_saxstr(__LINE__, pLocalName, nLocalName, expectCall->arg2);
 297     test_saxstr(__LINE__, pQName, nQName, expectCall->arg3);
 298     test_locator(__LINE__, expectCall->line, expectCall->column);
 299
 300     expectCall++;
 301     return S_OK;
 302 }
 303
 304 static HRESULT WINAPI contentHandler_characters(
 305         ISAXContentHandler* iface,
 306         const WCHAR *pChars,
 307         int nChars)
 308 {
 309     if(!test_expect_call(CH_CHARACTERS))
 310         return E_FAIL;
 311
 312     test_saxstr(__LINE__, pChars, nChars, expectCall->arg1);
 313     test_locator(__LINE__, expectCall->line, expectCall->column);
 314
 315     expectCall++;
 316     return S_OK;
 317 }
 318
 319 static HRESULT WINAPI contentHandler_ignorableWhitespace(
 320         ISAXContentHandler* iface,
 321         const WCHAR *pChars,
 322         int nChars)
 323 {
 324     if(!test_expect_call(CH_IGNORABLEWHITESPACE))
 325         return E_FAIL;
 326
 327     test_saxstr(__LINE__, pChars, nChars, expectCall->arg1);
 328     test_locator(__LINE__, expectCall->line, expectCall->column);
 329
 330     expectCall++;
 331     return S_OK;
 332 }
 333
 334 static HRESULT WINAPI contentHandler_processingInstruction(
 335         ISAXContentHandler* iface,
 336         const WCHAR *pTarget,
 337         int nTarget,
 338         const WCHAR *pData,
 339         int nData)
 340 {
 341     if(!test_expect_call(CH_PROCESSINGINSTRUCTION))
 342         return E_FAIL;
 343
 344     test_saxstr(__LINE__, pTarget, nTarget, expectCall->arg1);
 345     test_saxstr(__LINE__, pData, nData, expectCall->arg2);
 346     test_locator(__LINE__, expectCall->line, expectCall->column);
 347
 348     expectCall++;
 349     return S_OK;
 350 }
 351
 352 static HRESULT WINAPI contentHandler_skippedEntity(
 353         ISAXContentHandler* iface,
 354         const WCHAR *pName,
 355         int nName)
 356 {
 357     if(!test_expect_call(CH_SKIPPEDENTITY))
 358         return E_FAIL;
 359
 360     test_saxstr(__LINE__, pName, nName, expectCall->arg1);
 361     test_locator(__LINE__, expectCall->line, expectCall->column);
 362
 363     expectCall++;
 364     return S_OK;
 365 }
 366
 367
 368 static const ISAXContentHandlerVtbl contentHandlerVtbl =
 369 {
 370     contentHandler_QueryInterface,
 371     contentHandler_AddRef,
 372     contentHandler_Release,
 373     contentHandler_putDocumentLocator,
 374     contentHandler_startDocument,
 375     contentHandler_endDocument,
 376     contentHandler_startPrefixMapping,
 377     contentHandler_endPrefixMapping,
 378     contentHandler_startElement,
 379     contentHandler_endElement,
 380     contentHandler_characters,
 381     contentHandler_ignorableWhitespace,
 382     contentHandler_processingInstruction,
 383     contentHandler_skippedEntity
 384 };
 385
 386 static ISAXContentHandler contentHandler = { &contentHandlerVtbl };
 387
 388 static HRESULT WINAPI isaxerrorHandler_QueryInterface(
 389         ISAXErrorHandler* iface,
 390         REFIID riid,
 391         void **ppvObject)
 392 {
 393     *ppvObject = NULL;
 394
 395     if(IsEqualGUID(riid, &IID_IUnknown) || IsEqualGUID(riid, &IID_ISAXErrorHandler))
 396     {
 397         *ppvObject = iface;
 398     }
 399     else
 400     {
 401         return E_NOINTERFACE;
 402     }
 403
 404     return S_OK;
 405 }
 406
 407 static ULONG WINAPI isaxerrorHandler_AddRef(
 408         ISAXErrorHandler* iface)
 409 {
 410     return 2;
 411 }
 412
 413 static ULONG WINAPI isaxerrorHandler_Release(
 414         ISAXErrorHandler* iface)
 415 {
 416     return 1;
 417 }
 418
 419 static HRESULT WINAPI isaxerrorHandler_error(
 420         ISAXErrorHandler* iface,
 421         ISAXLocator *pLocator,
 422         const WCHAR *pErrorMessage,
 423         HRESULT hrErrorCode)
 424 {
 425     return S_OK;
 426 }
 427
 428 static HRESULT WINAPI isaxerrorHandler_fatalError(
 429         ISAXErrorHandler* iface,
 430         ISAXLocator *pLocator,
 431         const WCHAR *pErrorMessage,
 432         HRESULT hrErrorCode)
 433 {
 434     return S_OK;
 435 }
 436
 437 static HRESULT WINAPI isaxerrorHanddler_ignorableWarning(
 438         ISAXErrorHandler* iface,
 439         ISAXLocator *pLocator,
 440         const WCHAR *pErrorMessage,
 441         HRESULT hrErrorCode)
 442 {
 443     return S_OK;
 444 }
 445
 446 static const ISAXErrorHandlerVtbl errorHandlerVtbl =
 447 {
 448     isaxerrorHandler_QueryInterface,
 449     isaxerrorHandler_AddRef,
 450     isaxerrorHandler_Release,
 451     isaxerrorHandler_error,
 452     isaxerrorHandler_fatalError,
 453     isaxerrorHanddler_ignorableWarning
 454 };
 455
 456 static ISAXErrorHandler errorHandler = { &errorHandlerVtbl };
 457
 458 static void test_saxreader(void)
 459 {
 460     HRESULT hr;
 461     ISAXXMLReader *reader = NULL;
 462     VARIANT var;
 463     ISAXContentHandler *lpContentHandler;
 464     ISAXErrorHandler *lpErrorHandler;
 465     SAFEARRAY *pSA;
 466     SAFEARRAYBOUND SADim[1];
 467     char *pSAData = NULL;
 468     IStream *iStream;
 469     ULARGE_INTEGER liSize;
 470     LARGE_INTEGER liPos;
 471     ULONG bytesWritten;
 472     HANDLE file;
 473     static const CHAR testXmlA[] = "test.xml";
 474     static const WCHAR testXmlW[] = {'t','e','s','t','.','x','m','l',0};
 475     IXMLDOMDocument *domDocument;
 476     BSTR bstrData;
 477     VARIANT_BOOL vBool;
 478
 479     hr = CoCreateInstance(&CLSID_SAXXMLReader, NULL, CLSCTX_INPROC_SERVER,
 480             &IID_ISAXXMLReader, (LPVOID*)&reader);
 481
 482     if(FAILED(hr))
 483     {
 484         skip("Failed to create SAXXMLReader instance\n");
 485         return;
 486     }
 487
 488     hr = ISAXXMLReader_getContentHandler(reader, NULL);
 489     ok(hr == E_POINTER, "Expected E_POINTER, got %08x\n", hr);
 490
 491     hr = ISAXXMLReader_getErrorHandler(reader, NULL);
 492     ok(hr == E_POINTER, "Expected E_POINTER, got %08x\n", hr);
 493
 494     hr = ISAXXMLReader_getContentHandler(reader, &lpContentHandler);
 495     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
 496     ok(lpContentHandler == NULL, "Expected %p, got %p\n", NULL, lpContentHandler);
 497
 498     hr = ISAXXMLReader_getErrorHandler(reader, &lpErrorHandler);
 499     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
 500     ok(lpErrorHandler == NULL, "Expected %p, got %p\n", NULL, lpErrorHandler);
 501
 502     hr = ISAXXMLReader_putContentHandler(reader, NULL);
 503     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
 504
 505     hr = ISAXXMLReader_putContentHandler(reader, &contentHandler);
 506     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
 507
 508     hr = ISAXXMLReader_putErrorHandler(reader, &errorHandler);
 509     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
 510
 511     hr = ISAXXMLReader_getContentHandler(reader, &lpContentHandler);
 512     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
 513     ok(lpContentHandler == &contentHandler, "Expected %p, got %p\n", &contentHandler, lpContentHandler);
 514
 515     V_VT(&var) = VT_BSTR;
 516     V_BSTR(&var) = SysAllocString(szSimpleXML);
 517
 518     expectCall = contentHandlerTest1;
 519     hr = ISAXXMLReader_parse(reader, var);
 520     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
 521     test_expect_call(CH_ENDTEST);
 522
 523     VariantClear(&var);
 524
 525     SADim[0].lLbound= 0;
 526     SADim[0].cElements= sizeof(szTestXML)-1;
 527     pSA = SafeArrayCreate(VT_UI1, 1, SADim);
 528     SafeArrayAccessData(pSA, (void**)&pSAData);
 529     memcpy(pSAData, szTestXML, sizeof(szTestXML)-1);
 530     SafeArrayUnaccessData(pSA);
 531     V_VT(&var) = VT_ARRAY|VT_UI1;
 532     V_ARRAY(&var) = pSA;
 533
 534     expectCall = contentHandlerTest1;
 535     hr = ISAXXMLReader_parse(reader, var);
 536     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
 537     test_expect_call(CH_ENDTEST);
 538
 539     SafeArrayDestroy(pSA);
 540
 541     CreateStreamOnHGlobal(NULL, TRUE, &iStream);
 542     liSize.QuadPart = strlen(szTestXML);
 543     IStream_SetSize(iStream, liSize);
 544     IStream_Write(iStream, szTestXML, strlen(szTestXML), &bytesWritten);
 545     liPos.QuadPart = 0;
 546     IStream_Seek(iStream, liPos, STREAM_SEEK_SET, NULL);
 547     V_VT(&var) = VT_UNKNOWN|VT_DISPATCH;
 548     V_UNKNOWN(&var) = (IUnknown*)iStream;
 549
 550     expectCall = contentHandlerTest1;
 551     hr = ISAXXMLReader_parse(reader, var);
 552     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
 553     test_expect_call(CH_ENDTEST);
 554
 555     IStream_Release(iStream);
 556
 557     V_VT(&var) = VT_BSTR;
 558     V_BSTR(&var) = SysAllocString(szCarriageRetTest);
 559
 560     expectCall = contentHandlerTest2;
 561     hr = ISAXXMLReader_parse(reader, var);
 562     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
 563     test_expect_call(CH_ENDTEST);
 564
 565     VariantClear(&var);
 566
 567     file = CreateFileA(testXmlA, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
 568     ok(file != INVALID_HANDLE_VALUE, "Could not create file: %u\n", GetLastError());
 569     WriteFile(file, szTestXML, sizeof(szTestXML)-1, &bytesWritten, NULL);
 570     CloseHandle(file);
 571
 572     expectCall = contentHandlerTest1;
 573     hr = ISAXXMLReader_parseURL(reader, testXmlW);
 574     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
 575     test_expect_call(CH_ENDTEST);
 576
 577     DeleteFileA(testXmlA);
 578
 579     hr = CoCreateInstance(&CLSID_DOMDocument, NULL, CLSCTX_INPROC_SERVER,
 580             &IID_IXMLDOMDocument, (LPVOID*)&domDocument);
 581     if(FAILED(hr))
 582     {
 583         skip("Failed to create DOMDocument instance\n");
 584         return;
 585     }
 586     bstrData = SysAllocString(szSimpleXML);
 587     hr = IXMLDOMDocument_loadXML(domDocument, bstrData, &vBool);
 588     V_VT(&var) = VT_UNKNOWN;
 589     V_UNKNOWN(&var) = (IUnknown*)domDocument;
 590
 591     expectCall = contentHandlerTest2;
 592     hr = ISAXXMLReader_parse(reader, var);
 593     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
 594     test_expect_call(CH_ENDTEST);
 595     IXMLDOMDocument_Release(domDocument);
 596
 597     ISAXXMLReader_Release(reader);
 598     SysFreeString(bstrData);
 599 }
 600
 601 START_TEST(saxreader)
 602 {
 603     HRESULT hr;
 604
 605     hr = CoInitialize(NULL);
 606     ok(hr == S_OK, "failed to init com\n");
 607
 608     test_saxreader();
 609
 610     CoUninitialize();
 611 }