push 4e98c31ec75caed2ea3040ac2e710b58ba1ca0e1
[wine/hacks.git] / dlls / msxml3 / tests / saxreader.c
blob54ffe93c2ca717d4bfbd74f99a99bdc4df8797e3
1 /*
2 * XML test
4 * Copyright 2008 Piotr Caban
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.
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.
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
21 #define COBJMACROS
22 #define CONST_VTABLE
24 #include <stdio.h>
25 #include "windows.h"
26 #include "ole2.h"
27 #include "msxml2.h"
28 #include "ocidl.h"
30 #include "wine/test.h"
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;
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'
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'
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";
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;
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 }
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 }
117 static content_handler_test *expectCall;
118 static ISAXLocator *locator;
120 static const char *debugstr_wn(const WCHAR *szStr, int len)
122 static char buf[1024];
123 WideCharToMultiByte(CP_ACP, 0, szStr, len, buf, sizeof(buf), NULL, NULL);
124 return buf;
127 static void test_saxstr(unsigned line, const WCHAR *szStr, int nStr, const char *szTest)
129 WCHAR buf[1024];
130 int len;
132 if(!szTest) {
133 ok_(__FILE__,line) (szStr == NULL, "szStr != NULL\n");
134 ok_(__FILE__,line) (nStr == 0, "nStr = %d, expected 0\n", nStr);
135 return;
138 len = strlen(szTest);
139 ok_(__FILE__,line) (len == nStr, "nStr = %d, expected %d (%s)\n", nStr, len, szTest);
140 if(len != nStr)
141 return;
143 MultiByteToWideChar(CP_ACP, 0, szTest, -1, buf, sizeof(buf)/sizeof(WCHAR));
144 ok_(__FILE__,line) (!memcmp(szStr, buf, len*sizeof(WCHAR)), "unexpected szStr %s, expected %s\n",
145 debugstr_wn(szStr, nStr), szTest);
148 static BOOL test_expect_call(CH id)
150 ok(expectCall->id == id, "unexpected call %d, expected %d\n", id, expectCall->id);
151 return expectCall->id == id;
154 static void test_locator(unsigned line, int loc_line, int loc_column)
156 int rcolumn, rline;
157 ISAXLocator_getLineNumber(locator, &rline);
158 ISAXLocator_getColumnNumber(locator, &rcolumn);
160 ok_(__FILE__,line) (rline == loc_line,
161 "unexpected line %d, expected %d\n", rline, loc_line);
162 ok_(__FILE__,line) (rcolumn == loc_column,
163 "unexpected column %d, expected %d\n", rcolumn, loc_column);
166 static HRESULT WINAPI contentHandler_QueryInterface(
167 ISAXContentHandler* iface,
168 REFIID riid,
169 void **ppvObject)
171 *ppvObject = NULL;
173 if(IsEqualGUID(riid, &IID_IUnknown) || IsEqualGUID(riid, &IID_ISAXContentHandler))
175 *ppvObject = iface;
177 else
179 return E_NOINTERFACE;
182 return S_OK;
185 static ULONG WINAPI contentHandler_AddRef(
186 ISAXContentHandler* iface)
188 return 2;
191 static ULONG WINAPI contentHandler_Release(
192 ISAXContentHandler* iface)
194 return 1;
197 static HRESULT WINAPI contentHandler_putDocumentLocator(
198 ISAXContentHandler* iface,
199 ISAXLocator *pLocator)
201 if(!test_expect_call(CH_PUTDOCUMENTLOCATOR))
202 return E_FAIL;
204 locator = pLocator;
205 test_locator(__LINE__, expectCall->line, expectCall->column);
207 expectCall++;
208 return S_OK;
211 static HRESULT WINAPI contentHandler_startDocument(
212 ISAXContentHandler* iface)
214 if(!test_expect_call(CH_STARTDOCUMENT))
215 return E_FAIL;
217 test_locator(__LINE__, expectCall->line, expectCall->column);
219 expectCall++;
220 return S_OK;
223 static HRESULT WINAPI contentHandler_endDocument(
224 ISAXContentHandler* iface)
226 if(!test_expect_call(CH_ENDDOCUMENT))
227 return E_FAIL;
229 test_locator(__LINE__, expectCall->line, expectCall->column);
231 expectCall++;
232 return S_OK;
235 static HRESULT WINAPI contentHandler_startPrefixMapping(
236 ISAXContentHandler* iface,
237 const WCHAR *pPrefix,
238 int nPrefix,
239 const WCHAR *pUri,
240 int nUri)
242 if(!test_expect_call(CH_ENDDOCUMENT))
243 return E_FAIL;
245 test_saxstr(__LINE__, pPrefix, nPrefix, expectCall->arg1);
246 test_saxstr(__LINE__, pUri, nUri, expectCall->arg2);
247 test_locator(__LINE__, expectCall->line, expectCall->column);
249 expectCall++;
250 return S_OK;
253 static HRESULT WINAPI contentHandler_endPrefixMapping(
254 ISAXContentHandler* iface,
255 const WCHAR *pPrefix,
256 int nPrefix)
258 if(!test_expect_call(CH_ENDPREFIXMAPPING))
259 return E_FAIL;
261 test_saxstr(__LINE__, pPrefix, nPrefix, expectCall->arg1);
262 test_locator(__LINE__, expectCall->line, expectCall->column);
264 expectCall++;
265 return S_OK;
268 static HRESULT WINAPI contentHandler_startElement(
269 ISAXContentHandler* iface,
270 const WCHAR *pNamespaceUri,
271 int nNamespaceUri,
272 const WCHAR *pLocalName,
273 int nLocalName,
274 const WCHAR *pQName,
275 int nQName,
276 ISAXAttributes *pAttr)
278 if(!test_expect_call(CH_STARTELEMENT))
279 return E_FAIL;
281 test_saxstr(__LINE__, pNamespaceUri, nNamespaceUri, expectCall->arg1);
282 test_saxstr(__LINE__, pLocalName, nLocalName, expectCall->arg2);
283 test_saxstr(__LINE__, pQName, nQName, expectCall->arg3);
284 test_locator(__LINE__, expectCall->line, expectCall->column);
286 expectCall++;
287 return S_OK;
290 static HRESULT WINAPI contentHandler_endElement(
291 ISAXContentHandler* iface,
292 const WCHAR *pNamespaceUri,
293 int nNamespaceUri,
294 const WCHAR *pLocalName,
295 int nLocalName,
296 const WCHAR *pQName,
297 int nQName)
299 if(!test_expect_call(CH_ENDELEMENT))
300 return E_FAIL;
302 test_saxstr(__LINE__, pNamespaceUri, nNamespaceUri, expectCall->arg1);
303 test_saxstr(__LINE__, pLocalName, nLocalName, expectCall->arg2);
304 test_saxstr(__LINE__, pQName, nQName, expectCall->arg3);
305 test_locator(__LINE__, expectCall->line, expectCall->column);
307 expectCall++;
308 return S_OK;
311 static HRESULT WINAPI contentHandler_characters(
312 ISAXContentHandler* iface,
313 const WCHAR *pChars,
314 int nChars)
316 if(!test_expect_call(CH_CHARACTERS))
317 return E_FAIL;
319 test_saxstr(__LINE__, pChars, nChars, expectCall->arg1);
320 test_locator(__LINE__, expectCall->line, expectCall->column);
322 expectCall++;
323 return S_OK;
326 static HRESULT WINAPI contentHandler_ignorableWhitespace(
327 ISAXContentHandler* iface,
328 const WCHAR *pChars,
329 int nChars)
331 if(!test_expect_call(CH_IGNORABLEWHITESPACE))
332 return E_FAIL;
334 test_saxstr(__LINE__, pChars, nChars, expectCall->arg1);
335 test_locator(__LINE__, expectCall->line, expectCall->column);
337 expectCall++;
338 return S_OK;
341 static HRESULT WINAPI contentHandler_processingInstruction(
342 ISAXContentHandler* iface,
343 const WCHAR *pTarget,
344 int nTarget,
345 const WCHAR *pData,
346 int nData)
348 if(!test_expect_call(CH_PROCESSINGINSTRUCTION))
349 return E_FAIL;
351 test_saxstr(__LINE__, pTarget, nTarget, expectCall->arg1);
352 test_saxstr(__LINE__, pData, nData, expectCall->arg2);
353 test_locator(__LINE__, expectCall->line, expectCall->column);
355 expectCall++;
356 return S_OK;
359 static HRESULT WINAPI contentHandler_skippedEntity(
360 ISAXContentHandler* iface,
361 const WCHAR *pName,
362 int nName)
364 if(!test_expect_call(CH_SKIPPEDENTITY))
365 return E_FAIL;
367 test_saxstr(__LINE__, pName, nName, expectCall->arg1);
368 test_locator(__LINE__, expectCall->line, expectCall->column);
370 expectCall++;
371 return S_OK;
375 static const ISAXContentHandlerVtbl contentHandlerVtbl =
377 contentHandler_QueryInterface,
378 contentHandler_AddRef,
379 contentHandler_Release,
380 contentHandler_putDocumentLocator,
381 contentHandler_startDocument,
382 contentHandler_endDocument,
383 contentHandler_startPrefixMapping,
384 contentHandler_endPrefixMapping,
385 contentHandler_startElement,
386 contentHandler_endElement,
387 contentHandler_characters,
388 contentHandler_ignorableWhitespace,
389 contentHandler_processingInstruction,
390 contentHandler_skippedEntity
393 static ISAXContentHandler contentHandler = { &contentHandlerVtbl };
395 static HRESULT WINAPI isaxerrorHandler_QueryInterface(
396 ISAXErrorHandler* iface,
397 REFIID riid,
398 void **ppvObject)
400 *ppvObject = NULL;
402 if(IsEqualGUID(riid, &IID_IUnknown) || IsEqualGUID(riid, &IID_ISAXErrorHandler))
404 *ppvObject = iface;
406 else
408 return E_NOINTERFACE;
411 return S_OK;
414 static ULONG WINAPI isaxerrorHandler_AddRef(
415 ISAXErrorHandler* iface)
417 return 2;
420 static ULONG WINAPI isaxerrorHandler_Release(
421 ISAXErrorHandler* iface)
423 return 1;
426 static HRESULT WINAPI isaxerrorHandler_error(
427 ISAXErrorHandler* iface,
428 ISAXLocator *pLocator,
429 const WCHAR *pErrorMessage,
430 HRESULT hrErrorCode)
432 return S_OK;
435 static HRESULT WINAPI isaxerrorHandler_fatalError(
436 ISAXErrorHandler* iface,
437 ISAXLocator *pLocator,
438 const WCHAR *pErrorMessage,
439 HRESULT hrErrorCode)
441 return S_OK;
444 static HRESULT WINAPI isaxerrorHanddler_ignorableWarning(
445 ISAXErrorHandler* iface,
446 ISAXLocator *pLocator,
447 const WCHAR *pErrorMessage,
448 HRESULT hrErrorCode)
450 return S_OK;
453 static const ISAXErrorHandlerVtbl errorHandlerVtbl =
455 isaxerrorHandler_QueryInterface,
456 isaxerrorHandler_AddRef,
457 isaxerrorHandler_Release,
458 isaxerrorHandler_error,
459 isaxerrorHandler_fatalError,
460 isaxerrorHanddler_ignorableWarning
463 static ISAXErrorHandler errorHandler = { &errorHandlerVtbl };
465 static void test_saxreader(void)
467 HRESULT hr;
468 ISAXXMLReader *reader = NULL;
469 VARIANT var;
470 ISAXContentHandler *lpContentHandler;
471 ISAXErrorHandler *lpErrorHandler;
472 SAFEARRAY *pSA;
473 SAFEARRAYBOUND SADim[1];
474 char *pSAData = NULL;
475 IStream *iStream;
476 ULARGE_INTEGER liSize;
477 LARGE_INTEGER liPos;
478 ULONG bytesWritten;
479 HANDLE file;
480 static const CHAR testXmlA[] = "test.xml";
481 static const WCHAR testXmlW[] = {'t','e','s','t','.','x','m','l',0};
482 IXMLDOMDocument *domDocument;
483 BSTR bstrData;
484 VARIANT_BOOL vBool;
486 hr = CoCreateInstance(&CLSID_SAXXMLReader, NULL, CLSCTX_INPROC_SERVER,
487 &IID_ISAXXMLReader, (LPVOID*)&reader);
489 if(FAILED(hr))
491 skip("Failed to create SAXXMLReader instance\n");
492 return;
495 hr = ISAXXMLReader_getContentHandler(reader, NULL);
496 ok(hr == E_POINTER, "Expected E_POINTER, got %08x\n", hr);
498 hr = ISAXXMLReader_getErrorHandler(reader, NULL);
499 ok(hr == E_POINTER, "Expected E_POINTER, got %08x\n", hr);
501 hr = ISAXXMLReader_getContentHandler(reader, &lpContentHandler);
502 ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
503 ok(lpContentHandler == NULL, "Expected %p, got %p\n", NULL, lpContentHandler);
505 hr = ISAXXMLReader_getErrorHandler(reader, &lpErrorHandler);
506 ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
507 ok(lpErrorHandler == NULL, "Expected %p, got %p\n", NULL, lpErrorHandler);
509 hr = ISAXXMLReader_putContentHandler(reader, NULL);
510 ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
512 hr = ISAXXMLReader_putContentHandler(reader, &contentHandler);
513 ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
515 hr = ISAXXMLReader_putErrorHandler(reader, &errorHandler);
516 ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
518 hr = ISAXXMLReader_getContentHandler(reader, &lpContentHandler);
519 ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
520 ok(lpContentHandler == &contentHandler, "Expected %p, got %p\n", &contentHandler, lpContentHandler);
522 V_VT(&var) = VT_BSTR;
523 V_BSTR(&var) = SysAllocString(szSimpleXML);
525 expectCall = contentHandlerTest1;
526 hr = ISAXXMLReader_parse(reader, var);
527 ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
528 test_expect_call(CH_ENDTEST);
530 SADim[0].lLbound= 0;
531 SADim[0].cElements= sizeof(szTestXML)-1;
532 pSA = SafeArrayCreate(VT_UI1, 1, SADim);
533 SafeArrayAccessData(pSA, (void**)&pSAData);
534 memcpy(pSAData, szTestXML, sizeof(szTestXML)-1);
535 SafeArrayUnaccessData(pSA);
536 V_VT(&var) = VT_ARRAY|VT_UI1;
537 V_ARRAY(&var) = pSA;
539 expectCall = contentHandlerTest1;
540 hr = ISAXXMLReader_parse(reader, var);
541 ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
542 test_expect_call(CH_ENDTEST);
544 SafeArrayDestroy(pSA);
546 CreateStreamOnHGlobal(NULL, TRUE, &iStream);
547 liSize.QuadPart = strlen(szTestXML);
548 IStream_SetSize(iStream, liSize);
549 IStream_Write(iStream, (void const*)szTestXML, strlen(szTestXML), &bytesWritten);
550 liPos.QuadPart = 0;
551 IStream_Seek(iStream, liPos, STREAM_SEEK_SET, NULL);
552 V_VT(&var) = VT_UNKNOWN|VT_DISPATCH;
553 V_UNKNOWN(&var) = (IUnknown*)iStream;
555 expectCall = contentHandlerTest1;
556 hr = ISAXXMLReader_parse(reader, var);
557 ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
558 test_expect_call(CH_ENDTEST);
560 IStream_Release(iStream);
562 V_VT(&var) = VT_BSTR;
563 V_BSTR(&var) = SysAllocString(szCarriageRetTest);
565 expectCall = contentHandlerTest2;
566 hr = ISAXXMLReader_parse(reader, var);
567 ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
568 test_expect_call(CH_ENDTEST);
570 file = CreateFileA(testXmlA, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
571 ok(file != INVALID_HANDLE_VALUE, "Could not create file: %u\n", GetLastError());
572 WriteFile(file, szTestXML, sizeof(szTestXML)-1, &bytesWritten, NULL);
573 CloseHandle(file);
575 expectCall = contentHandlerTest1;
576 hr = ISAXXMLReader_parseURL(reader, testXmlW);
577 ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
578 test_expect_call(CH_ENDTEST);
580 DeleteFileA(testXmlA);
582 hr = CoCreateInstance(&CLSID_DOMDocument, NULL, CLSCTX_INPROC_SERVER,
583 &IID_IXMLDOMDocument, (LPVOID*)&domDocument);
584 if(FAILED(hr))
586 skip("Failed to create DOMDocument instance\n");
587 return;
589 bstrData = SysAllocString(szSimpleXML);
590 hr = IXMLDOMDocument_loadXML(domDocument, bstrData, &vBool);
591 V_VT(&var) = VT_UNKNOWN;
592 V_UNKNOWN(&var) = (IUnknown*)domDocument;
594 expectCall = contentHandlerTest2;
595 hr = ISAXXMLReader_parse(reader, var);
596 ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
597 test_expect_call(CH_ENDTEST);
598 IXMLDOMDocument_Release(domDocument);
600 ISAXXMLReader_Release(reader);
603 START_TEST(saxreader)
605 HRESULT hr;
607 hr = CoInitialize(NULL);
608 ok(hr == S_OK, "failed to init com\n");
610 test_saxreader();
612 CoUninitialize();