io/test/stm/marktest.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*************************************************************************
   3  *
   4  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   5  *
   6  * Copyright 2000, 2010 Oracle and/or its affiliates.
   7  *
   8  * OpenOffice.org - a multi-platform office productivity suite
   9  *
  10  * This file is part of OpenOffice.org.
  11  *
  12  * OpenOffice.org is free software: you can redistribute it and/or modify
  13  * it under the terms of the GNU Lesser General Public License version 3
  14  * only, as published by the Free Software Foundation.
  15  *
  16  * OpenOffice.org is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19  * GNU Lesser General Public License version 3 for more details
  20  * (a copy is included in the LICENSE file that accompanied this code).
  21  *
  22  * You should have received a copy of the GNU Lesser General Public License
  23  * version 3 along with OpenOffice.org.  If not, see
  24  * <http://www.openoffice.org/license.html>
  25  * for a copy of the LGPLv3 License.
  26  *
  27  ************************************************************************/
  28
  29 #include <com/sun/star/test/XSimpleTest.hpp>
  30 #include <com/sun/star/io/XActiveDataSink.hpp>
  31 #include <com/sun/star/io/XActiveDataSource.hpp>
  32 #include <com/sun/star/io/XMarkableStream.hpp>
  33 #include <com/sun/star/io/XConnectable.hpp>
  34
  35 #include <com/sun/star/lang/XServiceInfo.hpp>
  36
  37 #include <cppuhelper/factory.hxx>
  38
  39 #include <cppuhelper/implbase1.hxx>
  40 #include <cppuhelper/implbase2.hxx>
  41
  42 #include <osl/conditn.hxx>
  43 #include <osl/mutex.hxx>
  44
  45 using namespace ::rtl;
  46 using namespace ::osl;
  47 using namespace ::cppu;
  48 using namespace ::com::sun::star::uno;
  49 using namespace ::com::sun::star::io;
  50 using namespace ::com::sun::star::lang;
  51 using namespace ::com::sun::star::test;
  52 // streams
  53
  54 #include "testfactreg.hxx"
  55
  56
  57 class OMarkableOutputStreamTest : public WeakImplHelper1< XSimpleTest >
  58 {
  59 public:
  60     OMarkableOutputStreamTest( const Reference< XMultiServiceFactory > & rFactory );
  61     ~OMarkableOutputStreamTest();
  62
  63 public: // implementation names
  64     static Sequence< OUString >     getSupportedServiceNames_Static(void) throw ();
  65     static OUString                 getImplementationName_Static() throw ();
  66
  67 public:
  68     virtual void SAL_CALL testInvariant(
  69         const OUString& TestName,
  70         const Reference < XInterface >& TestObject)
  71         throw ( IllegalArgumentException,
  72                 RuntimeException) ;
  73
  74     virtual sal_Int32 SAL_CALL  test(   const OUString& TestName,
  75                         const Reference < XInterface >& TestObject,
  76                         sal_Int32 hTestHandle)
  77         throw ( IllegalArgumentException, RuntimeException);
  78     virtual sal_Bool SAL_CALL testPassed(void)
  79         throw ( RuntimeException);
  80     virtual Sequence< OUString > SAL_CALL getErrors(void)
  81         throw (RuntimeException);
  82     virtual Sequence< Any > SAL_CALL getErrorExceptions(void)
  83         throw (RuntimeException);
  84     virtual Sequence< OUString > SAL_CALL getWarnings(void)
  85         throw (RuntimeException);
  86
  87 private:
  88     void testSimple( const Reference< XOutputStream > &r, const Reference < XInputStream > &rInput );
  89
  90 private:
  91     Sequence<Any>  m_seqExceptions;
  92     Sequence<OUString> m_seqErrors;
  93     Sequence<OUString> m_seqWarnings;
  94     Reference< XMultiServiceFactory > m_rFactory;
  95
  96 };
  97
  98 OMarkableOutputStreamTest::OMarkableOutputStreamTest( const Reference< XMultiServiceFactory > &rFactory )
  99         : m_rFactory( rFactory )
 100 {
 101
 102 }
 103
 104 OMarkableOutputStreamTest::~OMarkableOutputStreamTest()
 105 {
 106
 107 }
 108
 109
 110
 111
 112 void OMarkableOutputStreamTest::testInvariant( const OUString& TestName,
 113                                                const Reference < XInterface >& TestObject )
 114     throw ( IllegalArgumentException, RuntimeException)
 115 {
 116     Reference< XServiceInfo > info( TestObject, UNO_QUERY );
 117     ERROR_ASSERT( info.is() , "XServiceInfo not supported !" );
 118     if( info.is() )
 119     {
 120         ERROR_ASSERT( info->supportsService( TestName ), "XServiceInfo test failed" );
 121         ERROR_ASSERT( ! info->supportsService(
 122             OUString( "bla bluzb") ) , "XServiceInfo test failed" );
 123     }
 124 }
 125
 126
 127 sal_Int32 OMarkableOutputStreamTest::test(
 128     const OUString& TestName,
 129     const Reference < XInterface >& TestObject,
 130     sal_Int32 hTestHandle)
 131     throw ( IllegalArgumentException, RuntimeException)
 132 {
 133     if( OUString( "com.sun.star.io.MarkableOutputStream" )
 134                   == TestName  )  {
 135         try
 136         {
 137             if( 0 == hTestHandle )
 138             {
 139                 testInvariant( TestName , TestObject );
 140             }
 141             else
 142             {
 143                 Reference < XInterface > x = m_rFactory->createInstance( OUString("com.sun.star.io.Pipe"));
 144                 Reference< XOutputStream >  rPipeOutput( x , UNO_QUERY );
 145                 Reference < XInputStream >  rPipeInput( x , UNO_QUERY );
 146
 147                 Reference<  XActiveDataSource >  source( TestObject , UNO_QUERY );
 148                 source->setOutputStream( rPipeOutput );
 149
 150                 Reference< XOutputStream > rOutput( TestObject , UNO_QUERY );
 151
 152                 OSL_ASSERT( rPipeInput.is() );
 153                 OSL_ASSERT( rOutput.is() );
 154                 if( 1 == hTestHandle ) {
 155                     // checks usual streaming
 156                     testSimple( rOutput , rPipeInput );
 157                 }
 158             }
 159
 160         }
 161         catch( const Exception &e )
 162         {
 163             OString o = OUStringToOString( e.Message , RTL_TEXTENCODING_ASCII_US );
 164             BUILD_ERROR( 0 , o.getStr() );
 165         }
 166         catch( ... )
 167         {
 168             BUILD_ERROR( 0 , "unknown exception (Exception is  not base class)" );
 169         }
 170
 171         hTestHandle ++;
 172
 173         if( 2 == hTestHandle )
 174         {
 175             // all tests finished.
 176             hTestHandle = -1;
 177         }
 178     }
 179     else {
 180         throw IllegalArgumentException();
 181     }
 182     return hTestHandle;
 183 }
 184
 185
 186
 187 sal_Bool OMarkableOutputStreamTest::testPassed(void)                        throw (RuntimeException)
 188 {
 189     return m_seqErrors.getLength() == 0;
 190 }
 191
 192
 193 Sequence< OUString > OMarkableOutputStreamTest::getErrors(void)         throw (RuntimeException)
 194 {
 195     return m_seqErrors;
 196 }
 197
 198
 199 Sequence< Any > OMarkableOutputStreamTest::getErrorExceptions(void) throw (RuntimeException)
 200 {
 201     return m_seqExceptions;
 202 }
 203
 204
 205 Sequence< OUString > OMarkableOutputStreamTest::getWarnings(void)       throw (RuntimeException)
 206 {
 207     return m_seqWarnings;
 208 }
 209
 210
 211 void OMarkableOutputStreamTest::testSimple(     const Reference< XOutputStream > &rOutput ,
 212                                                 const Reference< XInputStream > &rInput )
 213 {
 214     Reference < XMarkableStream > rMarkable( rOutput , UNO_QUERY );
 215
 216     ERROR_ASSERT( rMarkable.is() , "no MarkableStream implemented" );
 217
 218     // first check normal input/output facility
 219     char pcStr[] = "Live long and prosper !";
 220
 221     Sequence<sal_Int8> seqWrite( strlen( pcStr )+1 );
 222     memcpy( seqWrite.getArray() , pcStr , seqWrite.getLength() );
 223
 224     Sequence<sal_Int8> seqRead( seqWrite.getLength() );
 225
 226     int nMax = 10,i;
 227
 228     for( i = 0 ; i < nMax ; i ++ ) {
 229         rOutput->writeBytes( seqWrite );
 230         rInput->readBytes( seqRead , rInput->available() );
 231         ERROR_ASSERT( ! strcmp( (char *) seqWrite.getArray() , (char * )seqRead.getArray() ) ,
 232                       "error during read/write/skip" );
 233     }
 234
 235     // Check buffer resizing
 236     nMax = 3000;
 237     for( i = 0 ; i < nMax ; i ++ ) {
 238         rOutput->writeBytes( seqWrite );
 239     }
 240
 241     for( i = 0 ; i < nMax ; i ++ ) {
 242         rInput->readBytes( seqRead , seqWrite.getLength() );
 243         ERROR_ASSERT( ! strcmp( (char *) seqWrite.getArray() , (char * )seqRead.getArray() ) ,
 244                       "error during read/write" );
 245     }
 246
 247     // Check creating marks !
 248     sal_Int32 nMark = rMarkable->createMark();
 249
 250     for( i = 0 ; i < nMax ; i ++ ) {
 251         rOutput->writeBytes( seqWrite );
 252     }
 253
 254     ERROR_ASSERT( 0 == rInput->available() , "bytes available though mark is holded" );
 255
 256     ERROR_ASSERT( nMax*seqWrite.getLength() == rMarkable->offsetToMark( nMark ) ,
 257                                              "offsetToMark failure" );
 258
 259     rMarkable->deleteMark( nMark );
 260     ERROR_ASSERT( nMax*seqWrite.getLength() == rInput->available(),"bytes are not available though mark has been deleted" );
 261
 262     rInput->skipBytes( nMax*seqWrite.getLength() );
 263     ERROR_ASSERT( 0 == rInput->available(), "skip bytes failure" );
 264
 265     try
 266     {
 267         rMarkable->jumpToMark( nMark );
 268         ERROR_ASSERT( 0 , "jump to non existing mark possible !" );
 269     }
 270     catch ( IllegalArgumentException & )
 271     {
 272         // ok, exception was thrown
 273     }
 274
 275     // test putting marks not at the end of the stream!
 276     ERROR_ASSERT( 0 == rInput->available(), "stream isn't clean" );
 277     {
 278         Sequence< sal_Int8 > aByte(256);
 279
 280         for( i = 0 ; i < 256 ; i ++ )
 281         {
 282             aByte.getArray()[i] = i;
 283         }
 284         sal_Int32 nMark1 = rMarkable->createMark();
 285
 286         rOutput->writeBytes( aByte );
 287         rMarkable->jumpToMark( nMark1 );
 288         aByte.realloc( 10 );
 289         rOutput->writeBytes( aByte );
 290
 291         sal_Int32 nMark2 = rMarkable->createMark( );
 292
 293         for( i = 0 ; i < 10 ; i ++ )
 294         {
 295             aByte.getArray()[i] = i+10;
 296         }
 297
 298         rOutput->writeBytes( aByte );
 299
 300         // allow the bytes to be written !
 301         rMarkable->jumpToFurthest();
 302         rMarkable->deleteMark( nMark1 );
 303         rMarkable->deleteMark( nMark2 );
 304
 305         ERROR_ASSERT( 256 == rInput->available(), "in between mark failure" );
 306         rInput->readBytes( aByte ,256);
 307         for( i = 0 ; i < 256 ; i ++ )
 308         {
 309             ERROR_ASSERT( i == ((sal_uInt8*)(aByte.getArray()))[i] , "in between mark failure" );
 310         }
 311     }
 312
 313     {
 314         // now a more extensive mark test !
 315         Sequence<sal_Int8> as[4];
 316         sal_Int32 an[4];
 317
 318         for( i = 0 ; i < 4 ; i ++ ) {
 319             as[i].realloc(1);
 320             as[i].getArray()[0] = i;
 321             an[i] = rMarkable->createMark();
 322             rOutput->writeBytes( as[i] );
 323         }
 324
 325         // check offset to mark
 326         for( i = 0 ; i < 4 ; i ++ ) {
 327             ERROR_ASSERT( rMarkable->offsetToMark( an[i] ) == 4-i , "offsetToMark failure" );
 328         }
 329
 330         rMarkable->jumpToMark( an[1] );
 331         ERROR_ASSERT( rMarkable->offsetToMark( an[3] ) == -2 , "offsetToMark failure" );
 332
 333         rMarkable->jumpToFurthest( );
 334         ERROR_ASSERT( rMarkable->offsetToMark( an[0] ) == 4 , "offsetToMark failure" );
 335
 336         // now do a rewrite !
 337         for( i = 0 ; i < 4 ; i ++ ) {
 338             rMarkable->jumpToMark( an[3-i] );
 339             rOutput->writeBytes( as[i] );
 340         }
 341         // NOTE : CursorPos 1
 342
 343         // now delete the marks !
 344         for( i = 0 ; i < 4 ; i ++ ) {
 345             rMarkable->deleteMark( an[i] );
 346         }
 347         ERROR_ASSERT( rInput->available() == 1 , "wrong number of bytes flushed" );
 348
 349         rMarkable->jumpToFurthest();
 350
 351         ERROR_ASSERT( rInput->available() == 4 , "wrong number of bytes flushed" );
 352
 353         rInput->readBytes( seqRead , 4 );
 354
 355         ERROR_ASSERT( 3 == seqRead.getArray()[0] , "rewrite didn't work" );
 356         ERROR_ASSERT( 2 == seqRead.getArray()[1] , "rewrite didn't work" );
 357         ERROR_ASSERT( 1 == seqRead.getArray()[2] , "rewrite didn't work" );
 358         ERROR_ASSERT( 0 == seqRead.getArray()[3] , "rewrite didn't work" );
 359
 360         rOutput->closeOutput();
 361         rInput->closeInput();
 362     }
 363
 364 }
 365
 366 /***
 367 * the test methods
 368 *
 369 ****/
 370
 371
 372
 373
 374
 375 /**
 376 * for external binding
 377 *
 378 *
 379 **/
 380 Reference < XInterface > SAL_CALL OMarkableOutputStreamTest_CreateInstance( const Reference< XMultiServiceFactory > & rSMgr ) throw(Exception)
 381 {
 382     OMarkableOutputStreamTest *p = new OMarkableOutputStreamTest( rSMgr );
 383     return Reference < XInterface > ( (static_cast< OWeakObject *  >(p)) );
 384 }
 385
 386
 387
 388 Sequence<OUString> OMarkableOutputStreamTest_getSupportedServiceNames(void) throw ()
 389 {
 390     Sequence<OUString> aRet(1);
 391     aRet.getArray()[0] = OMarkableOutputStreamTest_getImplementationName();
 392
 393     return aRet;
 394 }
 395
 396 OUString     OMarkableOutputStreamTest_getServiceName() throw ()
 397 {
 398     return OUString( "test.com.sun.star.io.MarkableOutputStream");
 399 }
 400
 401 OUString    OMarkableOutputStreamTest_getImplementationName() throw ()
 402 {
 403     return OUString( "test.com.sun.starextensions.stm.MarkableOutputStream");
 404 }
 405
 406
 407
 408
 409
 410
 411
 412 //-----------------------------------------------------
 413 // Input stream
 414
 415
 416 class OMarkableInputStreamTest : public WeakImplHelper1< XSimpleTest >
 417 {
 418 public:
 419     OMarkableInputStreamTest( const Reference< XMultiServiceFactory > & rFactory );
 420     ~OMarkableInputStreamTest();
 421
 422 public: // implementation names
 423     static Sequence< OUString >     getSupportedServiceNames_Static(void) throw () ;
 424     static OUString                 getImplementationName_Static() throw () ;
 425
 426 public:
 427     virtual void SAL_CALL testInvariant(
 428         const OUString& TestName,
 429         const Reference < XInterface >& TestObject)
 430         throw ( IllegalArgumentException, RuntimeException) ;
 431
 432     virtual sal_Int32 SAL_CALL test(
 433         const OUString& TestName,
 434         const Reference < XInterface >& TestObject,
 435         sal_Int32 hTestHandle)
 436         throw ( IllegalArgumentException,
 437                 RuntimeException) ;
 438
 439     virtual sal_Bool SAL_CALL testPassed(void)
 440         throw ( RuntimeException);
 441     virtual Sequence< OUString > SAL_CALL getErrors(void)
 442         throw (RuntimeException);
 443     virtual Sequence< Any > SAL_CALL getErrorExceptions(void)
 444         throw (RuntimeException);
 445     virtual Sequence< OUString > SAL_CALL getWarnings(void)
 446         throw (RuntimeException);
 447
 448 private:
 449     void testSimple( const Reference< XOutputStream > &r,
 450                      const Reference < XInputStream > &rInput );
 451
 452 private:
 453     Sequence<Any>  m_seqExceptions;
 454     Sequence<OUString> m_seqErrors;
 455     Sequence<OUString> m_seqWarnings;
 456     Reference< XMultiServiceFactory > m_rFactory;
 457
 458 };
 459
 460 OMarkableInputStreamTest::OMarkableInputStreamTest( const Reference< XMultiServiceFactory > &rFactory )
 461         : m_rFactory( rFactory )
 462 {
 463
 464 }
 465
 466 OMarkableInputStreamTest::~OMarkableInputStreamTest()
 467 {
 468
 469 }
 470
 471
 472
 473 void OMarkableInputStreamTest::testInvariant(
 474     const OUString& TestName, const Reference < XInterface >& TestObject )
 475     throw ( IllegalArgumentException, RuntimeException)
 476 {
 477     if( OUString( "com.sun.star.io.MarkableInputStream")
 478         == TestName )  {
 479         Reference <XServiceInfo >  info( TestObject, UNO_QUERY );
 480         ERROR_ASSERT( info.is() , "XServiceInfo not supported !" );
 481         if( info.is() )
 482         {
 483             ERROR_ASSERT( info->supportsService( TestName ), "XServiceInfo test failed" );
 484             ERROR_ASSERT(
 485                 ! info->supportsService(
 486                     OUString("bla bluzb") ) ,
 487                 "XServiceInfo test failed" );
 488         }
 489     }
 490     else
 491     {
 492         throw IllegalArgumentException();
 493     }
 494 }
 495
 496
 497 sal_Int32 OMarkableInputStreamTest::test(
 498     const OUString& TestName,
 499     const Reference < XInterface >& TestObject,
 500     sal_Int32 hTestHandle)  throw ( IllegalArgumentException, RuntimeException)
 501 {
 502     if( OUString( "com.sun.star.io.MarkableInputStream") == TestName )
 503     {
 504         try
 505         {
 506             if( 0 == hTestHandle ) {
 507                 testInvariant( TestName , TestObject );
 508             }
 509             else  {
 510                 Reference < XInterface > x = m_rFactory->createInstance( OUString("com.sun.star.io.Pipe"));
 511                 Reference< XOutputStream >  rPipeOutput( x , UNO_QUERY );
 512                 Reference < XInputStream >  rPipeInput( x , UNO_QUERY );
 513
 514                 Reference < XActiveDataSink >  sink( TestObject , UNO_QUERY );
 515                 sink->setInputStream( rPipeInput );
 516
 517                 Reference < XInputStream > rInput( TestObject , UNO_QUERY );
 518
 519                 OSL_ASSERT( rPipeOutput.is() );
 520                 OSL_ASSERT( rInput.is() );
 521                 if( 1 == hTestHandle ) {
 522                     // checks usual streaming
 523                     testSimple( rPipeOutput , rInput );
 524                 }
 525             }
 526
 527         }
 528         catch( const Exception & e )
 529         {
 530             OString o = OUStringToOString( e.Message , RTL_TEXTENCODING_ASCII_US );
 531             BUILD_ERROR( 0 , o.getStr() );
 532         }
 533         catch( ... )
 534         {
 535             BUILD_ERROR( 0 , "unknown exception (Exception is  not base class)" );
 536         }
 537
 538         hTestHandle ++;
 539
 540         if( 2 == hTestHandle ) {
 541             // all tests finished.
 542             hTestHandle = -1;
 543         }
 544     }
 545     else
 546     {
 547         throw IllegalArgumentException();
 548     }
 549     return hTestHandle;
 550 }
 551
 552
 553
 554 sal_Bool OMarkableInputStreamTest::testPassed(void)                                         throw (RuntimeException)
 555 {
 556     return m_seqErrors.getLength() == 0;
 557 }
 558
 559
 560 Sequence< OUString > OMarkableInputStreamTest::getErrors(void)                          throw (RuntimeException)
 561 {
 562     return m_seqErrors;
 563 }
 564
 565
 566 Sequence< Any > OMarkableInputStreamTest::getErrorExceptions(void)                  throw (RuntimeException)
 567 {
 568     return m_seqExceptions;
 569 }
 570
 571
 572 Sequence< OUString > OMarkableInputStreamTest::getWarnings(void)                        throw (RuntimeException)
 573 {
 574     return m_seqWarnings;
 575 }
 576
 577
 578 void OMarkableInputStreamTest::testSimple(      const Reference< XOutputStream > &rOutput ,
 579                                                 const Reference < XInputStream > &rInput )
 580 {
 581     Reference < XMarkableStream > rMarkable( rInput , UNO_QUERY );
 582
 583     Sequence<sal_Int8> seqWrite( 256 );
 584     Sequence<sal_Int8> seqRead(10);
 585
 586     for( int i = 0 ; i < 256 ; i ++ )
 587     {
 588         seqWrite.getArray()[i] = i;
 589     }
 590
 591     rOutput->writeBytes( seqWrite );
 592     ERROR_ASSERT( 256 == rInput->available() , "basic read/write failure" );
 593
 594     rInput->readBytes( seqRead , 10 );
 595     ERROR_ASSERT( 9 == seqRead.getArray()[9] , "basic read/write failure" );
 596
 597     sal_Int32 nMark = rMarkable->createMark();
 598
 599     rInput->skipBytes( 50 );
 600     ERROR_ASSERT( 256-10-50 == rInput->available() , "marking error" );
 601     ERROR_ASSERT( 50 == rMarkable->offsetToMark( nMark ) , "marking error" );
 602
 603     rMarkable->jumpToMark( nMark );
 604     ERROR_ASSERT( 256-10 == rInput->available() , "marking error" );
 605
 606     rInput->readBytes( seqRead , 10 );
 607     ERROR_ASSERT( 10 == seqRead.getArray()[0] , "marking error" );
 608
 609     // pos 20
 610     {
 611         sal_Int32 nInBetweenMark = rMarkable->createMark( );
 612         rMarkable->jumpToMark( nMark );
 613         rMarkable->jumpToMark( nInBetweenMark );
 614
 615         rInput->readBytes( seqRead , 10 );
 616         ERROR_ASSERT( 20 == seqRead.getArray()[0] , "Inbetween mark failed!\n" );
 617
 618         rMarkable->deleteMark( nMark );
 619
 620         // Check if releasing the first bytes works correct.
 621         rMarkable->jumpToMark( nInBetweenMark);
 622         rInput->readBytes( seqRead , 10 );
 623         ERROR_ASSERT( 20 == seqRead.getArray()[0] , "Inbetween mark failed!\n" );
 624
 625         rMarkable->deleteMark( nInBetweenMark );
 626     }
 627
 628     rMarkable->jumpToFurthest();
 629     ERROR_ASSERT( 256-10-50 == rInput->available() , "marking error" );
 630
 631
 632     ERROR_ASSERT( 100 == rInput->readSomeBytes( seqRead , 100   ) , "wrong results using readSomeBytes" );
 633     ERROR_ASSERT( 96 == rInput->readSomeBytes( seqRead , 1000) , "wrong results using readSomeBytes" );
 634     rOutput->closeOutput();
 635     rInput->closeInput();
 636 }
 637
 638 /***
 639 * the test methods
 640 *
 641 ****/
 642
 643
 644
 645
 646
 647 /**
 648 * for external binding
 649 *
 650 *
 651 **/
 652 Reference < XInterface > SAL_CALL OMarkableInputStreamTest_CreateInstance( const Reference< XMultiServiceFactory > & rSMgr ) throw(Exception)
 653 {
 654     OMarkableInputStreamTest *p = new OMarkableInputStreamTest( rSMgr );
 655     return Reference < XInterface > ( (static_cast< OWeakObject *  >(p)) );
 656 }
 657
 658
 659
 660 Sequence<OUString> OMarkableInputStreamTest_getSupportedServiceNames(void) throw ()
 661 {
 662     Sequence<OUString> aRet(1);
 663     aRet.getArray()[0] = OMarkableInputStreamTest_getImplementationName();
 664
 665     return aRet;
 666 }
 667
 668 OUString     OMarkableInputStreamTest_getServiceName() throw ()
 669 {
 670     return OUString( "test.com.sun.star.io.MarkableInputStream");
 671 }
 672
 673 OUString    OMarkableInputStreamTest_getImplementationName() throw ()
 674 {
 675     return OUString( "test.com.sun.star.extensions.stm.MarkableInputStream" );
 676 }
 677
 678 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */