187d2adbcSAndrew Rist /**************************************************************
2cdf0e10cSrcweir *
387d2adbcSAndrew Rist * Licensed to the Apache Software Foundation (ASF) under one
487d2adbcSAndrew Rist * or more contributor license agreements. See the NOTICE file
587d2adbcSAndrew Rist * distributed with this work for additional information
687d2adbcSAndrew Rist * regarding copyright ownership. The ASF licenses this file
787d2adbcSAndrew Rist * to you under the Apache License, Version 2.0 (the
887d2adbcSAndrew Rist * "License"); you may not use this file except in compliance
987d2adbcSAndrew Rist * with the License. You may obtain a copy of the License at
1087d2adbcSAndrew Rist *
1187d2adbcSAndrew Rist * http://www.apache.org/licenses/LICENSE-2.0
1287d2adbcSAndrew Rist *
1387d2adbcSAndrew Rist * Unless required by applicable law or agreed to in writing,
1487d2adbcSAndrew Rist * software distributed under the License is distributed on an
1587d2adbcSAndrew Rist * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
1687d2adbcSAndrew Rist * KIND, either express or implied. See the License for the
1787d2adbcSAndrew Rist * specific language governing permissions and limitations
1887d2adbcSAndrew Rist * under the License.
1987d2adbcSAndrew Rist *
2087d2adbcSAndrew Rist *************************************************************/
2187d2adbcSAndrew Rist
2287d2adbcSAndrew Rist
23cdf0e10cSrcweir
24cdf0e10cSrcweir // MARKER(update_precomp.py): autogen include statement, do not remove
25cdf0e10cSrcweir #include "precompiled_sal.hxx"
26cdf0e10cSrcweir
27cdf0e10cSrcweir //------------------------------------------------------------------------
28cdf0e10cSrcweir // include files
29cdf0e10cSrcweir //------------------------------------------------------------------------
308748f2e1SDamjan Jovanovic #include "gtest/gtest.h"
31cdf0e10cSrcweir #include <osl_Mutex_Const.h>
32cdf0e10cSrcweir
33a03c9fa9SDamjan Jovanovic #ifdef WNT
34a03c9fa9SDamjan Jovanovic #define WIN32_LEAN_AND_MEAN
35a03c9fa9SDamjan Jovanovic #include <windows.h>
36a03c9fa9SDamjan Jovanovic #endif
37a03c9fa9SDamjan Jovanovic
38cdf0e10cSrcweir using namespace osl;
39cdf0e10cSrcweir using namespace rtl;
40cdf0e10cSrcweir
41cdf0e10cSrcweir //------------------------------------------------------------------------
42cdf0e10cSrcweir // helper functions
43cdf0e10cSrcweir //------------------------------------------------------------------------
44cdf0e10cSrcweir
45cdf0e10cSrcweir /** print a UNI_CODE String.
46cdf0e10cSrcweir */
printUString(const::rtl::OUString & str)47cdf0e10cSrcweir inline void printUString( const ::rtl::OUString & str )
48cdf0e10cSrcweir {
49cdf0e10cSrcweir rtl::OString aString;
50cdf0e10cSrcweir
51cdf0e10cSrcweir printf("#printUString_u# " );
52cdf0e10cSrcweir aString = ::rtl::OUStringToOString( str, RTL_TEXTENCODING_ASCII_US );
53cdf0e10cSrcweir printf("%s\n", aString.getStr( ) );
54cdf0e10cSrcweir }
55cdf0e10cSrcweir
56cdf0e10cSrcweir /** print Boolean value.
57cdf0e10cSrcweir */
printBool(sal_Bool bOk)58cdf0e10cSrcweir inline void printBool( sal_Bool bOk )
59cdf0e10cSrcweir {
60cdf0e10cSrcweir printf("#printBool# " );
61cdf0e10cSrcweir ( sal_True == bOk ) ? printf("YES!\n" ): printf("NO!\n" );
62cdf0e10cSrcweir }
63cdf0e10cSrcweir
64cdf0e10cSrcweir /** pause nSec seconds helper function.
65cdf0e10cSrcweir */
66cdf0e10cSrcweir namespace ThreadHelper
67cdf0e10cSrcweir {
thread_sleep(sal_Int32 _nSec)68cdf0e10cSrcweir void thread_sleep( sal_Int32 _nSec )
69cdf0e10cSrcweir {
70cdf0e10cSrcweir /// print statement in thread process must use fflush() to force display.
71cdf0e10cSrcweir // t_print("# wait %d seconds. ", _nSec );
72cdf0e10cSrcweir fflush(stdout);
73cdf0e10cSrcweir
74cdf0e10cSrcweir #ifdef WNT //Windows
75cdf0e10cSrcweir Sleep( _nSec * 1000 );
76cdf0e10cSrcweir #endif
77cdf0e10cSrcweir #if ( defined UNX ) || ( defined OS2 ) //Unix
78cdf0e10cSrcweir sleep( _nSec );
79cdf0e10cSrcweir #endif
80cdf0e10cSrcweir // printf("# done\n" );
81cdf0e10cSrcweir }
thread_sleep_tenth_sec(sal_Int32 _nTenthSec)82cdf0e10cSrcweir void thread_sleep_tenth_sec(sal_Int32 _nTenthSec)
83cdf0e10cSrcweir {
84cdf0e10cSrcweir #ifdef WNT //Windows
85cdf0e10cSrcweir Sleep(_nTenthSec * 100 );
86cdf0e10cSrcweir #endif
87cdf0e10cSrcweir #if ( defined UNX ) || ( defined OS2 ) //Unix
88cdf0e10cSrcweir TimeValue nTV;
89cdf0e10cSrcweir nTV.Seconds = static_cast<sal_uInt32>( _nTenthSec/10 );
90cdf0e10cSrcweir nTV.Nanosec = ( (_nTenthSec%10 ) * 100000000 );
91cdf0e10cSrcweir osl_waitThread(&nTV);
92cdf0e10cSrcweir #endif
93cdf0e10cSrcweir }
94cdf0e10cSrcweir }
95cdf0e10cSrcweir
96cdf0e10cSrcweir
97cdf0e10cSrcweir //------------------------------------------------------------------------
98cdf0e10cSrcweir // Beginning of the test cases for osl_Mutex class
99cdf0e10cSrcweir //------------------------------------------------------------------------
100cdf0e10cSrcweir
101cdf0e10cSrcweir
102cdf0e10cSrcweir /** mutually exclusive data
103cdf0e10cSrcweir */
104cdf0e10cSrcweir struct resource {
105cdf0e10cSrcweir sal_Int32 data1;
106cdf0e10cSrcweir sal_Int32 data2;
107cdf0e10cSrcweir Mutex lock;
108cdf0e10cSrcweir };
109cdf0e10cSrcweir
110cdf0e10cSrcweir /** IncreaseThread provide data.
111cdf0e10cSrcweir */
112cdf0e10cSrcweir class IncreaseThread : public Thread
113cdf0e10cSrcweir {
114cdf0e10cSrcweir public:
IncreaseThread(struct resource * pData)115cdf0e10cSrcweir IncreaseThread( struct resource *pData ): pResource( pData ) { }
116cdf0e10cSrcweir
~IncreaseThread()117cdf0e10cSrcweir ~IncreaseThread( )
118cdf0e10cSrcweir {
119a03c9fa9SDamjan Jovanovic EXPECT_TRUE(sal_False == this -> isRunning( )) << "#IncreaseThread does not shutdown properly.\n";
120cdf0e10cSrcweir }
121cdf0e10cSrcweir protected:
122cdf0e10cSrcweir struct resource *pResource;
123cdf0e10cSrcweir
run()124cdf0e10cSrcweir void SAL_CALL run( )
125cdf0e10cSrcweir {
126cdf0e10cSrcweir pResource->lock.acquire( );
127cdf0e10cSrcweir for( sal_Int8 i = 0; i < 3; i++ )
128cdf0e10cSrcweir {
129cdf0e10cSrcweir pResource->data1++;
130cdf0e10cSrcweir yield( ); //yield() give CPU time to other thread, other thread if not block, they will change the data;
131cdf0e10cSrcweir }
132cdf0e10cSrcweir if ( pResource->data2 == 0 )
133cdf0e10cSrcweir pResource->data2 = ( pResource->data1 > 0 ? pResource->data1 : 0 - pResource->data1 );
134cdf0e10cSrcweir pResource->lock.release();
135cdf0e10cSrcweir }
136cdf0e10cSrcweir };
137cdf0e10cSrcweir
138cdf0e10cSrcweir /** DecreaseThread consume data.
139cdf0e10cSrcweir */
140cdf0e10cSrcweir class DecreaseThread : public Thread
141cdf0e10cSrcweir {
142cdf0e10cSrcweir public:
DecreaseThread(struct resource * pData)143cdf0e10cSrcweir DecreaseThread( struct resource *pData ): pResource( pData ) { }
144cdf0e10cSrcweir
~DecreaseThread()145cdf0e10cSrcweir ~DecreaseThread( )
146cdf0e10cSrcweir {
147a03c9fa9SDamjan Jovanovic EXPECT_TRUE(sal_False == this -> isRunning( )) << "#DecreaseThread does not shutdown properly.\n";
148cdf0e10cSrcweir }
149cdf0e10cSrcweir protected:
150cdf0e10cSrcweir struct resource *pResource;
151cdf0e10cSrcweir
run()152cdf0e10cSrcweir void SAL_CALL run( )
153cdf0e10cSrcweir {
154cdf0e10cSrcweir pResource->lock.acquire( );
155cdf0e10cSrcweir for( sal_Int8 i = 0; i < 3; i++ )
156cdf0e10cSrcweir {
157cdf0e10cSrcweir pResource->data1--;
158cdf0e10cSrcweir yield( ); //yield() give CPU time to other thread, other thread if not block, they will change the data;
159cdf0e10cSrcweir }
160cdf0e10cSrcweir if ( pResource->data2 == 0 )
161cdf0e10cSrcweir pResource->data2 = ( pResource->data1 > 0 ? pResource->data1 : 0 - pResource->data1 );
162cdf0e10cSrcweir pResource->lock.release();
163cdf0e10cSrcweir }
164cdf0e10cSrcweir };
165cdf0e10cSrcweir
166cdf0e10cSrcweir
167cdf0e10cSrcweir /** chain structure used in Threads as critical resource
168cdf0e10cSrcweir */
169cdf0e10cSrcweir struct chain {
170cdf0e10cSrcweir sal_Int32 buffer[ BUFFER_SIZE ];
171cdf0e10cSrcweir Mutex lock;
172cdf0e10cSrcweir sal_Int8 pos;
173cdf0e10cSrcweir };
174cdf0e10cSrcweir
175cdf0e10cSrcweir /** PutThread write to the chain structure in a mutex manner.
176cdf0e10cSrcweir */
177cdf0e10cSrcweir class PutThread : public Thread
178cdf0e10cSrcweir {
179cdf0e10cSrcweir public:
180cdf0e10cSrcweir //get the struct pointer to write data to buffer
PutThread(struct chain * pData)181cdf0e10cSrcweir PutThread( struct chain* pData ): pChain( pData ) { }
182cdf0e10cSrcweir
~PutThread()183cdf0e10cSrcweir ~PutThread( )
184cdf0e10cSrcweir {
185a03c9fa9SDamjan Jovanovic EXPECT_TRUE(sal_False == this -> isRunning( )) << "#PutThread does not shutdown properly.\n";
186cdf0e10cSrcweir }
187cdf0e10cSrcweir protected:
188cdf0e10cSrcweir struct chain* pChain;
189cdf0e10cSrcweir
run()190cdf0e10cSrcweir void SAL_CALL run( )
191cdf0e10cSrcweir {
192cdf0e10cSrcweir //block here if the mutex has been acquired
193cdf0e10cSrcweir pChain->lock.acquire( );
194cdf0e10cSrcweir
195cdf0e10cSrcweir //current position in buffer to write
196cdf0e10cSrcweir sal_Int8 nPos = pChain->pos;
197cdf0e10cSrcweir oslThreadIdentifier oId = getIdentifier( );
198cdf0e10cSrcweir //write data
199cdf0e10cSrcweir sal_Int8 i;
200cdf0e10cSrcweir for ( i = 0; i < 5; i++ )
201cdf0e10cSrcweir {
202cdf0e10cSrcweir pChain->buffer[ nPos + i ] = oId;
203cdf0e10cSrcweir yield( );
204cdf0e10cSrcweir }
205cdf0e10cSrcweir //revise the position
206cdf0e10cSrcweir pChain->pos = nPos + i;
207cdf0e10cSrcweir
208cdf0e10cSrcweir //finish writing, release the mutex
209cdf0e10cSrcweir pChain->lock.release();
210cdf0e10cSrcweir }
211cdf0e10cSrcweir };
212cdf0e10cSrcweir
213cdf0e10cSrcweir /** thread for testing Mutex acquire.
214cdf0e10cSrcweir */
215cdf0e10cSrcweir class HoldThread : public Thread
216cdf0e10cSrcweir {
217cdf0e10cSrcweir public:
218cdf0e10cSrcweir //get the Mutex pointer to operate
HoldThread(Mutex * pMutex)219cdf0e10cSrcweir HoldThread( Mutex* pMutex ): pMyMutex( pMutex ) { }
220cdf0e10cSrcweir
~HoldThread()221cdf0e10cSrcweir ~HoldThread( )
222cdf0e10cSrcweir {
223a03c9fa9SDamjan Jovanovic EXPECT_TRUE(sal_False == this -> isRunning( )) << "#HoldThread does not shutdown properly.\n";
224cdf0e10cSrcweir }
225cdf0e10cSrcweir protected:
226cdf0e10cSrcweir Mutex* pMyMutex;
227cdf0e10cSrcweir
run()228cdf0e10cSrcweir void SAL_CALL run()
229cdf0e10cSrcweir {
230cdf0e10cSrcweir // block here if the mutex has been acquired
231cdf0e10cSrcweir pMyMutex->acquire( );
232cdf0e10cSrcweir printf("# Mutex acquired. \n" );
233cdf0e10cSrcweir pMyMutex->release( );
234cdf0e10cSrcweir }
235cdf0e10cSrcweir };
236cdf0e10cSrcweir
237cdf0e10cSrcweir class WaitThread : public Thread
238cdf0e10cSrcweir {
239cdf0e10cSrcweir public:
240cdf0e10cSrcweir //get the Mutex pointer to operate
WaitThread(Mutex * pMutex)241cdf0e10cSrcweir WaitThread( Mutex* pMutex ): pMyMutex( pMutex ) { }
242cdf0e10cSrcweir
~WaitThread()243cdf0e10cSrcweir ~WaitThread( )
244cdf0e10cSrcweir {
245a03c9fa9SDamjan Jovanovic EXPECT_TRUE(sal_False == this -> isRunning( )) << "#WaitThread does not shutdown properly.\n";
246cdf0e10cSrcweir }
247cdf0e10cSrcweir protected:
248cdf0e10cSrcweir Mutex* pMyMutex;
249cdf0e10cSrcweir
run()250cdf0e10cSrcweir void SAL_CALL run( )
251cdf0e10cSrcweir {
252cdf0e10cSrcweir // block here if the mutex has been acquired
253cdf0e10cSrcweir pMyMutex->acquire( );
254cdf0e10cSrcweir ThreadHelper::thread_sleep_tenth_sec( 2 );
255cdf0e10cSrcweir pMyMutex->release( );
256cdf0e10cSrcweir }
257cdf0e10cSrcweir };
258cdf0e10cSrcweir
259cdf0e10cSrcweir /** thread for testing getGlobalMutex.
260cdf0e10cSrcweir */
261cdf0e10cSrcweir class GlobalMutexThread : public Thread
262cdf0e10cSrcweir {
263cdf0e10cSrcweir public:
264cdf0e10cSrcweir //get the Mutex pointer to operate
GlobalMutexThread()265cdf0e10cSrcweir GlobalMutexThread( ){ }
266cdf0e10cSrcweir
~GlobalMutexThread()267cdf0e10cSrcweir ~GlobalMutexThread( )
268cdf0e10cSrcweir {
269a03c9fa9SDamjan Jovanovic EXPECT_TRUE(sal_False == this -> isRunning( )) << "#GlobalMutexThread does not shutdown properly.\n";
270cdf0e10cSrcweir }
271cdf0e10cSrcweir protected:
run()272cdf0e10cSrcweir void SAL_CALL run( )
273cdf0e10cSrcweir {
274cdf0e10cSrcweir // block here if the mutex has been acquired
275cdf0e10cSrcweir Mutex* pGlobalMutex;
276cdf0e10cSrcweir pGlobalMutex = pGlobalMutex->getGlobalMutex( );
277cdf0e10cSrcweir pGlobalMutex->acquire( );
278cdf0e10cSrcweir printf("# Global Mutex acquired. \n" );
279cdf0e10cSrcweir pGlobalMutex->release( );
280cdf0e10cSrcweir }
281cdf0e10cSrcweir };
282cdf0e10cSrcweir
283cdf0e10cSrcweir
284cdf0e10cSrcweir //--------------------------------------------------------------
285cdf0e10cSrcweir namespace osl_Mutex
286cdf0e10cSrcweir {
287cdf0e10cSrcweir
288cdf0e10cSrcweir /** Test of the osl::Mutex::constructor
289cdf0e10cSrcweir */
2908748f2e1SDamjan Jovanovic class MutexConstructor : public ::testing::Test
291cdf0e10cSrcweir {
292cdf0e10cSrcweir public:
293cdf0e10cSrcweir // initialise your test code values here.
294cdf0e10cSrcweir struct chain m_Data;
295cdf0e10cSrcweir struct resource m_Res;
296cdf0e10cSrcweir
SetUp()2978748f2e1SDamjan Jovanovic void SetUp( )
298cdf0e10cSrcweir {
299cdf0e10cSrcweir for ( sal_Int8 i=0; i < BUFFER_SIZE; i++ )
300cdf0e10cSrcweir m_Data.buffer[i] = 0;
301cdf0e10cSrcweir m_Data.pos = 0;
302cdf0e10cSrcweir
303cdf0e10cSrcweir m_Res.data1 = 0;
304cdf0e10cSrcweir m_Res.data2 = 0;
305cdf0e10cSrcweir }
306cdf0e10cSrcweir
TearDown()3078748f2e1SDamjan Jovanovic void TearDown()
308cdf0e10cSrcweir {
309cdf0e10cSrcweir }
3108748f2e1SDamjan Jovanovic }; // class ctor
3118748f2e1SDamjan Jovanovic
3128748f2e1SDamjan Jovanovic /** Create two threads to write data to the same buffer, use Mutex to assure
3138748f2e1SDamjan Jovanovic during one thread write data five times, the other thread should not begin writing.
3148748f2e1SDamjan Jovanovic the two threads wrote two different datas: their thread ID, so we can check the datas
3158748f2e1SDamjan Jovanovic in buffer to know the order of the two threads writing
3168748f2e1SDamjan Jovanovic */
TEST_F(MutexConstructor,ctor_001)3178748f2e1SDamjan Jovanovic TEST_F(MutexConstructor, ctor_001)
3188748f2e1SDamjan Jovanovic {
3198748f2e1SDamjan Jovanovic PutThread myThread1( &m_Data );
3208748f2e1SDamjan Jovanovic PutThread myThread2( &m_Data );
3218748f2e1SDamjan Jovanovic
3228748f2e1SDamjan Jovanovic myThread1.create( );
3238748f2e1SDamjan Jovanovic myThread2.create( );
3248748f2e1SDamjan Jovanovic
3258748f2e1SDamjan Jovanovic //wait until the two threads terminate
3268748f2e1SDamjan Jovanovic myThread1.join( );
3278748f2e1SDamjan Jovanovic myThread2.join( );
3288748f2e1SDamjan Jovanovic
3298748f2e1SDamjan Jovanovic sal_Bool bRes = sal_False;
3308748f2e1SDamjan Jovanovic
3318748f2e1SDamjan Jovanovic // every 5 datas should the same
3328748f2e1SDamjan Jovanovic // LLA: this is not a good check, it's too fix
3338748f2e1SDamjan Jovanovic if (m_Data.buffer[0] == m_Data.buffer[1] &&
3348748f2e1SDamjan Jovanovic m_Data.buffer[1] == m_Data.buffer[2] &&
3358748f2e1SDamjan Jovanovic m_Data.buffer[2] == m_Data.buffer[3] &&
3368748f2e1SDamjan Jovanovic m_Data.buffer[3] == m_Data.buffer[4] &&
3378748f2e1SDamjan Jovanovic m_Data.buffer[5] == m_Data.buffer[6] &&
3388748f2e1SDamjan Jovanovic m_Data.buffer[6] == m_Data.buffer[7] &&
3398748f2e1SDamjan Jovanovic m_Data.buffer[7] == m_Data.buffer[8] &&
3408748f2e1SDamjan Jovanovic m_Data.buffer[8] == m_Data.buffer[9])
3418748f2e1SDamjan Jovanovic bRes = sal_True;
3428748f2e1SDamjan Jovanovic
3438748f2e1SDamjan Jovanovic /*for (sal_Int8 i=0; i<BUFFER_SIZE; i++)
3448748f2e1SDamjan Jovanovic printf("#data in buffer is %d\n", m_Data.buffer[i]);
345cdf0e10cSrcweir */
3468748f2e1SDamjan Jovanovic
3478748f2e1SDamjan Jovanovic ASSERT_TRUE(bRes == sal_True) << "Mutex ctor";
3488748f2e1SDamjan Jovanovic
3498748f2e1SDamjan Jovanovic }
3508748f2e1SDamjan Jovanovic
3518748f2e1SDamjan Jovanovic /** Create two threads to write data to operate on the same number , use Mutex to assure,
3528748f2e1SDamjan Jovanovic one thread increase data 3 times, the other thread decrease 3 times, store the operate
3538748f2e1SDamjan Jovanovic result when the first thread complete, if it is interrupt by the other thread, the stored
3548748f2e1SDamjan Jovanovic number will not be 3.
3558748f2e1SDamjan Jovanovic */
TEST_F(MutexConstructor,ctor_002)3568748f2e1SDamjan Jovanovic TEST_F(MutexConstructor, ctor_002)
3578748f2e1SDamjan Jovanovic {
3588748f2e1SDamjan Jovanovic IncreaseThread myThread1( &m_Res );
3598748f2e1SDamjan Jovanovic DecreaseThread myThread2( &m_Res );
3608748f2e1SDamjan Jovanovic
3618748f2e1SDamjan Jovanovic myThread1.create( );
3628748f2e1SDamjan Jovanovic myThread2.create( );
3638748f2e1SDamjan Jovanovic
3648748f2e1SDamjan Jovanovic //wait until the two threads terminate
3658748f2e1SDamjan Jovanovic myThread1.join( );
3668748f2e1SDamjan Jovanovic myThread2.join( );
3678748f2e1SDamjan Jovanovic
3688748f2e1SDamjan Jovanovic sal_Bool bRes = sal_False;
369cdf0e10cSrcweir
3708748f2e1SDamjan Jovanovic // every 5 datas should the same
3718748f2e1SDamjan Jovanovic if ( ( m_Res.data1 == 0 ) && ( m_Res.data2 == 3 ) )
3728748f2e1SDamjan Jovanovic bRes = sal_True;
3738748f2e1SDamjan Jovanovic
3748748f2e1SDamjan Jovanovic ASSERT_TRUE(bRes == sal_True) << "test Mutex ctor function: increase and decrease a number 3 times without interrupt.";
3758748f2e1SDamjan Jovanovic }
376cdf0e10cSrcweir
377cdf0e10cSrcweir
378cdf0e10cSrcweir /** Test of the osl::Mutex::acquire method
379cdf0e10cSrcweir */
3808748f2e1SDamjan Jovanovic class acquire : public ::testing::Test
381cdf0e10cSrcweir {
382cdf0e10cSrcweir public:
3838748f2e1SDamjan Jovanovic }; // class acquire
384cdf0e10cSrcweir
3858748f2e1SDamjan Jovanovic // acquire mutex in main thread, and then call acquire again in myThread,
3868748f2e1SDamjan Jovanovic // the child thread should block, wait 2 secs, it still block.
3878748f2e1SDamjan Jovanovic // Then release mutex in main thread, the child thread could return from acquire,
3888748f2e1SDamjan Jovanovic // and go to exec next statement, so could terminate quickly.
TEST_F(acquire,acquire_001)3898748f2e1SDamjan Jovanovic TEST_F(acquire, acquire_001 )
3908748f2e1SDamjan Jovanovic {
3918748f2e1SDamjan Jovanovic Mutex aMutex;
3928748f2e1SDamjan Jovanovic //acquire here
3938748f2e1SDamjan Jovanovic sal_Bool bRes = aMutex.acquire( );
3948748f2e1SDamjan Jovanovic // pass the pointer of mutex to child thread
3958748f2e1SDamjan Jovanovic HoldThread myThread( &aMutex );
3968748f2e1SDamjan Jovanovic myThread.create( );
3978748f2e1SDamjan Jovanovic
3988748f2e1SDamjan Jovanovic ThreadHelper::thread_sleep_tenth_sec( 2 );
3998748f2e1SDamjan Jovanovic // if acquire in myThread does not work, 2 secs is long enough,
4008748f2e1SDamjan Jovanovic // myThread should terminate now, and bRes1 should be sal_False
4018748f2e1SDamjan Jovanovic sal_Bool bRes1 = myThread.isRunning( );
402cdf0e10cSrcweir
4038748f2e1SDamjan Jovanovic aMutex.release( );
4048748f2e1SDamjan Jovanovic ThreadHelper::thread_sleep_tenth_sec( 1 );
4058748f2e1SDamjan Jovanovic // after release mutex, myThread stops blocking and will terminate immediately
4068748f2e1SDamjan Jovanovic sal_Bool bRes2 = myThread.isRunning( );
4078748f2e1SDamjan Jovanovic myThread.join( );
4088748f2e1SDamjan Jovanovic
4098748f2e1SDamjan Jovanovic ASSERT_TRUE(bRes == sal_True && bRes1 == sal_True && bRes2 == sal_False) << "Mutex acquire";
4108748f2e1SDamjan Jovanovic }
4118748f2e1SDamjan Jovanovic
4128748f2e1SDamjan Jovanovic //in the same thread, acquire twice should success
TEST_F(acquire,acquire_002)4138748f2e1SDamjan Jovanovic TEST_F(acquire, acquire_002)
4148748f2e1SDamjan Jovanovic {
4158748f2e1SDamjan Jovanovic Mutex aMutex;
4168748f2e1SDamjan Jovanovic //acquire here
4178748f2e1SDamjan Jovanovic sal_Bool bRes = aMutex.acquire();
4188748f2e1SDamjan Jovanovic sal_Bool bRes1 = aMutex.acquire();
4198748f2e1SDamjan Jovanovic
4208748f2e1SDamjan Jovanovic sal_Bool bRes2 = aMutex.tryToAcquire();
4218748f2e1SDamjan Jovanovic
4228748f2e1SDamjan Jovanovic aMutex.release();
4238748f2e1SDamjan Jovanovic
4248748f2e1SDamjan Jovanovic ASSERT_TRUE(bRes == sal_True && bRes1 == sal_True && bRes2 == sal_True) << "Mutex acquire";
425cdf0e10cSrcweir
4268748f2e1SDamjan Jovanovic }
4278748f2e1SDamjan Jovanovic
428cdf0e10cSrcweir
429cdf0e10cSrcweir /** Test of the osl::Mutex::tryToAcquire method
430cdf0e10cSrcweir */
4318748f2e1SDamjan Jovanovic class tryToAcquire : public ::testing::Test
432cdf0e10cSrcweir {
433cdf0e10cSrcweir public:
434cdf0e10cSrcweir }; // class tryToAcquire
4358748f2e1SDamjan Jovanovic
4368748f2e1SDamjan Jovanovic // First let child thread acquire the mutex, and wait 2 secs, during the 2 secs,
4378748f2e1SDamjan Jovanovic // in main thread, tryToAcquire mutex should return False
4388748f2e1SDamjan Jovanovic // then after the child thread terminated, tryToAcquire should return True
TEST_F(tryToAcquire,tryToAcquire_001)4398748f2e1SDamjan Jovanovic TEST_F(tryToAcquire, tryToAcquire_001)
4408748f2e1SDamjan Jovanovic {
4418748f2e1SDamjan Jovanovic Mutex aMutex;
4428748f2e1SDamjan Jovanovic WaitThread myThread(&aMutex);
4438748f2e1SDamjan Jovanovic myThread.create();
4448748f2e1SDamjan Jovanovic
4458748f2e1SDamjan Jovanovic // ensure the child thread acquire the mutex
4468748f2e1SDamjan Jovanovic ThreadHelper::thread_sleep_tenth_sec(1);
4478748f2e1SDamjan Jovanovic
4488748f2e1SDamjan Jovanovic sal_Bool bRes1 = aMutex.tryToAcquire();
4498748f2e1SDamjan Jovanovic
4508748f2e1SDamjan Jovanovic if (bRes1 == sal_True)
4518748f2e1SDamjan Jovanovic aMutex.release();
4528748f2e1SDamjan Jovanovic // wait the child thread terminate
4538748f2e1SDamjan Jovanovic myThread.join();
4548748f2e1SDamjan Jovanovic
4558748f2e1SDamjan Jovanovic sal_Bool bRes2 = aMutex.tryToAcquire();
4568748f2e1SDamjan Jovanovic
4578748f2e1SDamjan Jovanovic if (bRes2 == sal_True)
4588748f2e1SDamjan Jovanovic aMutex.release();
4598748f2e1SDamjan Jovanovic
4608748f2e1SDamjan Jovanovic ASSERT_TRUE(bRes1 == sal_False && bRes2 == sal_True) << "Try to acquire Mutex";
4618748f2e1SDamjan Jovanovic }
4628748f2e1SDamjan Jovanovic
463cdf0e10cSrcweir
464cdf0e10cSrcweir /** Test of the osl::Mutex::release method
465cdf0e10cSrcweir */
4668748f2e1SDamjan Jovanovic class release : public ::testing::Test
467cdf0e10cSrcweir {
468cdf0e10cSrcweir public:
4698748f2e1SDamjan Jovanovic }; // class release
470cdf0e10cSrcweir
4718748f2e1SDamjan Jovanovic /** acquire/release are not used in pairs: after child thread acquired mutex,
4728748f2e1SDamjan Jovanovic the main thread release it, then any thread could acquire it.
4738748f2e1SDamjan Jovanovic */
TEST_F(release,release_001)4748748f2e1SDamjan Jovanovic TEST_F(release, release_001)
4758748f2e1SDamjan Jovanovic {
4768748f2e1SDamjan Jovanovic Mutex aMutex;
4778748f2e1SDamjan Jovanovic WaitThread myThread( &aMutex );
4788748f2e1SDamjan Jovanovic myThread.create( );
4798748f2e1SDamjan Jovanovic
4808748f2e1SDamjan Jovanovic // ensure the child thread acquire the mutex
4818748f2e1SDamjan Jovanovic ThreadHelper::thread_sleep_tenth_sec( 1 );
4828748f2e1SDamjan Jovanovic
4838748f2e1SDamjan Jovanovic sal_Bool bRunning = myThread.isRunning( );
4848748f2e1SDamjan Jovanovic sal_Bool bRes1 = aMutex.tryToAcquire( );
4858748f2e1SDamjan Jovanovic // wait the child thread terminate
4868748f2e1SDamjan Jovanovic myThread.join( );
4878748f2e1SDamjan Jovanovic
4888748f2e1SDamjan Jovanovic sal_Bool bRes2 = aMutex.tryToAcquire( );
4898748f2e1SDamjan Jovanovic
4908748f2e1SDamjan Jovanovic if ( bRes2 == sal_True )
4918748f2e1SDamjan Jovanovic aMutex.release( );
4928748f2e1SDamjan Jovanovic
49330acf5e8Spfg ASSERT_TRUE(bRes1 == sal_False && bRes2 == sal_True && bRunning == sal_True) << "release Mutex: try to acquire before and after the mutex has been released";
4948748f2e1SDamjan Jovanovic
4958748f2e1SDamjan Jovanovic }
4968748f2e1SDamjan Jovanovic
4978748f2e1SDamjan Jovanovic // how about release twice?
TEST_F(release,release_002)4988748f2e1SDamjan Jovanovic TEST_F(release, release_002)
4998748f2e1SDamjan Jovanovic {
500cdf0e10cSrcweir // LLA: is this a real test?
501cdf0e10cSrcweir #if 0
5028748f2e1SDamjan Jovanovic Mutex aMutex;
5038748f2e1SDamjan Jovanovic sal_Bool bRes1 = aMutex.release( );
5048748f2e1SDamjan Jovanovic sal_Bool bRes2 = aMutex.release( );
505cdf0e10cSrcweir
50630acf5e8Spfg ASSERT_TRUE(bRes1 == sal_False && bRes2 == sal_False) << "release Mutex: mutex should not be released without acquire, should not release twice. although the behaviour is still under discussion, this test is passed on (LINUX), not passed on (SOLARIS)&(WINDOWS)";
5078748f2e1SDamjan Jovanovic #endif
5088748f2e1SDamjan Jovanovic }
509cdf0e10cSrcweir
510cdf0e10cSrcweir
511cdf0e10cSrcweir /** Test of the osl::Mutex::getGlobalMutex method
512cdf0e10cSrcweir */
5138748f2e1SDamjan Jovanovic class getGlobalMutex : public ::testing::Test
514cdf0e10cSrcweir {
515cdf0e10cSrcweir public:
5168748f2e1SDamjan Jovanovic }; // class getGlobalMutex
5178748f2e1SDamjan Jovanovic
5188748f2e1SDamjan Jovanovic // initialise your test code values here.
TEST_F(getGlobalMutex,getGlobalMutex_001)5198748f2e1SDamjan Jovanovic TEST_F(getGlobalMutex, getGlobalMutex_001)
5208748f2e1SDamjan Jovanovic {
5218748f2e1SDamjan Jovanovic Mutex* pGlobalMutex;
5228748f2e1SDamjan Jovanovic pGlobalMutex = pGlobalMutex->getGlobalMutex();
5238748f2e1SDamjan Jovanovic pGlobalMutex->acquire();
5248748f2e1SDamjan Jovanovic
5258748f2e1SDamjan Jovanovic GlobalMutexThread myThread;
5268748f2e1SDamjan Jovanovic myThread.create();
5278748f2e1SDamjan Jovanovic
5288748f2e1SDamjan Jovanovic ThreadHelper::thread_sleep_tenth_sec(1);
5298748f2e1SDamjan Jovanovic sal_Bool bRes1 = myThread.isRunning();
5308748f2e1SDamjan Jovanovic
5318748f2e1SDamjan Jovanovic pGlobalMutex->release();
5328748f2e1SDamjan Jovanovic ThreadHelper::thread_sleep_tenth_sec(1);
5338748f2e1SDamjan Jovanovic // after release mutex, myThread stops blocking and will terminate immediately
5348748f2e1SDamjan Jovanovic sal_Bool bRes2 = myThread.isRunning();
5358748f2e1SDamjan Jovanovic
5368748f2e1SDamjan Jovanovic ASSERT_TRUE(bRes1 == sal_True && bRes2 == sal_False) << "Global Mutex works";
5378748f2e1SDamjan Jovanovic }
5388748f2e1SDamjan Jovanovic
TEST_F(getGlobalMutex,getGlobalMutex_002)5398748f2e1SDamjan Jovanovic TEST_F(getGlobalMutex, getGlobalMutex_002 )
5408748f2e1SDamjan Jovanovic {
5418748f2e1SDamjan Jovanovic sal_Bool bRes;
5428748f2e1SDamjan Jovanovic
5438748f2e1SDamjan Jovanovic Mutex *pGlobalMutex;
5448748f2e1SDamjan Jovanovic pGlobalMutex = pGlobalMutex->getGlobalMutex( );
5458748f2e1SDamjan Jovanovic pGlobalMutex->acquire( );
546cdf0e10cSrcweir {
5478748f2e1SDamjan Jovanovic Mutex *pGlobalMutex1;
5488748f2e1SDamjan Jovanovic pGlobalMutex1 = pGlobalMutex1->getGlobalMutex( );
5498748f2e1SDamjan Jovanovic bRes = pGlobalMutex1->release( );
550cdf0e10cSrcweir }
5518748f2e1SDamjan Jovanovic
5528748f2e1SDamjan Jovanovic ASSERT_TRUE(bRes == sal_True) << "Global Mutex works: if the code between {} get the different mutex as the former one, it will return false when release.";
5538748f2e1SDamjan Jovanovic }
5548748f2e1SDamjan Jovanovic
555cdf0e10cSrcweir } // namespace osl_Mutex
556cdf0e10cSrcweir
557cdf0e10cSrcweir
558cdf0e10cSrcweir //------------------------------------------------------------------------
559cdf0e10cSrcweir // Beginning of the test cases for osl_Guard class
560cdf0e10cSrcweir //------------------------------------------------------------------------
561cdf0e10cSrcweir
562cdf0e10cSrcweir class GuardThread : public Thread
563cdf0e10cSrcweir {
564cdf0e10cSrcweir public:
565cdf0e10cSrcweir //get the Mutex pointer to operate
GuardThread(Mutex * pMutex)566cdf0e10cSrcweir GuardThread( Mutex* pMutex ): pMyMutex( pMutex ) { }
567cdf0e10cSrcweir
~GuardThread()568cdf0e10cSrcweir ~GuardThread( )
569cdf0e10cSrcweir {
570a03c9fa9SDamjan Jovanovic EXPECT_TRUE(sal_False == this -> isRunning( )) << "#GuardThread does not shutdown properly.\n";
571cdf0e10cSrcweir }
572cdf0e10cSrcweir protected:
573cdf0e10cSrcweir Mutex* pMyMutex;
574cdf0e10cSrcweir
run()575cdf0e10cSrcweir void SAL_CALL run( )
576cdf0e10cSrcweir {
577cdf0e10cSrcweir // block here if the mutex has been acquired
578cdf0e10cSrcweir MutexGuard aGuard( pMyMutex );
579cdf0e10cSrcweir ThreadHelper::thread_sleep_tenth_sec( 2 );
580cdf0e10cSrcweir }
581cdf0e10cSrcweir };
582cdf0e10cSrcweir
583cdf0e10cSrcweir
584cdf0e10cSrcweir namespace osl_Guard
585cdf0e10cSrcweir {
5868748f2e1SDamjan Jovanovic class GuardThreadConstructor : public ::testing::Test
587cdf0e10cSrcweir {
588cdf0e10cSrcweir public:
589cdf0e10cSrcweir }; // class ctor
5908748f2e1SDamjan Jovanovic
5918748f2e1SDamjan Jovanovic // insert your test code here.
TEST_F(GuardThreadConstructor,ctor_001)5928748f2e1SDamjan Jovanovic TEST_F(GuardThreadConstructor, ctor_001)
5938748f2e1SDamjan Jovanovic {
5948748f2e1SDamjan Jovanovic Mutex aMutex;
5958748f2e1SDamjan Jovanovic GuardThread myThread(&aMutex);
5968748f2e1SDamjan Jovanovic myThread.create();
5978748f2e1SDamjan Jovanovic
5988748f2e1SDamjan Jovanovic ThreadHelper::thread_sleep_tenth_sec(1);
5998748f2e1SDamjan Jovanovic sal_Bool bRes = aMutex.tryToAcquire();
6008748f2e1SDamjan Jovanovic // after 1 second, the mutex has been guarded, and the child thread should be running
6018748f2e1SDamjan Jovanovic sal_Bool bRes1 = myThread.isRunning();
6028748f2e1SDamjan Jovanovic
6038748f2e1SDamjan Jovanovic myThread.join();
6048748f2e1SDamjan Jovanovic sal_Bool bRes2 = aMutex.tryToAcquire();
6058748f2e1SDamjan Jovanovic
6068748f2e1SDamjan Jovanovic ASSERT_TRUE(bRes == sal_False && bRes1 == sal_True && bRes2 == sal_True) << "GuardThread constructor";
6078748f2e1SDamjan Jovanovic }
6088748f2e1SDamjan Jovanovic
TEST_F(GuardThreadConstructor,ctor_002)6098748f2e1SDamjan Jovanovic TEST_F(GuardThreadConstructor, ctor_002 )
6108748f2e1SDamjan Jovanovic {
6118748f2e1SDamjan Jovanovic Mutex aMutex;
6128748f2e1SDamjan Jovanovic
6138748f2e1SDamjan Jovanovic /// use reference constructor here
6148748f2e1SDamjan Jovanovic MutexGuard myGuard( aMutex );
6158748f2e1SDamjan Jovanovic
6168748f2e1SDamjan Jovanovic /// the GuardThread will block here when it is initialised.
6178748f2e1SDamjan Jovanovic GuardThread myThread( &aMutex );
6188748f2e1SDamjan Jovanovic myThread.create( );
6198748f2e1SDamjan Jovanovic
6208748f2e1SDamjan Jovanovic /// is it still blocking?
6218748f2e1SDamjan Jovanovic ThreadHelper::thread_sleep_tenth_sec( 2 );
6228748f2e1SDamjan Jovanovic sal_Bool bRes = myThread.isRunning( );
6238748f2e1SDamjan Jovanovic
6248748f2e1SDamjan Jovanovic /// oh, release him.
6258748f2e1SDamjan Jovanovic aMutex.release( );
6268748f2e1SDamjan Jovanovic myThread.join( );
6278748f2e1SDamjan Jovanovic
62830acf5e8Spfg ASSERT_TRUE(bRes == sal_True) << "GuardThread constructor: reference initialization, acquire the mutex before running the thread, then check if it is blocking.";
6298748f2e1SDamjan Jovanovic }
630cdf0e10cSrcweir
631cdf0e10cSrcweir } // namespace osl_Guard
632cdf0e10cSrcweir
633cdf0e10cSrcweir
634cdf0e10cSrcweir //------------------------------------------------------------------------
635cdf0e10cSrcweir // Beginning of the test cases for osl_ClearableGuard class
636cdf0e10cSrcweir //------------------------------------------------------------------------
637cdf0e10cSrcweir
638cdf0e10cSrcweir /** Thread for test ClearableGuard
639cdf0e10cSrcweir */
640cdf0e10cSrcweir class ClearGuardThread : public Thread
641cdf0e10cSrcweir {
642cdf0e10cSrcweir public:
643cdf0e10cSrcweir //get the Mutex pointer to operate
ClearGuardThread(Mutex * pMutex)644cdf0e10cSrcweir ClearGuardThread( Mutex* pMutex ): pMyMutex( pMutex ) {}
645cdf0e10cSrcweir
~ClearGuardThread()646cdf0e10cSrcweir ~ClearGuardThread( )
647cdf0e10cSrcweir {
648a03c9fa9SDamjan Jovanovic EXPECT_TRUE(sal_False == this -> isRunning( )) << "#ClearGuardThread does not shutdown properly.\n";
649cdf0e10cSrcweir }
650cdf0e10cSrcweir protected:
651cdf0e10cSrcweir Mutex* pMyMutex;
652cdf0e10cSrcweir
run()653cdf0e10cSrcweir void SAL_CALL run( )
654cdf0e10cSrcweir {
655cdf0e10cSrcweir // acquire the mutex
656cdf0e10cSrcweir // printf("# ClearGuardThread" );
657cdf0e10cSrcweir ClearableMutexGuard aGuard( pMyMutex );
658cdf0e10cSrcweir ThreadHelper::thread_sleep( 5 );
659cdf0e10cSrcweir
660cdf0e10cSrcweir // release the mutex
661cdf0e10cSrcweir aGuard.clear( );
662cdf0e10cSrcweir ThreadHelper::thread_sleep( 2 );
663cdf0e10cSrcweir }
664cdf0e10cSrcweir };
665cdf0e10cSrcweir
666cdf0e10cSrcweir // -----------------------------------------------------------------------------
667cdf0e10cSrcweir namespace osl_ClearableGuard
668cdf0e10cSrcweir {
669cdf0e10cSrcweir
6708748f2e1SDamjan Jovanovic class ClearableGuardConstructor : public ::testing::Test
671cdf0e10cSrcweir {
672cdf0e10cSrcweir public:
673cdf0e10cSrcweir }; // class ctor
6748748f2e1SDamjan Jovanovic
TEST_F(ClearableGuardConstructor,ctor_001)6758748f2e1SDamjan Jovanovic TEST_F(ClearableGuardConstructor, ctor_001)
6768748f2e1SDamjan Jovanovic {
6778748f2e1SDamjan Jovanovic Mutex aMutex;
6788748f2e1SDamjan Jovanovic
6798748f2e1SDamjan Jovanovic /// now, the aMutex has been guarded.
6808748f2e1SDamjan Jovanovic ClearableMutexGuard myMutexGuard( &aMutex );
6818748f2e1SDamjan Jovanovic
6828748f2e1SDamjan Jovanovic /// it will return sal_False if the aMutex has not been Guarded.
6838748f2e1SDamjan Jovanovic sal_Bool bRes = aMutex.release( );
6848748f2e1SDamjan Jovanovic
68530acf5e8Spfg ASSERT_TRUE(bRes == sal_True) << "ClearableMutexGuard constructor, test the acquire operation when initilized.";
6868748f2e1SDamjan Jovanovic }
6878748f2e1SDamjan Jovanovic
TEST_F(ClearableGuardConstructor,ctor_002)6888748f2e1SDamjan Jovanovic TEST_F(ClearableGuardConstructor, ctor_002 )
6898748f2e1SDamjan Jovanovic {
6908748f2e1SDamjan Jovanovic Mutex aMutex;
6918748f2e1SDamjan Jovanovic
6928748f2e1SDamjan Jovanovic /// now, the aMutex has been guarded, this time, we use reference constructor.
6938748f2e1SDamjan Jovanovic ClearableMutexGuard myMutexGuard( aMutex );
6948748f2e1SDamjan Jovanovic
6958748f2e1SDamjan Jovanovic /// it will return sal_False if the aMutex has not been Guarded.
6968748f2e1SDamjan Jovanovic sal_Bool bRes = aMutex.release( );
6978748f2e1SDamjan Jovanovic
69830acf5e8Spfg ASSERT_TRUE(bRes == sal_True) << "ClearableMutexGuard constructor, test the acquire operation when initilized, we use reference constructor this time.";
6998748f2e1SDamjan Jovanovic }
700cdf0e10cSrcweir
7018748f2e1SDamjan Jovanovic class clear : public ::testing::Test
702cdf0e10cSrcweir {
703cdf0e10cSrcweir public:
7048748f2e1SDamjan Jovanovic }; // class clear
7058748f2e1SDamjan Jovanovic
TEST_F(clear,clear_001)7068748f2e1SDamjan Jovanovic TEST_F(clear, clear_001)
7078748f2e1SDamjan Jovanovic {
7088748f2e1SDamjan Jovanovic Mutex aMutex;
7098748f2e1SDamjan Jovanovic ClearGuardThread myThread(&aMutex);
7108748f2e1SDamjan Jovanovic myThread.create();
7118748f2e1SDamjan Jovanovic
7128748f2e1SDamjan Jovanovic TimeValue aTimeVal_befor;
7138748f2e1SDamjan Jovanovic osl_getSystemTime( &aTimeVal_befor );
7148748f2e1SDamjan Jovanovic // wait 1 second to assure the child thread has begun
7158748f2e1SDamjan Jovanovic ThreadHelper::thread_sleep(1);
7168748f2e1SDamjan Jovanovic
7178748f2e1SDamjan Jovanovic while (1)
718cdf0e10cSrcweir {
7198748f2e1SDamjan Jovanovic if (aMutex.tryToAcquire() == sal_True)
7208748f2e1SDamjan Jovanovic {
7218748f2e1SDamjan Jovanovic break;
7228748f2e1SDamjan Jovanovic }
7238748f2e1SDamjan Jovanovic ThreadHelper::thread_sleep(1);
724cdf0e10cSrcweir }
7258748f2e1SDamjan Jovanovic TimeValue aTimeVal_after;
7268748f2e1SDamjan Jovanovic osl_getSystemTime( &aTimeVal_after );
7278748f2e1SDamjan Jovanovic sal_Int32 nSec = aTimeVal_after.Seconds - aTimeVal_befor.Seconds;
728e7e17449SDamjan Jovanovic printf("nSec is %" SAL_PRIdINT32"\n", nSec);
7298748f2e1SDamjan Jovanovic
7308748f2e1SDamjan Jovanovic myThread.join();
731cdf0e10cSrcweir
732*b4039cddSDon Lewis ASSERT_TRUE(nSec <= 7 && nSec > 1) << "ClearableGuard method: clear";
7338748f2e1SDamjan Jovanovic }
7348748f2e1SDamjan Jovanovic
TEST_F(clear,clear_002)7358748f2e1SDamjan Jovanovic TEST_F(clear, clear_002 )
7368748f2e1SDamjan Jovanovic {
7378748f2e1SDamjan Jovanovic Mutex aMutex;
7388748f2e1SDamjan Jovanovic
7398748f2e1SDamjan Jovanovic /// now, the aMutex has been guarded.
7408748f2e1SDamjan Jovanovic ClearableMutexGuard myMutexGuard( &aMutex );
741cdf0e10cSrcweir
7428748f2e1SDamjan Jovanovic /// launch the HoldThread, it will be blocked here.
7438748f2e1SDamjan Jovanovic HoldThread myThread( &aMutex );
7448748f2e1SDamjan Jovanovic myThread.create( );
745cdf0e10cSrcweir
7468748f2e1SDamjan Jovanovic /// is it blocking?
7478748f2e1SDamjan Jovanovic ThreadHelper::thread_sleep_tenth_sec( 4 );
7488748f2e1SDamjan Jovanovic sal_Bool bRes = myThread.isRunning( );
7498748f2e1SDamjan Jovanovic
7508748f2e1SDamjan Jovanovic /// use clear to release.
7518748f2e1SDamjan Jovanovic myMutexGuard.clear( );
7528748f2e1SDamjan Jovanovic myThread.join( );
7538748f2e1SDamjan Jovanovic sal_Bool bRes1 = myThread.isRunning( );
7548748f2e1SDamjan Jovanovic
7558748f2e1SDamjan Jovanovic ASSERT_TRUE(( sal_True == bRes ) && ( sal_False == bRes1 )) << "ClearableGuard method: clear, control the HoldThread's running status!";
7568748f2e1SDamjan Jovanovic }
757cdf0e10cSrcweir
758cdf0e10cSrcweir } // namespace osl_ClearableGuard
759cdf0e10cSrcweir
760cdf0e10cSrcweir
761cdf0e10cSrcweir //------------------------------------------------------------------------
762cdf0e10cSrcweir // Beginning of the test cases for osl_ResettableGuard class
763cdf0e10cSrcweir //------------------------------------------------------------------------
764cdf0e10cSrcweir
765cdf0e10cSrcweir /** Thread for test ResettableGuard
766cdf0e10cSrcweir */
767cdf0e10cSrcweir class ResetGuardThread : public Thread
768cdf0e10cSrcweir {
769cdf0e10cSrcweir public:
770cdf0e10cSrcweir //get the Mutex pointer to operate
ResetGuardThread(Mutex * pMutex)771cdf0e10cSrcweir ResetGuardThread( Mutex* pMutex ): pMyMutex( pMutex ) {}
772cdf0e10cSrcweir
~ResetGuardThread()773cdf0e10cSrcweir ~ResetGuardThread( )
774cdf0e10cSrcweir {
775a03c9fa9SDamjan Jovanovic EXPECT_TRUE(sal_False == this -> isRunning( )) << "#ResetGuardThread does not shutdown properly.\n";
776cdf0e10cSrcweir }
777cdf0e10cSrcweir protected:
778cdf0e10cSrcweir Mutex* pMyMutex;
779cdf0e10cSrcweir
run()780cdf0e10cSrcweir void SAL_CALL run( )
781cdf0e10cSrcweir {
782cdf0e10cSrcweir // acquire the mutex
783cdf0e10cSrcweir printf("# ResettableGuard\n" );
784cdf0e10cSrcweir ResettableMutexGuard aGuard( pMyMutex );
785cdf0e10cSrcweir // release the mutex
786cdf0e10cSrcweir aGuard.clear( );
787cdf0e10cSrcweir ThreadHelper::thread_sleep_tenth_sec( 2 );
788cdf0e10cSrcweir }
789cdf0e10cSrcweir };
790cdf0e10cSrcweir
791cdf0e10cSrcweir // -----------------------------------------------------------------------------
792cdf0e10cSrcweir namespace osl_ResettableGuard
793cdf0e10cSrcweir {
7948748f2e1SDamjan Jovanovic class ctor : public ::testing::Test
795cdf0e10cSrcweir {
796cdf0e10cSrcweir public:
797cdf0e10cSrcweir }; // class ctor
7988748f2e1SDamjan Jovanovic
TEST_F(ctor,ctor_001)7998748f2e1SDamjan Jovanovic TEST_F(ctor, ctor_001)
8008748f2e1SDamjan Jovanovic {
8018748f2e1SDamjan Jovanovic Mutex aMutex;
8028748f2e1SDamjan Jovanovic
8038748f2e1SDamjan Jovanovic /// now, the aMutex has been guarded.
8048748f2e1SDamjan Jovanovic ResettableMutexGuard myMutexGuard( &aMutex );
8058748f2e1SDamjan Jovanovic
8068748f2e1SDamjan Jovanovic /// it will return sal_False if the aMutex has not been Guarded.
8078748f2e1SDamjan Jovanovic sal_Bool bRes = aMutex.release( );
8088748f2e1SDamjan Jovanovic
80930acf5e8Spfg ASSERT_TRUE(bRes == sal_True) << "ResettableMutexGuard constructor, test the acquire operation when initilized.";
8108748f2e1SDamjan Jovanovic }
8118748f2e1SDamjan Jovanovic
TEST_F(ctor,ctor_002)8128748f2e1SDamjan Jovanovic TEST_F(ctor, ctor_002 )
8138748f2e1SDamjan Jovanovic {
8148748f2e1SDamjan Jovanovic Mutex aMutex;
8158748f2e1SDamjan Jovanovic
8168748f2e1SDamjan Jovanovic /// now, the aMutex has been guarded, this time, we use reference constructor.
8178748f2e1SDamjan Jovanovic ResettableMutexGuard myMutexGuard( aMutex );
8188748f2e1SDamjan Jovanovic
8198748f2e1SDamjan Jovanovic /// it will return sal_False if the aMutex has not been Guarded.
8208748f2e1SDamjan Jovanovic sal_Bool bRes = aMutex.release( );
8218748f2e1SDamjan Jovanovic
82230acf5e8Spfg ASSERT_TRUE(bRes == sal_True) << "ResettableMutexGuard constructor, test the acquire operation when initilized, we use reference constructor this time.";
8238748f2e1SDamjan Jovanovic }
8248748f2e1SDamjan Jovanovic
825cdf0e10cSrcweir
8268748f2e1SDamjan Jovanovic class reset : public ::testing::Test
827cdf0e10cSrcweir {
828cdf0e10cSrcweir public:
8298748f2e1SDamjan Jovanovic }; // class reset
8308748f2e1SDamjan Jovanovic
8318748f2e1SDamjan Jovanovic
TEST_F(reset,reset_001)8328748f2e1SDamjan Jovanovic TEST_F(reset, reset_001 )
8338748f2e1SDamjan Jovanovic {
8348748f2e1SDamjan Jovanovic Mutex aMutex;
8358748f2e1SDamjan Jovanovic ResetGuardThread myThread( &aMutex );
8368748f2e1SDamjan Jovanovic ResettableMutexGuard myMutexGuard( aMutex );
8378748f2e1SDamjan Jovanovic myThread.create( );
838cdf0e10cSrcweir
8398748f2e1SDamjan Jovanovic /// is it running? and clear done?
8408748f2e1SDamjan Jovanovic sal_Bool bRes = myThread.isRunning( );
8418748f2e1SDamjan Jovanovic myMutexGuard.clear( );
8428748f2e1SDamjan Jovanovic ThreadHelper::thread_sleep_tenth_sec( 1 );
8438748f2e1SDamjan Jovanovic
8448748f2e1SDamjan Jovanovic /// if reset is not success, the release will return sal_False
8458748f2e1SDamjan Jovanovic myMutexGuard.reset( );
8468748f2e1SDamjan Jovanovic sal_Bool bRes1 = aMutex.release( );
8478748f2e1SDamjan Jovanovic myThread.join( );
8488748f2e1SDamjan Jovanovic
8498748f2e1SDamjan Jovanovic ASSERT_TRUE(( sal_True == bRes ) && ( sal_True == bRes1 )) << "ResettableMutexGuard method: reset";
8508748f2e1SDamjan Jovanovic }
8518748f2e1SDamjan Jovanovic
TEST_F(reset,reset_002)8528748f2e1SDamjan Jovanovic TEST_F(reset, reset_002 )
8538748f2e1SDamjan Jovanovic {
8548748f2e1SDamjan Jovanovic #ifdef LINUX
8558748f2e1SDamjan Jovanovic Mutex aMutex;
8568748f2e1SDamjan Jovanovic ResettableMutexGuard myMutexGuard( &aMutex );
8578748f2e1SDamjan Jovanovic
8588748f2e1SDamjan Jovanovic /// shouldn't release after clear;
8598748f2e1SDamjan Jovanovic myMutexGuard.clear( );
8608748f2e1SDamjan Jovanovic sal_Bool bRes = aMutex.release( );
861cdf0e10cSrcweir
8628748f2e1SDamjan Jovanovic /// can release after reset.
8638748f2e1SDamjan Jovanovic myMutexGuard.reset( );
8648748f2e1SDamjan Jovanovic sal_Bool bRes1 = aMutex.release( );
8658748f2e1SDamjan Jovanovic
86630acf5e8Spfg ASSERT_TRUE(( sal_False == bRes ) && ( sal_True == bRes1 )) << "ResettableMutexGuard method: reset, release after clear and reset, on Solaris, the mutex can be release without acquire, so it can not passed on (SOLARIS), but not the reason for reset_002";
867cdf0e10cSrcweir #endif
8688748f2e1SDamjan Jovanovic }
869cdf0e10cSrcweir
870cdf0e10cSrcweir } // namespace osl_ResettableGuard
871cdf0e10cSrcweir
main(int argc,char ** argv)8728748f2e1SDamjan Jovanovic int main(int argc, char **argv)
8738748f2e1SDamjan Jovanovic {
8748748f2e1SDamjan Jovanovic ::testing::InitGoogleTest(&argc, argv);
8758748f2e1SDamjan Jovanovic return RUN_ALL_TESTS();
8768748f2e1SDamjan Jovanovic }
877cdf0e10cSrcweir
878cdf0e10cSrcweir // The following sets variables for GNU EMACS
879cdf0e10cSrcweir // Local Variables:
880cdf0e10cSrcweir // tab-width:4
881cdf0e10cSrcweir // End:
882