io/test/stm/pipetest.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: pipetest.cxx,v $
  10  * $Revision: 1.8 $
  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_io.hxx"
  33
  34 #include <com/sun/star/test/XSimpleTest.hpp>
  35 #include <com/sun/star/io/XInputStream.hpp>
  36 #include <com/sun/star/io/XOutputStream.hpp>
  37 #include <com/sun/star/io/XConnectable.hpp>
  38 #include <com/sun/star/lang/IllegalArgumentException.hpp>
  39
  40 #include <com/sun/star/lang/XServiceInfo.hpp>
  41
  42 #include <cppuhelper/factory.hxx>
  43
  44 #include <cppuhelper/implbase1.hxx>      // OWeakObject
  45
  46 #include <osl/conditn.hxx>
  47 #include <osl/mutex.hxx>
  48 #include <osl/thread.hxx>
  49
  50 #include <string.h>
  51
  52 using namespace ::rtl;
  53 using namespace ::osl;
  54 using namespace ::cppu;
  55 using namespace ::com::sun::star::uno;
  56 using namespace ::com::sun::star::io;
  57 using namespace ::com::sun::star::lang;
  58 using namespace ::com::sun::star::test;
  59 // streams
  60
  61 #include "testfactreg.hxx"
  62 #define IMPLEMENTATION_NAME     "test.com.sun.star.comp.extensions.stm.Pipe"
  63 #define SERVICE_NAME            "test.com.sun.star.io.Pipe"
  64
  65
  66 class WriteToStreamThread :
  67         public Thread
  68 {
  69
  70 public:
  71
  72     WriteToStreamThread( Reference< XOutputStream >  xOutput , int iMax )
  73     {
  74         m_output = xOutput;
  75         m_iMax = iMax;
  76     }
  77
  78     virtual ~WriteToStreamThread() {}
  79
  80
  81 protected:
  82
  83     /// Working method which should be overridden.
  84     virtual void SAL_CALL run() {
  85         for( int i = 0 ; i < m_iMax ; i ++ ) {
  86             m_output->writeBytes( createIntSeq(i) );
  87         }
  88         m_output->closeOutput();
  89     }
  90
  91     /** Called when run() is done.
  92     * You might want to override it to do some cleanup.
  93     */
  94     virtual void SAL_CALL onTerminated()
  95     {
  96         delete this;
  97     }
  98
  99
 100 private:
 101
 102     Reference < XOutputStream >  m_output;
 103     int m_iMax;
 104 };
 105
 106
 107
 108 class OPipeTest : public WeakImplHelper1 < XSimpleTest >
 109 {
 110 public:
 111     OPipeTest( const Reference< XMultiServiceFactory >  & rFactory );
 112     ~OPipeTest();
 113
 114 public: // implementation names
 115     static Sequence< OUString >         getSupportedServiceNames_Static(void) throw();
 116     static OUString                             getImplementationName_Static() throw();
 117
 118 public:
 119     virtual void SAL_CALL testInvariant(const OUString& TestName, const Reference < XInterface >& TestObject)
 120         throw  ( IllegalArgumentException, RuntimeException) ;
 121
 122     virtual sal_Int32 SAL_CALL test(    const OUString& TestName,
 123                                         const Reference < XInterface >& TestObject,
 124                                         sal_Int32 hTestHandle)
 125         throw  (        IllegalArgumentException,
 126                     RuntimeException);
 127
 128     virtual sal_Bool SAL_CALL testPassed(void)                                                          throw  (        RuntimeException) ;
 129     virtual Sequence< OUString > SAL_CALL getErrors(void)                               throw  (RuntimeException) ;
 130     virtual Sequence< Any > SAL_CALL getErrorExceptions(void)           throw  (RuntimeException);
 131     virtual Sequence< OUString > SAL_CALL getWarnings(void)                             throw  (RuntimeException);
 132
 133 private:
 134     void testSimple( const Reference < XInterface > & );
 135     void testBufferResizing( const Reference < XInterface >  & );
 136     void testMultithreading( const Reference < XInterface > & );
 137
 138 private:
 139     Sequence<Any>  m_seqExceptions;
 140     Sequence<OUString> m_seqErrors;
 141     Sequence<OUString> m_seqWarnings;
 142
 143 };
 144
 145
 146
 147 OPipeTest::OPipeTest( const Reference< XMultiServiceFactory > &rFactory )
 148 {
 149
 150 }
 151
 152 OPipeTest::~OPipeTest()
 153 {
 154
 155 }
 156
 157
 158
 159 void OPipeTest::testInvariant( const OUString& TestName, const Reference < XInterface >& TestObject )
 160     throw  (    IllegalArgumentException,
 161                 RuntimeException)
 162 {
 163     Reference< XServiceInfo > info( TestObject, UNO_QUERY );
 164     ERROR_ASSERT( info.is() , "XServiceInfo not supported !" );
 165     if( info.is() )
 166     {
 167         ERROR_ASSERT( info->supportsService( TestName ), "XServiceInfo test failed" );
 168         ERROR_ASSERT( ! info->supportsService(
 169             OUString( RTL_CONSTASCII_USTRINGPARAM("bla bluzb") ) ), "XServiceInfo test failed" );
 170     }
 171
 172 }
 173
 174
 175 sal_Int32 OPipeTest::test(
 176     const OUString& TestName,
 177     const Reference < XInterface >& TestObject,
 178     sal_Int32 hTestHandle)
 179     throw  (    IllegalArgumentException, RuntimeException)
 180 {
 181     if( OUString( RTL_CONSTASCII_USTRINGPARAM("com.sun.star.io.Pipe") ) == TestName )  {
 182         try
 183         {
 184             if( 0 == hTestHandle ) {
 185                 testInvariant( TestName , TestObject );
 186             }
 187             else if( 1 == hTestHandle ) {
 188                 testSimple( TestObject );
 189             }
 190             else if( 2 == hTestHandle ) {
 191                 testBufferResizing( TestObject );
 192             }
 193             else if( 3 == hTestHandle ) {
 194                 testMultithreading( TestObject );
 195             }
 196         }
 197         catch( Exception & e )
 198         {
 199             OString s = OUStringToOString( e.Message , RTL_TEXTENCODING_ASCII_US );
 200             BUILD_ERROR( 0 , s.getStr() );
 201         }
 202         catch( ... )
 203         {
 204             BUILD_ERROR( 0 , "unknown exception (Exception is  not base class)" );
 205         }
 206
 207         hTestHandle ++;
 208
 209         if( 4 == hTestHandle )
 210         {
 211             // all tests finished.
 212             hTestHandle = -1;
 213         }
 214     }
 215     else {
 216         throw IllegalArgumentException();
 217     }
 218     return hTestHandle;
 219 }
 220
 221
 222
 223 sal_Bool OPipeTest::testPassed(void)            throw  (RuntimeException)
 224 {
 225     return m_seqErrors.getLength() == 0;
 226 }
 227
 228
 229 Sequence< OUString > OPipeTest::getErrors(void)         throw  (RuntimeException)
 230 {
 231     return m_seqErrors;
 232 }
 233
 234
 235 Sequence< Any > OPipeTest::getErrorExceptions(void)                                     throw  (RuntimeException)
 236 {
 237     return m_seqExceptions;
 238 }
 239
 240
 241 Sequence< OUString > OPipeTest::getWarnings(void)                                               throw  (RuntimeException)
 242 {
 243     return m_seqWarnings;
 244 }
 245
 246
 247 /***
 248 * the test methods
 249 *
 250 ****/
 251
 252
 253 void OPipeTest::testSimple( const Reference < XInterface > &r )
 254 {
 255
 256     Reference< XInputStream > input( r , UNO_QUERY );
 257     Reference < XOutputStream > output( r , UNO_QUERY );
 258
 259     ERROR_ASSERT( input.is()  , "queryInterface on XInputStream failed" );
 260     ERROR_ASSERT( output.is() , "queryInterface onXOutputStream failed" );
 261
 262     // basic read/write
 263     Sequence<sal_Int8> seqWrite = createSeq( "Hallo, du Ei !" );
 264
 265     Sequence<sal_Int8> seqRead;
 266     for( int i = 0 ; i < 5000 ; i ++ ) {
 267         output->writeBytes( seqWrite );
 268         input->readBytes( seqRead , input->available() );
 269
 270         ERROR_ASSERT( ! strcmp( (char *) seqWrite.getArray() , (char * )seqRead.getArray() ) ,
 271                       "error during read/write/skip" );
 272         ERROR_ASSERT( 0 == input->available() ,
 273                       "error during read/write/skip" );
 274
 275         // available shouldn't return a negative value
 276         input->skipBytes( seqWrite.getLength() - 5 );
 277         ERROR_ASSERT( 0 == input->available() , "wrong available after skip" );
 278
 279         // 5 bytes should be available
 280         output->writeBytes( seqWrite );
 281         ERROR_ASSERT( 5 == input->available() , "wrong available after skip/write " );
 282
 283         input->readBytes( seqRead , 5 );
 284         ERROR_ASSERT(   ! strcmp(       (char*) seqRead.getArray() ,
 285                             (char*) &( seqWrite.getArray()[seqWrite.getLength()-5] ) ),
 286                         "write/read mismatich" );
 287
 288     }
 289
 290     output->writeBytes( seqWrite );
 291     ERROR_ASSERT( seqWrite.getLength() == input->available(), "wrong available() after write" );
 292
 293     ERROR_ASSERT( 10 == input->readSomeBytes( seqRead , 10 ) , "maximal number of bytes ignored" );
 294     ERROR_ASSERT( seqWrite.getLength() -10 == input->readSomeBytes( seqRead , 100 ) ,
 295                                                             "something wrong with readSomeBytes" );
 296
 297
 298     output->closeOutput();
 299     try{
 300         output->writeBytes( Sequence<sal_Int8> (100) );
 301         ERROR_ASSERT( 0 , "writing on a closed stream does not cause an exception" );
 302     }
 303     catch (IOException & )
 304     {
 305     }
 306
 307     ERROR_ASSERT(! input->readBytes( seqRead , 1 ), "eof not found !" );
 308
 309     input->closeInput();
 310     try
 311     {
 312         input->readBytes( seqRead , 1 );
 313         ERROR_ASSERT( 0 , "reading from a closed stream does not cause an exception" );
 314     }
 315     catch( IOException & ) {
 316     }
 317
 318     try
 319     {
 320         input->available( );
 321         ERROR_ASSERT( 0 , "calling available from a closed stream should thrown an io exception" );
 322     }
 323     catch( IOException & )
 324     {
 325
 326     }
 327     try
 328     {
 329         input->skipBytes(42 );
 330         ERROR_ASSERT( 0 , "calling available from a closed stream should thrown an io exception" );
 331     }
 332     catch( IOException & )
 333     {
 334
 335     }
 336 }
 337
 338 void OPipeTest::testBufferResizing( const Reference < XInterface > &r )
 339 {
 340     int i;
 341     int iMax = 20000;
 342     Reference< XInputStream > input( r , UNO_QUERY );
 343     Reference < XOutputStream > output( r , UNO_QUERY );
 344
 345     ERROR_ASSERT( input.is()  , "queryInterface on XInputStream failed" );
 346     ERROR_ASSERT( output.is() , "queryInterface on XOutputStream failed" );
 347
 348     Sequence<sal_Int8> seqRead;
 349
 350     // this is just to better check the
 351     // internal buffers
 352     output->writeBytes( Sequence<sal_Int8>(100) );
 353     Sequence< sal_Int8 > dummy;
 354     input->readBytes( dummy , 100);
 355
 356     for( i = 0 ; i < iMax ; i ++ ) {
 357         output->writeBytes( createIntSeq( i ) );
 358     }
 359
 360     for( i = 0 ; i < iMax ; i ++ ) {
 361         input->readBytes( seqRead, createIntSeq(i).getLength() );
 362         ERROR_ASSERT( ! strcmp(         (char*) seqRead.getArray() ,
 363                                     (char*) createIntSeq(i).getArray() ) ,
 364                         "written/read mismatch\n" );
 365     }
 366
 367     output->closeOutput();
 368     ERROR_ASSERT( ! input->readBytes( seqRead , 1 ) , "eof not reached !" );
 369     input->closeInput();
 370 }
 371
 372
 373
 374 void OPipeTest::testMultithreading( const Reference < XInterface > &r )
 375 {
 376
 377     int i;
 378     int iMax = 30000;
 379
 380     Reference< XInputStream > input( r , UNO_QUERY );
 381     Reference < XOutputStream > output( r , UNO_QUERY );
 382
 383     ERROR_ASSERT( input.is()  , "queryInterface on XInputStream failed"  );
 384     ERROR_ASSERT( output.is() , "queryInterface on XOutputStream failed" );
 385
 386     Sequence<sal_Int8> seqRead;
 387
 388     // deletes itself
 389     Thread *p = new WriteToStreamThread( output,  iMax );
 390
 391     ERROR_ASSERT( p , "couldn't create thread for testing !\n" );
 392
 393     p->create();
 394
 395     for(  i = 0 ; sal_True ; i ++ ) {
 396         if( 0 == input->readBytes( seqRead, createIntSeq(i).getLength() ) ) {
 397             // eof reached !
 398             break;
 399         }
 400
 401         ERROR_ASSERT( ! strcmp(         (char*) seqRead.getArray() ,
 402                                     (char*) createIntSeq(i).getArray() ) ,
 403                         "written/read mismatch\n" );
 404     }
 405
 406     ERROR_ASSERT( i == iMax , "less elements read than written !");
 407     input->closeInput();
 408 }
 409
 410
 411
 412 /**
 413 * for external binding
 414 *
 415 *
 416 **/
 417 Reference < XInterface > SAL_CALL OPipeTest_CreateInstance( const Reference< XMultiServiceFactory>  & rSMgr ) throw (Exception)
 418 {
 419     OPipeTest *p = new OPipeTest( rSMgr );
 420     Reference< XInterface > x ( SAL_STATIC_CAST( OWeakObject * , p ) );
 421     return x;
 422 }
 423
 424
 425
 426 Sequence<OUString> OPipeTest_getSupportedServiceNames(void) throw()
 427 {
 428       Sequence<OUString> aRet(1);
 429     aRet.getArray()[0] = OPipeTest_getServiceName();
 430
 431       return aRet;
 432 }
 433
 434 OUString     OPipeTest_getServiceName() throw()
 435 {
 436     return OUString( RTL_CONSTASCII_USTRINGPARAM( SERVICE_NAME ) );
 437 }
 438
 439 OUString        OPipeTest_getImplementationName() throw()
 440 {
 441     return OUString( RTL_CONSTASCII_USTRINGPARAM( IMPLEMENTATION_NAME ) );
 442 }