io/test/stm/pipetest.cxx

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