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