Modified: openoffice/trunk/main/sal/qa/osl/process/osl_Thread.cxx URL: http://svn.apache.org/viewvc/openoffice/trunk/main/sal/qa/osl/process/osl_Thread.cxx?rev=1701288&r1=1701287&r2=1701288&view=diff ============================================================================== --- openoffice/trunk/main/sal/qa/osl/process/osl_Thread.cxx (original) +++ openoffice/trunk/main/sal/qa/osl/process/osl_Thread.cxx Fri Sep 4 16:32:10 2015 @@ -45,7 +45,7 @@ #endif #include <osl/time.h> -#include <testshl/simpleheader.hxx> +#include "gtest/gtest.h" using namespace osl; using namespace rtl; @@ -92,7 +92,7 @@ void StopWatch::start() m_bIsValid = false; m_bIsRunning = true; osl_getSystemTime( &t1 ); - t_print("# %d %d nsecs\n", t1.Seconds, t1.Nanosec); + printf("# %d %d nsecs\n", t1.Seconds, t1.Nanosec); // gettimeofday(&t1, 0); } @@ -103,7 +103,7 @@ void StopWatch::stop() // gettimeofday(&t2, 0); // Timer ausfragen osl_getSystemTime( &t2 ); - t_print("# %d %d nsecs\n", t2.Seconds, t2.Nanosec); + printf("# %d %d nsecs\n", t2.Seconds, t2.Nanosec); if (m_bIsRunning) { // check ob gestartet. @@ -123,7 +123,7 @@ void StopWatch::stop() m_nNanoSec = 1000000000 + static_cast<sal_Int32>(t2.Nanosec) - static_cast<sal_Int32>(t1.Nanosec); m_nSeconds -= 1; } - t_print("# %d %d nsecs\n", m_nSeconds, m_nNanoSec ); + printf("# %d %d nsecs\n", m_nSeconds, m_nNanoSec ); //if (m_nNanoSec < 0) //{ //m_nNanoSec += 1000000000; @@ -193,7 +193,7 @@ namespace ThreadHelper { // if (nVerbose == VERBOSE) // { - // t_print("wait %d tenth seconds. ", _nTenthSec ); + // printf("wait %d tenth seconds. ", _nTenthSec ); // fflush(stdout); // } #ifdef WNT //Windows @@ -207,7 +207,7 @@ namespace ThreadHelper #endif // if (nVerbose == VERBOSE) // { - // t_print("done\n"); + // printf("done\n"); // } } @@ -216,27 +216,27 @@ namespace ThreadHelper // LLA: output the priority if (_aPriority == osl_Thread_PriorityHighest) { - t_print("Prio is High\n"); + printf("Prio is High\n"); } else if (_aPriority == osl_Thread_PriorityAboveNormal) { - t_print("Prio is above normal\n"); + printf("Prio is above normal\n"); } else if (_aPriority == osl_Thread_PriorityNormal) { - t_print("Prio is normal\n"); + printf("Prio is normal\n"); } else if (_aPriority == osl_Thread_PriorityBelowNormal) { - t_print("Prio is below normal\n"); + printf("Prio is below normal\n"); } else if (_aPriority == osl_Thread_PriorityLowest) { - t_print("Prio is lowest\n"); + printf("Prio is lowest\n"); } else { - t_print("Prio is unknown\n"); + printf("Prio is unknown\n"); } } } @@ -277,7 +277,7 @@ public: { if (isRunning()) { - t_print("error: not terminated.\n"); + printf("error: not terminated.\n"); } } @@ -293,7 +293,7 @@ public: OCountThread() { m_nWaitSec = 0; - t_print("new OCountThread thread %d!\n", getIdentifier()); + printf("new OCountThread thread %d!\n", getIdentifier()); } sal_Int32 getValue() { return m_aFlag.getValue(); } @@ -339,7 +339,7 @@ protected: } void SAL_CALL onTerminated() { - t_print("normally terminate this thread %d!\n", getIdentifier()); + printf("normally terminate this thread %d!\n", getIdentifier()); } public: @@ -347,7 +347,7 @@ public: { if (isRunning()) { - t_print("error: not terminated.\n"); + printf("error: not terminated.\n"); } } @@ -399,7 +399,7 @@ public: { if (isRunning()) { - t_print("error: not terminated.\n"); + printf("error: not terminated.\n"); } } @@ -434,18 +434,18 @@ protected: } void SAL_CALL onTerminated() { - t_print("normally terminate this thread %d!\n", getIdentifier()); + printf("normally terminate this thread %d!\n", getIdentifier()); } public: ONoScheduleThread() { - t_print("new thread id %d!\n", getIdentifier()); + printf("new thread id %d!\n", getIdentifier()); } ~ONoScheduleThread() { if (isRunning()) { - t_print("error: not terminated.\n"); + printf("error: not terminated.\n"); } } @@ -478,7 +478,7 @@ protected: } void SAL_CALL onTerminated() { - // t_print("normally terminate this thread %d!\n", getIdentifier()); + // printf("normally terminate this thread %d!\n", getIdentifier()); } public: @@ -486,7 +486,7 @@ public: { if (isRunning()) { - // t_print("error: not terminated.\n"); + // printf("error: not terminated.\n"); } } @@ -504,7 +504,7 @@ namespace osl_Thread // while on Windows, after createSuspended, the thread can not terminate, wait endlessly, // so here call resume at first, then call terminate. #ifdef WNT - t_print("resumeAndWaitThread\n"); + printf("resumeAndWaitThread\n"); _pThread->resume(); ThreadHelper::thread_sleep_tenth_sec(1); #else @@ -525,145 +525,123 @@ namespace osl_Thread _pThread->resume(); ThreadHelper::thread_sleep_tenth_sec(1); #endif - t_print("#wait for join.\n"); + printf("#wait for join.\n"); _pThread->join(); } /** Test of the osl::Thread::create method */ - class create : public CppUnit::TestFixture + class create : public ::testing::Test { public: // initialise your test code values here. - void setUp() + void SetUp() { } - void tearDown() + void TearDown() { } + }; // class create - /** Simple create a thread. - - Create a simple thread, it just does add 1 to value(which initialized 0), - if the thread run, the value should be 1. - */ - void create_001() - { - myThread* newthread = new myThread(); - sal_Bool bRes = newthread->create(); - CPPUNIT_ASSERT_MESSAGE("Can not creates a new thread!\n", bRes == sal_True ); - - ThreadHelper::thread_sleep_tenth_sec(1); // wait short - sal_Bool isRunning = newthread->isRunning(); // check if thread is running - /// wait for the new thread to assure it has run - ThreadHelper::thread_sleep_tenth_sec(3); - sal_Int32 nValue = newthread->getValue(); - /// to assure the new thread has terminated - termAndJoinThread(newthread); - delete newthread; - t_print(" nValue = %d\n", nValue); - t_print("isRunning = %d\n", isRunning); + /** Simple create a thread. - CPPUNIT_ASSERT_MESSAGE( - "Creates a new thread", - nValue >= 1 && isRunning == sal_True - ); + Create a simple thread, it just does add 1 to value(which initialized 0), + if the thread run, the value should be 1. + */ + TEST_F(create, create_001) + { + myThread* newthread = new myThread(); + sal_Bool bRes = newthread->create(); + ASSERT_TRUE(bRes == sal_True) << "Can not creates a new thread!\n"; + + ThreadHelper::thread_sleep_tenth_sec(1); // wait short + sal_Bool isRunning = newthread->isRunning(); // check if thread is running + /// wait for the new thread to assure it has run + ThreadHelper::thread_sleep_tenth_sec(3); + sal_Int32 nValue = newthread->getValue(); + /// to assure the new thread has terminated + termAndJoinThread(newthread); + delete newthread; - } + printf(" nValue = %d\n", nValue); + printf("isRunning = %d\n", isRunning); - /** only one running thread per instance, return false if create secondly - */ - void create_002() - { - myThread* newthread = new myThread(); - sal_Bool res1 = newthread->create(); - sal_Bool res2 = newthread->create(); - t_print("In non pro, an assertion should occurred. This behaviour is right.\n"); - termAndJoinThread(newthread); - delete newthread; + ASSERT_TRUE(nValue >= 1 && isRunning == sal_True) << "Creates a new thread"; - CPPUNIT_ASSERT_MESSAGE( - "Creates a new thread: can not create two threads per instance", - res1 && !res2 - ); + } - } + /** only one running thread per instance, return false if create secondly + */ + TEST_F(create, create_002) + { + myThread* newthread = new myThread(); + sal_Bool res1 = newthread->create(); + sal_Bool res2 = newthread->create(); + printf("In non pro, an assertion should occured. This behaviour is right.\n"); + termAndJoinThread(newthread); + delete newthread; - CPPUNIT_TEST_SUITE(create); - CPPUNIT_TEST(create_001); - CPPUNIT_TEST(create_002); - CPPUNIT_TEST_SUITE_END(); - }; // class create + ASSERT_TRUE(res1 && !res2) << "Creates a new thread: can not create two threads per instance"; + } /** Test of the osl::Thread::createSuspended method */ - class createSuspended : public CppUnit::TestFixture + class createSuspended : public ::testing::Test { public: // initialise your test code values here. - void setUp() + void SetUp() { } - void tearDown() + void TearDown() { } + }; // class createSuspended - /** Create a suspended thread, use the same class as create_001 + /** Create a suspended thread, use the same class as create_001 - after create, wait enough time, check the value, if it's still the initial value, pass - */ - void createSuspended_001() - { - myThread* newthread = new myThread(); - sal_Bool bRes = newthread->createSuspended(); - CPPUNIT_ASSERT_MESSAGE("Can not creates a new thread!", bRes == sal_True ); - - ThreadHelper::thread_sleep_tenth_sec(1); - sal_Bool isRunning = newthread->isRunning(); - ThreadHelper::thread_sleep_tenth_sec(3); - sal_Int32 nValue = newthread->getValue(); + after create, wait enough time, check the value, if it's still the initial value, pass + */ + TEST_F(createSuspended, createSuspended_001) + { + myThread* newthread = new myThread(); + sal_Bool bRes = newthread->createSuspended(); + ASSERT_TRUE(bRes == sal_True) << "Can not creates a new thread!"; - resumeAndWaitThread(newthread); + ThreadHelper::thread_sleep_tenth_sec(1); + sal_Bool isRunning = newthread->isRunning(); + ThreadHelper::thread_sleep_tenth_sec(3); + sal_Int32 nValue = newthread->getValue(); - termAndJoinThread(newthread); - delete newthread; + resumeAndWaitThread(newthread); - CPPUNIT_ASSERT_MESSAGE( - "Creates a new suspended thread", - nValue == 0 && isRunning - ); - } + termAndJoinThread(newthread); + delete newthread; - void createSuspended_002() - { - myThread* newthread = new myThread(); - sal_Bool res1 = newthread->createSuspended(); - sal_Bool res2 = newthread->createSuspended(); + ASSERT_TRUE(nValue == 0 && isRunning) << "Creates a new suspended thread"; + } + // LLA: Deadlocked!!! + TEST_F(createSuspended, createSuspended_002) + { + myThread* newthread = new myThread(); + sal_Bool res1 = newthread->createSuspended(); + sal_Bool res2 = newthread->createSuspended(); - resumeAndWaitThread(newthread); + resumeAndWaitThread(newthread); - termAndJoinThread(newthread); + termAndJoinThread(newthread); - delete newthread; + delete newthread; - CPPUNIT_ASSERT_MESSAGE( - "Creates a new thread: can not create two threads per instance", - res1 && !res2 - ); - } + ASSERT_TRUE(res1 && !res2) << "Creates a new thread: can not create two threads per instance"; + } - CPPUNIT_TEST_SUITE(createSuspended); - CPPUNIT_TEST(createSuspended_001); - // LLA: Deadlocked!!! - CPPUNIT_TEST(createSuspended_002); - CPPUNIT_TEST_SUITE_END(); - }; // class createSuspended /** when the count value equal to or more than 3, suspend the thread. */ @@ -683,436 +661,384 @@ namespace osl_Thread /** Test of the osl::Thread::suspend method */ - class suspend : public CppUnit::TestFixture + class suspend : public ::testing::Test { public: // initialise your test code values here. - void setUp() + void SetUp() { } - void tearDown() + void TearDown() { } + }; // class suspend - /** Use a thread which has a flag added 1 every second + /** Use a thread which has a flag added 1 every second + + ALGORITHM: + create the thread, after running special time, record value of flag, then suspend it, + wait a long time, check the flag, if it remains unchanged during suspending + */ + TEST_F(suspend, suspend_001) + { + OCountThread* aCountThread = new OCountThread(); + sal_Bool bRes = aCountThread->create(); + ASSERT_TRUE(bRes == sal_True) << "Can't start thread!"; + // the thread run for some seconds, but not terminate + suspendCountThread( aCountThread ); + + // the value just after calling suspend + sal_Int32 nValue = aCountThread->getValue(); // (2) + + ThreadHelper::thread_sleep_tenth_sec(3); + + // the value after waiting 3 seconds + sal_Int32 nLaterValue = aCountThread->getValue(); // (3) + + resumeAndWaitThread(aCountThread); + termAndJoinThread(aCountThread); + delete aCountThread; + + ASSERT_TRUE(bRes == sal_True && nValue == nLaterValue) << "Suspend the thread"; + + } + /** suspend a thread in it's worker-function, the ALGORITHM is same as suspend_001 + reason of deadlocked I think: no schedule can schedule other threads to go on excuting + */ + TEST_F(suspend, suspend_002) + { +#if 0 + OSuspendThread* aThread = new OSuspendThread(); + sal_Bool bRes = aThread->create(); + ASSERT_TRUE(bRes == sal_True) << "Can't start thread!"; + // first the thread run for some seconds, but not terminate + sal_Int32 nValue = 0; + //while (1) + //{ + ThreadHelper::thread_sleep_tenth_sec(3); + nValue = aThread->getValue(); // (1) + printf(" getValue is %d !", nValue ); + if (nValue >= 2) + { + aThread->setSuspend(); + //break; + } + //} + printf(" after while!"); + // the value just after calling suspend + nValue = aThread->getValue(); // (2) + + ThreadHelper::thread_sleep_tenth_sec(3); + printf(" after sleep!"); + // the value after waiting 3 seconds + sal_Int32 nLaterValue = aThread->getValue(); // (3) + + //resumeAndWaitThread(aThread); + aThread->resume(); + termAndJoinThread(aThread); + delete aThread; + + ASSERT_TRUE(bRes == sal_True && nValue == nLaterValue) << "Suspend the thread"; +#endif + } - ALGORITHM: - create the thread, after running special time, record value of flag, then suspend it, - wait a long time, check the flag, if it remains unchanged during suspending - */ - void suspend_001() - { - OCountThread* aCountThread = new OCountThread(); - sal_Bool bRes = aCountThread->create(); - CPPUNIT_ASSERT_MESSAGE ( "Can't start thread!", bRes == sal_True ); - // the thread run for some seconds, but not terminate - suspendCountThread( aCountThread ); - - // the value just after calling suspend - sal_Int32 nValue = aCountThread->getValue(); // (2) - - ThreadHelper::thread_sleep_tenth_sec(3); - - // the value after waiting 3 seconds - sal_Int32 nLaterValue = aCountThread->getValue(); // (3) - - resumeAndWaitThread(aCountThread); - termAndJoinThread(aCountThread); - delete aCountThread; - - CPPUNIT_ASSERT_MESSAGE( - "Suspend the thread", - bRes == sal_True && nValue == nLaterValue - ); - - } - /** suspend a thread in it's worker-function, the ALGORITHM is same as suspend_001 - reason of deadlocked I think: no schedule can schedule other threads to go on excuting - */ - void suspend_002() - { - OSuspendThread* aThread = new OSuspendThread(); - sal_Bool bRes = aThread->create(); - CPPUNIT_ASSERT_MESSAGE ( "Can't start thread!", bRes == sal_True ); - // first the thread run for some seconds, but not terminate - sal_Int32 nValue = 0; - //while (1) - //{ - ThreadHelper::thread_sleep_tenth_sec(3); - nValue = aThread->getValue(); // (1) - t_print(" getValue is %d !", nValue ); - if (nValue >= 2) - { - aThread->setSuspend(); - //break; - } - //} - t_print(" after while!"); - // the value just after calling suspend - nValue = aThread->getValue(); // (2) - - ThreadHelper::thread_sleep_tenth_sec(3); - t_print(" after sleep!"); - // the value after waiting 3 seconds - sal_Int32 nLaterValue = aThread->getValue(); // (3) - - //resumeAndWaitThread(aThread); - aThread->resume(); - termAndJoinThread(aThread); - delete aThread; - - CPPUNIT_ASSERT_MESSAGE( - "Suspend the thread", - bRes == sal_True && nValue == nLaterValue - ); - } - - CPPUNIT_TEST_SUITE(suspend); - CPPUNIT_TEST(suspend_001); - // LLA: Deadlocked!!! - // CPPUNIT_TEST(createSuspended_002); - CPPUNIT_TEST_SUITE_END(); - }; // class suspend /** Test of the osl::Thread::resume method */ - class resume : public CppUnit::TestFixture + class resume : public ::testing::Test { public: // initialise your test code values here. - void setUp() + void SetUp() { } - void tearDown() + void TearDown() { } + }; // class resume - /** check if the thread run samely as usual after suspend and resume - - ALGORITHM: - compare the values before and after suspend, they should be same, - then compare values before and after resume, the difference should be same as the sleep seconds number - */ - void resume_001() - { - OCountThread* pCountThread = new OCountThread(); - sal_Bool bRes = pCountThread->create(); - CPPUNIT_ASSERT_MESSAGE ( "Can't start thread!", bRes == sal_True ); + /** check if the thread run samely as usual after suspend and resume - suspendCountThread(pCountThread); + ALGORITHM: + compare the values before and after suspend, they should be same, + then compare values before and after resume, the difference should be same as the sleep seconds number + */ + TEST_F(resume, resume_001) + { + OCountThread* pCountThread = new OCountThread(); + sal_Bool bRes = pCountThread->create(); + ASSERT_TRUE(bRes == sal_True) << "Can't start thread!"; - sal_Int32 nSuspendValue = pCountThread->getValue(); // (2) - // suspend for 3 seconds - ThreadHelper::thread_sleep_tenth_sec(3); - pCountThread->resume(); + suspendCountThread(pCountThread); - ThreadHelper::thread_sleep_tenth_sec(3); - sal_Int32 nResumeValue = pCountThread->getValue(); + sal_Int32 nSuspendValue = pCountThread->getValue(); // (2) + // suspend for 3 seconds + ThreadHelper::thread_sleep_tenth_sec(3); + pCountThread->resume(); - ThreadHelper::thread_sleep_tenth_sec(3); - sal_Int32 nLaterValue = pCountThread->getValue(); + ThreadHelper::thread_sleep_tenth_sec(3); + sal_Int32 nResumeValue = pCountThread->getValue(); - termAndJoinThread(pCountThread); - delete pCountThread; + ThreadHelper::thread_sleep_tenth_sec(3); + sal_Int32 nLaterValue = pCountThread->getValue(); - t_print("SuspendValue: %d\n", nSuspendValue); - t_print("ResumeValue: %d\n", nResumeValue); - t_print("LaterValue: %d\n", nLaterValue); + termAndJoinThread(pCountThread); + delete pCountThread; - /* LLA: this assumption is no longer relevant: nResumeValue == nSuspendValue && */ - CPPUNIT_ASSERT_MESSAGE( - "Suspend then resume the thread", - nLaterValue >= 9 && - nResumeValue > nSuspendValue && - nLaterValue > nResumeValue - ); + printf("SuspendValue: %d\n", nSuspendValue); + printf("ResumeValue: %d\n", nResumeValue); + printf("LaterValue: %d\n", nLaterValue); - } + /* LLA: this assumption is no longer relevant: nResumeValue == nSuspendValue && */ + ASSERT_TRUE(nLaterValue >= 9 && + nResumeValue > nSuspendValue && + nLaterValue > nResumeValue) << "Suspend then resume the thread"; - /** Create a suspended thread then resume, check if the thread has run - */ - void resume_002() - { - myThread* newthread = new myThread(); - sal_Bool bRes = newthread->createSuspended(); - CPPUNIT_ASSERT_MESSAGE ( "Can't create thread!", bRes == sal_True ); + } - newthread->resume(); - ThreadHelper::thread_sleep_tenth_sec(2); - sal_Int32 nValue = newthread->getValue(); + /** Create a suspended thread then resume, check if the thread has run + */ + TEST_F(resume, resume_002) + { + myThread* newthread = new myThread(); + sal_Bool bRes = newthread->createSuspended(); + ASSERT_TRUE(bRes == sal_True) << "Can't create thread!"; - termAndJoinThread(newthread); - delete newthread; + newthread->resume(); + ThreadHelper::thread_sleep_tenth_sec(2); + sal_Int32 nValue = newthread->getValue(); - t_print(" nValue = %d\n", nValue); + termAndJoinThread(newthread); + delete newthread; - CPPUNIT_ASSERT_MESSAGE( - "Creates a suspended thread, then resume", - nValue >= 1 - ); - } + printf(" nValue = %d\n", nValue); - CPPUNIT_TEST_SUITE(resume); - CPPUNIT_TEST(resume_001); - CPPUNIT_TEST(resume_002); - CPPUNIT_TEST_SUITE_END(); - }; // class resume + ASSERT_TRUE(nValue >= 1) << "Creates a suspended thread, then resume"; + } /** Test of the osl::Thread::terminate method */ - class terminate : public CppUnit::TestFixture + class terminate : public ::testing::Test { public: // initialise your test code values here. - void setUp() + void SetUp() { } - void tearDown() + void TearDown() { } + }; // class terminate - /** Check after call terminate if the running thread running go on executing + /** Check after call terminate if the running thread running go on executing - ALGORITHM: - before and after call terminate, the values should be the same - */ - void terminate_001() - { - OCountThread* aCountThread = new OCountThread(); - sal_Bool bRes = aCountThread->create(); - CPPUNIT_ASSERT_MESSAGE ( "Can't start thread!", bRes == sal_True ); - - ThreadHelper::thread_sleep_tenth_sec(2); - sal_Int32 nValue = aCountThread->getValue(); - aCountThread->terminate(); - ThreadHelper::thread_sleep_tenth_sec(2); - sal_Int32 nLaterValue = aCountThread->getValue(); - - // isRunning should be false after terminate - sal_Bool isRunning = aCountThread->isRunning(); - aCountThread->join(); - delete aCountThread; - - t_print(" nValue = %d\n", nValue); - t_print("nLaterValue = %d\n", nLaterValue); - - CPPUNIT_ASSERT_MESSAGE( - "Terminate the thread", - isRunning == sal_False && nLaterValue >= nValue - ); - } - /** Check if a suspended thread will terminate after call terminate, different on w32 and on UNX - */ - void terminate_002() - { - OCountThread* aCountThread = new OCountThread(); - sal_Bool bRes = aCountThread->create(); - CPPUNIT_ASSERT_MESSAGE ( "Can't start thread!", bRes == sal_True ); + ALGORITHM: + before and after call terminate, the values should be the same + */ + TEST_F(terminate, terminate_001) + { + OCountThread* aCountThread = new OCountThread(); + sal_Bool bRes = aCountThread->create(); + ASSERT_TRUE(bRes == sal_True) << "Can't start thread!"; - ThreadHelper::thread_sleep_tenth_sec(1); - suspendCountThread(aCountThread); - sal_Int32 nValue = aCountThread->getValue(); + ThreadHelper::thread_sleep_tenth_sec(2); + sal_Int32 nValue = aCountThread->getValue(); + aCountThread->terminate(); + ThreadHelper::thread_sleep_tenth_sec(2); + sal_Int32 nLaterValue = aCountThread->getValue(); - // seems a suspended thread can not be terminated on W32, while on Solaris can - resumeAndWaitThread(aCountThread); + // isRunning should be false after terminate + sal_Bool isRunning = aCountThread->isRunning(); + aCountThread->join(); + delete aCountThread; - ThreadHelper::thread_sleep_tenth_sec(2); + printf(" nValue = %d\n", nValue); + printf("nLaterValue = %d\n", nLaterValue); - termAndJoinThread(aCountThread); - sal_Int32 nLaterValue = aCountThread->getValue(); - delete aCountThread; + ASSERT_TRUE(isRunning == sal_False && nLaterValue >= nValue) << "Terminate the thread"; + } + /** Check if a suspended thread will terminate after call terminate, different on w32 and on UNX + */ + TEST_F(terminate, terminate_002) + { + OCountThread* aCountThread = new OCountThread(); + sal_Bool bRes = aCountThread->create(); + ASSERT_TRUE(bRes == sal_True) << "Can't start thread!"; - t_print(" nValue = %d\n", nValue); - t_print("nLaterValue = %d\n", nLaterValue); + ThreadHelper::thread_sleep_tenth_sec(1); + suspendCountThread(aCountThread); + sal_Int32 nValue = aCountThread->getValue(); - CPPUNIT_ASSERT_MESSAGE( - "Suspend then resume the thread", - nLaterValue > nValue ); - } + // seems a suspended thread can not be terminated on W32, while on Solaris can + resumeAndWaitThread(aCountThread); + + ThreadHelper::thread_sleep_tenth_sec(2); + + termAndJoinThread(aCountThread); + sal_Int32 nLaterValue = aCountThread->getValue(); + delete aCountThread; + + printf(" nValue = %d\n", nValue); + printf("nLaterValue = %d\n", nLaterValue); + + ASSERT_TRUE(nLaterValue > nValue) << "Suspend then resume the thread"; + } - CPPUNIT_TEST_SUITE(terminate); - CPPUNIT_TEST(terminate_001); - CPPUNIT_TEST(terminate_002); - CPPUNIT_TEST_SUITE_END(); - }; // class terminate /** Test of the osl::Thread::join method */ - class join : public CppUnit::TestFixture + class join : public ::testing::Test { public: // initialise your test code values here. - void setUp() + void SetUp() { } - void tearDown() + void TearDown() { } + }; // class join - /** Check after call terminate if the thread running function will not go on executing + /** Check after call terminate if the thread running function will not go on executing - the next statement after join will not exec before the thread terminate - ALGORITHM: - recode system time at the beginning of the thread run, call join, then record system time again, - the difference of the two time should be equal or more than 20 seconds, the CountThead normally terminate - */ - void join_001() - { - OCountThread *aCountThread = new OCountThread(); - sal_Bool bRes = aCountThread->create(); - CPPUNIT_ASSERT_MESSAGE ( "Can't start thread!", bRes == sal_True ); - - StopWatch aStopWatch; - aStopWatch.start(); - // TimeValue aTimeVal_befor; - // osl_getSystemTime( &aTimeVal_befor ); - //t_print("#join:the system time is %d,%d\n", pTimeVal_befor->Seconds,pTimeVal_befor->Nanosec); - - aCountThread->join(); - - //the below line will be executed after aCountThread terminate - // TimeValue aTimeVal_after; - // osl_getSystemTime( &aTimeVal_after ); - aStopWatch.stop(); - // sal_uInt32 nSec = aTimeVal_after.Seconds - aTimeVal_befor.Seconds; - double nSec = aStopWatch.getSeconds(); - t_print("join_001 nSec=%f\n", nSec); - delete aCountThread; - - CPPUNIT_ASSERT_MESSAGE( - "Join the thread: after the thread terminate", - nSec >= 2 - ); + the next statement after join will not exec before the thread terminate + ALGORITHM: + recode system time at the beginning of the thread run, call join, then record system time again, + the difference of the two time should be equal or more than 20 seconds, the CountThead normally terminate + */ + TEST_F(join, join_001) + { + OCountThread *aCountThread = new OCountThread(); + sal_Bool bRes = aCountThread->create(); + ASSERT_TRUE(bRes == sal_True) << "Can't start thread!"; - } - /** after terminated by another thread, join exited immediately + StopWatch aStopWatch; + aStopWatch.start(); + // TimeValue aTimeVal_befor; + // osl_getSystemTime( &aTimeVal_befor ); + //printf("#join:the system time is %d,%d\n", pTimeVal_befor->Seconds,pTimeVal_befor->Nanosec); - ALGORITHM: - terminate the thread when value>=3, call join, check the beginning time and time after join, - the difference should be 3 seconds, join costs little time - */ - void join_002() - { - OCountThread *aCountThread = new OCountThread(); - sal_Bool bRes = aCountThread->create(); - CPPUNIT_ASSERT_MESSAGE ( "Can't start thread!", bRes == sal_True ); - - //record the time when the running begin - // TimeValue aTimeVal_befor; - // osl_getSystemTime( &aTimeVal_befor ); - StopWatch aStopWatch; - aStopWatch.start(); - - ThreadHelper::thread_sleep_tenth_sec(10); - termAndJoinThread(aCountThread); - - //the below line will be executed after aCountThread terminate - // TimeValue aTimeVal_after; - // osl_getSystemTime( &aTimeVal_after ); - // sal_uInt32 nSec = aTimeVal_after.Seconds - aTimeVal_befor.Seconds; - aStopWatch.stop(); - double nSec = aStopWatch.getSeconds(); - t_print("join_002 nSec=%f\n", nSec); - - delete aCountThread; - CPPUNIT_ASSERT_MESSAGE( - "Join the thread: after thread terminate by another thread", - nSec >= 1 - ); - } - - CPPUNIT_TEST_SUITE(join); - CPPUNIT_TEST(join_001); - CPPUNIT_TEST(join_002); - CPPUNIT_TEST_SUITE_END(); - }; // class join + aCountThread->join(); + + //the below line will be executed after aCountThread terminate + // TimeValue aTimeVal_after; + // osl_getSystemTime( &aTimeVal_after ); + aStopWatch.stop(); + // sal_uInt32 nSec = aTimeVal_after.Seconds - aTimeVal_befor.Seconds; + double nSec = aStopWatch.getSeconds(); + printf("join_001 nSec=%f\n", nSec); + delete aCountThread; + + ASSERT_TRUE(nSec >= 2) << "Join the thread: after the thread terminate"; + + } + /** after terminated by another thread, join exited immediately + + ALGORITHM: + terminate the thread when value>=3, call join, check the beginning time and time after join, + the difference should be 3 seconds, join costs little time + */ + TEST_F(join, join_002) + { + OCountThread *aCountThread = new OCountThread(); + sal_Bool bRes = aCountThread->create(); + ASSERT_TRUE(bRes == sal_True) << "Can't start thread!"; + + //record the time when the running begin + // TimeValue aTimeVal_befor; + // osl_getSystemTime( &aTimeVal_befor ); + StopWatch aStopWatch; + aStopWatch.start(); + + ThreadHelper::thread_sleep_tenth_sec(10); + termAndJoinThread(aCountThread); + + //the below line will be executed after aCountThread terminate + // TimeValue aTimeVal_after; + // osl_getSystemTime( &aTimeVal_after ); + // sal_uInt32 nSec = aTimeVal_after.Seconds - aTimeVal_befor.Seconds; + aStopWatch.stop(); + double nSec = aStopWatch.getSeconds(); + printf("join_002 nSec=%f\n", nSec); + + delete aCountThread; + ASSERT_TRUE(nSec >= 1) << "Join the thread: after thread terminate by another thread"; + } /** Test of the osl::Thread::isRunning method */ - class isRunning : public CppUnit::TestFixture + class isRunning : public ::testing::Test { public: // initialise your test code values here. - void setUp() + void SetUp() { } - void tearDown() + void TearDown() { } - - /** - */ - void isRunning_001() - { - OCountThread *aCountThread = new OCountThread(); - sal_Bool bRes = aCountThread->create(); - CPPUNIT_ASSERT_MESSAGE ( "Can't start thread!", bRes == sal_True ); - - sal_Bool bRun = aCountThread->isRunning(); - - ThreadHelper::thread_sleep_tenth_sec(2); - termAndJoinThread(aCountThread); - sal_Bool bTer = aCountThread->isRunning(); - delete aCountThread; - - CPPUNIT_ASSERT_MESSAGE( - "Test isRunning", - bRun == sal_True && bTer == sal_False - ); - } - /** check the value of isRunning when suspending and after resume - */ - void isRunning_002() - { - OCountThread *aCountThread = new OCountThread(); - sal_Bool bRes = aCountThread->create(); - CPPUNIT_ASSERT_MESSAGE ( "Can't start thread!", bRes == sal_True ); - - // sal_Bool bRunning = aCountThread->isRunning(); - // sal_Int32 nValue = 0; - suspendCountThread(aCountThread); - - sal_Bool bRunning_sup = aCountThread->isRunning(); - ThreadHelper::thread_sleep_tenth_sec(2); - aCountThread->resume(); - ThreadHelper::thread_sleep_tenth_sec(2); - sal_Bool bRunning_res = aCountThread->isRunning(); - termAndJoinThread(aCountThread); - sal_Bool bRunning_ter = aCountThread->isRunning(); - delete aCountThread; - - CPPUNIT_ASSERT_MESSAGE( - "Test isRunning", - bRes == sal_True && - bRunning_sup == sal_True && - bRunning_res == sal_True && - bRunning_ter == sal_False - ); - - } - - CPPUNIT_TEST_SUITE(isRunning); - CPPUNIT_TEST(isRunning_001); - CPPUNIT_TEST(isRunning_002); - CPPUNIT_TEST_SUITE_END(); }; // class isRunning + /** + */ + TEST_F(isRunning, isRunning_001) + { + OCountThread *aCountThread = new OCountThread(); + sal_Bool bRes = aCountThread->create(); + ASSERT_TRUE(bRes == sal_True) << "Can't start thread!"; + + sal_Bool bRun = aCountThread->isRunning(); + + ThreadHelper::thread_sleep_tenth_sec(2); + termAndJoinThread(aCountThread); + sal_Bool bTer = aCountThread->isRunning(); + delete aCountThread; + + ASSERT_TRUE(bRun == sal_True && bTer == sal_False) << "Test isRunning"; + } + /** check the value of isRunning when suspending and after resume + */ + TEST_F(isRunning, isRunning_002) + { + OCountThread *aCountThread = new OCountThread(); + sal_Bool bRes = aCountThread->create(); + ASSERT_TRUE(bRes == sal_True) << "Can't start thread!"; + + // sal_Bool bRunning = aCountThread->isRunning(); + // sal_Int32 nValue = 0; + suspendCountThread(aCountThread); + + sal_Bool bRunning_sup = aCountThread->isRunning(); + ThreadHelper::thread_sleep_tenth_sec(2); + aCountThread->resume(); + ThreadHelper::thread_sleep_tenth_sec(2); + sal_Bool bRunning_res = aCountThread->isRunning(); + termAndJoinThread(aCountThread); + sal_Bool bRunning_ter = aCountThread->isRunning(); + delete aCountThread; + + ASSERT_TRUE(bRes == sal_True && + bRunning_sup == sal_True && + bRunning_res == sal_True && + bRunning_ter == sal_False) << "Test isRunning"; + + } /// check osl::Thread::setPriority - class setPriority : public CppUnit::TestFixture + class setPriority : public ::testing::Test { public: // initialise your test code values here. - void setUp() + void SetUp() { } - void tearDown() + void TearDown() { } @@ -1179,10 +1105,10 @@ namespace osl_Thread nValueNormal2 = p2Thread->getValue(); rtl::OString sPrio = getPrioName(_aPriority); - t_print("After 10 tenth seconds\n"); + printf("After 10 tenth seconds\n"); - t_print("nValue in %s Prio Thread is %d\n",sPrio.getStr(), nValueNormal); - t_print("nValue in %s Prio Thread is %d\n", sPrio.getStr(), nValueNormal2); + printf("nValue in %s Prio Thread is %d\n",sPrio.getStr(), nValueNormal); + printf("nValue in %s Prio Thread is %d\n", sPrio.getStr(), nValueNormal2); // ThreadHelper::thread_sleep_tenth_sec(1); pThread->join(); @@ -1193,618 +1119,556 @@ namespace osl_Thread sal_Int32 nDelta = abs(nValueNormal - nValueNormal2); double nQuotient = std::max(nValueNormal, nValueNormal2); - CPPUNIT_ASSERT_MESSAGE( - "Quotient is zero, which means, there exist no right values.", - nQuotient != 0 - ); + ASSERT_TRUE(nQuotient != 0) << "Quotient is zero, which means, there exist no right values."; double nDeltaPercent = nDelta / nQuotient * 100; - t_print("Delta value %d, percent %f\n",nDelta, nDeltaPercent); + printf("Delta value %d, percent %f\n",nDelta, nDeltaPercent); // LLA: it's not a bug if the current OS is not able to handle thread scheduling right and good. // like Windows XP - // LLA: CPPUNIT_ASSERT_MESSAGE( - // LLA: "Run 2 normal threads, the count diff more than 5 percent.", - // LLA: nDeltaPercent <= 5 - // LLA: ); - } - - void setPriority_001_1() - { - check2Threads(osl_Thread_PriorityHighest); - } - void setPriority_001_2() - { - check2Threads(osl_Thread_PriorityAboveNormal); - } - void setPriority_001_3() - { - check2Threads(osl_Thread_PriorityNormal); - } - void setPriority_001_4() - { - check2Threads(osl_Thread_PriorityBelowNormal); - } - void setPriority_001_5() - { - check2Threads(osl_Thread_PriorityLowest); + // LLA: ASSERT_TRUE(// LLA: nDeltaPercent <= 5 + // LLA:) << // LLA: "Run 2 normal threads, the count diff more than 5 percent."; } + }; // class setPriority - void setPriority_002() - { - // initial 5 threads with different priorities - - OAddThread aHighestThread; - OAddThread aAboveNormalThread; - OAddThread aNormalThread; - //OAddThread *aBelowNormalThread = new OAddThread(); - //OAddThread *aLowestThread = new OAddThread(); - - //Create them and start running at the same time - aHighestThread.createSuspended(); - aHighestThread.setPriority(osl_Thread_PriorityHighest); - - aAboveNormalThread.createSuspended(); - aAboveNormalThread.setPriority(osl_Thread_PriorityAboveNormal); - - aNormalThread.createSuspended(); - aNormalThread.setPriority(osl_Thread_PriorityNormal); - /*aBelowNormalThread->create(); - aBelowNormalThread->setPriority(osl_Thread_PriorityBelowNormal); - aLowestThread->create(); - aLowestThread->setPriority(osl_Thread_PriorityLowest); - */ - - aHighestThread.resume(); - aAboveNormalThread.resume(); - aNormalThread.resume(); - - ThreadHelper::thread_sleep_tenth_sec(5); - - aHighestThread.suspend(); - aAboveNormalThread.suspend(); - aNormalThread.suspend(); - - termAndJoinThread(&aNormalThread); - termAndJoinThread(&aAboveNormalThread); - termAndJoinThread(&aHighestThread); - //aBelowNormalThread->terminate(); - //aLowestThread->terminate(); - - sal_Int32 nValueHighest = 0; - nValueHighest = aHighestThread.getValue(); - - sal_Int32 nValueAboveNormal = 0; - nValueAboveNormal = aAboveNormalThread.getValue(); + TEST_F(setPriority, setPriority_001_1) + { + check2Threads(osl_Thread_PriorityHighest); + } + TEST_F(setPriority, setPriority_001_2) + { + check2Threads(osl_Thread_PriorityAboveNormal); + } + TEST_F(setPriority, setPriority_001_3) + { + check2Threads(osl_Thread_PriorityNormal); + } + TEST_F(setPriority, setPriority_001_4) + { + check2Threads(osl_Thread_PriorityBelowNormal); + } + TEST_F(setPriority, setPriority_001_5) + { + check2Threads(osl_Thread_PriorityLowest); + } - sal_Int32 nValueNormal = 0; - nValueNormal = aNormalThread.getValue(); +#ifndef SOLARIS + TEST_F(setPriority, setPriority_002) + { + // initial 5 threads with different priorities - // sal_Int32 nValueBelowNormal = 0; - //nValueBelowNormal = aBelowNormalThread->getValue(); - // sal_Int32 nValueLowest = 0; - //nValueLowest = aLowestThread->getValue(); - t_print("After 10 tenth seconds\n"); - t_print("nValue in Highest Prio Thread is %d\n",nValueHighest); - t_print("nValue in AboveNormal Prio Thread is %d\n",nValueAboveNormal); - t_print("nValue in Normal Prio Thread is %d\n",nValueNormal); - - // LLA: this is not a save test, so we only check if all values not zero - // LLA: CPPUNIT_ASSERT_MESSAGE( - // LLA: "SetPriority", - // LLA: nValueHighest >= nValueAboveNormal && - // LLA: nValueAboveNormal >= nValueNormal && - // LLA: nValueNormal > 0 - // LLA: ); + OAddThread aHighestThread; + OAddThread aAboveNormalThread; + OAddThread aNormalThread; + //OAddThread *aBelowNormalThread = new OAddThread(); + //OAddThread *aLowestThread = new OAddThread(); + + //Create them and start running at the same time + aHighestThread.createSuspended(); + aHighestThread.setPriority(osl_Thread_PriorityHighest); + + aAboveNormalThread.createSuspended(); + aAboveNormalThread.setPriority(osl_Thread_PriorityAboveNormal); + + aNormalThread.createSuspended(); + aNormalThread.setPriority(osl_Thread_PriorityNormal); + /*aBelowNormalThread->create(); + aBelowNormalThread->setPriority(osl_Thread_PriorityBelowNormal); + aLowestThread->create(); + aLowestThread->setPriority(osl_Thread_PriorityLowest); + */ + + aHighestThread.resume(); + aAboveNormalThread.resume(); + aNormalThread.resume(); + + ThreadHelper::thread_sleep_tenth_sec(5); + + aHighestThread.suspend(); + aAboveNormalThread.suspend(); + aNormalThread.suspend(); + + termAndJoinThread(&aNormalThread); + termAndJoinThread(&aAboveNormalThread); + termAndJoinThread(&aHighestThread); + //aBelowNormalThread->terminate(); + //aLowestThread->terminate(); + + sal_Int32 nValueHighest = 0; + nValueHighest = aHighestThread.getValue(); + + sal_Int32 nValueAboveNormal = 0; + nValueAboveNormal = aAboveNormalThread.getValue(); + + sal_Int32 nValueNormal = 0; + nValueNormal = aNormalThread.getValue(); + + // sal_Int32 nValueBelowNormal = 0; + //nValueBelowNormal = aBelowNormalThread->getValue(); + // sal_Int32 nValueLowest = 0; + //nValueLowest = aLowestThread->getValue(); + printf("After 10 tenth seconds\n"); + printf("nValue in Highest Prio Thread is %d\n",nValueHighest); + printf("nValue in AboveNormal Prio Thread is %d\n",nValueAboveNormal); + printf("nValue in Normal Prio Thread is %d\n",nValueNormal); + + // LLA: this is not a save test, so we only check if all values not zero + // LLA: ASSERT_TRUE(// LLA: nValueHighest >= nValueAboveNormal && + // LLA: nValueAboveNormal >= nValueNormal && + // LLA: nValueNormal > 0 + // LLA:) << // LLA: "SetPriority"; // LLA: windows let starve threads with lower priority #ifndef WNT - CPPUNIT_ASSERT_MESSAGE( - "SetPriority", - nValueHighest > 0 && - nValueAboveNormal > 0 && - nValueNormal > 0 - ); + ASSERT_TRUE(nValueHighest > 0 && + nValueAboveNormal > 0 && + nValueNormal > 0) << "SetPriority"; #endif - } - - void setPriority_003() - { - // initial 5 threads with different priorities - OAddThread *pHighestThread = new OAddThread(); - OAddThread *pAboveNormalThread = new OAddThread(); - OAddThread *pNormalThread = new OAddThread(); - OAddThread *pBelowNormalThread = new OAddThread(); - OAddThread *pLowestThread = new OAddThread(); - - //Create them and start running at the same time - pHighestThread->createSuspended(); - pHighestThread->setPriority(osl_Thread_PriorityHighest); - - pAboveNormalThread->createSuspended(); - pAboveNormalThread->setPriority(osl_Thread_PriorityAboveNormal); - - pNormalThread->createSuspended(); - pNormalThread->setPriority(osl_Thread_PriorityNormal); - - pBelowNormalThread->createSuspended(); - pBelowNormalThread->setPriority(osl_Thread_PriorityBelowNormal); - - pLowestThread->createSuspended(); - pLowestThread->setPriority(osl_Thread_PriorityLowest); - - pHighestThread->resume(); - pAboveNormalThread->resume(); - pNormalThread->resume(); - pBelowNormalThread->resume(); - pLowestThread->resume(); - - ThreadHelper::thread_sleep_tenth_sec(5); - - pHighestThread->suspend(); - pAboveNormalThread->suspend(); - pNormalThread->suspend(); - pBelowNormalThread->suspend(); - pLowestThread->suspend(); - - termAndJoinThread(pHighestThread); - termAndJoinThread(pAboveNormalThread); - termAndJoinThread(pNormalThread); - termAndJoinThread(pBelowNormalThread); - termAndJoinThread(pLowestThread); - - sal_Int32 nValueHighest = 0; - nValueHighest = pHighestThread->getValue(); - - sal_Int32 nValueAboveNormal = 0; - nValueAboveNormal = pAboveNormalThread->getValue(); - - sal_Int32 nValueNormal = 0; - nValueNormal = pNormalThread->getValue(); - - sal_Int32 nValueBelowNormal = 0; - nValueBelowNormal = pBelowNormalThread->getValue(); - - sal_Int32 nValueLowest = 0; - nValueLowest = pLowestThread->getValue(); + } - t_print("After 10 tenth seconds\n"); - t_print("nValue in Highest Prio Thread is %d\n",nValueHighest); - t_print("nValue in AboveNormal Prio Thread is %d\n",nValueAboveNormal); - t_print("nValue in Normal Prio Thread is %d\n",nValueNormal); - t_print("nValue in BelowNormal Prio Thread is %d\n",nValueBelowNormal); - t_print("nValue in Lowest Prio Thread is %d\n",nValueLowest); - - delete pHighestThread; - delete pAboveNormalThread; - delete pNormalThread; - delete pBelowNormalThread; - delete pLowestThread; - - // LLA: this is not a save test, so we only check if all values not zero - // LLA: CPPUNIT_ASSERT_MESSAGE( - // LLA: "SetPriority", - // LLA: nValueHighest > nValueAboveNormal && - // LLA: nValueAboveNormal > nValueNormal && - // LLA: nValueNormal > nValueBelowNormal && - // LLA: nValueBelowNormal > nValueLowest && - // LLA: nValueLowest > 0 - // LLA: ); + TEST_F(setPriority, setPriority_003) + { + // initial 5 threads with different priorities + OAddThread *pHighestThread = new OAddThread(); + OAddThread *pAboveNormalThread = new OAddThread(); + OAddThread *pNormalThread = new OAddThread(); + OAddThread *pBelowNormalThread = new OAddThread(); + OAddThread *pLowestThread = new OAddThread(); + + //Create them and start running at the same time + pHighestThread->createSuspended(); + pHighestThread->setPriority(osl_Thread_PriorityHighest); + + pAboveNormalThread->createSuspended(); + pAboveNormalThread->setPriority(osl_Thread_PriorityAboveNormal); + + pNormalThread->createSuspended(); + pNormalThread->setPriority(osl_Thread_PriorityNormal); + + pBelowNormalThread->createSuspended(); + pBelowNormalThread->setPriority(osl_Thread_PriorityBelowNormal); + + pLowestThread->createSuspended(); + pLowestThread->setPriority(osl_Thread_PriorityLowest); + + pHighestThread->resume(); + pAboveNormalThread->resume(); + pNormalThread->resume(); + pBelowNormalThread->resume(); + pLowestThread->resume(); + + ThreadHelper::thread_sleep_tenth_sec(5); + + pHighestThread->suspend(); + pAboveNormalThread->suspend(); + pNormalThread->suspend(); + pBelowNormalThread->suspend(); + pLowestThread->suspend(); + + termAndJoinThread(pHighestThread); + termAndJoinThread(pAboveNormalThread); + termAndJoinThread(pNormalThread); + termAndJoinThread(pBelowNormalThread); + termAndJoinThread(pLowestThread); + + sal_Int32 nValueHighest = 0; + nValueHighest = pHighestThread->getValue(); + + sal_Int32 nValueAboveNormal = 0; + nValueAboveNormal = pAboveNormalThread->getValue(); + + sal_Int32 nValueNormal = 0; + nValueNormal = pNormalThread->getValue(); + + sal_Int32 nValueBelowNormal = 0; + nValueBelowNormal = pBelowNormalThread->getValue(); + + sal_Int32 nValueLowest = 0; + nValueLowest = pLowestThread->getValue(); + + printf("After 10 tenth seconds\n"); + printf("nValue in Highest Prio Thread is %d\n",nValueHighest); + printf("nValue in AboveNormal Prio Thread is %d\n",nValueAboveNormal); + printf("nValue in Normal Prio Thread is %d\n",nValueNormal); + printf("nValue in BelowNormal Prio Thread is %d\n",nValueBelowNormal); + printf("nValue in Lowest Prio Thread is %d\n",nValueLowest); + + delete pHighestThread; + delete pAboveNormalThread; + delete pNormalThread; + delete pBelowNormalThread; + delete pLowestThread; + + // LLA: this is not a save test, so we only check if all values not zero + // LLA: ASSERT_TRUE(// LLA: nValueHighest > nValueAboveNormal && + // LLA: nValueAboveNormal > nValueNormal && + // LLA: nValueNormal > nValueBelowNormal && + // LLA: nValueBelowNormal > nValueLowest && + // LLA: nValueLowest > 0 + // LLA:) << // LLA: "SetPriority"; // LLA: windows let starve threads with lower priority #ifndef WNT - CPPUNIT_ASSERT_MESSAGE( - "SetPriority", - nValueHighest > 0 && - nValueAboveNormal > 0 && - nValueNormal > 0 && - nValueBelowNormal > 0 && - nValueLowest > 0 - ); + ASSERT_TRUE(nValueHighest > 0 && + nValueAboveNormal > 0 && + nValueNormal > 0 && + nValueBelowNormal > 0 && + nValueLowest > 0) << "SetPriority"; #endif - } - - void setPriority_004() - { - // initial 5 threads with different priorities - // OAddThread *pHighestThread = new OAddThread(); - OAddThread *pAboveNormalThread = new OAddThread(); - OAddThread *pNormalThread = new OAddThread(); - OAddThread *pBelowNormalThread = new OAddThread(); - OAddThread *pLowestThread = new OAddThread(); - - //Create them and start running at the same time - // pHighestThread->createSuspended(); - // pHighestThread->setPriority(osl_Thread_PriorityHighest); - - pAboveNormalThread->createSuspended(); - pAboveNormalThread->setPriority(osl_Thread_PriorityAboveNormal); - - pNormalThread->createSuspended(); - pNormalThread->setPriority(osl_Thread_PriorityNormal); - - pBelowNormalThread->createSuspended(); - pBelowNormalThread->setPriority(osl_Thread_PriorityBelowNormal); - - pLowestThread->createSuspended(); - pLowestThread->setPriority(osl_Thread_PriorityLowest); - - // pHighestThread->resume(); - pAboveNormalThread->resume(); - pNormalThread->resume(); - pBelowNormalThread->resume(); - pLowestThread->resume(); - - ThreadHelper::thread_sleep_tenth_sec(5); - - // pHighestThread->suspend(); - pAboveNormalThread->suspend(); - pNormalThread->suspend(); - pBelowNormalThread->suspend(); - pLowestThread->suspend(); - - // termAndJoinThread(pHighestThread); - termAndJoinThread(pAboveNormalThread); - termAndJoinThread(pNormalThread); - termAndJoinThread(pBelowNormalThread); - termAndJoinThread(pLowestThread); - - // sal_Int32 nValueHighest = 0; - // nValueHighest = pHighestThread->getValue(); - - sal_Int32 nValueAboveNormal = 0; - nValueAboveNormal = pAboveNormalThread->getValue(); - - sal_Int32 nValueNormal = 0; - nValueNormal = pNormalThread->getValue(); - - sal_Int32 nValueBelowNormal = 0; - nValueBelowNormal = pBelowNormalThread->getValue(); - - sal_Int32 nValueLowest = 0; - nValueLowest = pLowestThread->getValue(); + } - t_print("After 5 tenth seconds\n"); - // t_print("nValue in Highest Prio Thread is %d\n",nValueHighest); - t_print("nValue in AboveNormal Prio Thread is %d\n",nValueAboveNormal); - t_print("nValue in Normal Prio Thread is %d\n",nValueNormal); - t_print("nValue in BelowNormal Prio Thread is %d\n",nValueBelowNormal); - t_print("nValue in Lowest Prio Thread is %d\n",nValueLowest); - - // delete pHighestThread; - delete pAboveNormalThread; - delete pNormalThread; - delete pBelowNormalThread; - delete pLowestThread; - - // LLA: this is not a save test, so we only check if all values not zero - // LLA: CPPUNIT_ASSERT_MESSAGE( - // LLA: "SetPriority", - // LLA: nValueHighest > nValueAboveNormal && - // LLA: nValueAboveNormal > nValueNormal && - // LLA: nValueNormal > nValueBelowNormal && - // LLA: nValueBelowNormal > nValueLowest && - // LLA: nValueLowest > 0 - // LLA: ); + TEST_F(setPriority, setPriority_004) + { + // initial 5 threads with different priorities + // OAddThread *pHighestThread = new OAddThread(); + OAddThread *pAboveNormalThread = new OAddThread(); + OAddThread *pNormalThread = new OAddThread(); + OAddThread *pBelowNormalThread = new OAddThread(); + OAddThread *pLowestThread = new OAddThread(); + + //Create them and start running at the same time + // pHighestThread->createSuspended(); + // pHighestThread->setPriority(osl_Thread_PriorityHighest); + + pAboveNormalThread->createSuspended(); + pAboveNormalThread->setPriority(osl_Thread_PriorityAboveNormal); + + pNormalThread->createSuspended(); + pNormalThread->setPriority(osl_Thread_PriorityNormal); + + pBelowNormalThread->createSuspended(); + pBelowNormalThread->setPriority(osl_Thread_PriorityBelowNormal); + + pLowestThread->createSuspended(); + pLowestThread->setPriority(osl_Thread_PriorityLowest); + + // pHighestThread->resume(); + pAboveNormalThread->resume(); + pNormalThread->resume(); + pBelowNormalThread->resume(); + pLowestThread->resume(); + + ThreadHelper::thread_sleep_tenth_sec(5); + + // pHighestThread->suspend(); + pAboveNormalThread->suspend(); + pNormalThread->suspend(); + pBelowNormalThread->suspend(); + pLowestThread->suspend(); + + // termAndJoinThread(pHighestThread); + termAndJoinThread(pAboveNormalThread); + termAndJoinThread(pNormalThread); + termAndJoinThread(pBelowNormalThread); + termAndJoinThread(pLowestThread); + + // sal_Int32 nValueHighest = 0; + // nValueHighest = pHighestThread->getValue(); + + sal_Int32 nValueAboveNormal = 0; + nValueAboveNormal = pAboveNormalThread->getValue(); + + sal_Int32 nValueNormal = 0; + nValueNormal = pNormalThread->getValue(); + + sal_Int32 nValueBelowNormal = 0; + nValueBelowNormal = pBelowNormalThread->getValue(); + + sal_Int32 nValueLowest = 0; + nValueLowest = pLowestThread->getValue(); + + printf("After 5 tenth seconds\n"); + // printf("nValue in Highest Prio Thread is %d\n",nValueHighest); + printf("nValue in AboveNormal Prio Thread is %d\n",nValueAboveNormal); + printf("nValue in Normal Prio Thread is %d\n",nValueNormal); + printf("nValue in BelowNormal Prio Thread is %d\n",nValueBelowNormal); + printf("nValue in Lowest Prio Thread is %d\n",nValueLowest); + + // delete pHighestThread; + delete pAboveNormalThread; + delete pNormalThread; + delete pBelowNormalThread; + delete pLowestThread; + + // LLA: this is not a save test, so we only check if all values not zero + // LLA: ASSERT_TRUE(// LLA: nValueHighest > nValueAboveNormal && + // LLA: nValueAboveNormal > nValueNormal && + // LLA: nValueNormal > nValueBelowNormal && + // LLA: nValueBelowNormal > nValueLowest && + // LLA: nValueLowest > 0 + // LLA:) << // LLA: "SetPriority"; // LLA: windows let starve threads with lower priority #ifndef WNT - CPPUNIT_ASSERT_MESSAGE( - "SetPriority", - /* nValueHighest > 0 && */ - nValueAboveNormal > 0 && - nValueNormal > 0 && - nValueBelowNormal > 0 && - nValueLowest > 0 - ); + ASSERT_TRUE(/* nValueHighest > 0 && */ + nValueAboveNormal > 0 && + nValueNormal > 0 && + nValueBelowNormal > 0 && + nValueLowest > 0) << "SetPriority"; #endif - } - void setPriority_005() - { - // initial 5 threads with different priorities - // OAddThread *pHighestThread = new OAddThread(); - // OAddThread *pAboveNormalThread = new OAddThread(); - OAddThread *pNormalThread = new OAddThread(); - OAddThread *pBelowNormalThread = new OAddThread(); - OAddThread *pLowestThread = new OAddThread(); - - //Create them and start running at the same time - // pHighestThread->createSuspended(); - // pHighestThread->setPriority(osl_Thread_PriorityHighest); - - // pAboveNormalThread->createSuspended(); - // pAboveNormalThread->setPriority(osl_Thread_PriorityAboveNormal); - - pNormalThread->createSuspended(); - pNormalThread->setPriority(osl_Thread_PriorityNormal); - - pBelowNormalThread->createSuspended(); - pBelowNormalThread->setPriority(osl_Thread_PriorityBelowNormal); - - pLowestThread->createSuspended(); - pLowestThread->setPriority(osl_Thread_PriorityLowest); - - // pHighestThread->resume(); - // pAboveNormalThread->resume(); - pNormalThread->resume(); - pBelowNormalThread->resume(); - pLowestThread->resume(); - - ThreadHelper::thread_sleep_tenth_sec(5); - - // pHighestThread->suspend(); - // pAboveNormalThread->suspend(); - pNormalThread->suspend(); - pBelowNormalThread->suspend(); - pLowestThread->suspend(); - - // termAndJoinThread(pHighestThread); - // termAndJoinThread(pAboveNormalThread); - termAndJoinThread(pNormalThread); - termAndJoinThread(pBelowNormalThread); - termAndJoinThread(pLowestThread); - - // sal_Int32 nValueHighest = 0; - // nValueHighest = pHighestThread->getValue(); - - // sal_Int32 nValueAboveNormal = 0; - // nValueAboveNormal = pAboveNormalThread->getValue(); - - sal_Int32 nValueNormal = 0; - nValueNormal = pNormalThread->getValue(); - - sal_Int32 nValueBelowNormal = 0; - nValueBelowNormal = pBelowNormalThread->getValue(); - - sal_Int32 nValueLowest = 0; - nValueLowest = pLowestThread->getValue(); - - t_print("After 5 tenth seconds\n"); - // t_print("nValue in Highest Prio Thread is %d\n",nValueHighest); - // t_print("nValue in AboveNormal Prio Thread is %d\n",nValueAboveNormal); - t_print("nValue in Normal Prio Thread is %d\n",nValueNormal); - t_print("nValue in BelowNormal Prio Thread is %d\n",nValueBelowNormal); - t_print("nValue in Lowest Prio Thread is %d\n",nValueLowest); - - // delete pHighestThread; - // delete pAboveNormalThread; - delete pNormalThread; - delete pBelowNormalThread; - delete pLowestThread; - - // LLA: this is not a save test, so we only check if all values not zero - // LLA: CPPUNIT_ASSERT_MESSAGE( - // LLA: "SetPriority", - // LLA: nValueHighest > nValueAboveNormal && - // LLA: nValueAboveNormal > nValueNormal && - // LLA: nValueNormal > nValueBelowNormal && - // LLA: nValueBelowNormal > nValueLowest && - // LLA: nValueLowest > 0 - // LLA: ); + } + TEST_F(setPriority, setPriority_005) + { + // initial 5 threads with different priorities + // OAddThread *pHighestThread = new OAddThread(); + // OAddThread *pAboveNormalThread = new OAddThread(); + OAddThread *pNormalThread = new OAddThread(); + OAddThread *pBelowNormalThread = new OAddThread(); + OAddThread *pLowestThread = new OAddThread(); + + //Create them and start running at the same time + // pHighestThread->createSuspended(); + // pHighestThread->setPriority(osl_Thread_PriorityHighest); + + // pAboveNormalThread->createSuspended(); + // pAboveNormalThread->setPriority(osl_Thread_PriorityAboveNormal); + + pNormalThread->createSuspended(); + pNormalThread->setPriority(osl_Thread_PriorityNormal); + + pBelowNormalThread->createSuspended(); + pBelowNormalThread->setPriority(osl_Thread_PriorityBelowNormal); + + pLowestThread->createSuspended(); + pLowestThread->setPriority(osl_Thread_PriorityLowest); + + // pHighestThread->resume(); + // pAboveNormalThread->resume(); + pNormalThread->resume(); + pBelowNormalThread->resume(); + pLowestThread->resume(); + + ThreadHelper::thread_sleep_tenth_sec(5); + + // pHighestThread->suspend(); + // pAboveNormalThread->suspend(); + pNormalThread->suspend(); + pBelowNormalThread->suspend(); + pLowestThread->suspend(); + + // termAndJoinThread(pHighestThread); + // termAndJoinThread(pAboveNormalThread); + termAndJoinThread(pNormalThread); + termAndJoinThread(pBelowNormalThread); + termAndJoinThread(pLowestThread); + + // sal_Int32 nValueHighest = 0; + // nValueHighest = pHighestThread->getValue(); + + // sal_Int32 nValueAboveNormal = 0; + // nValueAboveNormal = pAboveNormalThread->getValue(); + + sal_Int32 nValueNormal = 0; + nValueNormal = pNormalThread->getValue(); + + sal_Int32 nValueBelowNormal = 0; + nValueBelowNormal = pBelowNormalThread->getValue(); + + sal_Int32 nValueLowest = 0; + nValueLowest = pLowestThread->getValue(); + + printf("After 5 tenth seconds\n"); + // printf("nValue in Highest Prio Thread is %d\n",nValueHighest); + // printf("nValue in AboveNormal Prio Thread is %d\n",nValueAboveNormal); + printf("nValue in Normal Prio Thread is %d\n",nValueNormal); + printf("nValue in BelowNormal Prio Thread is %d\n",nValueBelowNormal); + printf("nValue in Lowest Prio Thread is %d\n",nValueLowest); + + // delete pHighestThread; + // delete pAboveNormalThread; + delete pNormalThread; + delete pBelowNormalThread; + delete pLowestThread; + + // LLA: this is not a save test, so we only check if all values not zero + // LLA: ASSERT_TRUE(// LLA: nValueHighest > nValueAboveNormal && + // LLA: nValueAboveNormal > nValueNormal && + // LLA: nValueNormal > nValueBelowNormal && + // LLA: nValueBelowNormal > nValueLowest && + // LLA: nValueLowest > 0 + // LLA:) << // LLA: "SetPriority"; // LLA: windows let starve threads with lower priority #ifndef WNT - CPPUNIT_ASSERT_MESSAGE( - "SetPriority", - /* nValueHighest > 0 && */ - /* nValueAboveNormal > 0 && */ - nValueNormal > 0 && - nValueBelowNormal > 0 && - nValueLowest > 0 - ); + ASSERT_TRUE(/* nValueHighest > 0 && */ + /* nValueAboveNormal > 0 && */ + nValueNormal > 0 && + nValueBelowNormal > 0 && + nValueLowest > 0) << "SetPriority"; #endif - } - + } +#endif // SOLARIS - CPPUNIT_TEST_SUITE(setPriority); -#ifndef SOLARIS - CPPUNIT_TEST(setPriority_002); - CPPUNIT_TEST(setPriority_003); - CPPUNIT_TEST(setPriority_004); - CPPUNIT_TEST(setPriority_005); -#endif - CPPUNIT_TEST(setPriority_001_1); - CPPUNIT_TEST(setPriority_001_2); - CPPUNIT_TEST(setPriority_001_3); - CPPUNIT_TEST(setPriority_001_4); - CPPUNIT_TEST(setPriority_001_5); - CPPUNIT_TEST_SUITE_END(); - }; // class setPriority /** Test of the osl::Thread::getPriority method */ - class getPriority : public CppUnit::TestFixture + class getPriority : public ::testing::Test { public: // initialise your test code values here. - void setUp() + void SetUp() { } - void tearDown() + void TearDown() { } + }; // class getPriority - // insert your test code here. - void getPriority_001() - { - OAddThread *pHighestThread = new OAddThread(); + TEST_F(getPriority, getPriority_001) + { + OAddThread *pHighestThread = new OAddThread(); - //Create them and start running at the same time - pHighestThread->create(); - pHighestThread->setPriority(osl_Thread_PriorityHighest); + //Create them and start running at the same time + pHighestThread->create(); + pHighestThread->setPriority(osl_Thread_PriorityHighest); - oslThreadPriority aPriority = pHighestThread->getPriority(); - termAndJoinThread(pHighestThread); - delete pHighestThread; + oslThreadPriority aPriority = pHighestThread->getPriority(); + termAndJoinThread(pHighestThread); + delete pHighestThread; - ThreadHelper::outputPriority(aPriority); + ThreadHelper::outputPriority(aPriority); // LLA: Priority settings may not work within some OS versions. #if ( defined WNT ) || ( defined SOLARIS ) - CPPUNIT_ASSERT_MESSAGE( - "getPriority", - aPriority == osl_Thread_PriorityHighest - ); + ASSERT_TRUE(aPriority == osl_Thread_PriorityHighest) << "getPriority"; #else // LLA: Linux // NO_PTHREAD_PRIORITY ??? - CPPUNIT_ASSERT_MESSAGE( - "getPriority", - aPriority == osl_Thread_PriorityNormal - ); + ASSERT_TRUE(aPriority == osl_Thread_PriorityNormal) << "getPriority"; #endif - } - - void getPriority_002() - { + } - } + TEST_F(getPriority, getPriority_002) + { - CPPUNIT_TEST_SUITE(getPriority); - CPPUNIT_TEST(getPriority_001); - CPPUNIT_TEST(getPriority_002); - CPPUNIT_TEST_SUITE_END(); - }; // class getPriority + } - class getIdentifier : public CppUnit::TestFixture + class getIdentifier : public ::testing::Test { public: // initialise your test code values here. - void setUp() + void SetUp() { } - void tearDown() + void TearDown() { } + }; // class getIdentifier - // insert your test code here. - void getIdentifier_001() - { - - } + // insert your test code here. + TEST_F(getIdentifier, getIdentifier_001) + { - void getIdentifier_002() - { + } - } + TEST_F(getIdentifier, getIdentifier_002) + { - CPPUNIT_TEST_SUITE(getIdentifier); - CPPUNIT_TEST(getIdentifier_001); - CPPUNIT_TEST(getIdentifier_002); - CPPUNIT_TEST_SUITE_END(); - }; // class getIdentifier + } /** Test of the osl::Thread::getCurrentIdentifier method */ - class getCurrentIdentifier : public CppUnit::TestFixture + class getCurrentIdentifier : public ::testing::Test { public: // initialise your test code values here. - void setUp() + void SetUp() { } - void tearDown() + void TearDown() { } + }; // class getCurrentIdentifier - // insert your test code here. - void getCurrentIdentifier_001() - { - oslThreadIdentifier oId; - OCountThread* pCountThread = new OCountThread; - //OCountThread* pCountThread2 = new OCountThread; - pCountThread->create(); - //pCountThread2->create(); - pCountThread->setWait(3); - oId = Thread::getCurrentIdentifier(); - oslThreadIdentifier oIdChild = pCountThread->getIdentifier(); - //t_print("CurrentId is %ld, Child1 id is %ld, Child2 id is %ld\n",oId, oIdChild,pCountThread2->m_id ); - termAndJoinThread(pCountThread); - delete pCountThread; - //termAndJoinThread(pCountThread2); - //delete pCountThread2; + // insert your test code here. + TEST_F(getCurrentIdentifier, getCurrentIdentifier_001) + { + oslThreadIdentifier oId; + OCountThread* pCountThread = new OCountThread; + //OCountThread* pCountThread2 = new OCountThread; + pCountThread->create(); + //pCountThread2->create(); + pCountThread->setWait(3); + oId = Thread::getCurrentIdentifier(); + oslThreadIdentifier oIdChild = pCountThread->getIdentifier(); + //printf("CurrentId is %ld, Child1 id is %ld, Child2 id is %ld\n",oId, oIdChild,pCountThread2->m_id ); + termAndJoinThread(pCountThread); + delete pCountThread; + //termAndJoinThread(pCountThread2); + //delete pCountThread2; - CPPUNIT_ASSERT_MESSAGE( - "Get the identifier for the current active thread.", - oId != oIdChild - ); + ASSERT_TRUE(oId != oIdChild) << "Get the identifier for the current active thread."; - } + } - void getCurrentIdentifier_002() - { - } + TEST_F(getCurrentIdentifier, getCurrentIdentifier_002) + { + } - CPPUNIT_TEST_SUITE(getCurrentIdentifier); - CPPUNIT_TEST(getCurrentIdentifier_001); - //CPPUNIT_TEST(getCurrentIdentifier_002); - CPPUNIT_TEST_SUITE_END(); - }; // class getCurrentIdentifier /** Test of the osl::Thread::wait method */ - class wait : public CppUnit::TestFixture + class wait : public ::testing::Test { public: // initialise your test code values here. - void setUp() + void SetUp() { } - void tearDown() + void TearDown() { } + }; // class wait - /** call wait in the run method - ALGORITHM: - tested thread wait nWaitSec seconds, main thread sleep (2) seconds, - then terminate the tested thread, due to the fact that the thread do a sleep(1) + wait(5) - it's finish after 6 seconds. - */ - void wait_001() - { - OCountThread *aCountThread = new OCountThread(); - sal_Int32 nWaitSec = 5; - aCountThread->setWait(nWaitSec); - // thread runs at least 5 seconds. - sal_Bool bRes = aCountThread->create(); - CPPUNIT_ASSERT_MESSAGE ( "Can't start thread!", bRes == sal_True ); - - //record the time when the running begin - StopWatch aStopWatch; - aStopWatch.start(); - - // wait a little bit, to let the thread the time, to start - ThreadHelper::thread_sleep_tenth_sec( 4 ); - - // if wait works, - // this function returns, after 4 sec. later - termAndJoinThread(aCountThread); - - // value should be one. - sal_Int32 nValue = aCountThread->getValue(); - - aStopWatch.stop(); - - // sal_uInt32 nSec = aTimeVal_after.Seconds - aTimeVal_befor.Seconds; - double nTenthSec = aStopWatch.getTenthSec(); - double nSec = aStopWatch.getSeconds(); - delete aCountThread; - t_print("nTenthSec = %f \n", nTenthSec); - t_print("nSec = %f \n", nSec); - t_print("nValue = %d \n", nValue); - - CPPUNIT_ASSERT_MESSAGE( - "Wait: Blocks the calling thread for the given number of time.", - nTenthSec >= 5 && nValue == 1 - ); + /** call wait in the run method - } + ALGORITHM: + tested thread wait nWaitSec seconds, main thread sleep (2) seconds, + then terminate the tested thread, due to the fact that the thread do a sleep(1) + wait(5) + it's finish after 6 seconds. + */ + TEST_F(wait, wait_001) + { + OCountThread *aCountThread = new OCountThread(); + sal_Int32 nWaitSec = 5; + aCountThread->setWait(nWaitSec); + // thread runs at least 5 seconds. + sal_Bool bRes = aCountThread->create(); + ASSERT_TRUE(bRes == sal_True) << "Can't start thread!"; + + //record the time when the running begin + StopWatch aStopWatch; + aStopWatch.start(); + + // wait a little bit, to let the thread the time, to start + ThreadHelper::thread_sleep_tenth_sec( 4 ); + + // if wait works, + // this function returns, after 4 sec. later + termAndJoinThread(aCountThread); + + // value should be one. + sal_Int32 nValue = aCountThread->getValue(); + + aStopWatch.stop(); + + // sal_uInt32 nSec = aTimeVal_after.Seconds - aTimeVal_befor.Seconds; + double nTenthSec = aStopWatch.getTenthSec(); + double nSec = aStopWatch.getSeconds(); + delete aCountThread; + printf("nTenthSec = %f \n", nTenthSec); + printf("nSec = %f \n", nSec); + printf("nValue = %d \n", nValue); + + ASSERT_TRUE(nTenthSec >= 5 && nValue == 1) << "Wait: Blocks the calling thread for the given number of time."; + + } // LLA: wait_001 does the same. // LLA: /** wait then terminate the thread // LLA: @@ -1812,7 +1676,7 @@ namespace osl_Thread // LLA: wait nWaitSec seconds, and terminate when the wait does not finish // LLA: Windows & UNX: thread terminates immediatlly // LLA: */ -// LLA: void wait_002() +// LLA: TEST_F(wait, wait_002) // LLA: { // LLA: OCountThread aThread; // LLA: @@ -1820,7 +1684,7 @@ namespace osl_Thread // LLA: aThread.setWait(nWaitSec); // LLA: // LLA: sal_Bool bRes = aThread.create(); -// LLA: CPPUNIT_ASSERT_MESSAGE ( "Can't start thread!", bRes == sal_True ); +// LLA: ASSERT_TRUE(bRes == sal_True) << "Can't start thread!"; // LLA: // LLA: StopWatch aStopWatch; // LLA: // TimeValue aTimeVal_befor; @@ -1835,184 +1699,135 @@ namespace osl_Thread // LLA: aStopWatch.stop(); // LLA: // sal_Int32 nSec = aTimeVal_after.Seconds - aTimeVal_befor.Seconds; // LLA: double nSec = aStopWatch.getSeconds(); -// LLA: t_print("sec=%f\n", nSec); -// LLA: t_print("nValue = %d\n", nValue); +// LLA: printf("sec=%f\n", nSec); +// LLA: printf("nValue = %d\n", nValue); // LLA: -// LLA: CPPUNIT_ASSERT_MESSAGE( -// LLA: "Wait: Blocks the calling thread for the given number of time.", -// LLA: nSec < 1 && nValue == 0 -// LLA: ); +// LLA: ASSERT_TRUE(// LLA: nSec < 1 && nValue == 0 +// LLA:) << // LLA: "Wait: Blocks the calling thread for the given number of time."; // LLA: } - - CPPUNIT_TEST_SUITE(wait); - CPPUNIT_TEST(wait_001); - // LLA: CPPUNIT_TEST(wait_002); - CPPUNIT_TEST_SUITE_END(); - }; // class wait - /** osl::Thread::yield method: can not design good test scenario to test up to now */ - class yield : public CppUnit::TestFixture + class yield : public ::testing::Test { public: - void setUp() - { - } - - void tearDown() + void SetUp() { } - // insert your test code here. - void yield_001() + void TearDown() { } - - - CPPUNIT_TEST_SUITE(yield); - CPPUNIT_TEST(yield_001); - CPPUNIT_TEST_SUITE_END(); }; // class yield + // insert your test code here. + TEST_F(yield, yield_001) + { + } + /** Test of the osl::Thread::schedule method */ - class schedule : public CppUnit::TestFixture + class schedule : public ::testing::Test { public: // initialise your test code values here. - void setUp() + void SetUp() { } - void tearDown() + void TearDown() { } + }; // class schedule - /** The requested thread will get terminate the next time schedule() is called. - - Note: on UNX, if call suspend thread is not the to be suspended thread, the to be - suspended thread will get suspended the next time schedule() is called, - while on w32, it's nothing with schedule. + /** The requested thread will get terminate the next time schedule() is called. - check if suspend and terminate work well via schedule - */ - void schedule_001() - { - OAddThread* aThread = new OAddThread(); - sal_Bool bRes = aThread->create(); - CPPUNIT_ASSERT_MESSAGE ( "Can't start thread!", bRes == sal_True ); + Note: on UNX, if call suspend thread is not the to be suspended thread, the to be + suspended thread will get suspended the next time schedule() is called, + while on w32, it's nothing with schedule. - ThreadHelper::thread_sleep_tenth_sec(2); - aThread->suspend(); - ThreadHelper::thread_sleep_tenth_sec(1); - sal_Int32 nValue = aThread->getValue();
[... 597 lines stripped ...]
