xref: /aoo42x/main/sal/qa/osl/process/osl_Thread.cxx (revision 30acf5e8)
1 /**************************************************************
2  *
3  * Licensed to the Apache Software Foundation (ASF) under one
4  * or more contributor license agreements.  See the NOTICE file
5  * distributed with this work for additional information
6  * regarding copyright ownership.  The ASF licenses this file
7  * to you under the Apache License, Version 2.0 (the
8  * "License"); you may not use this file except in compliance
9  * with the License.  You may obtain a copy of the License at
10  *
11  *   http://www.apache.org/licenses/LICENSE-2.0
12  *
13  * Unless required by applicable law or agreed to in writing,
14  * software distributed under the License is distributed on an
15  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16  * KIND, either express or implied.  See the License for the
17  * specific language governing permissions and limitations
18  * under the License.
19  *
20  *************************************************************/
21 
22 
23 
24 // MARKER(update_precomp.py): autogen include statement, do not remove
25 #include "precompiled_sal.hxx"
26 //------------------------------------------------------------------------
27 // include files
28 //------------------------------------------------------------------------
29 #include <sal/types.h>
30 
31 #ifndef _RTL_USTRING_HXX_
32 #include <rtl/string.hxx>
33 #endif
34 
35 #ifndef _RTL_USTRING_HXX_
36 #include <rtl/strbuf.hxx>
37 #endif
38 
39 #ifndef _OSL_THREAD_HXX
40 #include <osl/thread.hxx>
41 #endif
42 
43 #ifndef _OSL_MUTEX_HXX
44 #include <osl/mutex.hxx>
45 #endif
46 #include <osl/time.h>
47 
48 #include "gtest/gtest.h"
49 
50 using namespace osl;
51 using namespace rtl;
52 
53 #ifdef UNX
54 #include <unistd.h>
55 #include <time.h>
56 #endif
57 // -----------------------------------------------------------------------------
58 // Kleine Stopuhr
59 class StopWatch {
60     TimeValue t1,t2;                                // Start und Stopzeit
61 
62 protected:
63     sal_Int32 m_nNanoSec;
64     sal_Int32 m_nSeconds;
65 
66     bool m_bIsValid;                                   // TRUE, wenn gestartet und gestoppt
67     bool m_bIsRunning;                                 // TRUE, wenn gestartet.
68 
69 public:
70     StopWatch();
~StopWatch()71     ~StopWatch() {}
72 
73     void start();                                 // Startet Timer
74     void stop();                                  // Stoppt Timer
75 
76     double getSeconds() const;
77     double getTenthSec() const;
78 };
79 
80 // ================================= Stop Watch =================================
81 
82 // Eine kleine Stop-Uhr fuer den internen Gebrauch.
83 // (c) Lars Langhans 29.12.1996 22:10
84 
StopWatch()85 StopWatch::StopWatch():m_bIsValid(false),m_bIsRunning(false) {}
86 
start()87 void StopWatch::start()
88 {
89 // pre: %
90 // post: Start Timer
91 
92     m_bIsValid = false;
93     m_bIsRunning = true;
94     osl_getSystemTime( &t1 );
95     printf("# %d %d nsecs\n", t1.Seconds, t1.Nanosec);
96     // gettimeofday(&t1, 0);
97 }
98 
stop()99 void StopWatch::stop()
100 {
101 // pre: Timer should be started
102 // post: Timer will stopped
103 
104     // gettimeofday(&t2, 0);                         // Timer ausfragen
105     osl_getSystemTime( &t2 );
106     printf("# %d %d nsecs\n", t2.Seconds, t2.Nanosec);
107 
108     if (m_bIsRunning)
109     {                                // check ob gestartet.
110 // LLA: old         m_nNanoSec = static_cast<sal_Int32>(t2.Nanosec) - static_cast<sal_Int32>(t1.Nanosec);
111 // LLA: old         m_nSeconds = static_cast<sal_Int32>(t2.Seconds) - static_cast<sal_Int32>(t1.Seconds);
112 // LLA: old         if (m_nNanoSec < 0)
113 // LLA: old         {
114 // LLA: old             m_nNanoSec += 1000000000;
115 // LLA: old             m_nSeconds -= 1;
116 // LLA: old         }
117         //m_nNanoSec = t2.Nanosec - t1.Nanosec;
118         m_nSeconds = static_cast<sal_Int32>(t2.Seconds) - static_cast<sal_Int32>(t1.Seconds);
119         if ( t2.Nanosec > t1.Nanosec )
120        		m_nNanoSec = static_cast<sal_Int32>(t2.Nanosec) - static_cast<sal_Int32>(t1.Nanosec);
121        	else
122        	{
123 		m_nNanoSec = 1000000000 + static_cast<sal_Int32>(t2.Nanosec) - static_cast<sal_Int32>(t1.Nanosec);
124             	m_nSeconds -= 1;
125 	}
126 	printf("# %d %d nsecs\n", m_nSeconds, m_nNanoSec );
127         //if (m_nNanoSec < 0)
128         //{
129             //m_nNanoSec += 1000000000;
130             //m_nSeconds -= 1;
131         //}
132         m_bIsValid = true;
133         m_bIsRunning = false;
134     }
135 }
136 
getSeconds() const137 double StopWatch::getSeconds() const
138 {
139 // pre: gueltig = TRUE
140 // BACK: Zeit in Sekunden.
141 
142     double nValue = 0.0;
143     if (m_bIsValid)
144     {
145         nValue = double(m_nNanoSec) / 1000000000.0 + m_nSeconds; // milli micro nano
146     }
147     return nValue;
148 }
149 
getTenthSec() const150 double StopWatch::getTenthSec() const
151 {
152     double nValue = 0.0;
153     if (m_bIsValid)
154     {
155         nValue = double(m_nNanoSec) / 100000000.0 + m_nSeconds * 10;
156     }
157     return nValue ;
158 }
159 
160 // -----------------------------------------------------------------------------
161 template <class T>
162 class ThreadSafeValue
163 {
164     T   m_nFlag;
165     Mutex   m_aMutex;
166 public:
ThreadSafeValue(T n=0)167     ThreadSafeValue(T n = 0): m_nFlag(n) {}
getValue()168     T getValue()
169         {
170             //block if already acquired by another thread.
171             osl::MutexGuard g(m_aMutex);
172             return m_nFlag;
173         }
addValue(T n)174     void addValue(T n)
175         {
176             //only one thread operate on the flag.
177             osl::MutexGuard g(m_aMutex);
178             m_nFlag += n;
179         }
acquire()180     void acquire() {m_aMutex.acquire();}
release()181     void release() {m_aMutex.release();}
182 };
183 
184 // -----------------------------------------------------------------------------
185 namespace ThreadHelper
186 {
187     // typedef enum {
188     //     QUIET=1,
189     //     VERBOSE
190     // } eSleepVerboseMode;
191 
thread_sleep_tenth_sec(sal_Int32 _nTenthSec)192     void thread_sleep_tenth_sec(sal_Int32 _nTenthSec/*, eSleepVerboseMode nVerbose = VERBOSE*/)
193     {
194         // if (nVerbose == VERBOSE)
195         // {
196         //     printf("wait %d tenth seconds. ", _nTenthSec );
197         //     fflush(stdout);
198         // }
199 #ifdef WNT      //Windows
200         Sleep(_nTenthSec * 100 );
201 #endif
202 #if ( defined UNX ) || ( defined OS2 )  //Unix
203         TimeValue nTV;
204         nTV.Seconds = static_cast<sal_uInt32>( _nTenthSec/10 );
205         nTV.Nanosec = ( (_nTenthSec%10 ) * 100000000 );
206         osl_waitThread(&nTV);
207 #endif
208         // if (nVerbose == VERBOSE)
209         // {
210         //     printf("done\n");
211         // }
212     }
213 
outputPriority(oslThreadPriority const & _aPriority)214     void outputPriority(oslThreadPriority const& _aPriority)
215     {
216         // LLA: output the priority
217         if (_aPriority == osl_Thread_PriorityHighest)
218         {
219             printf("Prio is High\n");
220         }
221         else if (_aPriority == osl_Thread_PriorityAboveNormal)
222         {
223             printf("Prio is above normal\n");
224         }
225         else if (_aPriority == osl_Thread_PriorityNormal)
226         {
227             printf("Prio is normal\n");
228         }
229         else if (_aPriority == osl_Thread_PriorityBelowNormal)
230         {
231             printf("Prio is below normal\n");
232         }
233         else if (_aPriority == osl_Thread_PriorityLowest)
234         {
235             printf("Prio is lowest\n");
236         }
237         else
238         {
239             printf("Prio is unknown\n");
240         }
241     }
242 }
243 
244 /** Simple thread for testing Thread-create.
245 
246     Just add 1 of value 0, and after running, result is 1.
247  */
248 class myThread : public Thread
249 {
250     ThreadSafeValue<sal_Int32> m_aFlag;
251 public:
getValue()252     sal_Int32 getValue() { return m_aFlag.getValue(); }
253 protected:
254     /** guarded value which initialized 0
255 
256         @see ThreadSafeValue
257     */
run()258     void SAL_CALL run()
259         {
260             while(schedule())
261             {
262                 m_aFlag.addValue(1);
263                 ThreadHelper::thread_sleep_tenth_sec(1);
264             }
265         }
266 
267 public:
268 
suspend()269     virtual void SAL_CALL suspend()
270         {
271             m_aFlag.acquire();
272             ::osl::Thread::suspend();
273             m_aFlag.release();
274         }
275 
~myThread()276     ~myThread()
277         {
278             if (isRunning())
279             {
280                 printf("error: not terminated.\n");
281             }
282         }
283 
284 };
285 
286 // -----------------------------------------------------------------------------
287 /** Thread which has a flag add 1 every second until 20
288  */
289 class OCountThread : public Thread
290 {
291     ThreadSafeValue<sal_Int32> m_aFlag;
292 public:
OCountThread()293     OCountThread()
294         {
295             m_nWaitSec = 0;
296             printf("new OCountThread thread %d!\n", getIdentifier());
297         }
getValue()298     sal_Int32 getValue() { return m_aFlag.getValue(); }
299 
setWait(sal_Int32 nSec)300     void setWait(sal_Int32 nSec)
301         {
302             m_nWaitSec = nSec;
303             //m_bWait = sal_True;
304         }
305 
suspend()306     virtual void SAL_CALL suspend()
307         {
308             m_aFlag.acquire();
309             ::osl::Thread::suspend();
310             m_aFlag.release();
311         }
312 
313 protected:
314     //sal_Bool m_bWait;
315     sal_Int32 m_nWaitSec;
316 
run()317     void SAL_CALL run()
318         {
319             /// if the thread should terminate, schedule return false
320             while (m_aFlag.getValue() < 20 && schedule() == sal_True)
321             {
322                 m_aFlag.addValue(1);
323                 ThreadHelper::thread_sleep_tenth_sec(1);
324                 // TimeValue nTV;
325                 // nTV.Seconds = 1;
326                 // nTV.Nanosec = 0;
327                 // wait(nTV);
328 
329                 if (m_nWaitSec != 0)
330                 {
331                     //ThreadHelper::thread_sleep_tenth_sec(m_nWaitSec * 10);
332                     TimeValue nTV;
333                     nTV.Seconds = m_nWaitSec / 10 ;
334                     nTV.Nanosec = ( m_nWaitSec%10 ) * 100000000 ;
335                     wait( nTV );
336                     m_nWaitSec = 0;
337                 }
338             }
339         }
onTerminated()340     void SAL_CALL onTerminated()
341         {
342             printf("normally terminate this thread %d!\n", getIdentifier());
343         }
344 public:
345 
~OCountThread()346     ~OCountThread()
347         {
348             if (isRunning())
349             {
350                 printf("error: not terminated.\n");
351             }
352         }
353 
354 };
355 
356 /** call suspend in the run method
357 */
358 class OSuspendThread : public Thread
359 {
360     ThreadSafeValue<sal_Int32> m_aFlag;
361 public:
OSuspendThread()362     OSuspendThread(){ m_bSuspend = sal_False; }
getValue()363     sal_Int32 getValue() { return m_aFlag.getValue(); }
setSuspend()364     void setSuspend()
365         {
366             m_bSuspend = sal_True;
367         }
suspend()368     virtual void SAL_CALL suspend()
369         {
370             m_aFlag.acquire();
371             ::osl::Thread::suspend();
372             m_aFlag.release();
373         }
374 protected:
375     sal_Bool m_bSuspend;
run()376     void SAL_CALL run()
377         {
378             //if the thread should terminate, schedule return false
379             while (schedule() == sal_True)
380             {
381                 m_aFlag.addValue(1);
382 
383                 ThreadHelper::thread_sleep_tenth_sec(1);
384                 // m_bWait =    sal_False;
385                 // TimeValue nTV;
386                 // nTV.Seconds = 1;
387                 // nTV.Nanosec = 0;
388                 // wait(nTV);
389                 if (m_bSuspend == sal_True)
390                 {
391                     suspend();
392                     m_bSuspend  = sal_False;
393                 }
394             }
395         }
396 public:
397 
~OSuspendThread()398     ~OSuspendThread()
399         {
400             if (isRunning())
401             {
402                 printf("error: not terminated.\n");
403             }
404         }
405 
406 };
407 
408 /** no call schedule in the run method
409 */
410 class ONoScheduleThread : public Thread
411 {
412     ThreadSafeValue<sal_Int32> m_aFlag;
413 public:
getValue()414     sal_Int32 getValue() { return m_aFlag.getValue(); }
415 
suspend()416     virtual void SAL_CALL suspend()
417         {
418             m_aFlag.acquire();
419             ::osl::Thread::suspend();
420             m_aFlag.release();
421         }
422 protected:
run()423     void SAL_CALL run()
424         {
425             while (m_aFlag.getValue() < 10)
426             {
427                 m_aFlag.addValue(1);
428                 ThreadHelper::thread_sleep_tenth_sec(1);
429                 // TimeValue nTV;
430                 // nTV.Seconds = 1;
431                 // nTV.Nanosec = 0;
432                 // wait(nTV);
433             }
434         }
onTerminated()435     void SAL_CALL onTerminated()
436         {
437             printf("normally terminate this thread %d!\n", getIdentifier());
438         }
439 public:
ONoScheduleThread()440     ONoScheduleThread()
441         {
442                 printf("new thread id %d!\n", getIdentifier());
443         }
~ONoScheduleThread()444     ~ONoScheduleThread()
445         {
446             if (isRunning())
447             {
448                 printf("error: not terminated.\n");
449             }
450         }
451 
452 };
453 
454 /**
455 */
456 class OAddThread : public Thread
457 {
458     ThreadSafeValue<sal_Int32> m_aFlag;
459 public:
460     //oslThreadIdentifier m_id, m_CurId;
OAddThread()461     OAddThread(){}
getValue()462     sal_Int32 getValue() { return m_aFlag.getValue(); }
463 
suspend()464     virtual void SAL_CALL suspend()
465         {
466             m_aFlag.acquire();
467             ::osl::Thread::suspend();
468             m_aFlag.release();
469         }
470 protected:
run()471     void SAL_CALL run()
472         {
473             //if the thread should terminate, schedule return false
474             while (schedule() == sal_True)
475             {
476                 m_aFlag.addValue(1);
477             }
478         }
onTerminated()479     void SAL_CALL onTerminated()
480         {
481             // printf("normally terminate this thread %d!\n", getIdentifier());
482         }
483 public:
484 
~OAddThread()485     ~OAddThread()
486         {
487             if (isRunning())
488             {
489                 // printf("error: not terminated.\n");
490             }
491         }
492 
493 };
494 
495 namespace osl_Thread
496 {
497 
resumeAndWaitThread(Thread * _pThread)498     void resumeAndWaitThread(Thread* _pThread)
499     {
500         // This functions starts a thread, wait a second and suspends the thread
501         // Due to the fact, that a suspend and never run thread never really exists.
502 
503         // Note: on UNX, after createSuspended, and then terminate the thread, it performs well;
504         // while on Windows, after createSuspended, the thread can not terminate, wait endlessly,
505         // so here call resume at first, then call terminate.
506 #ifdef WNT
507         printf("resumeAndWaitThread\n");
508         _pThread->resume();
509         ThreadHelper::thread_sleep_tenth_sec(1);
510 #else
511         _pThread->resume();
512 #endif
513         // ThreadHelper::thread_sleep_tenth_sec(1);
514         // _pThread->suspend();
515         // ThreadHelper::thread_sleep_tenth_sec(1);
516     }
517 
518     // kill a running thread and join it, if it has terminated, do nothing
termAndJoinThread(Thread * _pThread)519     void termAndJoinThread(Thread* _pThread)
520     {
521         _pThread->terminate();
522 
523 // LLA: Windows feature???, a suspended thread can not terminated, so we have to weak it up
524 #ifdef WNT
525         _pThread->resume();
526         ThreadHelper::thread_sleep_tenth_sec(1);
527 #endif
528         printf("#wait for join.\n");
529         _pThread->join();
530     }
531 /** Test of the osl::Thread::create method
532  */
533 
534     class create : public ::testing::Test
535     {
536     public:
537 
538         // initialise your test code values here.
SetUp()539         void SetUp()
540             {
541             }
542 
TearDown()543         void TearDown()
544             {
545             }
546     }; // class create
547 
548 
549     /** Simple create a thread.
550 
551         Create a simple thread, it just does add 1 to value(which initialized 0),
552         if the thread run, the value should be 1.
553     */
TEST_F(create,create_001)554     TEST_F(create, create_001)
555         {
556             myThread* newthread = new myThread();
557             sal_Bool bRes = newthread->create();
558             ASSERT_TRUE(bRes == sal_True) << "Can not creates a new thread!\n";
559 
560             ThreadHelper::thread_sleep_tenth_sec(1);        // wait short
561             sal_Bool isRunning = newthread->isRunning();    // check if thread is running
562             /// wait for the new thread to assure it has run
563             ThreadHelper::thread_sleep_tenth_sec(3);
564             sal_Int32 nValue = newthread->getValue();
565             /// to assure the new thread has terminated
566             termAndJoinThread(newthread);
567             delete newthread;
568 
569             printf("   nValue = %d\n", nValue);
570             printf("isRunning = %d\n", isRunning);
571 
572             ASSERT_TRUE(nValue >= 1 && isRunning == sal_True) << "Creates a new thread";
573 
574         }
575 
576     /** only one running thread per instance, return false if create secondly
577      */
TEST_F(create,create_002)578     TEST_F(create, create_002)
579         {
580             myThread* newthread = new myThread();
581             sal_Bool res1 = newthread->create();
582             sal_Bool res2 = newthread->create();
583             printf("In non pro, an assertion should occurred. This behaviour is right.\n");
584             termAndJoinThread(newthread);
585             delete newthread;
586 
587             ASSERT_TRUE(res1 && !res2) << "Creates a new thread: can not create two threads per instance";
588 
589         }
590 
591 
592     /** Test of the osl::Thread::createSuspended method
593     */
594     class createSuspended : public ::testing::Test
595     {
596     public:
597         // initialise your test code values here.
SetUp()598         void SetUp()
599             {
600             }
601 
TearDown()602         void TearDown()
603             {
604             }
605     }; // class createSuspended
606 
607     /** Create a suspended thread, use the same class as create_001
608 
609         after create, wait enough time, check the value, if it's still the initial value, pass
610     */
TEST_F(createSuspended,createSuspended_001)611     TEST_F(createSuspended, createSuspended_001)
612         {
613             myThread* newthread = new myThread();
614             sal_Bool bRes = newthread->createSuspended();
615             ASSERT_TRUE(bRes == sal_True) << "Can not creates a new thread!";
616 
617             ThreadHelper::thread_sleep_tenth_sec(1);
618             sal_Bool isRunning = newthread->isRunning();
619             ThreadHelper::thread_sleep_tenth_sec(3);
620             sal_Int32 nValue = newthread->getValue();
621 
622             resumeAndWaitThread(newthread);
623 
624             termAndJoinThread(newthread);
625             delete newthread;
626 
627             ASSERT_TRUE(nValue == 0 && isRunning) << "Creates a new suspended thread";
628         }
629     // LLA: Deadlocked!!!
TEST_F(createSuspended,createSuspended_002)630     TEST_F(createSuspended, createSuspended_002)
631         {
632             myThread* newthread = new myThread();
633             sal_Bool res1 = newthread->createSuspended();
634             sal_Bool res2 = newthread->createSuspended();
635 
636             resumeAndWaitThread(newthread);
637 
638             termAndJoinThread(newthread);
639 
640             delete newthread;
641 
642             ASSERT_TRUE(res1 && !res2) << "Creates a new thread: can not create two threads per instance";
643         }
644 
645 
646     /** when the count value equal to or more than 3, suspend the thread.
647     */
suspendCountThread(OCountThread * _pCountThread)648     void suspendCountThread(OCountThread* _pCountThread)
649     {
650         sal_Int32 nValue = 0;
651         while (1)
652         {
653             nValue = _pCountThread->getValue();
654             if (nValue >= 3)
655             {
656                 _pCountThread->suspend();
657                 break;
658             }
659         }
660     }
661 
662     /** Test of the osl::Thread::suspend method
663     */
664     class suspend : public ::testing::Test
665     {
666     public:
667         // initialise your test code values here.
SetUp()668         void SetUp()
669             {
670             }
671 
TearDown()672         void TearDown()
673             {
674             }
675     }; // class suspend
676 
677     /** Use a thread which has a flag added 1 every second
678 
679         ALGORITHM:
680         create the thread, after running special time, record value of flag, then suspend it,
681         wait a long time, check the flag, if it remains unchanged during suspending
682     */
TEST_F(suspend,suspend_001)683     TEST_F(suspend, suspend_001)
684         {
685             OCountThread* aCountThread = new OCountThread();
686             sal_Bool bRes = aCountThread->create();
687             ASSERT_TRUE(bRes == sal_True) << "Can't start thread!";
688             // the thread run for some seconds, but not terminate
689             suspendCountThread( aCountThread );
690 
691             // the value just after calling suspend
692             sal_Int32 nValue = aCountThread->getValue();       // (2)
693 
694             ThreadHelper::thread_sleep_tenth_sec(3);
695 
696             // the value after waiting 3 seconds
697             sal_Int32 nLaterValue = aCountThread->getValue();    // (3)
698 
699             resumeAndWaitThread(aCountThread);
700             termAndJoinThread(aCountThread);
701             delete aCountThread;
702 
703             ASSERT_TRUE(bRes == sal_True && nValue == nLaterValue) << "Suspend the thread";
704 
705         }
706     /** suspend a thread in it's worker-function, the ALGORITHM is same as suspend_001
707          reason of deadlocked I think: no schedule can schedule other threads to go on excuting
708      */
TEST_F(suspend,suspend_002)709     TEST_F(suspend, suspend_002)
710         {
711 #if 0
712             OSuspendThread* aThread = new OSuspendThread();
713             sal_Bool bRes = aThread->create();
714             ASSERT_TRUE(bRes == sal_True) << "Can't start thread!";
715             // first the thread run for some seconds, but not terminate
716             sal_Int32 nValue = 0;
717             //while (1)
718             //{
719             ThreadHelper::thread_sleep_tenth_sec(3);
720             nValue = aThread->getValue();    // (1)
721             printf(" getValue is %d !", nValue );
722             if (nValue >= 2)
723             {
724                     aThread->setSuspend();
725                     //break;
726             }
727             //}
728             printf(" after while!");
729             // the value just after calling suspend
730             nValue = aThread->getValue();       // (2)
731 
732             ThreadHelper::thread_sleep_tenth_sec(3);
733             printf(" after sleep!");
734             // the value after waiting 3 seconds
735             sal_Int32 nLaterValue = aThread->getValue();        // (3)
736 
737             //resumeAndWaitThread(aThread);
738             aThread->resume();
739             termAndJoinThread(aThread);
740             delete aThread;
741 
742             ASSERT_TRUE(bRes == sal_True && nValue == nLaterValue) << "Suspend the thread";
743 #endif
744         }
745 
746 
747     /** Test of the osl::Thread::resume method
748     */
749     class resume : public ::testing::Test
750     {
751     public:
752         // initialise your test code values here.
SetUp()753         void SetUp()
754             {
755             }
756 
TearDown()757         void TearDown()
758             {
759             }
760     }; // class resume
761 
762     /** check if the thread run samely as usual after suspend and resume
763 
764         ALGORITHM:
765         compare the values before and after suspend, they should be same,
766         then compare values before and after resume, the difference should be same as the sleep seconds number
767     */
TEST_F(resume,resume_001)768     TEST_F(resume, resume_001)
769         {
770             OCountThread* pCountThread = new OCountThread();
771             sal_Bool bRes = pCountThread->create();
772             ASSERT_TRUE(bRes == sal_True) << "Can't start thread!";
773 
774             suspendCountThread(pCountThread);
775 
776             sal_Int32 nSuspendValue = pCountThread->getValue();  // (2)
777             // suspend for 3 seconds
778             ThreadHelper::thread_sleep_tenth_sec(3);
779             pCountThread->resume();
780 
781             ThreadHelper::thread_sleep_tenth_sec(3);
782             sal_Int32 nResumeValue = pCountThread->getValue();
783 
784             ThreadHelper::thread_sleep_tenth_sec(3);
785             sal_Int32 nLaterValue = pCountThread->getValue();
786 
787             termAndJoinThread(pCountThread);
788             delete pCountThread;
789 
790             printf("SuspendValue: %d\n", nSuspendValue);
791             printf("ResumeValue:  %d\n", nResumeValue);
792             printf("LaterValue:   %d\n", nLaterValue);
793 
794             /* LLA: this assumption is no longer relevant: nResumeValue ==  nSuspendValue && */
795             ASSERT_TRUE(nLaterValue >= 9 &&
796                 nResumeValue > nSuspendValue &&
797                 nLaterValue > nResumeValue) << "Suspend then resume the thread";
798 
799         }
800 
801     /** Create a suspended thread then resume, check if the thread has run
802      */
TEST_F(resume,resume_002)803     TEST_F(resume, resume_002)
804         {
805             myThread* newthread = new myThread();
806             sal_Bool bRes = newthread->createSuspended();
807             ASSERT_TRUE(bRes == sal_True) << "Can't create thread!";
808 
809             newthread->resume();
810             ThreadHelper::thread_sleep_tenth_sec(2);
811             sal_Int32 nValue = newthread->getValue();
812 
813             termAndJoinThread(newthread);
814             delete newthread;
815 
816             printf("   nValue = %d\n", nValue);
817 
818             ASSERT_TRUE(nValue >= 1) << "Creates a suspended thread, then resume";
819         }
820 
821     /** Test of the osl::Thread::terminate method
822     */
823     class terminate : public ::testing::Test
824     {
825     public:
826         // initialise your test code values here.
SetUp()827         void SetUp()
828             {
829             }
830 
TearDown()831         void TearDown()
832             {
833             }
834     }; // class terminate
835 
836     /** Check after call terminate if the running thread running go on executing
837 
838         ALGORITHM:
839         before and after call terminate, the values should be the same
840     */
TEST_F(terminate,terminate_001)841     TEST_F(terminate, terminate_001)
842         {
843             OCountThread* aCountThread = new OCountThread();
844             sal_Bool bRes = aCountThread->create();
845             ASSERT_TRUE(bRes == sal_True) << "Can't start thread!";
846 
847             ThreadHelper::thread_sleep_tenth_sec(2);
848             sal_Int32 nValue = aCountThread->getValue();
849             aCountThread->terminate();
850             ThreadHelper::thread_sleep_tenth_sec(2);
851             sal_Int32 nLaterValue = aCountThread->getValue();
852 
853             // isRunning should be false after terminate
854             sal_Bool isRunning = aCountThread->isRunning();
855             aCountThread->join();
856             delete aCountThread;
857 
858             printf("     nValue = %d\n", nValue);
859             printf("nLaterValue = %d\n", nLaterValue);
860 
861             ASSERT_TRUE(isRunning == sal_False && nLaterValue >= nValue) << "Terminate the thread";
862         }
863     /** Check if a suspended thread will terminate after call terminate, different on w32 and on UNX
864      */
TEST_F(terminate,terminate_002)865     TEST_F(terminate, terminate_002)
866         {
867             OCountThread* aCountThread = new OCountThread();
868             sal_Bool bRes = aCountThread->create();
869             ASSERT_TRUE(bRes == sal_True) << "Can't start thread!";
870 
871             ThreadHelper::thread_sleep_tenth_sec(1);
872             suspendCountThread(aCountThread);
873             sal_Int32 nValue = aCountThread->getValue();
874 
875             // seems a suspended thread can not be terminated on W32, while on Solaris can
876             resumeAndWaitThread(aCountThread);
877 
878             ThreadHelper::thread_sleep_tenth_sec(2);
879 
880             termAndJoinThread(aCountThread);
881             sal_Int32 nLaterValue = aCountThread->getValue();
882             delete aCountThread;
883 
884             printf("     nValue = %d\n", nValue);
885             printf("nLaterValue = %d\n", nLaterValue);
886 
887             ASSERT_TRUE(nLaterValue > nValue) << "Suspend then resume the thread";
888         }
889 
890 
891     /** Test of the osl::Thread::join method
892     */
893     class join : public ::testing::Test
894     {
895     public:
896         // initialise your test code values here.
SetUp()897         void SetUp()
898             {
899             }
900 
TearDown()901         void TearDown()
902             {
903             }
904     }; // class join
905 
906     /** Check after call terminate if the thread running function will not go on executing
907 
908         the next statement after join will not exec before the thread terminate
909         ALGORITHM:
910         recode system time at the beginning of the thread run, call join, then record system time again,
911         the difference of the two time should be equal or more than 20 seconds, the CountThead normally terminate
912     */
TEST_F(join,join_001)913     TEST_F(join, join_001)
914         {
915             OCountThread *aCountThread = new OCountThread();
916             sal_Bool bRes = aCountThread->create();
917             ASSERT_TRUE(bRes == sal_True) << "Can't start thread!";
918 
919             StopWatch aStopWatch;
920             aStopWatch.start();
921             // TimeValue aTimeVal_befor;
922             // osl_getSystemTime( &aTimeVal_befor );
923             //printf("#join:the system time is %d,%d\n", pTimeVal_befor->Seconds,pTimeVal_befor->Nanosec);
924 
925             aCountThread->join();
926 
927             //the below line will be executed after aCountThread terminate
928             // TimeValue aTimeVal_after;
929             // osl_getSystemTime( &aTimeVal_after );
930             aStopWatch.stop();
931             // sal_uInt32 nSec  = aTimeVal_after.Seconds - aTimeVal_befor.Seconds;
932             double nSec = aStopWatch.getSeconds();
933             printf("join_001 nSec=%f\n", nSec);
934             delete aCountThread;
935 
936             ASSERT_TRUE(nSec >= 2) << "Join the thread: after the thread terminate";
937 
938         }
939     /** after terminated by another thread, join exited immediately
940 
941         ALGORITHM:
942         terminate the thread when value>=3, call join, check the beginning time and time after join,
943         the difference should be 3 seconds, join costs little time
944     */
TEST_F(join,join_002)945     TEST_F(join, join_002)
946         {
947             OCountThread *aCountThread = new OCountThread();
948             sal_Bool bRes = aCountThread->create();
949             ASSERT_TRUE(bRes == sal_True) << "Can't start thread!";
950 
951             //record the time when the running begin
952             // TimeValue aTimeVal_befor;
953             // osl_getSystemTime( &aTimeVal_befor );
954             StopWatch aStopWatch;
955             aStopWatch.start();
956 
957             ThreadHelper::thread_sleep_tenth_sec(10);
958             termAndJoinThread(aCountThread);
959 
960             //the below line will be executed after aCountThread terminate
961             // TimeValue aTimeVal_after;
962             // osl_getSystemTime( &aTimeVal_after );
963             // sal_uInt32 nSec  = aTimeVal_after.Seconds - aTimeVal_befor.Seconds;
964             aStopWatch.stop();
965             double nSec = aStopWatch.getSeconds();
966             printf("join_002 nSec=%f\n", nSec);
967 
968             delete aCountThread;
969             ASSERT_TRUE(nSec >= 1) << "Join the thread: after thread terminate by another thread";
970         }
971 
972     /** Test of the osl::Thread::isRunning method
973     */
974     class isRunning : public ::testing::Test
975     {
976     public:
977         // initialise your test code values here.
SetUp()978         void SetUp()
979             {
980             }
981 
TearDown()982         void TearDown()
983             {
984             }
985     }; // class isRunning
986 
987     /**
988      */
TEST_F(isRunning,isRunning_001)989     TEST_F(isRunning, isRunning_001)
990         {
991             OCountThread *aCountThread = new OCountThread();
992             sal_Bool bRes = aCountThread->create();
993             ASSERT_TRUE(bRes == sal_True) << "Can't start thread!";
994 
995             sal_Bool bRun = aCountThread->isRunning();
996 
997             ThreadHelper::thread_sleep_tenth_sec(2);
998             termAndJoinThread(aCountThread);
999             sal_Bool bTer = aCountThread->isRunning();
1000             delete aCountThread;
1001 
1002             ASSERT_TRUE(bRun == sal_True && bTer == sal_False) << "Test isRunning";
1003         }
1004     /** check the value of isRunning when suspending and after resume
1005      */
TEST_F(isRunning,isRunning_002)1006     TEST_F(isRunning, isRunning_002)
1007         {
1008             OCountThread *aCountThread = new OCountThread();
1009             sal_Bool bRes = aCountThread->create();
1010             ASSERT_TRUE(bRes == sal_True) << "Can't start thread!";
1011 
1012             // sal_Bool bRunning = aCountThread->isRunning();
1013             // sal_Int32 nValue = 0;
1014             suspendCountThread(aCountThread);
1015 
1016             sal_Bool bRunning_sup = aCountThread->isRunning();
1017             ThreadHelper::thread_sleep_tenth_sec(2);
1018             aCountThread->resume();
1019             ThreadHelper::thread_sleep_tenth_sec(2);
1020             sal_Bool bRunning_res = aCountThread->isRunning();
1021             termAndJoinThread(aCountThread);
1022             sal_Bool bRunning_ter = aCountThread->isRunning();
1023             delete aCountThread;
1024 
1025             ASSERT_TRUE(bRes == sal_True &&
1026                 bRunning_sup == sal_True &&
1027                 bRunning_res == sal_True &&
1028                 bRunning_ter == sal_False) << "Test isRunning";
1029 
1030         }
1031 
1032     /// check osl::Thread::setPriority
1033     class setPriority : public ::testing::Test
1034     {
1035     public:
1036         // initialise your test code values here.
SetUp()1037         void SetUp()
1038             {
1039             }
1040 
TearDown()1041         void TearDown()
1042             {
1043             }
1044 
1045         // insert your test code here.
getPrioName(oslThreadPriority _aPriority)1046         rtl::OString getPrioName(oslThreadPriority _aPriority)
1047             {
1048                 rtl::OString sPrioStr;
1049                 switch (_aPriority)
1050                 {
1051                 case osl_Thread_PriorityHighest:
1052                     sPrioStr = "Highest";
1053                     break;
1054 
1055                 case osl_Thread_PriorityAboveNormal:
1056                     sPrioStr = "AboveNormal";
1057 
1058                 case osl_Thread_PriorityNormal:
1059                     sPrioStr = "Normal";
1060 
1061                 case osl_Thread_PriorityBelowNormal:
1062                     sPrioStr = "BelowNormal";
1063                     break;
1064 
1065                 case osl_Thread_PriorityLowest:
1066                     sPrioStr = "Lowest";
1067                     break;
1068                 default:
1069                     sPrioStr = "unknown";
1070                 }
1071                 return sPrioStr;
1072             }
1073 
1074 
1075         /** check 2 threads.
1076 
1077             ALGORITHM:
1078             Here the function should show, that 2 different threads,
1079             which only increase a value, should run at the same time with same prio.
1080             The test fails, if the difference between the two values is more than 5%
1081             but IMHO this isn't a failure, it's only a feature of the OS.
1082         */
1083 
check2Threads(oslThreadPriority _aPriority)1084         void check2Threads(oslThreadPriority _aPriority)
1085             {
1086                 // initial 5 threads with different priorities
1087                 OAddThread* pThread = new OAddThread();
1088                 OAddThread* p2Thread = new OAddThread();
1089 
1090                 //Create them and start running at the same time
1091                 pThread->create();
1092                 pThread->setPriority(_aPriority);
1093                 p2Thread->create();
1094                 p2Thread->setPriority(_aPriority);
1095 
1096                 ThreadHelper::thread_sleep_tenth_sec(5);
1097 
1098                 pThread->terminate();
1099                 p2Thread->terminate();
1100 
1101                 sal_Int32 nValueNormal = 0;
1102                 nValueNormal = pThread->getValue();
1103 
1104                 sal_Int32 nValueNormal2 = 0;
1105                 nValueNormal2 = p2Thread->getValue();
1106 
1107                 rtl::OString sPrio = getPrioName(_aPriority);
1108                 printf("After 10 tenth seconds\n");
1109 
1110                 printf("nValue in %s Prio Thread is  %d\n",sPrio.getStr(), nValueNormal);
1111                 printf("nValue in %s Prio Thread is %d\n", sPrio.getStr(), nValueNormal2);
1112 
1113                 // ThreadHelper::thread_sleep_tenth_sec(1);
1114                 pThread->join();
1115                 p2Thread->join();
1116 
1117                 delete pThread;
1118                 delete p2Thread;
1119 
1120                 sal_Int32 nDelta = abs(nValueNormal - nValueNormal2);
1121                 double nQuotient = std::max(nValueNormal, nValueNormal2);
1122                 ASSERT_TRUE(nQuotient != 0) << "Quotient is zero, which means, there exist no right values.";
1123                 double nDeltaPercent = nDelta / nQuotient * 100;
1124 
1125                 printf("Delta value %d, percent %f\n",nDelta, nDeltaPercent);
1126 
1127                 // LLA: it's not a bug if the current OS is not able to handle thread scheduling right and good.
1128                 // like Windows XP
1129                 // LLA: ASSERT_TRUE(// LLA:     nDeltaPercent <= 5
1130                 // LLA:) << // LLA:     "Run 2 normal threads, the count diff more than 5 percent.";
1131             }
1132     }; // class setPriority
1133 
TEST_F(setPriority,setPriority_001_1)1134     TEST_F(setPriority, setPriority_001_1)
1135         {
1136             check2Threads(osl_Thread_PriorityHighest);
1137         }
TEST_F(setPriority,setPriority_001_2)1138     TEST_F(setPriority, setPriority_001_2)
1139         {
1140             check2Threads(osl_Thread_PriorityAboveNormal);
1141         }
TEST_F(setPriority,setPriority_001_3)1142     TEST_F(setPriority, setPriority_001_3)
1143         {
1144             check2Threads(osl_Thread_PriorityNormal);
1145         }
TEST_F(setPriority,setPriority_001_4)1146     TEST_F(setPriority, setPriority_001_4)
1147         {
1148             check2Threads(osl_Thread_PriorityBelowNormal);
1149         }
TEST_F(setPriority,setPriority_001_5)1150     TEST_F(setPriority, setPriority_001_5)
1151         {
1152             check2Threads(osl_Thread_PriorityLowest);
1153         }
1154 
1155 #ifndef SOLARIS
TEST_F(setPriority,setPriority_002)1156     TEST_F(setPriority, setPriority_002)
1157         {
1158             // initial 5 threads with different priorities
1159 
1160             OAddThread aHighestThread;
1161             OAddThread aAboveNormalThread;
1162             OAddThread aNormalThread;
1163             //OAddThread *aBelowNormalThread = new OAddThread();
1164             //OAddThread *aLowestThread = new OAddThread();
1165 
1166             //Create them and start running at the same time
1167             aHighestThread.createSuspended();
1168             aHighestThread.setPriority(osl_Thread_PriorityHighest);
1169 
1170             aAboveNormalThread.createSuspended();
1171             aAboveNormalThread.setPriority(osl_Thread_PriorityAboveNormal);
1172 
1173             aNormalThread.createSuspended();
1174             aNormalThread.setPriority(osl_Thread_PriorityNormal);
1175             /*aBelowNormalThread->create();
1176               aBelowNormalThread->setPriority(osl_Thread_PriorityBelowNormal);
1177               aLowestThread->create();
1178               aLowestThread->setPriority(osl_Thread_PriorityLowest);
1179             */
1180 
1181             aHighestThread.resume();
1182             aAboveNormalThread.resume();
1183             aNormalThread.resume();
1184 
1185             ThreadHelper::thread_sleep_tenth_sec(5);
1186 
1187             aHighestThread.suspend();
1188             aAboveNormalThread.suspend();
1189             aNormalThread.suspend();
1190 
1191             termAndJoinThread(&aNormalThread);
1192             termAndJoinThread(&aAboveNormalThread);
1193             termAndJoinThread(&aHighestThread);
1194             //aBelowNormalThread->terminate();
1195             //aLowestThread->terminate();
1196 
1197             sal_Int32 nValueHighest = 0;
1198             nValueHighest = aHighestThread.getValue();
1199 
1200             sal_Int32 nValueAboveNormal = 0;
1201             nValueAboveNormal = aAboveNormalThread.getValue();
1202 
1203             sal_Int32 nValueNormal = 0;
1204             nValueNormal = aNormalThread.getValue();
1205 
1206             // sal_Int32 nValueBelowNormal = 0;
1207             //nValueBelowNormal = aBelowNormalThread->getValue();
1208             // sal_Int32 nValueLowest = 0;
1209             //nValueLowest = aLowestThread->getValue();
1210             printf("After 10 tenth seconds\n");
1211             printf("nValue in Highest Prio Thread is %d\n",nValueHighest);
1212             printf("nValue in AboveNormal Prio Thread is %d\n",nValueAboveNormal);
1213             printf("nValue in Normal Prio Thread is %d\n",nValueNormal);
1214 
1215             // LLA: this is not a save test, so we only check if all values not zero
1216             // LLA: ASSERT_TRUE(// LLA:     nValueHighest >= nValueAboveNormal &&
1217             // LLA:     nValueAboveNormal >= nValueNormal &&
1218             // LLA:     nValueNormal > 0
1219             // LLA:) << // LLA:     "SetPriority";
1220 
1221 // LLA: windows let starve threads with lower priority
1222 #ifndef WNT
1223             ASSERT_TRUE(nValueHighest     > 0 &&
1224                 nValueAboveNormal > 0 &&
1225                 nValueNormal > 0) << "SetPriority";
1226 #endif
1227         }
1228 
TEST_F(setPriority,setPriority_003)1229     TEST_F(setPriority, setPriority_003)
1230         {
1231             // initial 5 threads with different priorities
1232             OAddThread *pHighestThread = new OAddThread();
1233             OAddThread *pAboveNormalThread = new OAddThread();
1234             OAddThread *pNormalThread = new OAddThread();
1235             OAddThread *pBelowNormalThread = new OAddThread();
1236             OAddThread *pLowestThread = new OAddThread();
1237 
1238             //Create them and start running at the same time
1239             pHighestThread->createSuspended();
1240             pHighestThread->setPriority(osl_Thread_PriorityHighest);
1241 
1242             pAboveNormalThread->createSuspended();
1243             pAboveNormalThread->setPriority(osl_Thread_PriorityAboveNormal);
1244 
1245             pNormalThread->createSuspended();
1246             pNormalThread->setPriority(osl_Thread_PriorityNormal);
1247 
1248             pBelowNormalThread->createSuspended();
1249             pBelowNormalThread->setPriority(osl_Thread_PriorityBelowNormal);
1250 
1251             pLowestThread->createSuspended();
1252             pLowestThread->setPriority(osl_Thread_PriorityLowest);
1253 
1254             pHighestThread->resume();
1255             pAboveNormalThread->resume();
1256             pNormalThread->resume();
1257             pBelowNormalThread->resume();
1258             pLowestThread->resume();
1259 
1260             ThreadHelper::thread_sleep_tenth_sec(5);
1261 
1262             pHighestThread->suspend();
1263             pAboveNormalThread->suspend();
1264             pNormalThread->suspend();
1265             pBelowNormalThread->suspend();
1266             pLowestThread->suspend();
1267 
1268             termAndJoinThread(pHighestThread);
1269             termAndJoinThread(pAboveNormalThread);
1270             termAndJoinThread(pNormalThread);
1271             termAndJoinThread(pBelowNormalThread);
1272             termAndJoinThread(pLowestThread);
1273 
1274             sal_Int32 nValueHighest = 0;
1275             nValueHighest = pHighestThread->getValue();
1276 
1277             sal_Int32 nValueAboveNormal = 0;
1278             nValueAboveNormal = pAboveNormalThread->getValue();
1279 
1280             sal_Int32 nValueNormal = 0;
1281             nValueNormal = pNormalThread->getValue();
1282 
1283             sal_Int32 nValueBelowNormal = 0;
1284             nValueBelowNormal = pBelowNormalThread->getValue();
1285 
1286             sal_Int32 nValueLowest = 0;
1287             nValueLowest = pLowestThread->getValue();
1288 
1289             printf("After 10 tenth seconds\n");
1290             printf("nValue in Highest Prio Thread is     %d\n",nValueHighest);
1291             printf("nValue in AboveNormal Prio Thread is %d\n",nValueAboveNormal);
1292             printf("nValue in Normal Prio Thread is      %d\n",nValueNormal);
1293             printf("nValue in BelowNormal Prio Thread is %d\n",nValueBelowNormal);
1294             printf("nValue in Lowest Prio Thread is      %d\n",nValueLowest);
1295 
1296             delete pHighestThread;
1297             delete pAboveNormalThread;
1298             delete pNormalThread;
1299             delete pBelowNormalThread;
1300             delete pLowestThread;
1301 
1302             // LLA: this is not a save test, so we only check if all values not zero
1303             // LLA: ASSERT_TRUE(// LLA:     nValueHighest > nValueAboveNormal &&
1304             // LLA:     nValueAboveNormal > nValueNormal &&
1305             // LLA:     nValueNormal > nValueBelowNormal &&
1306             // LLA:     nValueBelowNormal > nValueLowest &&
1307             // LLA:     nValueLowest > 0
1308             // LLA:) << // LLA:     "SetPriority";
1309 
1310 // LLA: windows let starve threads with lower priority
1311 #ifndef WNT
1312             ASSERT_TRUE(nValueHighest     > 0 &&
1313                 nValueAboveNormal > 0 &&
1314                 nValueNormal      > 0 &&
1315                 nValueBelowNormal > 0 &&
1316                 nValueLowest      > 0) << "SetPriority";
1317 #endif
1318         }
1319 
TEST_F(setPriority,setPriority_004)1320     TEST_F(setPriority, setPriority_004)
1321         {
1322             // initial 5 threads with different priorities
1323             // OAddThread *pHighestThread = new OAddThread();
1324             OAddThread *pAboveNormalThread = new OAddThread();
1325             OAddThread *pNormalThread = new OAddThread();
1326             OAddThread *pBelowNormalThread = new OAddThread();
1327             OAddThread *pLowestThread = new OAddThread();
1328 
1329             //Create them and start running at the same time
1330             // pHighestThread->createSuspended();
1331             // pHighestThread->setPriority(osl_Thread_PriorityHighest);
1332 
1333             pAboveNormalThread->createSuspended();
1334             pAboveNormalThread->setPriority(osl_Thread_PriorityAboveNormal);
1335 
1336             pNormalThread->createSuspended();
1337             pNormalThread->setPriority(osl_Thread_PriorityNormal);
1338 
1339             pBelowNormalThread->createSuspended();
1340             pBelowNormalThread->setPriority(osl_Thread_PriorityBelowNormal);
1341 
1342             pLowestThread->createSuspended();
1343             pLowestThread->setPriority(osl_Thread_PriorityLowest);
1344 
1345             // pHighestThread->resume();
1346             pAboveNormalThread->resume();
1347             pNormalThread->resume();
1348             pBelowNormalThread->resume();
1349             pLowestThread->resume();
1350 
1351             ThreadHelper::thread_sleep_tenth_sec(5);
1352 
1353             // pHighestThread->suspend();
1354             pAboveNormalThread->suspend();
1355             pNormalThread->suspend();
1356             pBelowNormalThread->suspend();
1357             pLowestThread->suspend();
1358 
1359             // termAndJoinThread(pHighestThread);
1360             termAndJoinThread(pAboveNormalThread);
1361             termAndJoinThread(pNormalThread);
1362             termAndJoinThread(pBelowNormalThread);
1363             termAndJoinThread(pLowestThread);
1364 
1365             // sal_Int32 nValueHighest  = 0;
1366             // nValueHighest =  pHighestThread->getValue();
1367 
1368             sal_Int32 nValueAboveNormal = 0;
1369             nValueAboveNormal = pAboveNormalThread->getValue();
1370 
1371             sal_Int32 nValueNormal = 0;
1372             nValueNormal = pNormalThread->getValue();
1373 
1374             sal_Int32 nValueBelowNormal = 0;
1375             nValueBelowNormal = pBelowNormalThread->getValue();
1376 
1377             sal_Int32 nValueLowest = 0;
1378             nValueLowest = pLowestThread->getValue();
1379 
1380             printf("After 5 tenth seconds\n");
1381             // printf("nValue in Highest Prio Thread  is     %d\n",nValueHighest);
1382             printf("nValue in AboveNormal Prio Thread is %d\n",nValueAboveNormal);
1383             printf("nValue in Normal Prio Thread is      %d\n",nValueNormal);
1384             printf("nValue in BelowNormal Prio Thread is %d\n",nValueBelowNormal);
1385             printf("nValue in Lowest Prio Thread is      %d\n",nValueLowest);
1386 
1387             // delete pHighestThread;
1388             delete pAboveNormalThread;
1389             delete pNormalThread;
1390             delete pBelowNormalThread;
1391             delete pLowestThread;
1392 
1393             // LLA: this is not a save test, so we only check if all values not zero
1394             // LLA: ASSERT_TRUE(// LLA:     nValueHighest > nValueAboveNormal &&
1395             // LLA:     nValueAboveNormal > nValueNormal &&
1396             // LLA:     nValueNormal > nValueBelowNormal &&
1397             // LLA:     nValueBelowNormal > nValueLowest &&
1398             // LLA:     nValueLowest > 0
1399             // LLA:) << // LLA:     "SetPriority";
1400 
1401 // LLA: windows let starve threads with lower priority
1402 #ifndef WNT
1403             ASSERT_TRUE(/* nValueHighest     > 0 &&  */
1404                 nValueAboveNormal > 0 &&
1405                 nValueNormal      > 0 &&
1406                 nValueBelowNormal > 0 &&
1407                 nValueLowest      > 0) << "SetPriority";
1408 #endif
1409         }
TEST_F(setPriority,setPriority_005)1410     TEST_F(setPriority, setPriority_005)
1411         {
1412             // initial 5 threads with different priorities
1413             // OAddThread *pHighestThread = new OAddThread();
1414             // OAddThread *pAboveNormalThread = new OAddThread();
1415             OAddThread *pNormalThread = new OAddThread();
1416             OAddThread *pBelowNormalThread = new OAddThread();
1417             OAddThread *pLowestThread = new OAddThread();
1418 
1419             //Create them and start running at the same time
1420             // pHighestThread->createSuspended();
1421             // pHighestThread->setPriority(osl_Thread_PriorityHighest);
1422 
1423             // pAboveNormalThread->createSuspended();
1424             // pAboveNormalThread->setPriority(osl_Thread_PriorityAboveNormal);
1425 
1426             pNormalThread->createSuspended();
1427             pNormalThread->setPriority(osl_Thread_PriorityNormal);
1428 
1429             pBelowNormalThread->createSuspended();
1430             pBelowNormalThread->setPriority(osl_Thread_PriorityBelowNormal);
1431 
1432             pLowestThread->createSuspended();
1433             pLowestThread->setPriority(osl_Thread_PriorityLowest);
1434 
1435             // pHighestThread->resume();
1436             // pAboveNormalThread->resume();
1437             pNormalThread->resume();
1438             pBelowNormalThread->resume();
1439             pLowestThread->resume();
1440 
1441             ThreadHelper::thread_sleep_tenth_sec(5);
1442 
1443             // pHighestThread->suspend();
1444             // pAboveNormalThread->suspend();
1445             pNormalThread->suspend();
1446             pBelowNormalThread->suspend();
1447             pLowestThread->suspend();
1448 
1449             // termAndJoinThread(pHighestThread);
1450             // termAndJoinThread(pAboveNormalThread);
1451             termAndJoinThread(pNormalThread);
1452             termAndJoinThread(pBelowNormalThread);
1453             termAndJoinThread(pLowestThread);
1454 
1455             // sal_Int32 nValueHighest  = 0;
1456             // nValueHighest =  pHighestThread->getValue();
1457 
1458             // sal_Int32 nValueAboveNormal = 0;
1459             // nValueAboveNormal = pAboveNormalThread->getValue();
1460 
1461             sal_Int32 nValueNormal = 0;
1462             nValueNormal = pNormalThread->getValue();
1463 
1464             sal_Int32 nValueBelowNormal = 0;
1465             nValueBelowNormal = pBelowNormalThread->getValue();
1466 
1467             sal_Int32 nValueLowest = 0;
1468             nValueLowest = pLowestThread->getValue();
1469 
1470             printf("After 5 tenth seconds\n");
1471             // printf("nValue in Highest Prio Thread  is     %d\n",nValueHighest);
1472             // printf("nValue in AboveNormal  Prio Thread is %d\n",nValueAboveNormal);
1473             printf("nValue in Normal Prio Thread is      %d\n",nValueNormal);
1474             printf("nValue in BelowNormal Prio Thread is %d\n",nValueBelowNormal);
1475             printf("nValue in Lowest Prio Thread is      %d\n",nValueLowest);
1476 
1477             // delete pHighestThread;
1478             // delete pAboveNormalThread;
1479             delete pNormalThread;
1480             delete pBelowNormalThread;
1481             delete pLowestThread;
1482 
1483             // LLA: this is not a save test, so we only check if all values not zero
1484             // LLA: ASSERT_TRUE(// LLA:     nValueHighest > nValueAboveNormal &&
1485             // LLA:     nValueAboveNormal > nValueNormal &&
1486             // LLA:     nValueNormal > nValueBelowNormal &&
1487             // LLA:     nValueBelowNormal > nValueLowest &&
1488             // LLA:     nValueLowest > 0
1489             // LLA:) << // LLA:     "SetPriority";
1490 
1491 // LLA: windows let starve threads with lower priority
1492 #ifndef WNT
1493             ASSERT_TRUE(/* nValueHighest     > 0 &&  */
1494                 /* nValueAboveNormal > 0 &&  */
1495                 nValueNormal      > 0 &&
1496                 nValueBelowNormal > 0 &&
1497                 nValueLowest      > 0) << "SetPriority";
1498 #endif
1499         }
1500 #endif // SOLARIS
1501 
1502 
1503     /** Test of the osl::Thread::getPriority method
1504     */
1505     class getPriority : public ::testing::Test
1506     {
1507     public:
1508         // initialise your test code values here.
SetUp()1509         void SetUp()
1510             {
1511             }
1512 
TearDown()1513         void TearDown()
1514             {
1515             }
1516     }; // class getPriority
1517 
TEST_F(getPriority,getPriority_001)1518     TEST_F(getPriority, getPriority_001)
1519         {
1520             OAddThread *pHighestThread = new OAddThread();
1521 
1522             //Create them and start running at the same time
1523             pHighestThread->create();
1524             pHighestThread->setPriority(osl_Thread_PriorityHighest);
1525 
1526             oslThreadPriority aPriority = pHighestThread->getPriority();
1527             termAndJoinThread(pHighestThread);
1528             delete pHighestThread;
1529 
1530             ThreadHelper::outputPriority(aPriority);
1531 
1532 // LLA: Priority settings may not work within some OS versions.
1533 #if ( defined WNT ) || ( defined SOLARIS )
1534             ASSERT_TRUE(aPriority == osl_Thread_PriorityHighest) << "getPriority";
1535 #else
1536 // LLA: Linux
1537 // NO_PTHREAD_PRIORITY ???
1538             ASSERT_TRUE(aPriority == osl_Thread_PriorityNormal) << "getPriority";
1539 #endif
1540         }
1541 
TEST_F(getPriority,getPriority_002)1542     TEST_F(getPriority, getPriority_002)
1543         {
1544 
1545         }
1546 
1547 
1548     class getIdentifier : public ::testing::Test
1549     {
1550     public:
1551         // initialise your test code values here.
SetUp()1552         void SetUp()
1553             {
1554             }
1555 
TearDown()1556         void TearDown()
1557             {
1558             }
1559     }; // class getIdentifier
1560 
1561     // insert your test code here.
TEST_F(getIdentifier,getIdentifier_001)1562     TEST_F(getIdentifier, getIdentifier_001)
1563         {
1564 
1565         }
1566 
TEST_F(getIdentifier,getIdentifier_002)1567     TEST_F(getIdentifier, getIdentifier_002)
1568         {
1569 
1570         }
1571 
1572     /** Test of the osl::Thread::getCurrentIdentifier method
1573     */
1574     class getCurrentIdentifier : public ::testing::Test
1575     {
1576     public:
1577         // initialise your test code values here.
SetUp()1578         void SetUp()
1579             {
1580             }
1581 
TearDown()1582         void TearDown()
1583             {
1584             }
1585     }; // class getCurrentIdentifier
1586 
1587     // insert your test code here.
TEST_F(getCurrentIdentifier,getCurrentIdentifier_001)1588     TEST_F(getCurrentIdentifier, getCurrentIdentifier_001)
1589         {
1590             oslThreadIdentifier oId;
1591             OCountThread* pCountThread = new OCountThread;
1592             //OCountThread* pCountThread2 = new OCountThread;
1593             pCountThread->create();
1594             //pCountThread2->create();
1595             pCountThread->setWait(3);
1596             oId = Thread::getCurrentIdentifier();
1597             oslThreadIdentifier oIdChild = pCountThread->getIdentifier();
1598             //printf("CurrentId is %ld, Child1 id is %ld, Child2 id is %ld\n",oId, oIdChild,pCountThread2->m_id );
1599             termAndJoinThread(pCountThread);
1600             delete pCountThread;
1601             //termAndJoinThread(pCountThread2);
1602             //delete pCountThread2;
1603 
1604             ASSERT_TRUE(oId != oIdChild) << "Get the identifier for the current active thread.";
1605 
1606         }
1607 
TEST_F(getCurrentIdentifier,getCurrentIdentifier_002)1608     TEST_F(getCurrentIdentifier, getCurrentIdentifier_002)
1609         {
1610         }
1611 
1612 
1613     /** Test of the osl::Thread::wait method
1614     */
1615     class wait : public ::testing::Test
1616     {
1617     public:
1618         // initialise your test code values here.
SetUp()1619         void SetUp()
1620             {
1621             }
1622 
TearDown()1623         void TearDown()
1624             {
1625             }
1626     }; // class wait
1627 
1628 
1629     /** call wait in the run method
1630 
1631         ALGORITHM:
1632         tested thread wait nWaitSec seconds, main thread sleep (2) seconds,
1633         then terminate the tested thread, due to the fact that the thread do a sleep(1) + wait(5)
1634         it's finish after 6 seconds.
1635     */
TEST_F(wait,wait_001)1636     TEST_F(wait, wait_001)
1637         {
1638             OCountThread *aCountThread = new OCountThread();
1639             sal_Int32 nWaitSec = 5;
1640             aCountThread->setWait(nWaitSec);
1641             // thread runs at least 5 seconds.
1642             sal_Bool bRes = aCountThread->create();
1643             ASSERT_TRUE(bRes == sal_True) << "Can't start thread!";
1644 
1645             //record the time when the running begin
1646             StopWatch aStopWatch;
1647             aStopWatch.start();
1648 
1649             // wait a little bit, to let the thread the time, to start
1650             ThreadHelper::thread_sleep_tenth_sec( 4 );
1651 
1652             // if wait works,
1653             // this function returns, after 4 sec. later
1654             termAndJoinThread(aCountThread);
1655 
1656             // value should be one.
1657             sal_Int32 nValue = aCountThread->getValue();
1658 
1659             aStopWatch.stop();
1660 
1661             // sal_uInt32 nSec  = aTimeVal_after.Seconds - aTimeVal_befor.Seconds;
1662             double nTenthSec = aStopWatch.getTenthSec();
1663             double nSec = aStopWatch.getSeconds();
1664             delete aCountThread;
1665             printf("nTenthSec = %f \n", nTenthSec);
1666             printf("nSec = %f \n", nSec);
1667             printf("nValue = %d \n", nValue);
1668 
1669             ASSERT_TRUE(nTenthSec >= 5 && nValue == 1) << "Wait: Blocks the calling thread for the given number of time.";
1670 
1671         }
1672 // LLA: wait_001 does the same.
1673 // LLA:         /** wait then terminate the thread
1674 // LLA:
1675 // LLA:         ALGORITHM:
1676 // LLA:         wait nWaitSec seconds, and terminate when the wait does not finish
1677 // LLA:         Windows & UNX: thread terminates immediatlly
1678 // LLA:     */
1679 // LLA:     TEST_F(wait, wait_002)
1680 // LLA:     {
1681 // LLA:         OCountThread aThread;
1682 // LLA:
1683 // LLA:         sal_Int32 nWaitSec = 3;
1684 // LLA:         aThread.setWait(nWaitSec);
1685 // LLA:
1686 // LLA:         sal_Bool bRes = aThread.create();
1687 // LLA:         ASSERT_TRUE(bRes == sal_True) << "Can't start thread!";
1688 // LLA:
1689 // LLA:         StopWatch aStopWatch;
1690 // LLA:         // TimeValue aTimeVal_befor;
1691 // LLA:         // osl_getSystemTime( &aTimeVal_befor );
1692 // LLA:         aStopWatch.start();
1693 // LLA:
1694 // LLA:         termAndJoinThread(&aThread);
1695 // LLA:         sal_Int32 nValue = aThread.getValue();
1696 // LLA:
1697 // LLA:         // TimeValue aTimeVal_after;
1698 // LLA:         // osl_getSystemTime( &aTimeVal_after );
1699 // LLA:         aStopWatch.stop();
1700 // LLA:         // sal_Int32 nSec = aTimeVal_after.Seconds  - aTimeVal_befor.Seconds;
1701 // LLA:         double nSec = aStopWatch.getSeconds();
1702 // LLA:         printf("sec=%f\n", nSec);
1703 // LLA:         printf("nValue = %d\n", nValue);
1704 // LLA:
1705 // LLA:         ASSERT_TRUE(// LLA:             nSec < 1 && nValue == 0
1706 // LLA:) << // LLA:             "Wait: Blocks the calling thread for the given number of time.";
1707 // LLA:     }
1708     /** osl::Thread::yield method: can not design good test scenario to test up to now
1709     */
1710     class yield : public ::testing::Test
1711     {
1712     public:
SetUp()1713         void SetUp()
1714             {
1715             }
1716 
TearDown()1717         void TearDown()
1718             {
1719             }
1720     }; // class yield
1721 
1722     // insert your test code here.
TEST_F(yield,yield_001)1723     TEST_F(yield, yield_001)
1724         {
1725         }
1726 
1727     /** Test of the osl::Thread::schedule method
1728     */
1729     class schedule : public ::testing::Test
1730     {
1731     public:
1732         // initialise your test code values here.
SetUp()1733         void SetUp()
1734             {
1735             }
1736 
TearDown()1737         void TearDown()
1738             {
1739             }
1740     }; // class schedule
1741 
1742     /** The requested thread will get terminate the next time schedule() is called.
1743 
1744         Note: on UNX, if call suspend thread is not the to be suspended thread, the to be
1745         suspended   thread will get suspended the next time schedule() is called,
1746         while on w32, it's nothing with schedule.
1747 
1748         check if suspend and terminate work well via schedule
1749     */
TEST_F(schedule,schedule_001)1750     TEST_F(schedule, schedule_001)
1751         {
1752             OAddThread* aThread = new OAddThread();
1753             sal_Bool bRes = aThread->create();
1754             ASSERT_TRUE(bRes == sal_True) << "Can't start thread!";
1755 
1756             ThreadHelper::thread_sleep_tenth_sec(2);
1757             aThread->suspend();
1758             ThreadHelper::thread_sleep_tenth_sec(1);
1759             sal_Int32 nValue = aThread->getValue();
1760             ThreadHelper::thread_sleep_tenth_sec(3);
1761             sal_Int32 nLaterValue = aThread->getValue();
1762             // resumeAndWaitThread(aThread);
1763             printf("      value = %d\n", nValue);
1764             printf("later value = %d\n", nLaterValue);
1765             // if value and latervalue not equal, than the thread would not suspended
1766 
1767             ASSERT_TRUE(nLaterValue == nValue) << "Schedule: suspend works.";
1768 
1769             aThread->resume();
1770             ThreadHelper::thread_sleep_tenth_sec(2);
1771 
1772             aThread->terminate();
1773             sal_Int32 nValue_term = aThread->getValue();
1774 
1775             aThread->join();
1776             sal_Int32 nValue_join = aThread->getValue();
1777 
1778             printf("value after term = %d\n", nValue_term);
1779             printf("value after join = %d\n", nValue_join);
1780 
1781             // nValue_term and nValue_join should be the same
1782             // but should be differ from nValue
1783 
1784             delete aThread;
1785             //check if thread really terminate after call terminate, if join immediatlly return
1786             ASSERT_TRUE(nValue_join -  nValue_term <= 1 && nValue_join -  nValue_term >= 0) << "Schedule: Returns False if the thread should terminate.";
1787 
1788         }
1789 
1790     /** design a thread that has not call schedule in the workfunction--run method
1791      */
TEST_F(schedule,schedule_002)1792     TEST_F(schedule, schedule_002)
1793         {
1794             ONoScheduleThread aThread; // this thread runs 10 sec. (no schedule() used)
1795             sal_Bool bRes = aThread.create();
1796             ASSERT_TRUE(bRes == sal_True) << "Can't start thread!";
1797 
1798             ThreadHelper::thread_sleep_tenth_sec(2);
1799             aThread.suspend();
1800             sal_Int32 nValue = aThread.getValue();
1801 
1802             ThreadHelper::thread_sleep_tenth_sec(3);
1803             sal_Int32 nLaterValue = aThread.getValue();
1804             ThreadHelper::thread_sleep_tenth_sec(5);
1805 
1806             resumeAndWaitThread(&aThread);
1807 
1808             printf("      value = %d\n", nValue);
1809             printf("later value = %d\n", nLaterValue);
1810 
1811             //On windows, suspend works, so the values are same
1812 #ifdef WNT
1813             ASSERT_TRUE(nLaterValue == nValue) << "Schedule: don't schedule in thread run method, suspend works.";
1814 #endif
1815 
1816             //On UNX, suspend does not work, so the difference of the values equals to sleep seconds number
1817 #ifdef UNX
1818             aThread.resume();
1819             ASSERT_TRUE(nLaterValue > nValue) << "Schedule: don't schedule in thread run method, suspend does not work too.";
1820 #endif
1821 
1822             // terminate will not work if no schedule in thread's work function
1823             termAndJoinThread(&aThread);
1824             sal_Int32 nValue_term = aThread.getValue();
1825 
1826             printf(" value term = %d\n", nValue_term);
1827 
1828             ASSERT_TRUE(nValue_term == 10) << "Schedule: don't schedule in thread run method, terminate failed.";
1829         }
1830 
1831 } // namespace osl_Thread
1832 
1833 
1834 // -----------------------------------------------------------------------------
1835 // destroy function when the binding thread terminate
destroyCallback(void * data)1836 void SAL_CALL destroyCallback(void * data)
1837 {
1838     printf("destroying local data %s\n", (char *) data);
1839     delete[] (char *) data;
1840 }
1841 
1842 static ThreadData myThreadData(destroyCallback);
1843 
1844 /**
1845 */
1846 class myKeyThread : public Thread
1847 {
1848 public:
1849     // a public char member for test result checking
1850     char m_Char_Test;
1851     // for pass thread-special data to thread
myKeyThread(const char cData)1852     myKeyThread(const char cData)
1853         {
1854             m_nData = cData;
1855         }
1856 private:
1857     char m_nData;
1858 
run()1859     void SAL_CALL run()
1860         {
1861             char * pc = new char[2];
1862 //      strcpy(pc, &m_nData);
1863             memcpy(pc, &m_nData, 1);
1864             pc[1] = '\0';
1865 
1866             myThreadData.setData(pc);
1867             char* pData = (char*)myThreadData.getData();
1868             m_Char_Test = *pData;
1869             // wait for long time to check the data value in main thread
1870             ThreadHelper::thread_sleep_tenth_sec(3);
1871         }
1872 public:
~myKeyThread()1873     ~myKeyThread()
1874         {
1875             if (isRunning())
1876             {
1877                 printf("error: not terminated.\n");
1878             }
1879         }
1880 };
1881 
1882 static ThreadData idData;
1883 
1884 class idThread: public Thread
1885 {
1886 public:
1887     oslThreadIdentifier m_Id;
1888 private:
run()1889     void SAL_CALL run()
1890         {
1891             oslThreadIdentifier* pId = new oslThreadIdentifier;
1892             *pId = getIdentifier();
1893             idData.setData(pId);
1894             oslThreadIdentifier* pIdData = (oslThreadIdentifier*)idData.getData();
1895             //printf("Thread %d has Data %d\n", getIdentifier(), *pIdData);
1896             m_Id = *pIdData;
1897             delete pId;
1898         }
1899 
1900 public:
~idThread()1901     ~idThread()
1902         {
1903             if (isRunning())
1904             {
1905                 printf("error: not terminated.\n");
1906             }
1907         }
1908 };
1909 
1910 namespace osl_ThreadData
1911 {
1912 
1913     class ctors : public ::testing::Test
1914     {
1915     public:
1916         // initialise your test code values here.
SetUp()1917         void SetUp()
1918             {
1919             }
1920 
TearDown()1921         void TearDown()
1922             {
1923             }
1924     }; // class ctors
1925 
1926 
1927     // insert your test code here.
TEST_F(ctors,ctor_001)1928     TEST_F(ctors, ctor_001)
1929         {
1930 
1931         }
1932 
1933     class setData : public ::testing::Test
1934     {
1935     public:
1936         // initialise your test code values here.
SetUp()1937         void SetUp()
1938             {
1939             }
1940 
TearDown()1941         void TearDown()
1942             {
1943             }
1944     }; // class setData
1945 
1946     /** the same instance of the class can have different values in different threads
1947      */
TEST_F(setData,setData_001)1948     TEST_F(setData, setData_001)
1949         {
1950             idThread aThread1;
1951             aThread1.create();
1952             idThread aThread2;
1953             aThread2.create();
1954 
1955             aThread1.join();
1956             aThread2.join();
1957 
1958             oslThreadIdentifier aThreadId1 = aThread1.getIdentifier();
1959             oslThreadIdentifier aThreadId2 = aThread2.getIdentifier();
1960 
1961             ASSERT_TRUE(aThread1.m_Id == aThreadId1 && aThread2.m_Id == aThreadId2) << "ThreadData setData: ";
1962 
1963         }
1964 
TEST_F(setData,setData_002)1965     TEST_F(setData, setData_002)
1966         {
1967             // at first, set the data a value
1968             char* pc = new char[2];
1969             char m_nData = 'm';
1970 // LLA: this is a copy functions only and really only for \0 terminated strings
1971 //      m_nData is not a string, it's a character
1972 //          strcpy(pc, &m_nData);
1973             memcpy(pc, &m_nData, 1);
1974             pc[1] = '\0';
1975 
1976             myThreadData.setData(pc);
1977 
1978             myKeyThread aThread1('a');
1979             aThread1.create();
1980             myKeyThread aThread2('b');
1981             aThread2.create();
1982             // aThread1 and aThread2 should have not terminated yet, check current data, not 'a' 'b'
1983             char* pChar = (char*)myThreadData.getData();
1984             char aChar = *pChar;
1985 
1986             aThread1.join();
1987             aThread2.join();
1988 
1989             // the saved thread data of aThread1 & aThread2, different
1990             char cData1 = aThread1.m_Char_Test;
1991             char cData2 = aThread2.m_Char_Test;
1992 
1993             ASSERT_TRUE(cData1 == 'a' && cData2 == 'b' && aChar == 'm') << "ThreadData setData: ";
1994 
1995         }
1996     /** setData the second time, and then getData
1997      */
TEST_F(setData,setData_003)1998     TEST_F(setData, setData_003)
1999         {
2000             // at first, set the data a value
2001             char* pc = new char[2];
2002             char m_nData = 'm';
2003 //          strcpy(pc, &m_nData);
2004             memcpy(pc, &m_nData, 1);
2005             pc[1] = '\0';
2006             myThreadData.setData(pc);
2007 
2008             myKeyThread aThread1('a');
2009             aThread1.create();
2010             myKeyThread aThread2('b');
2011             aThread2.create();
2012             // aThread1 and aThread2 should have not terminated yet
2013             // setData the second time
2014             char* pc2 = new char[2];
2015             m_nData = 'o';
2016 //          strcpy(pc2, &m_nData);
2017             memcpy(pc2, &m_nData, 1);
2018             pc2[1] = '\0';
2019 
2020             myThreadData.setData(pc2);
2021             char* pChar = (char*)myThreadData.getData();
2022             char aChar = *pChar;
2023 
2024             aThread1.join();
2025             aThread2.join();
2026 
2027             // the saved thread data of aThread1 & aThread2, different
2028             char cData1 = aThread1.m_Char_Test;
2029             char cData2 = aThread2.m_Char_Test;
2030 
2031             ASSERT_TRUE(cData1 == 'a' && cData2 == 'b' && aChar == 'o') << "ThreadData setData: ";
2032 
2033         }
2034 
2035     //sal_Bool buildTwoThreads(char)
2036 
2037     class getData : public ::testing::Test
2038     {
2039     public:
2040         // initialise your test code values here.
SetUp()2041         void SetUp()
2042             {
2043             }
2044 
TearDown()2045         void TearDown()
2046             {
2047             }
2048     }; // class getData
2049 
2050     // After setData in child threads, get Data in the main thread, should be independent
TEST_F(getData,getData_001)2051     TEST_F(getData, getData_001)
2052         {
2053             char* pc = new char[2];
2054             char m_nData[] = "i";
2055             strcpy(pc, m_nData);
2056             printf("pc %s\n", pc);
2057             myThreadData.setData(pc);
2058 
2059             myKeyThread aThread1('c');
2060             aThread1.create();
2061             myKeyThread aThread2('d');
2062             aThread2.create();
2063 
2064             aThread1.join();
2065             aThread2.join();
2066 
2067             char cData1 = aThread1.m_Char_Test;
2068             char cData2 = aThread2.m_Char_Test;
2069 
2070             char* pChar = (char*)myThreadData.getData();
2071             char aChar = *pChar;
2072 
2073             ASSERT_TRUE(cData1 == 'c' && cData2 == 'd' && aChar == 'i') << "ThreadData setData: ";
2074 
2075         }
2076 
2077     // setData then change the value in the address data pointer points,
2078     // and then getData, should get the new value
TEST_F(getData,getData_002)2079     TEST_F(getData, getData_002)
2080         {
2081             char* pc = new char[2];
2082             char m_nData = 'i';
2083 //          strcpy(pc, &m_nData);
2084             memcpy(pc, &m_nData, 1);
2085             pc[1] = '\0';
2086 //          strncpy(pc, &m_nData, sizeof(char);
2087 
2088             printf("pc %s\n", pc);
2089             myThreadData.setData(pc);
2090 
2091             myKeyThread aThread1('a');
2092             aThread1.create();
2093             myKeyThread aThread2('b');
2094             aThread2.create();
2095 
2096             // change the value which pc points
2097             char m_nData2 = 'j';
2098             // strcpy(pc, &m_nData2);
2099             memcpy(pc, &m_nData2, 1);
2100             pc[1] = '\0';
2101 
2102             //printf("pc %s\n", pc);
2103             void* pChar = myThreadData.getData();
2104             char aChar = *(char*)pChar;
2105 
2106             aThread1.join();
2107             aThread2.join();
2108 
2109             char cData1 = aThread1.m_Char_Test;
2110             char cData2 = aThread2.m_Char_Test;
2111 
2112             ASSERT_TRUE(cData1 == 'a' && cData2 == 'b' && aChar == 'j') << "ThreadData setData: ";
2113 
2114         }
2115 
2116 
2117 } // namespace osl_ThreadData
2118 
main(int argc,char ** argv)2119 int main(int argc, char **argv)
2120 {
2121     ::testing::InitGoogleTest(&argc, argv);
2122     return RUN_ALL_TESTS();
2123 }
2124