You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@openoffice.apache.org by da...@apache.org on 2015/09/04 18:32:10 UTC
svn commit: r1701288 [2/3] - in /openoffice/trunk/main/sal/qa/osl/process:
makefile.mk osl_Thread.cxx osl_process.cxx
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 ...]