xref: /AOO41X/main/extensions/test/sax/testsax.cxx (revision 1ecadb572e7010ff3b3382ad9bf179dbc6efadbb) 
1 /*************************************************************************
2  *
3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4  *
5  * Copyright 2000, 2010 Oracle and/or its affiliates.
6  *
7  * OpenOffice.org - a multi-platform office productivity suite
8  *
9  * This file is part of OpenOffice.org.
10  *
11  * OpenOffice.org is free software: you can redistribute it and/or modify
12  * it under the terms of the GNU Lesser General Public License version 3
13  * only, as published by the Free Software Foundation.
14  *
15  * OpenOffice.org is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18  * GNU Lesser General Public License version 3 for more details
19  * (a copy is included in the LICENSE file that accompanied this code).
20  *
21  * You should have received a copy of the GNU Lesser General Public License
22  * version 3 along with OpenOffice.org.  If not, see
23  * <http://www.openoffice.org/license.html>
24  * for a copy of the LGPLv3 License.
25  *
26  ************************************************************************/
27 
28 // MARKER(update_precomp.py): autogen include statement, do not remove
29 #include "precompiled_extensions.hxx"
30 
31 #include <stdio.h>
32 #include <string.h>
33 #include <smart/com/sun/star/test/XSimpleTest.hxx>
34 
35 #include <rtl/wstring.hxx>
36 #include <osl/time.h>
37 //#include <vos/dynload.hxx>
38 //#include <vos/diagnose.hxx>
39 #include <usr/weak.hxx>
40 #include <tools/string.hxx>
41 #include <vos/conditn.hxx>
42 
43 #include <smart/com/sun/star/io/XOutputStream.hxx>
44 #include <smart/com/sun/star/xml/sax/SAXParseException.hxx>
45 #include <smart/com/sun/star/xml/sax/XParser.hxx>
46 #include <smart/com/sun/star/xml/sax/XExtendedDocumentHandler.hxx>
47 
48 #include <smart/com/sun/star/lang/XMultiServiceFactory.hxx>  // for the multiservice-factories
49 #include <usr/factoryhlp.hxx>
50 
51 #include <usr/reflserv.hxx>  // for EXTERN_SERVICE_CALLTYPE
52 
53 #include "factory.hxx"
54 
55 using namespace rtl;
56 using namespace vos;
57 using namespace usr;
58 
59 
60 #define BUILD_ERROR(expr, Message)\
61 		{\
62 			m_seqErrors.realloc( m_seqErrors.getLen() + 1 ); \
63 		m_seqExceptions.realloc(  m_seqExceptions.getLen() + 1 ); \
64 		String str; \
65 		str += __FILE__;\
66 		str += " "; \
67 		str += "(" ; \
68 		str += __LINE__ ;\
69 		str += ")\n";\
70 		str += "[ " ; \
71 		str += #expr; \
72 		str += " ] : " ; \
73 		str += Message; \
74 		m_seqErrors.getArray()[ m_seqErrors.getLen()-1] = StringToUString( str , CHARSET_SYSTEM ); \
75 		}\
76 		((void)0)
77 
78 
79 #define WARNING_ASSERT(expr, Message) \
80 		if( ! (expr) ) { \
81 			m_seqWarnings.realloc( m_seqErrors.getLen() +1 ); \
82 			String str;\
83 			str += __FILE__;\
84 			str += " "; \
85 			str += "(" ; \
86 			str += __LINE__ ;\
87 			str += ")\n";\
88 			str += "[ " ; \
89 			str += #expr; \
90 			str += " ] : " ; \
91 			str += Message; \
92 			m_seqWarnings.getArray()[ m_seqWarnings.getLen()-1] = StringToUString( str , CHARSET_SYSTEM ); \
93 			return; \
94 		}\
95 		((void)0)
96 
97 #define ERROR_ASSERT(expr, Message) \
98 		if( ! (expr) ) { \
99 			BUILD_ERROR(expr, Message );\
100 			return; \
101 		}\
102 		((void)0)
103 
104 #define ERROR_EXCEPTION_ASSERT(expr, Message, Exception) \
105 	if( !(expr)) { \
106 		BUILD_ERROR(expr,Message);\
107 		m_seqExceptions.getArray()[ m_seqExceptions.getLen()-1] = UsrAny( Exception );\
108 		return; \
109 	} \
110 	((void)0)
111 
112 /****
113 * test szenarios :
114 *
115 *
116 *
117 ****/
118 
119 
120 
121 class OSaxParserTest :
122 		public XSimpleTest,
123         public OWeakObject
124 {
125 public:
126 	OSaxParserTest( const XMultiServiceFactoryRef & rFactory ) : m_rFactory( rFactory )
127 	{
128 
129 	}
130 
131 public: // refcounting
132 	BOOL						queryInterface( Uik aUik, XInterfaceRef & rOut );
133 	void 						acquire() 						 { OWeakObject::acquire(); }
134 	void 						release() 						 { OWeakObject::release(); }
135 	void* 						getImplementation(Reflection *p) { return OWeakObject::getImplementation(p); }
136 
137 public:
138     virtual void testInvariant(const UString& TestName, const XInterfaceRef& TestObject)
139     															THROWS( (	IllegalArgumentException,
140     																		UsrSystemException) );
141 
142     virtual INT32 test(	const UString& TestName,
143     					const XInterfaceRef& TestObject,
144     					INT32 hTestHandle) 						THROWS( (	IllegalArgumentException,
145     																		UsrSystemException) );
146 
147     virtual BOOL testPassed(void) 								THROWS( (	UsrSystemException) );
148     virtual Sequence< UString > getErrors(void) 				THROWS( (UsrSystemException) );
149     virtual Sequence< UsrAny > getErrorExceptions(void) 		THROWS( (UsrSystemException) );
150     virtual Sequence< UString > getWarnings(void) 				THROWS( (UsrSystemException) );
151 
152 private:
153 	void testSimple( const XParserRef &r );
154 	void testNamespaces( const XParserRef &r );
155 	void testFile(  const XParserRef &r );
156 	void testEncoding( const XParserRef &rParser );
157 	void testPerformance( const XParserRef &rParser );
158 
159 private:
160 	Sequence<UsrAny>  		m_seqExceptions;
161 	Sequence<UString> 		m_seqErrors;
162 	Sequence<UString> 		m_seqWarnings;
163 	XMultiServiceFactoryRef m_rFactory;
164 };
165 
166 
167 
168 /**
169 * for external binding
170 *
171 *
172 **/
173 XInterfaceRef OSaxParserTest_CreateInstance( const XMultiServiceFactoryRef & rSMgr ) THROWS((Exception))
174 {
175 	OSaxParserTest *p = new OSaxParserTest( rSMgr );
176 	XInterfaceRef xService = *p;
177 	return xService;
178 }
179 
180 
181 UString     OSaxParserTest_getServiceName( ) THROWS( () )
182 {
183 	return L"test.com.sun.star.xml.sax.Parser";
184 }
185 
186 UString 	OSaxParserTest_getImplementationName( ) THROWS( () )
187 {
188 	return L"test.extensions.xml.sax.Parser";
189 }
190 
191 Sequence<UString> OSaxParserTest_getSupportedServiceNames( ) THROWS( () )
192 {
193 	Sequence<UString> aRet(1);
194 
195 	aRet.getArray()[0] = OSaxParserTest_getImplementationName( );
196 
197 	return aRet;
198 }
199 
200 
201 BOOL OSaxParserTest::queryInterface( Uik uik , XInterfaceRef &rOut )
202 {
203 	if( XSimpleTest::getSmartUik() == uik ) {
204 		rOut = (XSimpleTest *) this;
205 	}
206 	else {
207 		return OWeakObject::queryInterface( uik , rOut );
208 	}
209 	return TRUE;
210 }
211 
212 
213 void OSaxParserTest::testInvariant( const UString& TestName, const XInterfaceRef& TestObject )
214     															THROWS( (	IllegalArgumentException,
215     																		UsrSystemException) )
216 {
217 	if( L"com.sun.star.xml.sax.Parser" == TestName ) {
218 		XParserRef parser( TestObject , USR_QUERY );
219 
220 		ERROR_ASSERT( parser.is() , "XDataInputStream cannot be queried" );
221 	}
222 }
223 
224 
225 INT32 OSaxParserTest::test(	const UString& TestName,
226     					const XInterfaceRef& TestObject,
227     					INT32 hTestHandle) 						THROWS( (	IllegalArgumentException,
228     																		UsrSystemException) )
229 {
230 	if( L"com.sun.star.xml.sax.Parser" == TestName )  {
231 		try {
232 			if( 0 == hTestHandle ) {
233 				testInvariant( TestName , TestObject );
234 			}
235 			else {
236 
237 				XParserRef parser( TestObject , USR_QUERY );
238 
239 				if( 1 == hTestHandle ) {
240 					testSimple( parser );
241 				}
242 				else if( 2 == hTestHandle ) {
243 					testNamespaces( parser );
244 				}
245 				else if( 3 == hTestHandle ) {
246 					testEncoding( parser );
247 				}
248 				else if( 4 == hTestHandle ) {
249 					testFile( parser );
250 				}
251 				else if( 5 == hTestHandle ) {
252 					testPerformance( parser );
253 				}
254 			}
255 		}
256 		catch( Exception& e )  {
257 			BUILD_ERROR( 0 , UStringToString( e.getName() , CHARSET_SYSTEM ).GetCharStr() );
258 		}
259 		catch(...) {
260 			BUILD_ERROR( 0 , "unknown exception (Exception is  not base class)" );
261 		}
262 
263 		hTestHandle ++;
264 
265 		if( hTestHandle >= 6) {
266 			// all tests finished.
267 			hTestHandle = -1;
268 		}
269 	}
270 	else {
271 		BUILD_ERROR( 0 , "service not supported by test." );
272 	}
273 	return hTestHandle;
274 }
275 
276 
277 
278 BOOL OSaxParserTest::testPassed(void) 										THROWS( (UsrSystemException) )
279 {
280 	return m_seqErrors.getLen() == 0;
281 }
282 
283 
284 Sequence< UString > OSaxParserTest::getErrors(void) 							THROWS( (UsrSystemException) )
285 {
286 	return m_seqErrors;
287 }
288 
289 
290 Sequence< UsrAny > OSaxParserTest::getErrorExceptions(void) 					THROWS( (UsrSystemException) )
291 {
292 	return m_seqExceptions;
293 }
294 
295 
296 Sequence< UString > OSaxParserTest::getWarnings(void) 						THROWS( (UsrSystemException) )
297 {
298 	return m_seqWarnings;
299 }
300 
301 XInputStreamRef createStreamFromSequence( const Sequence<BYTE> seqBytes , XMultiServiceFactoryRef &xSMgr )
302 {
303 	XInterfaceRef xOutStreamService = xSMgr->createInstance( L"com.sun.star.io.Pipe" );
304 	OSL_ASSERT( xOutStreamService.is() );
305 	XOutputStreamRef rOutStream( xOutStreamService , USR_QUERY );
306 	OSL_ASSERT( rOutStream.is() );
307 
308 	XInputStreamRef rInStream( xOutStreamService , USR_QUERY );
309 	OSL_ASSERT( rInStream.is() );
310 
311 	rOutStream->writeBytes( seqBytes );
312 	rOutStream->flush();
313 	rOutStream->closeOutput();
314 
315 	return rInStream;
316 }
317 
318 XInputStreamRef createStreamFromFile( const char *pcFile , XMultiServiceFactoryRef &xSMgr )
319 {
320 	FILE *f = fopen( pcFile , "rb" );
321 	XInputStreamRef r;
322 
323 	if( f ) {
324 		fseek( f , 0 , SEEK_END );
325 		int nLength = ftell( f );
326 		fseek( f , 0 , SEEK_SET );
327 
328 		Sequence<BYTE> seqIn(nLength);
329 		fread( seqIn.getArray() , nLength , 1 , f );
330 
331 		r = createStreamFromSequence( seqIn , xSMgr );
332 		fclose( f );
333 	}
334 	return r;
335 }
336 
337 
338 
339 
340 
341 
342 
343 
344 
345 #define PCHAR_TO_USTRING(x) StringToUString(String(x),CHARSET_PC_1252)
346 #define USTRING_TO_PCHAR(x) UStringToString(x,CHARSET_PC_437).GetStr()
347 
348 
349 
350 class TestDocumentHandler :
351 			public XExtendedDocumentHandler,
352 			public XEntityResolver,
353 			public XErrorHandler,
354 			public OWeakObject
355 {
356 public:
357 	TestDocumentHandler( XMultiServiceFactoryRef  &r , BOOL bPrint )
358 	{
359 		m_xSMgr = r;
360 		m_bPrint = bPrint;
361 	}
362 
363 
364 public:
365 	BOOL						queryInterface( Uik aUik, XInterfaceRef & rOut );
366 	void 						acquire() 						 { OWeakObject::acquire(); }
367 	void 						release() 						 { OWeakObject::release(); }
368 	void* 						getImplementation(Reflection *p) { return OWeakObject::getImplementation(p); }
369 
370 
371 public: // Error handler
372     virtual void error(const UsrAny& aSAXParseException) THROWS( (SAXException, UsrSystemException) )
373     {
374     	printf( "Error !\n" );
375     	THROW( SAXException( L"error from error handler" , XInterfaceRef() , aSAXParseException ) );
376     }
377     virtual void fatalError(const UsrAny& aSAXParseException) THROWS( (SAXException, UsrSystemException) )
378     {
379     	printf( "Fatal Error !\n" );
380     }
381     virtual void warning(const UsrAny& aSAXParseException) THROWS( (SAXException, UsrSystemException) )
382     {
383     	printf( "Warning !\n" );
384     }
385 
386 
387 public: // ExtendedDocumentHandler
388 
389     virtual void startDocument(void) THROWS( (SAXException, UsrSystemException) )
390     {
391  		m_iLevel = 0;
392 		m_iElementCount = 0;
393 		m_iAttributeCount = 0;
394 		m_iWhitespaceCount =0;
395 		m_iCharCount=0;
396 		if( m_bPrint ) {
397     		printf( "document started\n" );
398     	}
399     }
400     virtual void endDocument(void) THROWS( (SAXException, UsrSystemException) )
401     {
402 		if( m_bPrint ) {
403     		printf( "document finished\n" );
404     		printf( "(ElementCount %d),(AttributeCount %d),(WhitespaceCount %d),(CharCount %d)\n",
405     			m_iElementCount, m_iAttributeCount, m_iWhitespaceCount , m_iCharCount );
406     	}
407     }
408     virtual void startElement(const UString& aName, const XAttributeListRef& xAttribs)
409     								THROWS( (SAXException,UsrSystemException) )
410     {
411 
412 		if( m_rLocator.is() ) {
413 			if( m_bPrint )
414 				printf( "%s(%d):" , USTRING_TO_PCHAR( m_rLocator->getSystemId() ) ,
415 									m_rLocator->getLineNumber() );
416 		}
417 		if( m_bPrint ) {
418 	    	int i;
419 	    	for( i = 0; i < m_iLevel ; i ++ ) {
420 	    		printf( "  " );
421 	    	}
422 	    	printf( "<%s> " , USTRING_TO_PCHAR( aName ) );
423 
424 	    	for( i = 0 ; i < xAttribs->getLength() ; i ++ ) {
425 	    		printf( "(%s,%s,'%s')" ,	USTRING_TO_PCHAR( xAttribs->getNameByIndex( i ) ) ,
426 	    									USTRING_TO_PCHAR( xAttribs->getTypeByIndex( i ) ) ,
427 	    									USTRING_TO_PCHAR( xAttribs->getValueByIndex( i ) ) );
428 	    	}
429 	    	printf( "\n" );
430 		}
431     	m_iLevel ++;
432     	m_iElementCount ++;
433     	m_iAttributeCount += xAttribs->getLength();
434     }
435     virtual void endElement(const UString& aName) THROWS( (SAXException,UsrSystemException) )
436     {
437     	OSL_ASSERT( m_iLevel );
438     	m_iLevel --;
439     	if( m_bPrint ) {
440 	    	int i;
441 	    	for( i = 0; i < m_iLevel ; i ++ ) {
442 	    		printf( "  " );
443 	    	}
444 	    	printf( "</%s>\n" , USTRING_TO_PCHAR( aName ) );
445 	    }
446     }
447 
448     virtual void characters(const UString& aChars) THROWS( (SAXException,UsrSystemException) )
449     {
450     	if( m_bPrint ) {
451 	    	int i;
452 	    	for( i = 0; i < m_iLevel ; i ++ ) {
453 	    		printf( "  " );
454 	    	}
455 	    	printf( "%s\n" , USTRING_TO_PCHAR( aChars ) );
456 	    }
457     	m_iCharCount += aChars.len();
458     }
459     virtual void ignorableWhitespace(const UString& aWhitespaces) THROWS( (SAXException,UsrSystemException) )
460     {
461 		m_iWhitespaceCount += aWhitespaces.len();
462     }
463 
464     virtual void processingInstruction(const UString& aTarget, const UString& aData) THROWS( (SAXException,UsrSystemException) )
465     {
466 		if( m_bPrint )
467     				printf( "PI : %s,%s\n" , USTRING_TO_PCHAR( aTarget ) , USTRING_TO_PCHAR( aData ) );
468     }
469 
470     virtual void setDocumentLocator(const XLocatorRef& xLocator) THROWS( (SAXException,UsrSystemException) )
471     {
472 		m_rLocator = xLocator;
473     }
474 
475     virtual InputSource resolveEntity(const UString& sPublicId, const UString& sSystemId)
476     																	THROWS( (SAXException,UsrSystemException) )
477 	{
478 		InputSource source;
479 		source.sSystemId = sSystemId;
480 		source.sPublicId = sPublicId;
481 		source.aInputStream = createStreamFromFile( USTRING_TO_PCHAR( sSystemId ) , m_xSMgr );
482 
483 		return source;
484 	}
485 
486     virtual void startCDATA(void) THROWS( (SAXException,UsrSystemException) )
487     {
488 		if( m_bPrint ) {
489     		printf( "CDataStart :\n" );
490     	}
491     }
492     virtual void endCDATA(void) THROWS( (SAXException,UsrSystemException) )
493     {
494 		if( m_bPrint ) {
495     		printf( "CEndStart :\n" );
496     	}
497     }
498     virtual void comment(const UString& sComment) THROWS( (SAXException,UsrSystemException) )
499     {
500 		if( m_bPrint ) {
501     		printf( "<!--%s-->\n" , USTRING_TO_PCHAR( sComment ) );
502     	}
503     }
504     virtual void unknown(const UString& sString) THROWS( (SAXException,UsrSystemException) )
505     {
506 		if( m_bPrint ) {
507     		printf( "UNKNOWN : {%s}\n" , USTRING_TO_PCHAR( sString ) );
508     	}
509     }
510 
511 	virtual void allowLineBreak( void) THROWS( (SAXException, UsrSystemException ) )
512 	{
513 
514 	}
515 
516 
517 public:
518 	int m_iLevel;
519 	int m_iElementCount;
520 	int m_iAttributeCount;
521 	int m_iWhitespaceCount;
522 	int m_iCharCount;
523 	BOOL m_bPrint;
524 
525 	XMultiServiceFactoryRef m_xSMgr;
526 	XLocatorRef m_rLocator;
527 };
528 
529 BOOL TestDocumentHandler::queryInterface( Uik aUik , XInterfaceRef & rOut )
530 {
531 	if( aUik == XDocumentHandler::getSmartUik() ) {
532 		rOut = (XDocumentHandler * )this;
533 	}
534 	else if ( aUik == XExtendedDocumentHandler::getSmartUik() ) {
535 		rOut = (XExtendedDocumentHandler *) this;
536 	}
537 	else if ( aUik == XEntityResolver::getSmartUik() ) {
538 		rOut = (XEntityResolver *) this;
539 	}
540 	else if ( aUik == XErrorHandler::getSmartUik() ) {
541 		rOut = (XErrorHandler * ) this;
542 	}
543 	else {
544 		return OWeakObject::queryInterface( aUik , rOut );
545 	}
546 	return TRUE;
547 }
548 
549 
550 
551 
552 void OSaxParserTest::testSimple( 	const XParserRef &rParser )
553 {
554 
555 	char TestString[] =
556 						"<!DOCTYPE personnel [\n"
557 						"<!ENTITY testInternal \"internal Test!\">\n"
558 						"<!ENTITY test SYSTEM \"external_entity.xml\">\n"
559 						"]>\n"
560 
561 						"<personnel>\n"
562 						"<person> fjklsfdklsdfkl\n"
563 						"fjklsfdklsdfkl\n"
564 						"<?testpi pidata?>\n"
565 						"&testInternal;\n"
566 						"<HUHU x='5' y='kjfd'> blahuhu\n"
567 						"<HI> blahi\n"
568 						"     <![CDATA[<greeting>Hello, '+1+12world!</greeting>]]>\n"
569 						"   <!-- huhu <jdk> -->\n"
570 						"<?testpi pidata?>\n"
571 						"</HI>\n"
572 						"aus XMLTest\n"
573 						"</HUHU>\n"
574 						"</person>\n"
575 						"</personnel>\n\n\n";
576 
577 	Sequence<BYTE> seqBytes( strlen( TestString ) );
578 	memcpy( seqBytes.getArray() , TestString , strlen( TestString ) );
579 
580 
581 	XInputStreamRef rInStream;
582 	UString sInput;
583 	rInStream = createStreamFromSequence( seqBytes , m_rFactory );
584 	sInput = UString( L"internal" );
585 
586 	if( rParser.is() ) {
587 		InputSource source;
588 
589 		source.aInputStream = rInStream;
590 		source.sSystemId 	= sInput;
591 
592 		TestDocumentHandler *pDocHandler = new TestDocumentHandler( m_rFactory , FALSE );
593 		XDocumentHandlerRef rDocHandler( (XDocumentHandler *) pDocHandler , USR_QUERY );
594 		XEntityResolverRef 	rEntityResolver( (XEntityResolver *) pDocHandler , USR_QUERY );
595 
596 		rParser->setDocumentHandler( rDocHandler );
597 		rParser->setEntityResolver( rEntityResolver );
598 
599 		try {
600 			rParser->parseStream( source );
601 			ERROR_ASSERT( pDocHandler->m_iElementCount 		== 4 , "wrong element count" 	);
602 			ERROR_ASSERT( pDocHandler->m_iAttributeCount 	== 2 , "wrong attribut count" 	);
603 			ERROR_ASSERT( pDocHandler->m_iCharCount 		== 130 , "wrong char count" 	);
604 			ERROR_ASSERT( pDocHandler->m_iWhitespaceCount 	== 0, "wrong whitespace count" );
605 		}
606 		catch( SAXParseException& e ) {
607 			BUILD_ERROR( 1 , USTRING_TO_PCHAR( e.Message ) );
608 		}
609 		catch( SAXException& e ) {
610 			BUILD_ERROR( 1 , USTRING_TO_PCHAR( e.Message ) );
611 
612 		}
613 		catch( Exception& e ) {
614 			BUILD_ERROR( 1 , USTRING_TO_PCHAR( e.Message ) );
615 		}
616 		catch(...) {
617 			BUILD_ERROR( 1 , "unknown exception" );
618 		}
619 
620 	}
621 
622 
623 }
624 
625 void OSaxParserTest::testNamespaces( const XParserRef &rParser )
626 {
627 
628 	char TestString[] =
629 	"<?xml version='1.0'?>\n"
630   	"<!-- all elements here are explicitly in the HTML namespace -->\n"
631   	"<html:html xmlns:html='http://www.w3.org/TR/REC-html40'>\n"
632     	"<html:head><html:title>Frobnostication</html:title></html:head>\n"
633     	"<html:body><html:p>Moved to \n"
634       	"<html:a href='http://frob.com'>here.</html:a></html:p></html:body>\n"
635   	"</html:html>\n";
636 
637 	Sequence<BYTE> seqBytes( strlen( TestString ) );
638 	memcpy( seqBytes.getArray() , TestString , strlen( TestString ) );
639 
640 
641 	XInputStreamRef rInStream;
642 	UString sInput;
643 
644 	rInStream = createStreamFromSequence( seqBytes , m_rFactory );
645 	sInput = UString( L"internal" );
646 
647 	if( rParser.is() ) {
648 		InputSource source;
649 
650 		source.aInputStream = rInStream;
651 		source.sSystemId 	= sInput;
652 
653 		TestDocumentHandler *pDocHandler = new TestDocumentHandler( m_rFactory , FALSE );
654 		XDocumentHandlerRef rDocHandler( (XDocumentHandler *) pDocHandler , USR_QUERY );
655 		XEntityResolverRef 	rEntityResolver( (XEntityResolver *) pDocHandler , USR_QUERY );
656 
657 		rParser->setDocumentHandler( rDocHandler );
658 		rParser->setEntityResolver( rEntityResolver );
659 
660 		try {
661 			rParser->parseStream( source );
662 			ERROR_ASSERT( pDocHandler->m_iElementCount 		== 6 , "wrong element count" 	);
663 			ERROR_ASSERT( pDocHandler->m_iAttributeCount 	== 2 , "wrong attribut count" 	);
664 			ERROR_ASSERT( pDocHandler->m_iCharCount 		== 33, "wrong char count" 		);
665 			ERROR_ASSERT( pDocHandler->m_iWhitespaceCount 	== 0 , "wrong whitespace count" );
666 		}
667 		catch( SAXParseException& e ) {
668 			BUILD_ERROR( 1 , USTRING_TO_PCHAR( e.Message ) );
669 		}
670 		catch( SAXException& e ) {
671 			BUILD_ERROR( 1 , USTRING_TO_PCHAR( e.Message ) );
672 
673 		}
674 		catch( Exception& e ) {
675 			BUILD_ERROR( 1 , USTRING_TO_PCHAR( e.Message ) );
676 		}
677 		catch(...) {
678 			BUILD_ERROR( 1 , "unknown exception" );
679 		}
680 	}
681 }
682 
683 void OSaxParserTest::testEncoding( const XParserRef &rParser )
684 {
685 	char TestString[] =
686 	"<?xml version='1.0' encoding=\"iso-8859-1\"?>\n"
687   	"<!-- all elements here are explicitly in the HTML namespace -->\n"
688   	"<html:html xmlns:html='http://www.w3.org/TR/REC-html40'>\n"
689     	"<html:head><html:title>Frobnostication</html:title></html:head>\n"
690     	"<html:body><html:p>Moved to �\n"
691       	"<html:a href='http://frob.com'>here.</html:a></html:p></html:body>\n"
692   	"</html:html>\n";
693 
694 	Sequence<BYTE> seqBytes( strlen( TestString ) );
695 	memcpy( seqBytes.getArray() , TestString , strlen( TestString ) );
696 
697 
698 	XInputStreamRef rInStream;
699 	UString sInput;
700 
701 	rInStream = createStreamFromSequence( seqBytes , m_rFactory );
702 	sInput = UString( L"internal" );
703 
704 	if( rParser.is() ) {
705 		InputSource source;
706 
707 		source.aInputStream = rInStream;
708 		source.sSystemId 	= sInput;
709 
710 		TestDocumentHandler *pDocHandler = new TestDocumentHandler( m_rFactory , FALSE );
711 		XDocumentHandlerRef rDocHandler( (XDocumentHandler *) pDocHandler , USR_QUERY );
712 		XEntityResolverRef 	rEntityResolver( (XEntityResolver *) pDocHandler , USR_QUERY );
713 
714 		rParser->setDocumentHandler( rDocHandler );
715 		rParser->setEntityResolver( rEntityResolver );
716 		try {
717 			rParser->parseStream( source );
718 		}
719 		catch( SAXParseException& e ) {
720 			BUILD_ERROR( 1 , USTRING_TO_PCHAR( e.Message ) );
721 		}
722 		catch( SAXException& e ) {
723 			BUILD_ERROR( 1 , USTRING_TO_PCHAR( e.Message ) );
724 
725 		}
726 		catch( Exception& e ) {
727 			BUILD_ERROR( 1 , USTRING_TO_PCHAR( e.Message ) );
728 		}
729 		catch(...) {
730 			BUILD_ERROR( 1 , "unknown exception" );
731 		}
732 
733 	}
734 
735 }
736 
737 void OSaxParserTest::testFile( const XParserRef & rParser )
738 {
739 
740 	XInputStreamRef rInStream = createStreamFromFile( "testsax.xml" , m_rFactory );
741 	UString sInput = UString( PCHAR_TO_USTRING( "testsax.xml" ) );
742 
743 
744 	if( rParser.is() && rInStream.is() ) {
745 		InputSource source;
746 
747 		source.aInputStream = rInStream;
748 		source.sSystemId 	= sInput;
749 
750 		TestDocumentHandler *pDocHandler = new TestDocumentHandler( m_rFactory , TRUE );
751 		XDocumentHandlerRef rDocHandler( (XDocumentHandler *) pDocHandler , USR_QUERY );
752 		XEntityResolverRef 	rEntityResolver( (XEntityResolver *) pDocHandler , USR_QUERY );
753 		XErrorHandlerRef	rErrorHandler( ( XErrorHandler * )pDocHandler , USR_QUERY );
754 
755 		rParser->setDocumentHandler( rDocHandler );
756 		rParser->setEntityResolver( rEntityResolver );
757 		rParser->setErrorHandler( rErrorHandler );
758 
759 		try {
760 			rParser->parseStream( source );
761 		}
762 		catch( SAXParseException& e ) {
763 			UsrAny any;
764 			any.set( &e , SAXParseException_getReflection() );
765 			while(TRUE) {
766 				SAXParseException *pEx;
767 				if( any.getReflection() == SAXParseException_getReflection() ) {
768 					pEx = ( SAXParseException * ) any.get();
769 					printf( "%s\n" , UStringToString( pEx->Message , CHARSET_SYSTEM ).GetStr()  );
770 					any = pEx->WrappedException;
771 				}
772 				else {
773 					break;
774 				}
775 			}
776 		}
777 		catch( SAXException& e ) {
778 			printf( "%s\n" , UStringToString( e.Message , CHARSET_SYSTEM ).GetStr()  );
779 
780 		}
781 		catch( Exception& e ) {
782 			printf( "normal exception ! %s\n", e.getName() );
783 		}
784 		catch(...) {
785 			printf( "any exception !!!!\n" );
786 		}
787 	}
788 }
789 
790 void OSaxParserTest::testPerformance( const XParserRef & rParser )
791 {
792 
793 	XInputStreamRef rInStream = createStreamFromFile( "testPerformance.xml" , m_rFactory );
794 	UString sInput = UString( PCHAR_TO_USTRING( "testperformance.xml" ) );
795 
796 	if( rParser.is() && rInStream.is() ) {
797 		InputSource source;
798 
799 		source.aInputStream = rInStream;
800 		source.sSystemId 	= sInput;
801 
802 		TestDocumentHandler *pDocHandler = new TestDocumentHandler( m_rFactory , FALSE );
803 		XDocumentHandlerRef rDocHandler( (XDocumentHandler *) pDocHandler , USR_QUERY );
804 		XEntityResolverRef 	rEntityResolver( (XEntityResolver *) pDocHandler , USR_QUERY );
805 		XErrorHandlerRef	rErrorHandler( ( XErrorHandler * )pDocHandler , USR_QUERY );
806 
807 		rParser->setDocumentHandler( rDocHandler );
808 		rParser->setEntityResolver( rEntityResolver );
809 		rParser->setErrorHandler( rErrorHandler );
810 
811 		try {
812 			TimeValue aStartTime, aEndTime;
813 			osl_getSystemTime( &aStartTime );
814 			rParser->parseStream( source );
815 			osl_getSystemTime( &aEndTime );
816 
817 			double fStart = (double)aStartTime.Seconds + ((double)aStartTime.Nanosec / 1000000000.0);
818 			double fEnd = (double)aEndTime.Seconds + ((double)aEndTime.Nanosec / 1000000000.0);
819 
820 			printf( "Performance reading : %g s\n" , fEnd - fStart );
821 
822 		}
823 		catch( SAXParseException& e ) {
824 			UsrAny any;
825 			any.set( &e , SAXParseException_getReflection() );
826 			while(TRUE) {
827 				SAXParseException *pEx;
828 				if( any.getReflection() == SAXParseException_getReflection() ) {
829 					pEx = ( SAXParseException * ) any.get();
830 					printf( "%s\n" , UStringToString( pEx->Message , CHARSET_SYSTEM ).GetStr()  );
831 					any = pEx->WrappedException;
832 				}
833 				else {
834 					break;
835 				}
836 			}
837 		}
838 		catch( SAXException& e ) {
839 			printf( "%s\n" , UStringToString( e.Message , CHARSET_SYSTEM ).GetStr()  );
840 
841 		}
842 		catch( Exception& e ) {
843 			printf( "normal exception ! %s\n", e.getName() );
844 		}
845 		catch(...) {
846 			printf( "any exception !!!!\n" );
847 		}
848 	}
849 
850 }
851 
852 
853 extern "C"
854 {
855 BOOL EXTERN_SERVICE_CALLTYPE exService_writeRegEntry(
856         const UNO_INTERFACE(XRegistryKey)* xUnoKey)
857 
858 {
859 	XRegistryKeyRef   xKey;
860 	uno2smart(xKey, *xUnoKey);
861 
862 	UString str = UString( L"/" ) + OSaxParserTest_getImplementationName() + UString( L"/UNO/SERVICES" );
863 	XRegistryKeyRef xNewKey = xKey->createKey( str );
864 	xNewKey->createKey( OSaxParserTest_getServiceName() );
865 
866 	str = UString( L"/" ) + OSaxWriterTest_getImplementationName() + UString( L"/UNO/SERVICES" );
867 	xNewKey = xKey->createKey( str );
868 	xNewKey->createKey( OSaxWriterTest_getServiceName() );
869 
870 	return TRUE;
871 }
872 
873 
874 UNO_INTERFACE(XInterface) EXTERN_SERVICE_CALLTYPE exService_getFactory
875 (
876 	const wchar_t* implementationName,
877 	const UNO_INTERFACE(XMultiServiceFactory)* xUnoFact,
878 	const UNO_INTERFACE(XRegistryKey)*
879 )
880 {
881 	UNO_INTERFACE(XInterface) xUnoRet = {0, 0};
882 
883 	XInterfaceRef 			xRet;
884 	XMultiServiceFactoryRef xSMgr;
885 	UString					aImplementationName(implementationName);
886 
887 	uno2smart(xSMgr, *xUnoFact);
888 
889 	if (aImplementationName == OSaxWriterTest_getImplementationName() )
890 	{
891 		xRet = createSingleFactory( xSMgr, implementationName,
892 									OSaxWriterTest_CreateInstance,
893 									OSaxWriterTest_getSupportedServiceNames() );
894 	}
895 	else if (aImplementationName == OSaxParserTest_getImplementationName() )
896 	{
897 		xRet = createSingleFactory( xSMgr, implementationName,
898 									OSaxParserTest_CreateInstance,
899 									OSaxParserTest_getSupportedServiceNames() );
900 	}
901 	if (xRet.is())
902 	{
903 		smart2uno(xRet, xUnoRet);
904 	}
905 
906 	return xUnoRet;
907 }
908 
909 }
910 
911 
912