sal/qa/osl/condition/osl_Condition.cxx

   1  /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2000, 2010 Oracle and/or its affiliates.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * This file is part of OpenOffice.org.
  10  *
  11  * OpenOffice.org is free software: you can redistribute it and/or modify
  12  * it under the terms of the GNU Lesser General Public License version 3
  13  * only, as published by the Free Software Foundation.
  14  *
  15  * OpenOffice.org is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU Lesser General Public License version 3 for more details
  19  * (a copy is included in the LICENSE file that accompanied this code).
  20  *
  21  * You should have received a copy of the GNU Lesser General Public License
  22  * version 3 along with OpenOffice.org.  If not, see
  23  * <http://www.openoffice.org/license.html>
  24  * for a copy of the LGPLv3 License.
  25  *
  26  ************************************************************************/
  27
  28 // MARKER(update_precomp.py): autogen include statement, do not remove
  29 #include "precompiled_sal.hxx"
  30
  31 //------------------------------------------------------------------------
  32 // include files
  33 //------------------------------------------------------------------------
  34 #include <osl_Condition_Const.h>
  35
  36 using namespace osl;
  37 using namespace rtl;
  38
  39
  40 //------------------------------------------------------------------------
  41 // helper functions and classes
  42 //------------------------------------------------------------------------
  43
  44 /** print Boolean value.
  45 */
  46 inline void printBool( sal_Bool bOk )
  47 {
  48     t_print("#printBool# " );
  49     ( sal_True == bOk ) ? t_print("TRUE!\n" ): t_print("FALSE!\n" );
  50 }
  51
  52 /** print a UNI_CODE String.
  53 */
  54 inline void printUString( const ::rtl::OUString & str )
  55 {
  56     rtl::OString aString;
  57
  58     t_print("#printUString_u# " );
  59     aString = ::rtl::OUStringToOString( str, RTL_TEXTENCODING_ASCII_US );
  60     t_print("%s\n", aString.getStr( ) );
  61 }
  62
  63 /** wait _nSec seconds.
  64 */
  65 void thread_sleep( sal_Int32 _nSec )
  66 {
  67     /// print statement in thread process must use fflush() to force display.
  68     t_print("# wait %d seconds. ", _nSec );
  69     fflush( stdout );
  70
  71 #ifdef WNT                               //Windows
  72     Sleep( _nSec * 1000 );
  73 #endif
  74 #if ( defined UNX ) || ( defined OS2 )   //Unix
  75     sleep( _nSec );
  76 #endif
  77     t_print("# done\n" );
  78 }
  79
  80 enum ConditionType
  81 {
  82     thread_type_set,
  83     thread_type_reset,
  84     thread_type_wait,
  85     thread_type_check
  86 };
  87
  88 /** thread for testing Condition.
  89  */
  90 class ConditionThread : public Thread
  91 {
  92 public:
  93     //get the Condition to operate
  94     ConditionThread( ::osl::Condition& Con, ConditionType tType): m_MyCon( Con ), m_MyType( tType ) { }
  95
  96     ~ConditionThread( )
  97     {
  98         // LLA: do not throw in DTors!
  99         // LLA: CPPUNIT_ASSERT_MESSAGE( "#ConditionThread does not shutdown properly.\n", sal_False == this -> isRunning( ) );
 100     }
 101 protected:
 102     ::osl::Condition& m_MyCon;
 103     ConditionType m_MyType;
 104
 105     void SAL_CALL run()
 106     {
 107         switch ( m_MyType )
 108         {
 109             case thread_type_wait:
 110                 m_MyCon.wait(); break;
 111             case thread_type_set:
 112                 m_MyCon.set(); break;
 113             case thread_type_reset:
 114                 m_MyCon.reset(); break;
 115             default:
 116                 break;
 117         }
 118     }
 119 };
 120
 121
 122 //------------------------------------------------------------------------
 123 // test code start here
 124 //------------------------------------------------------------------------
 125
 126 namespace osl_Condition
 127 {
 128
 129     /** testing the method:
 130         Condition()
 131     */
 132     class ctors : public CppUnit::TestFixture
 133     {
 134     public:
 135         sal_Bool bRes, bRes1;
 136
 137         void ctors_001( )
 138         {
 139             ::osl::Condition aCond;
 140             bRes = aCond.check( );
 141
 142             CPPUNIT_ASSERT_MESSAGE( "#test comment#: create a condition its initial check state should be sal_False.",
 143                                     sal_False == bRes );
 144         }
 145
 146         void ctors_002( )
 147         {
 148             ::osl::Condition aCond;
 149             aCond.set( );
 150             bRes = aCond.check( );
 151
 152             CPPUNIT_ASSERT_MESSAGE( "#test comment#: create a condition and set it.",
 153                                     sal_True == bRes );
 154         }
 155
 156         CPPUNIT_TEST_SUITE( ctors );
 157         CPPUNIT_TEST( ctors_001 );
 158         CPPUNIT_TEST( ctors_002 );
 159         CPPUNIT_TEST_SUITE_END( );
 160     }; // class ctors
 161
 162
 163     /** testing the method:
 164         void set()
 165     */
 166     class set : public CppUnit::TestFixture
 167     {
 168     public:
 169         sal_Bool bRes, bRes1, bRes2;
 170
 171         void set_001( )
 172         {
 173             ::osl::Condition aCond;
 174             aCond.set( );
 175             bRes = aCond.check( );
 176
 177             CPPUNIT_ASSERT_MESSAGE( "#test comment#: check state should be sal_True after set.",
 178                                     sal_True == bRes );
 179         }
 180
 181         void set_002( )
 182         {
 183             ::osl::Condition aCond;
 184             ConditionThread myThread1( aCond, thread_type_wait );
 185             myThread1.create();
 186             bRes = myThread1.isRunning( );
 187
 188             ConditionThread myThread2( aCond, thread_type_set );
 189             myThread2.create();
 190             thread_sleep(1);
 191             bRes1 = myThread1.isRunning( );
 192             bRes2 = aCond.check( );
 193
 194             myThread1.join( );
 195             myThread2.join( );
 196
 197             CPPUNIT_ASSERT_MESSAGE( "#test comment#: use one thread to set the condition in order to release another thread.",
 198                                     sal_True == bRes && sal_False == bRes1 && sal_True == bRes2 );
 199         }
 200
 201
 202         CPPUNIT_TEST_SUITE( set );
 203         CPPUNIT_TEST( set_001 );
 204         CPPUNIT_TEST( set_002 );
 205         CPPUNIT_TEST_SUITE_END( );
 206     }; // class set
 207
 208
 209     /** testing the method:
 210         void reset()
 211     */
 212     class reset : public CppUnit::TestFixture
 213     {
 214     public:
 215         sal_Bool bRes, bRes1, bRes2;
 216
 217         void reset_001( )
 218         {
 219             ::osl::Condition aCond;
 220             aCond.reset( );
 221
 222             ConditionThread myThread( aCond, thread_type_wait );
 223             myThread.create();
 224             bRes = myThread.isRunning( );
 225             bRes2 = aCond.check( );
 226
 227             aCond.set( );
 228             myThread.join( );
 229             bRes1 = myThread.isRunning( );
 230
 231             CPPUNIT_ASSERT_MESSAGE( "#test comment#: wait will cause a reset thread block, use set to release it.",
 232                                     sal_True == bRes && sal_False == bRes1 && sal_False == bRes2 );
 233         }
 234
 235         void reset_002( )
 236         {
 237             ::osl::Condition aCond;
 238             aCond.reset( );
 239             bRes = aCond.check( );
 240             aCond.set( );
 241             bRes1 = aCond.check( );
 242
 243             CPPUNIT_ASSERT_MESSAGE( "#test comment#: create a condition and reset/set it.",
 244                                     ( sal_False == bRes && sal_True == bRes1 ) );
 245         }
 246
 247         CPPUNIT_TEST_SUITE( reset );
 248         CPPUNIT_TEST( reset_001 );
 249         CPPUNIT_TEST( reset_002 );
 250         CPPUNIT_TEST_SUITE_END( );
 251     }; // class reset
 252
 253
 254     /** testing the method:
 255         Result wait(const TimeValue *pTimeout = 0)
 256     */
 257     class wait : public CppUnit::TestFixture
 258     {
 259     public:
 260         sal_Bool bRes, bRes1, bRes2;
 261         TimeValue *tv1;
 262
 263         void setUp( )
 264         {
 265             tv1 = (TimeValue*)malloc(sizeof(TimeValue));
 266             tv1->Seconds = 1;
 267
 268         }
 269
 270         void tearDown( )
 271         {
 272             free( tv1 );
 273         }
 274
 275
 276         void wait_001( )
 277         {
 278             ::osl::Condition cond1;
 279             ::osl::Condition cond2;
 280             ::osl::Condition cond3;
 281
 282             cond1.set();
 283             cond2.set();
 284
 285 osl::Condition::Result r1=cond1.wait(tv1);
 286 osl::Condition::Result r2=cond2.wait();
 287 osl::Condition::Result r3=cond3.wait(tv1);
 288 fprintf(stderr,"%d %d %d\n",r1,r2,r3);
 289             CPPUNIT_ASSERT_MESSAGE( "#test comment#: test three types of wait.",
 290                                     (cond1.wait(tv1) == ::osl::Condition::result_ok) &&
 291                                     (cond2.wait() == ::osl::Condition::result_ok) &&
 292                                     (cond3.wait(tv1) == ::osl::Condition::result_timeout) );
 293
 294         }
 295
 296         void wait_002( )
 297         {
 298             ::osl::Condition aCond;
 299             ::osl::Condition::Result wRes, wRes1;
 300
 301             aCond.reset( );
 302             bRes = aCond.check( );
 303             wRes = aCond.wait( tv1 );
 304
 305             aCond.set( );
 306             wRes1 = aCond.wait( tv1 );
 307             bRes1 = aCond.check( );
 308
 309             CPPUNIT_ASSERT_MESSAGE( "#test comment#: wait a condition after set/reset.",
 310                                     ( sal_False == bRes ) && ( sal_True == bRes1 ) &&
 311                                     ( ::osl::Condition::result_timeout == wRes ) &&
 312                                     ( ::osl::Condition::result_ok == wRes1 ) );
 313         }
 314
 315         CPPUNIT_TEST_SUITE( wait );
 316         CPPUNIT_TEST( wait_001 );
 317         CPPUNIT_TEST( wait_002 );
 318         CPPUNIT_TEST_SUITE_END( );
 319     }; // class wait
 320
 321
 322     /** testing the method:
 323         sal_Bool check()
 324     */
 325     class check : public CppUnit::TestFixture
 326     {
 327     public:
 328         sal_Bool bRes, bRes1, bRes2;
 329
 330         void check_001( )
 331         {
 332             ::osl::Condition aCond;
 333
 334             aCond.reset( );
 335             bRes = aCond.check( );
 336             aCond.set( );
 337             bRes1 = aCond.check( );
 338
 339             CPPUNIT_ASSERT_MESSAGE( "#test comment#: check the condition states.",
 340                                     ( sal_False == bRes && sal_True == bRes1 ) );
 341         }
 342
 343         void check_002( )
 344         {
 345             ::osl::Condition aCond;
 346             aCond.reset( );
 347
 348             ConditionThread myThread( aCond, thread_type_set );
 349             myThread.create( );
 350             myThread.join( );
 351             bRes = aCond.check( );
 352
 353             ConditionThread myThread1( aCond, thread_type_reset );
 354             myThread1.create( );
 355             myThread1.join( );
 356             bRes1 = aCond.check( );
 357
 358             CPPUNIT_ASSERT_MESSAGE( "#test comment#: use threads to set/reset Condition and check it in main routine.",
 359                                     ( sal_True == bRes && sal_False == bRes1 ) );
 360         }
 361
 362         CPPUNIT_TEST_SUITE( check );
 363         CPPUNIT_TEST( check_001 );
 364         CPPUNIT_TEST( check_002 );
 365         CPPUNIT_TEST_SUITE_END( );
 366     }; // class check
 367
 368
 369 // -----------------------------------------------------------------------------
 370 CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(osl_Condition::ctors, "osl_Condition");
 371 CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(osl_Condition::set, "osl_Condition");
 372 CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(osl_Condition::reset, "osl_Condition");
 373 CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(osl_Condition::wait, "osl_Condition");
 374 CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(osl_Condition::check, "osl_Condition");
 375 // -----------------------------------------------------------------------------
 376
 377 } // namespace osl_Condition
 378
 379
 380 // -----------------------------------------------------------------------------
 381
 382 // this macro creates an empty function, which will called by the RegisterAllFunctions()
 383 // to let the user the possibility to also register some functions by hand.
 384 NOADDITIONAL;