extensions/test/sax/testwriter.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: testwriter.cxx,v $
  10  * $Revision: 1.7 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_extensions.hxx"
  33
  34 //#include <tools/presys.h>
  35 #include <vector>
  36 //#include <tools/postsys.h>
  37 #include <smart/com/sun/star/test/XSimpleTest.hxx>
  38 #include <smart/com/sun/star/lang/XMultiServiceFactory.hxx>  // for the multiservice-factories
  39
  40 #include <stdio.h>
  41
  42 #include <smart/com/sun/star/io/XActiveDataSource.hxx>
  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 <rtl/wstring.hxx>
  49 #include <osl/time.h>
  50 #include <usr/weak.hxx>
  51 #include <tools/string.hxx>
  52
  53 #if OSL_DEBUG_LEVEL == 0
  54 #define NDEBUG
  55 #endif
  56 #include <assert.h>
  57
  58 #include <usr/factoryhlp.hxx>
  59
  60 #include <usr/reflserv.hxx>  // for EXTERN_SERVICE_CALLTYPE
  61
  62 using namespace std;
  63 using namespace rtl;
  64 using namespace vos;
  65 using namespace usr;
  66
  67 #define BUILD_ERROR(expr, Message)\
  68         {\
  69             m_seqErrors.realloc( m_seqErrors.getLen() + 1 ); \
  70         m_seqExceptions.realloc(  m_seqExceptions.getLen() + 1 ); \
  71         String str; \
  72         str += __FILE__;\
  73         str += " "; \
  74         str += "(" ; \
  75         str += __LINE__ ;\
  76         str += ")\n";\
  77         str += "[ " ; \
  78         str += #expr; \
  79         str += " ] : " ; \
  80         str += Message; \
  81         m_seqErrors.getArray()[ m_seqErrors.getLen()-1] = StringToUString( str , CHARSET_SYSTEM ); \
  82         }\
  83         ((void)0)
  84
  85
  86 #define WARNING_ASSERT(expr, Message) \
  87         if( ! (expr) ) { \
  88             m_seqWarnings.realloc( m_seqErrors.getLen() +1 ); \
  89             String str;\
  90             str += __FILE__;\
  91             str += " "; \
  92             str += "(" ; \
  93             str += __LINE__ ;\
  94             str += ")\n";\
  95             str += "[ " ; \
  96             str += #expr; \
  97             str += " ] : " ; \
  98             str += Message; \
  99             m_seqWarnings.getArray()[ m_seqWarnings.getLen()-1] = StringToUString( str , CHARSET_SYSTEM ); \
 100             return; \
 101         }\
 102         ((void)0)
 103
 104 #define ERROR_ASSERT(expr, Message) \
 105         if( ! (expr) ) { \
 106             BUILD_ERROR(expr, Message );\
 107             return; \
 108         }\
 109         ((void)0)
 110
 111 #define ERROR_EXCEPTION_ASSERT(expr, Message, Exception) \
 112     if( !(expr)) { \
 113         BUILD_ERROR(expr,Message);\
 114         m_seqExceptions.getArray()[ m_seqExceptions.getLen()-1] = UsrAny( Exception );\
 115         return; \
 116     } \
 117     ((void)0)
 118
 119 /****
 120 * test szenarios :
 121 *
 122 *
 123 *
 124 ****/
 125
 126
 127 class OFileWriter :
 128         public XOutputStream,
 129         public OWeakObject
 130 {
 131 public:
 132     OFileWriter( char *pcFile ) { strcpy( m_pcFile , pcFile ); m_f = 0; }
 133
 134
 135 public: // refcounting
 136     BOOL                                                queryInterface( Uik aUik, XInterfaceRef & rOut )
 137     {
 138         if( XOutputStream::getSmartUik() == aUik ) {
 139             rOut = (XOutputStream *) this;
 140         }
 141         else return OWeakObject::queryInterface( aUik , rOut );
 142
 143         return TRUE;
 144     }
 145     void                                                acquire()                                                { OWeakObject::acquire(); }
 146     void                                                release()                                                { OWeakObject::release(); }
 147     void*                                               getImplementation(Reflection *p) { return OWeakObject::getImplementation(p); }
 148
 149 public:
 150     virtual void writeBytes(const Sequence< BYTE >& aData)
 151                         THROWS( (NotConnectedException, BufferSizeExceededException, UsrSystemException) );
 152     virtual void flush(void)
 153                         THROWS( (NotConnectedException, BufferSizeExceededException, UsrSystemException) );
 154     virtual void closeOutput(void)
 155                         THROWS( (NotConnectedException, BufferSizeExceededException, UsrSystemException) );
 156
 157
 158 private:
 159     char m_pcFile[256];
 160     FILE *m_f;
 161 };
 162
 163
 164 void OFileWriter::writeBytes(const Sequence< BYTE >& aData)
 165             THROWS( (NotConnectedException, BufferSizeExceededException, UsrSystemException) )
 166 {
 167     if( ! m_f ) {
 168         m_f = fopen( m_pcFile , "w" );
 169     }
 170
 171     fwrite( aData.getConstArray() , 1 , aData.getLen() , m_f );
 172
 173 }
 174
 175
 176 void OFileWriter::flush(void)
 177             THROWS( (NotConnectedException, BufferSizeExceededException, UsrSystemException) )
 178 {
 179     fflush( m_f );
 180 }
 181
 182 void OFileWriter::closeOutput(void)
 183                         THROWS( (NotConnectedException, BufferSizeExceededException, UsrSystemException) )
 184 {
 185     fclose( m_f );
 186     m_f = 0;
 187 }
 188
 189
 190 class OSaxWriterTest :
 191         public XSimpleTest,
 192         public OWeakObject
 193 {
 194 public:
 195     OSaxWriterTest( const XMultiServiceFactoryRef & rFactory ) : m_rFactory( rFactory )
 196     {
 197
 198     }
 199     ~OSaxWriterTest() {}
 200
 201 public: // refcounting
 202     BOOL                                                queryInterface( Uik aUik, XInterfaceRef & rOut );
 203     void                                                acquire()                                                { OWeakObject::acquire(); }
 204     void                                                release()                                                { OWeakObject::release(); }
 205     void*                                               getImplementation(Reflection *p) { return OWeakObject::getImplementation(p); }
 206
 207 public:
 208     virtual void testInvariant(const UString& TestName, const XInterfaceRef& TestObject)
 209                                                                 THROWS( (       IllegalArgumentException,
 210                                                                             UsrSystemException) );
 211
 212     virtual INT32 test( const UString& TestName,
 213                         const XInterfaceRef& TestObject,
 214                         INT32 hTestHandle)                                              THROWS( (       IllegalArgumentException,
 215                                                                             UsrSystemException) );
 216
 217     virtual BOOL testPassed(void)                                                               THROWS( (       UsrSystemException) );
 218     virtual Sequence< UString > getErrors(void)                                 THROWS( (UsrSystemException) );
 219     virtual Sequence< UsrAny > getErrorExceptions(void)                 THROWS( (UsrSystemException) );
 220     virtual Sequence< UString > getWarnings(void)                               THROWS( (UsrSystemException) );
 221
 222 private:
 223     void testSimple( const XExtendedDocumentHandlerRef &r );
 224     void testExceptions( const XExtendedDocumentHandlerRef &r );
 225     void testDTD( const XExtendedDocumentHandlerRef &r );
 226     void testPerformance( const XExtendedDocumentHandlerRef &r );
 227     void writeParagraph( const XExtendedDocumentHandlerRef &r , const UString & s);
 228
 229 private:
 230     Sequence<UsrAny>            m_seqExceptions;
 231     Sequence<UString>           m_seqErrors;
 232     Sequence<UString>           m_seqWarnings;
 233     XMultiServiceFactoryRef m_rFactory;
 234
 235 };
 236
 237
 238
 239 /*----------------------------------------
 240 *
 241 *       Attributlist implementation
 242 *
 243 *----------------------------------------*/
 244 struct AttributeListImpl_impl;
 245 class AttributeListImpl :
 246         public XAttributeList,
 247         public OWeakObject
 248 {
 249 public:
 250     AttributeListImpl();
 251     AttributeListImpl( const AttributeListImpl & );
 252     ~AttributeListImpl();
 253
 254 public:
 255     BOOL                                        queryInterface( Uik aUik, XInterfaceRef & rOut );
 256     void                                        acquire()                                                { OWeakObject::acquire(); }
 257     void                                        release()                                                { OWeakObject::release(); }
 258     void*                                       getImplementation(Reflection *p) { return OWeakObject::getImplementation(p); }
 259
 260 public:
 261     virtual INT16 getLength(void) THROWS( (UsrSystemException) );
 262     virtual UString getNameByIndex(INT16 i) THROWS( (UsrSystemException) );
 263     virtual UString getTypeByIndex(INT16 i) THROWS( (UsrSystemException) );
 264     virtual UString getTypeByName(const UString& aName) THROWS( (UsrSystemException) );
 265     virtual UString getValueByIndex(INT16 i) THROWS( (UsrSystemException) );
 266     virtual UString getValueByName(const UString& aName) THROWS( (UsrSystemException) );
 267
 268 public:
 269     void addAttribute( const UString &sName , const UString &sType , const UString &sValue );
 270     void clear();
 271
 272 private:
 273     struct AttributeListImpl_impl *m_pImpl;
 274 };
 275
 276
 277 struct TagAttribute
 278 {
 279     TagAttribute(){}
 280     TagAttribute( const UString &sName, const UString &sType , const UString &sValue )
 281     {
 282         this->sName     = sName;
 283         this->sType     = sType;
 284         this->sValue    = sValue;
 285     }
 286
 287     UString sName;
 288     UString sType;
 289     UString sValue;
 290 };
 291
 292 struct AttributeListImpl_impl
 293 {
 294     AttributeListImpl_impl()
 295     {
 296         // performance improvement during adding
 297         vecAttribute.reserve(20);
 298     }
 299     vector<struct TagAttribute> vecAttribute;
 300 };
 301
 302
 303
 304 INT16 AttributeListImpl::getLength(void) THROWS( (UsrSystemException) )
 305 {
 306     return m_pImpl->vecAttribute.size();
 307 }
 308
 309
 310 AttributeListImpl::AttributeListImpl( const AttributeListImpl &r )
 311 {
 312     m_pImpl = new AttributeListImpl_impl;
 313     *m_pImpl = *(r.m_pImpl);
 314 }
 315
 316 UString AttributeListImpl::getNameByIndex(INT16 i) THROWS( (UsrSystemException) )
 317 {
 318     if( i < m_pImpl->vecAttribute.size() ) {
 319         return m_pImpl->vecAttribute[i].sName;
 320     }
 321     return UString();
 322 }
 323
 324
 325 UString AttributeListImpl::getTypeByIndex(INT16 i) THROWS( (UsrSystemException) )
 326 {
 327     if( i < m_pImpl->vecAttribute.size() ) {
 328         return m_pImpl->vecAttribute[i].sType;
 329     }
 330     return UString();
 331 }
 332
 333 UString AttributeListImpl::getValueByIndex(INT16 i) THROWS( (UsrSystemException) )
 334 {
 335     if( i < m_pImpl->vecAttribute.size() ) {
 336         return m_pImpl->vecAttribute[i].sValue;
 337     }
 338     return UString();
 339
 340 }
 341
 342 UString AttributeListImpl::getTypeByName( const UString& sName ) THROWS( (UsrSystemException) )
 343 {
 344     vector<struct TagAttribute>::iterator ii = m_pImpl->vecAttribute.begin();
 345
 346     for( ; ii != m_pImpl->vecAttribute.end() ; ii ++ ) {
 347         if( (*ii).sName == sName ) {
 348             return (*ii).sType;
 349         }
 350     }
 351     return UString();
 352 }
 353
 354 UString AttributeListImpl::getValueByName(const UString& sName) THROWS( (UsrSystemException) )
 355 {
 356     vector<struct TagAttribute>::iterator ii = m_pImpl->vecAttribute.begin();
 357
 358     for( ; ii != m_pImpl->vecAttribute.end() ; ii ++ ) {
 359         if( (*ii).sName == sName ) {
 360             return (*ii).sValue;
 361         }
 362     }
 363     return UString();
 364 }
 365
 366
 367 BOOL AttributeListImpl::queryInterface( Uik aUik, XInterfaceRef & rOut )
 368 {
 369     if( aUik == XAttributeList::getSmartUik() ) {
 370         rOut = (XAttributeList * )this;
 371     }
 372     else {
 373         return OWeakObject::queryInterface( aUik , rOut );
 374     }
 375     return TRUE;
 376 }
 377
 378
 379 AttributeListImpl::AttributeListImpl()
 380 {
 381     m_pImpl = new AttributeListImpl_impl;
 382 }
 383
 384
 385
 386 AttributeListImpl::~AttributeListImpl()
 387 {
 388     delete m_pImpl;
 389 }
 390
 391
 392 void AttributeListImpl::addAttribute(   const UString &sName ,
 393                                         const UString &sType ,
 394                                         const UString &sValue )
 395 {
 396     m_pImpl->vecAttribute.push_back( TagAttribute( sName , sType , sValue ) );
 397 }
 398
 399 void AttributeListImpl::clear()
 400 {
 401     vector<struct TagAttribute> dummy;
 402     m_pImpl->vecAttribute.swap( dummy );
 403
 404     assert( ! getLength() );
 405 }
 406
 407
 408
 409
 410
 411
 412
 413
 414
 415
 416
 417 /**
 418 * for external binding
 419 *
 420 *
 421 **/
 422 XInterfaceRef OSaxWriterTest_CreateInstance( const XMultiServiceFactoryRef & rSMgr ) THROWS((Exception))
 423 {
 424     OSaxWriterTest *p = new OSaxWriterTest( rSMgr );
 425     XInterfaceRef xService = *p;
 426     return xService;
 427 }
 428
 429 UString     OSaxWriterTest_getServiceName( ) THROWS( () )
 430 {
 431     return L"test.com.sun.star.xml.sax.Writer";
 432 }
 433
 434 UString         OSaxWriterTest_getImplementationName( ) THROWS( () )
 435 {
 436     return L"test.extensions.xml.sax.Writer";
 437 }
 438
 439 Sequence<UString> OSaxWriterTest_getSupportedServiceNames( ) THROWS( () )
 440 {
 441     Sequence<UString> aRet(1);
 442
 443     aRet.getArray()[0] = OSaxWriterTest_getImplementationName( );
 444
 445     return aRet;
 446 }
 447
 448
 449 BOOL OSaxWriterTest::queryInterface( Uik uik , XInterfaceRef &rOut )
 450 {
 451     if( XSimpleTest::getSmartUik() == uik ) {
 452         rOut = (XSimpleTest *) this;
 453     }
 454     else {
 455         return OWeakObject::queryInterface( uik , rOut );
 456     }
 457     return TRUE;
 458 }
 459
 460
 461 void OSaxWriterTest::testInvariant( const UString& TestName, const XInterfaceRef& TestObject )
 462                                                                 THROWS( (       IllegalArgumentException,
 463                                                                             UsrSystemException) )
 464 {
 465     if( L"com.sun.star.xml.sax.Writer" == TestName ) {
 466         XDocumentHandlerRef doc( TestObject , USR_QUERY );
 467         XExtendedDocumentHandlerRef ext( TestObject , USR_QUERY );
 468         XActiveDataSourceRef source( TestObject , USR_QUERY );
 469
 470         ERROR_ASSERT( doc.is() , "XDocumentHandler cannot be queried" );
 471         ERROR_ASSERT( ext.is() , "XExtendedDocumentHandler cannot be queried" );
 472         ERROR_ASSERT( source.is() , "XActiveDataSource cannot be queried" );
 473     }
 474     else {
 475         BUILD_ERROR( 0 , "wrong test" );
 476     }
 477 }
 478
 479
 480 INT32 OSaxWriterTest::test(     const UString& TestName,
 481                         const XInterfaceRef& TestObject,
 482                         INT32 hTestHandle)                                              THROWS( (       IllegalArgumentException,
 483                                                                             UsrSystemException) )
 484 {
 485     if( L"com.sun.star.xml.sax.Writer" == TestName )  {
 486         try {
 487             if( 0 == hTestHandle ) {
 488                 testInvariant( TestName , TestObject );
 489             }
 490             else {
 491
 492                 XExtendedDocumentHandlerRef writer( TestObject , USR_QUERY );
 493
 494                 if( 1 == hTestHandle ) {
 495                     testSimple( writer );
 496                 }
 497                 else if( 2 == hTestHandle ) {
 498                     testExceptions( writer );
 499                 }
 500                 else if( 3 == hTestHandle ) {
 501                     testDTD( writer );
 502                 }
 503                 else if( 4 == hTestHandle ) {
 504                     testPerformance( writer );
 505                 }
 506             }
 507         }
 508         catch( Exception& e )  {
 509             BUILD_ERROR( 0 , UStringToString( e.getName() , CHARSET_SYSTEM ).GetCharStr() );
 510         }
 511         catch(...) {
 512             BUILD_ERROR( 0 , "unknown exception (Exception is  not base class)" );
 513         }
 514
 515         hTestHandle ++;
 516
 517         if( hTestHandle >= 5) {
 518             // all tests finished.
 519             hTestHandle = -1;
 520         }
 521     }
 522     else {
 523         BUILD_ERROR( 0 , "service not supported by test." );
 524     }
 525     return hTestHandle;
 526 }
 527
 528
 529
 530 BOOL OSaxWriterTest::testPassed(void)                                                                           THROWS( (UsrSystemException) )
 531 {
 532     return m_seqErrors.getLen() == 0;
 533 }
 534
 535
 536 Sequence< UString > OSaxWriterTest::getErrors(void)                                                     THROWS( (UsrSystemException) )
 537 {
 538     return m_seqErrors;
 539 }
 540
 541
 542 Sequence< UsrAny > OSaxWriterTest::getErrorExceptions(void)                                     THROWS( (UsrSystemException) )
 543 {
 544     return m_seqExceptions;
 545 }
 546
 547
 548 Sequence< UString > OSaxWriterTest::getWarnings(void)                                           THROWS( (UsrSystemException) )
 549 {
 550     return m_seqWarnings;
 551 }
 552
 553 void OSaxWriterTest::writeParagraph( const XExtendedDocumentHandlerRef &r , const UString & s)
 554 {
 555     int nMax = s.len();
 556     int nStart = 0;
 557
 558     Sequence<UINT16> seq( s.len() );
 559     memcpy( seq.getArray() , s.getStr() , s.len() * sizeof( UINT16 ) );
 560
 561     for( int n = 1 ; n < nMax ; n++ ){
 562         if( 32 == seq.getArray()[n] ) {
 563             r->allowLineBreak();
 564             r->characters( s.copy( nStart , n - nStart ) );
 565             nStart = n;
 566         }
 567     }
 568     r->allowLineBreak();
 569     r->characters( s.copy( nStart , n - nStart ) );
 570
 571
 572 }
 573
 574
 575
 576 void OSaxWriterTest::testSimple( const XExtendedDocumentHandlerRef &r )
 577 {
 578     UString testParagraph = L"Dies ist ein bloeder Test um zu uberpruefen, ob der SAXWriter "
 579                             L"wohl Zeilenumbrueche halbwegs richtig macht oder ob er die Zeile "
 580                             L"bis zum bitteren Ende schreibt.";
 581
 582     OFileWriter *pw = new OFileWriter("output.xml");
 583     AttributeListImpl *pList = new AttributeListImpl;
 584
 585     XAttributeListRef rList( (XAttributeList *) pList , USR_QUERY );
 586     XOutputStreamRef ref( ( XOutputStream * ) pw , USR_QUERY );
 587
 588     XActiveDataSourceRef source( r , USR_QUERY );
 589
 590     ERROR_ASSERT( ref.is() , "no output stream" );
 591     ERROR_ASSERT( source.is() , "no active data source" );
 592
 593     source->setOutputStream( ref );
 594
 595     r->startDocument();
 596
 597     pList->addAttribute( L"Arg1" , L"CDATA" , L"bla\n   u" );
 598     pList->addAttribute( L"Arg2" , L"CDATA" , L"blub" );
 599
 600     r->startElement( L"tag1"  , rList );
 601     r->ignorableWhitespace( L"" );
 602
 603     r->characters( L"huhu" );
 604     r->ignorableWhitespace( L"" );
 605
 606     r->startElement( L"hi" , rList );
 607     r->ignorableWhitespace( L"" );
 608
 609     // the enpassant must be converted & -> &amp;
 610     r->characters( L"&#252;" );
 611
 612     // Test added for mib. Tests if errors during conversions occurs
 613     r->ignorableWhitespace( UString() );
 614     sal_Char array[256];
 615     for( sal_Int32 n = 32 ; n < 254 ; n ++ ) {
 616         array[n-32] = n;
 617     }
 618     array[254-32] = 0;
 619     r->characters(
 620         StringToUString( array , RTL_TEXTENCODING_SYMBOL )
 621         );
 622     r->ignorableWhitespace( UString() );
 623
 624     // '>' must not be converted
 625     r->startCDATA();
 626     r->characters( L">fsfsdf<" );
 627     r->endCDATA();
 628     r->ignorableWhitespace( UString() );
 629
 630     writeParagraph( r , testParagraph );
 631
 632
 633     r->ignorableWhitespace( UString() );
 634     r->comment( L"Dies ist ein Kommentar !" );
 635     r->ignorableWhitespace( UString() );
 636
 637     r->startElement( L"emptytagtest"  , rList );
 638     r->endElement( L"emptytagtest" );
 639
 640     r->endElement( L"hi" );
 641     r->ignorableWhitespace( L"" );
 642
 643     r->endElement( L"tag1" );
 644     r->endDocument();
 645
 646 }
 647
 648 void OSaxWriterTest::testExceptions( const XExtendedDocumentHandlerRef & r )
 649 {
 650
 651     OFileWriter *pw = new OFileWriter("output2.xml");
 652     AttributeListImpl *pList = new AttributeListImpl;
 653
 654     XAttributeListRef rList( (XAttributeList *) pList , USR_QUERY );
 655     XOutputStreamRef ref( ( XOutputStream * ) pw , USR_QUERY );
 656
 657     XActiveDataSourceRef source( r , USR_QUERY );
 658
 659     ERROR_ASSERT( ref.is() , "no output stream" );
 660     ERROR_ASSERT( source.is() , "no active data source" );
 661
 662     source->setOutputStream( ref );
 663
 664     { // startDocument must be called before start element
 665         BOOL bException = TRUE;
 666         try {
 667             r->startElement( L"huhu" , rList );
 668             bException = FALSE;
 669         }
 670         catch( SAXException& e ) {
 671
 672         }
 673         ERROR_ASSERT( bException , "expected exception not thrown !" );
 674     }
 675
 676     r->startDocument();
 677
 678     r->startElement( L"huhu" , rList );
 679     r->startCDATA();
 680
 681     {
 682         BOOL bException = TRUE;
 683         try {
 684             r->startElement( L"huhu" , rList );
 685             bException = FALSE;
 686         }
 687         catch( SAXException& e ) {
 688
 689         }
 690         ERROR_ASSERT( bException , "expected exception not thrown !" );
 691     }
 692
 693     r->endCDATA();
 694     r->endElement( L"hi" );
 695
 696     r->endDocument();
 697 }
 698
 699
 700 void OSaxWriterTest::testDTD(const  XExtendedDocumentHandlerRef &r )
 701 {
 702     OFileWriter *pw = new OFileWriter("outputDTD.xml");
 703     AttributeListImpl *pList = new AttributeListImpl;
 704
 705     XAttributeListRef rList( (XAttributeList *) pList , USR_QUERY );
 706     XOutputStreamRef ref( ( XOutputStream * ) pw , USR_QUERY );
 707
 708     XActiveDataSourceRef source( r , USR_QUERY );
 709
 710     ERROR_ASSERT( ref.is() , "no output stream" );
 711     ERROR_ASSERT( source.is() , "no active data source" );
 712
 713     source->setOutputStream( ref );
 714
 715
 716     r->startDocument();
 717     r->unknown( L"<!DOCTYPE iCalendar >\n" );
 718     r->startElement( L"huhu" , rList );
 719
 720     r->endElement( L"huhu" );
 721     r->endDocument();
 722 }
 723
 724 void OSaxWriterTest::testPerformance(const  XExtendedDocumentHandlerRef &r )
 725 {
 726     OFileWriter *pw = new OFileWriter("testPerformance.xml");
 727     AttributeListImpl *pList = new AttributeListImpl;
 728
 729     UString testParagraph = L"Dies ist ein bloeder Test um zu uberpruefen, ob der SAXWriter "
 730                             L"wohl > Zeilenumbrueche halbwegs richtig macht oder ob er die Zeile "
 731                             L"bis zum bitteren Ende schreibt.";
 732
 733
 734     XAttributeListRef rList( (XAttributeList *) pList , USR_QUERY );
 735     XOutputStreamRef ref( ( XOutputStream * ) pw , USR_QUERY );
 736
 737     XActiveDataSourceRef source( r , USR_QUERY );
 738
 739     ERROR_ASSERT( ref.is() , "no output stream" );
 740     ERROR_ASSERT( source.is() , "no active data source" );
 741
 742     source->setOutputStream( ref );
 743
 744     TimeValue aStartTime, aEndTime;
 745     osl_getSystemTime( &aStartTime );
 746
 747
 748     r->startDocument();
 749     // just write a bunch of xml tags !
 750     // for performance testing
 751     sal_Int32 i2;
 752     for( i2 = 0 ; i2 < 15 ; i2 ++ )
 753     {
 754         r->startElement( UString( L"tag" ) + UString::valueOf( i2 ), rList );
 755         for( sal_Int32 i = 0 ; i < 450 ; i ++ )
 756         {
 757             r->ignorableWhitespace( L"");
 758             r->startElement( L"huhu" , rList );
 759             r->characters( testParagraph );
 760 //                      writeParagraph( r , testParagraph );
 761
 762             r->ignorableWhitespace( L"");
 763             r->endElement( L"huhu" );
 764         }
 765     }
 766     for( i2 = 14 ; i2 >= 0  ; i2-- )
 767     {
 768         r->ignorableWhitespace( L"");
 769         r->endElement( UString( L"tag" ) + UString::valueOf( i2 ) );
 770     }
 771
 772     r->endDocument();
 773
 774     osl_getSystemTime( &aEndTime );
 775
 776     double fStart = (double)aStartTime.Seconds + ((double)aStartTime.Nanosec / 1000000000.0);
 777     double fEnd = (double)aEndTime.Seconds + ((double)aEndTime.Nanosec / 1000000000.0);
 778
 779     printf( "Performance writing : %g s\n" , fEnd - fStart );
 780 }