1 /************************************************************** 2 * 3 * Licensed to the Apache Software Foundation (ASF) under one 4 * or more contributor license agreements. See the NOTICE file 5 * distributed with this work for additional information 6 * regarding copyright ownership. The ASF licenses this file 7 * to you under the Apache License, Version 2.0 (the 8 * "License"); you may not use this file except in compliance 9 * with the License. You may obtain a copy of the License at 10 * 11 * http://www.apache.org/licenses/LICENSE-2.0 12 * 13 * Unless required by applicable law or agreed to in writing, 14 * software distributed under the License is distributed on an 15 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY 16 * KIND, either express or implied. See the License for the 17 * specific language governing permissions and limitations 18 * under the License. 19 * 20 *************************************************************/ 21 22 23 24 // MARKER(update_precomp.py): autogen include statement, do not remove 25 #include "precompiled_sal.hxx" 26 27 //------------------------------------------------------------------------ 28 // include files 29 //------------------------------------------------------------------------ 30 #include <osl_Condition_Const.h> 31 32 #ifdef WNT 33 #include <Windows.h> 34 #endif 35 36 #include "gtest/gtest.h" 37 38 using namespace osl; 39 using namespace rtl; 40 41 42 //------------------------------------------------------------------------ 43 // helper functions and classes 44 //------------------------------------------------------------------------ 45 46 /** print Boolean value. 47 */ 48 inline void printBool( sal_Bool bOk ) 49 { 50 printf("#printBool# " ); 51 ( sal_True == bOk ) ? printf("TRUE!\n" ): printf("FALSE!\n" ); 52 } 53 54 /** print a UNI_CODE String. 55 */ 56 inline void printUString( const ::rtl::OUString & str ) 57 { 58 rtl::OString aString; 59 60 printf("#printUString_u# " ); 61 aString = ::rtl::OUStringToOString( str, RTL_TEXTENCODING_ASCII_US ); 62 printf("%s\n", aString.getStr( ) ); 63 } 64 65 /** wait _nSec seconds. 66 */ 67 void thread_sleep( sal_Int32 _nSec ) 68 { 69 /// print statement in thread process must use fflush() to force display. 70 printf("# wait %d seconds. ", _nSec ); 71 fflush( stdout ); 72 73 #ifdef WNT //Windows 74 Sleep( _nSec * 1000 ); 75 #endif 76 #if ( defined UNX ) || ( defined OS2 ) //Unix 77 sleep( _nSec ); 78 #endif 79 printf("# done\n" ); 80 } 81 82 enum ConditionType 83 { 84 thread_type_set, 85 thread_type_reset, 86 thread_type_wait, 87 thread_type_check 88 }; 89 90 /** thread for testing Condition. 91 */ 92 class ConditionThread : public Thread 93 { 94 public: 95 //get the Condition to operate 96 ConditionThread( ::osl::Condition& Con, ConditionType tType): m_MyCon( Con ), m_MyType( tType ) { } 97 98 ~ConditionThread( ) 99 { 100 EXPECT_TRUE( sal_False == this -> isRunning( ) ) << "#ConditionThread does not shutdown properly.\n"; 101 } 102 protected: 103 ::osl::Condition& m_MyCon; 104 ConditionType m_MyType; 105 106 void SAL_CALL run() 107 { 108 switch ( m_MyType ) 109 { 110 case thread_type_wait: 111 m_MyCon.wait(); break; 112 case thread_type_set: 113 m_MyCon.set(); break; 114 case thread_type_reset: 115 m_MyCon.reset(); break; 116 default: 117 break; 118 } 119 } 120 }; 121 122 123 //------------------------------------------------------------------------ 124 // test code start here 125 //------------------------------------------------------------------------ 126 127 namespace osl_Condition 128 { 129 /** testing the method: 130 Condition() 131 */ 132 TEST(Sal_Test_Condition, ctors_001) { 133 ::osl::Condition aCond; 134 sal_Bool bRes = aCond.check( ); 135 136 // #test comment#: create a condition its initial check state should be sal_False. 137 ASSERT_TRUE( !bRes ); 138 } 139 140 TEST(Sal_Test_Condition, ctors_002) { 141 ::osl::Condition aCond; 142 aCond.set( ); 143 sal_Bool bRes = aCond.check( ); 144 145 // #test comment#: create a condition and set it. 146 ASSERT_TRUE( bRes ); 147 } 148 149 150 /** testing the method: 151 void set() 152 */ 153 TEST(Sal_Test_Condition, set_001) { 154 ::osl::Condition aCond; 155 aCond.set( ); 156 sal_Bool bRes = aCond.check( ); 157 158 // #test comment#: check state should be sal_True after set. 159 ASSERT_TRUE( bRes ); 160 } 161 162 TEST(Sal_Test_Condition, set_002) { 163 ::osl::Condition aCond; 164 ConditionThread myThread1( aCond, thread_type_wait ); 165 myThread1.create(); 166 sal_Bool bRes = myThread1.isRunning( ); 167 168 ConditionThread myThread2( aCond, thread_type_set ); 169 myThread2.create(); 170 thread_sleep(1); 171 sal_Bool bRes1 = myThread1.isRunning( ); 172 sal_Bool bRes2 = aCond.check( ); 173 174 myThread1.join( ); 175 myThread2.join( ); 176 177 // #test comment#: use one thread to set the condition in order to release another thread." 178 ASSERT_TRUE( bRes && !bRes1 && bRes2 ); 179 } 180 181 182 /** testing the method: 183 void reset() 184 */ 185 TEST(Sal_Test_Condition, reset_001) { 186 ::osl::Condition aCond; 187 aCond.reset( ); 188 189 ConditionThread myThread( aCond, thread_type_wait ); 190 myThread.create(); 191 sal_Bool bRes = myThread.isRunning( ); 192 sal_Bool bRes2 = aCond.check( ); 193 194 aCond.set( ); 195 myThread.join( ); 196 sal_Bool bRes1 = myThread.isRunning( ); 197 198 // #test comment#: wait will cause a reset thread block, use set to release it. 199 ASSERT_TRUE( bRes && !bRes1 && !bRes2 ); 200 } 201 202 TEST(Sal_Test_Condition, reset_002) { 203 ::osl::Condition aCond; 204 aCond.reset( ); 205 sal_Bool bRes = aCond.check( ); 206 aCond.set( ); 207 sal_Bool bRes1 = aCond.check( ); 208 209 // #test comment#: create a condition and reset/set it. 210 ASSERT_TRUE( sal_False == bRes && sal_True == bRes1 ); 211 } 212 213 214 /** testing the method: 215 Result wait(const TimeValue *pTimeout = 0) 216 */ 217 TEST(Sal_Test_Condition, wait_001) { 218 TimeValue tv1 = {1,0}; 219 220 ::osl::Condition cond1; 221 ::osl::Condition cond2; 222 ::osl::Condition cond3; 223 224 cond1.set(); 225 cond2.set(); 226 227 osl::Condition::Result r1=cond1.wait(&tv1); 228 osl::Condition::Result r2=cond2.wait(); 229 osl::Condition::Result r3=cond3.wait(&tv1); 230 fprintf(stderr,"%d %d %d\n",r1,r2,r3); 231 232 // #test comment#: test three types of wait. 233 ASSERT_TRUE( cond1.wait(&tv1) == ::osl::Condition::result_ok ); 234 ASSERT_TRUE( cond2.wait() == ::osl::Condition::result_ok ); 235 ASSERT_TRUE( cond3.wait(&tv1) == ::osl::Condition::result_timeout ); 236 } 237 238 TEST(Sal_Test_Condition, wait_002) { 239 TimeValue tv1 = {1,0}; 240 241 ::osl::Condition aCond; 242 ::osl::Condition::Result wRes, wRes1; 243 244 aCond.reset( ); 245 sal_Bool bRes = aCond.check( ); 246 wRes = aCond.wait( &tv1 ); 247 248 aCond.set( ); 249 wRes1 = aCond.wait( &tv1 ); 250 sal_Bool bRes1 = aCond.check( ); 251 252 // #test comment#: wait a condition after set/reset. 253 ASSERT_TRUE( !bRes ); 254 ASSERT_TRUE( bRes1 ); 255 ASSERT_TRUE( ::osl::Condition::result_timeout == wRes ); 256 ASSERT_TRUE( ::osl::Condition::result_ok == wRes1 ); 257 } 258 259 260 /** testing the method: 261 sal_Bool check() 262 */ 263 TEST(Sal_Test_Condition, check_001) { 264 ::osl::Condition aCond; 265 aCond.reset( ); 266 sal_Bool bRes = aCond.check( ); 267 aCond.set( ); 268 sal_Bool bRes1 = aCond.check( ); 269 270 // #test comment#: check the condition states. 271 ASSERT_TRUE( !bRes && bRes1 ); 272 } 273 274 TEST(Sal_Test_Condition, check_002) { 275 ::osl::Condition aCond; 276 aCond.reset( ); 277 278 ConditionThread myThread( aCond, thread_type_set ); 279 myThread.create( ); 280 myThread.join( ); 281 sal_Bool bRes = aCond.check( ); 282 283 ConditionThread myThread1( aCond, thread_type_reset ); 284 myThread1.create( ); 285 myThread1.join( ); 286 sal_Bool bRes1 = aCond.check( ); 287 288 // #test comment#: use threads to set/reset Condition and check it in main routine. 289 ASSERT_TRUE( bRes ); 290 ASSERT_TRUE( !bRes1 ); 291 } 292 293 } // namespace osl_Condition 294 295 296 int main(int argc, char **argv) 297 { 298 ::testing::InitGoogleTest(&argc, argv); 299 return RUN_ALL_TESTS(); 300 } 301