![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to test_threading.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / strongswan / src / libstrongswan / tests / suites|
Return to test_threading.c CVS log | Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / strongswan / src / libstrongswan / tests / suites |
1.1 misho 1: /*
2: * Copyright (C) 2013-2018 Tobias Brunner
3: * Copyright (C) 2008 Martin Willi
4: * HSR Hochschule fuer Technik Rapperswil
5: *
6: * This program is free software; you can redistribute it and/or modify it
7: * under the terms of the GNU General Public License as published by the
8: * Free Software Foundation; either version 2 of the License, or (at your
9: * option) any later version. See <http://www.fsf.org/copyleft/gpl.txt>.
10: *
11: * This program is distributed in the hope that it will be useful, but
12: * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
13: * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14: * for more details.
15: */
16:
17: #include "test_suite.h"
18:
19: #include <unistd.h>
20:
21: #include <threading/thread.h>
22: #include <threading/mutex.h>
23: #include <threading/condvar.h>
24: #include <threading/rwlock.h>
25: #include <threading/rwlock_condvar.h>
26: #include <threading/spinlock.h>
27: #include <threading/semaphore.h>
28: #include <threading/thread_value.h>
29:
30: #ifdef WIN32
31: /* when running on AppVeyor the wait functions seem to frequently trigger a bit
32: * early, allow this if the difference is within 5ms. */
33: static inline void time_is_at_least(timeval_t *expected, timeval_t *actual)
34: {
35: if (!timercmp(actual, expected, >))
36: {
37: timeval_t diff;
38:
39: timersub(expected, actual, &diff);
40: if (!diff.tv_sec && diff.tv_usec <= 5000)
41: {
42: warn("allow timer event %dus too early on Windows (expected: %u.%u, "
43: "actual: %u.%u)", diff.tv_usec, expected->tv_sec,
44: expected->tv_usec, actual->tv_sec, actual->tv_usec);
45: return;
46: }
47: fail("expected: %u.%u, actual: %u.%u", expected->tv_sec,
48: expected->tv_usec, actual->tv_sec, actual->tv_usec);
49: }
50: }
51: #else /* WIN32 */
52: static inline void time_is_at_least(timeval_t *expected, timeval_t *actual)
53: {
54: ck_assert_msg(timercmp(actual, expected, >), "expected: %u.%u, actual: "
55: "%u.%u", expected->tv_sec, expected->tv_usec, actual->tv_sec,
56: actual->tv_usec);
57: }
58: #endif /* WIN32 */
59:
60: /*******************************************************************************
61: * recursive mutex test
62: */
63:
64: #define THREADS 20
65:
66: /**
67: * Thread barrier data
68: */
69: typedef struct {
70: mutex_t *mutex;
71: condvar_t *cond;
72: int count;
73: int current;
74: bool active;
75: } barrier_t;
76:
77: /**
78: * Create a thread barrier for count threads
79: */
80: static barrier_t* barrier_create(int count)
81: {
82: barrier_t *this;
83:
84: INIT(this,
85: .mutex = mutex_create(MUTEX_TYPE_DEFAULT),
86: .cond = condvar_create(CONDVAR_TYPE_DEFAULT),
87: .count = count,
88: );
89:
90: return this;
91: }
92:
93: /**
94: * Destroy a thread barrier
95: */
96: static void barrier_destroy(barrier_t *this)
97: {
98: this->mutex->destroy(this->mutex);
99: this->cond->destroy(this->cond);
100: free(this);
101: }
102:
103: /**
104: * Wait to have configured number of threads in barrier
105: */
106: static bool barrier_wait(barrier_t *this)
107: {
108: bool winner = FALSE;
109:
110: this->mutex->lock(this->mutex);
111: if (!this->active)
112: { /* first, reset */
113: this->active = TRUE;
114: this->current = 0;
115: }
116:
117: this->current++;
118: while (this->current < this->count)
119: {
120: this->cond->wait(this->cond, this->mutex);
121: }
122: if (this->active)
123: { /* first, win */
124: winner = TRUE;
125: this->active = FALSE;
126: }
127: this->mutex->unlock(this->mutex);
128: this->cond->broadcast(this->cond);
129: sched_yield();
130:
131: return winner;
132: }
133:
134: /**
135: * Barrier for some tests
136: */
137: static barrier_t *barrier;
138:
139: /**
140: * A mutex for tests requiring one
141: */
142: static mutex_t *mutex;
143:
144: /**
145: * A condvar for tests requiring one
146: */
147: static condvar_t *condvar;
148:
149: /**
150: * A counter for signaling
151: */
152: static int sigcount;
153:
154: static void *mutex_run(void *data)
155: {
156: int locked = 0;
157: int i;
158:
159: /* wait for all threads before getting in action */
160: barrier_wait(barrier);
161:
162: for (i = 0; i < 100; i++)
163: {
164: mutex->lock(mutex);
165: mutex->lock(mutex);
166: mutex->lock(mutex);
167: locked++;
168: sched_yield();
169: if (locked > 1)
170: {
171: fail("two threads locked the mutex concurrently");
172: }
173: locked--;
174: mutex->unlock(mutex);
175: mutex->unlock(mutex);
176: mutex->unlock(mutex);
177: }
178: return NULL;
179: }
180:
181: START_TEST(test_mutex)
182: {
183: thread_t *threads[THREADS];
184: int i;
185:
186: barrier = barrier_create(THREADS);
187: mutex = mutex_create(MUTEX_TYPE_RECURSIVE);
188:
189: for (i = 0; i < 10; i++)
190: {
191: mutex->lock(mutex);
192: mutex->unlock(mutex);
193: }
194: for (i = 0; i < 10; i++)
195: {
196: mutex->lock(mutex);
197: }
198: for (i = 0; i < 10; i++)
199: {
200: mutex->unlock(mutex);
201: }
202:
203: for (i = 0; i < THREADS; i++)
204: {
205: threads[i] = thread_create(mutex_run, NULL);
206: }
207: for (i = 0; i < THREADS; i++)
208: {
209: threads[i]->join(threads[i]);
210: }
211:
212: mutex->destroy(mutex);
213: barrier_destroy(barrier);
214: }
215: END_TEST
216:
217: /**
218: * Spinlock for testing
219: */
220: static spinlock_t *spinlock;
221:
222: static void *spinlock_run(void *data)
223: {
224: int i, *locked = (int*)data;
225:
226: barrier_wait(barrier);
227:
228: for (i = 0; i < 1000; i++)
229: {
230: spinlock->lock(spinlock);
231: (*locked)++;
232: ck_assert_int_eq(*locked, 1);
233: (*locked)--;
234: spinlock->unlock(spinlock);
235: }
236: return NULL;
237: }
238:
239: START_TEST(test_spinlock)
240: {
241: thread_t *threads[THREADS];
242: int i, locked = 0;
243:
244: barrier = barrier_create(THREADS);
245: spinlock = spinlock_create();
246:
247: for (i = 0; i < THREADS; i++)
248: {
249: threads[i] = thread_create(spinlock_run, &locked);
250: }
251: for (i = 0; i < THREADS; i++)
252: {
253: threads[i]->join(threads[i]);
254: }
255:
256: spinlock->destroy(spinlock);
257: barrier_destroy(barrier);
258: }
259: END_TEST
260:
261: static void *condvar_run(void *data)
262: {
263: mutex->lock(mutex);
264: sigcount++;
265: condvar->signal(condvar);
266: mutex->unlock(mutex);
267: return NULL;
268: }
269:
270: START_TEST(test_condvar)
271: {
272: thread_t *threads[THREADS];
273: int i;
274:
275: mutex = mutex_create(MUTEX_TYPE_DEFAULT);
276: condvar = condvar_create(CONDVAR_TYPE_DEFAULT);
277: sigcount = 0;
278:
279: for (i = 0; i < THREADS; i++)
280: {
281: threads[i] = thread_create(condvar_run, NULL);
282: }
283:
284: mutex->lock(mutex);
285: while (sigcount < THREADS)
286: {
287: condvar->wait(condvar, mutex);
288: }
289: mutex->unlock(mutex);
290:
291: for (i = 0; i < THREADS; i++)
292: {
293: threads[i]->join(threads[i]);
294: }
295:
296: mutex->destroy(mutex);
297: condvar->destroy(condvar);
298: }
299: END_TEST
300:
301: static void *condvar_recursive_run(void *data)
302: {
303: mutex->lock(mutex);
304: mutex->lock(mutex);
305: mutex->lock(mutex);
306: sigcount++;
307: condvar->signal(condvar);
308: mutex->unlock(mutex);
309: mutex->unlock(mutex);
310: mutex->unlock(mutex);
311: return NULL;
312: }
313:
314: START_TEST(test_condvar_recursive)
315: {
316: thread_t *threads[THREADS];
317: int i;
318:
319: mutex = mutex_create(MUTEX_TYPE_RECURSIVE);
320: condvar = condvar_create(CONDVAR_TYPE_DEFAULT);
321: sigcount = 0;
322:
323: mutex->lock(mutex);
324:
325: for (i = 0; i < THREADS; i++)
326: {
327: threads[i] = thread_create(condvar_recursive_run, NULL);
328: }
329:
330: mutex->lock(mutex);
331: mutex->lock(mutex);
332: while (sigcount < THREADS)
333: {
334: condvar->wait(condvar, mutex);
335: }
336: mutex->unlock(mutex);
337: mutex->unlock(mutex);
338: mutex->unlock(mutex);
339:
340: for (i = 0; i < THREADS; i++)
341: {
342: threads[i]->join(threads[i]);
343: }
344:
345: mutex->destroy(mutex);
346: condvar->destroy(condvar);
347: }
348: END_TEST
349:
350: static void *condvar_run_broad(void *data)
351: {
352: mutex->lock(mutex);
353: while (sigcount < 0)
354: {
355: condvar->wait(condvar, mutex);
356: }
357: mutex->unlock(mutex);
358: return NULL;
359: }
360:
361: START_TEST(test_condvar_broad)
362: {
363: thread_t *threads[THREADS];
364: int i;
365:
366: mutex = mutex_create(MUTEX_TYPE_DEFAULT);
367: condvar = condvar_create(CONDVAR_TYPE_DEFAULT);
368: sigcount = 0;
369:
370: for (i = 0; i < THREADS; i++)
371: {
372: threads[i] = thread_create(condvar_run_broad, NULL);
373: }
374:
375: sched_yield();
376:
377: mutex->lock(mutex);
378: sigcount = 1;
379: condvar->broadcast(condvar);
380: mutex->unlock(mutex);
381:
382: for (i = 0; i < THREADS; i++)
383: {
384: threads[i]->join(threads[i]);
385: }
386:
387: mutex->destroy(mutex);
388: condvar->destroy(condvar);
389: }
390: END_TEST
391:
392: START_TEST(test_condvar_timed)
393: {
394: thread_t *thread;
395: timeval_t start, end, diff = { .tv_usec = 50000 };
396:
397: mutex = mutex_create(MUTEX_TYPE_DEFAULT);
398: condvar = condvar_create(CONDVAR_TYPE_DEFAULT);
399: sigcount = 0;
400:
401: mutex->lock(mutex);
402: while (TRUE)
403: {
404: time_monotonic(&start);
405: if (condvar->timed_wait(condvar, mutex, diff.tv_usec / 1000))
406: {
407: break;
408: }
409: }
410: time_monotonic(&end);
411: mutex->unlock(mutex);
412: timersub(&end, &start, &end);
413: time_is_at_least(&diff, &end);
414:
415: thread = thread_create(condvar_run, NULL);
416:
417: mutex->lock(mutex);
418: while (sigcount == 0)
419: {
420: ck_assert(!condvar->timed_wait(condvar, mutex, 1000));
421: }
422: mutex->unlock(mutex);
423:
424: thread->join(thread);
425: mutex->destroy(mutex);
426: condvar->destroy(condvar);
427: }
428: END_TEST
429:
430: START_TEST(test_condvar_timed_abs)
431: {
432: thread_t *thread;
433: timeval_t start, end, abso, diff = { .tv_usec = 50000 };
434:
435: mutex = mutex_create(MUTEX_TYPE_DEFAULT);
436: condvar = condvar_create(CONDVAR_TYPE_DEFAULT);
437: sigcount = 0;
438:
439: mutex->lock(mutex);
440: while (TRUE)
441: {
442: time_monotonic(&start);
443: timeradd(&start, &diff, &abso);
444: if (condvar->timed_wait_abs(condvar, mutex, abso))
445: {
446: break;
447: }
448: }
449: time_monotonic(&end);
450: mutex->unlock(mutex);
451: time_is_at_least(&diff, &end);
452:
453: thread = thread_create(condvar_run, NULL);
454:
455: time_monotonic(&start);
456: diff.tv_sec = 1;
457: timeradd(&start, &diff, &abso);
458: mutex->lock(mutex);
459: while (sigcount == 0)
460: {
461: ck_assert(!condvar->timed_wait_abs(condvar, mutex, abso));
462: }
463: mutex->unlock(mutex);
464:
465: thread->join(thread);
466: mutex->destroy(mutex);
467: condvar->destroy(condvar);
468: }
469: END_TEST
470:
471: static void *condvar_cancel_run(void *data)
472: {
473: thread_cancelability(FALSE);
474:
475: mutex->lock(mutex);
476:
477: sigcount++;
478: condvar->broadcast(condvar);
479:
480: thread_cleanup_push((void*)mutex->unlock, mutex);
481: thread_cancelability(TRUE);
482: while (TRUE)
483: {
484: condvar->wait(condvar, mutex);
485: }
486: thread_cleanup_pop(TRUE);
487:
488: return NULL;
489: }
490:
491: START_TEST(test_condvar_cancel)
492: {
493: thread_t *threads[THREADS];
494: int i;
495:
496: mutex = mutex_create(MUTEX_TYPE_DEFAULT);
497: condvar = condvar_create(CONDVAR_TYPE_DEFAULT);
498: sigcount = 0;
499:
500: for (i = 0; i < THREADS; i++)
501: {
502: threads[i] = thread_create(condvar_cancel_run, NULL);
503: }
504:
505: /* wait for all threads */
506: mutex->lock(mutex);
507: while (sigcount < THREADS)
508: {
509: condvar->wait(condvar, mutex);
510: }
511: mutex->unlock(mutex);
512:
513: for (i = 0; i < THREADS; i++)
514: {
515: threads[i]->cancel(threads[i]);
516: }
517: for (i = 0; i < THREADS; i++)
518: {
519: threads[i]->join(threads[i]);
520: }
521:
522: mutex->destroy(mutex);
523: condvar->destroy(condvar);
524: }
525: END_TEST
526:
527: /**
528: * RWlock for different tests
529: */
530: static rwlock_t *rwlock;
531:
532: static void *rwlock_run(refcount_t *refs)
533: {
534: rwlock->read_lock(rwlock);
535: ref_get(refs);
536: sched_yield();
537: ignore_result(ref_put(refs));
538: rwlock->unlock(rwlock);
539:
540: if (rwlock->try_write_lock(rwlock))
541: {
542: ck_assert_int_eq(*refs, 0);
543: sched_yield();
544: rwlock->unlock(rwlock);
545: }
546:
547: rwlock->write_lock(rwlock);
548: ck_assert_int_eq(*refs, 0);
549: sched_yield();
550: rwlock->unlock(rwlock);
551:
552: rwlock->read_lock(rwlock);
553: rwlock->read_lock(rwlock);
554: ref_get(refs);
555: sched_yield();
556: ignore_result(ref_put(refs));
557: rwlock->unlock(rwlock);
558: rwlock->unlock(rwlock);
559:
560: return NULL;
561: }
562:
563: START_TEST(test_rwlock)
564: {
565: thread_t *threads[THREADS];
566: refcount_t refs = 0;
567: int i;
568:
569: rwlock = rwlock_create(RWLOCK_TYPE_DEFAULT);
570:
571: for (i = 0; i < THREADS; i++)
572: {
573: threads[i] = thread_create((void*)rwlock_run, &refs);
574: }
575: for (i = 0; i < THREADS; i++)
576: {
577: threads[i]->join(threads[i]);
578: }
579:
580: rwlock->destroy(rwlock);
581: }
582: END_TEST
583:
584: static void *rwlock_try_run(void *param)
585: {
586: if (rwlock->try_write_lock(rwlock))
587: {
588: rwlock->unlock(rwlock);
589: return param;
590: }
591: return NULL;
592: }
593:
594: START_TEST(test_rwlock_try)
595: {
596: uintptr_t magic = 0xcafebabe;
597: thread_t *thread;
598:
599: rwlock = rwlock_create(RWLOCK_TYPE_DEFAULT);
600:
601: thread = thread_create(rwlock_try_run, (void*)magic);
602: ck_assert_int_eq((uintptr_t)thread->join(thread), magic);
603:
604: rwlock->read_lock(rwlock);
605: thread = thread_create(rwlock_try_run, (void*)magic);
606: ck_assert(thread->join(thread) == NULL);
607: rwlock->unlock(rwlock);
608:
609: rwlock->read_lock(rwlock);
610: rwlock->read_lock(rwlock);
611: rwlock->read_lock(rwlock);
612: thread = thread_create(rwlock_try_run, (void*)magic);
613: ck_assert(thread->join(thread) == NULL);
614: rwlock->unlock(rwlock);
615: rwlock->unlock(rwlock);
616: rwlock->unlock(rwlock);
617:
618: rwlock->write_lock(rwlock);
619: thread = thread_create(rwlock_try_run, (void*)magic);
620: ck_assert(thread->join(thread) == NULL);
621: rwlock->unlock(rwlock);
622:
623: rwlock->destroy(rwlock);
624: }
625: END_TEST
626:
627: /**
628: * Rwlock condvar
629: */
630: static rwlock_condvar_t *rwcond;
631:
632: static void *rwlock_condvar_run(void *data)
633: {
634: rwlock->write_lock(rwlock);
635: sigcount++;
636: rwcond->signal(rwcond);
637: rwlock->unlock(rwlock);
638: return NULL;
639: }
640:
641: START_TEST(test_rwlock_condvar)
642: {
643: thread_t *threads[THREADS];
644: int i;
645:
646: rwlock = rwlock_create(RWLOCK_TYPE_DEFAULT);
647: rwcond = rwlock_condvar_create();
648: sigcount = 0;
649:
650: for (i = 0; i < THREADS; i++)
651: {
652: threads[i] = thread_create(rwlock_condvar_run, NULL);
653: }
654:
655: rwlock->write_lock(rwlock);
656: while (sigcount < THREADS)
657: {
658: rwcond->wait(rwcond, rwlock);
659: }
660: rwlock->unlock(rwlock);
661:
662: for (i = 0; i < THREADS; i++)
663: {
664: threads[i]->join(threads[i]);
665: }
666:
667: rwlock->destroy(rwlock);
668: rwcond->destroy(rwcond);
669: }
670: END_TEST
671:
672: static void *rwlock_condvar_run_broad(void *data)
673: {
674: rwlock->write_lock(rwlock);
675: while (sigcount < 0)
676: {
677: rwcond->wait(rwcond, rwlock);
678: }
679: rwlock->unlock(rwlock);
680: return NULL;
681: }
682:
683: START_TEST(test_rwlock_condvar_broad)
684: {
685: thread_t *threads[THREADS];
686: int i;
687:
688: rwlock = rwlock_create(RWLOCK_TYPE_DEFAULT);
689: rwcond = rwlock_condvar_create();
690: sigcount = 0;
691:
692: for (i = 0; i < THREADS; i++)
693: {
694: threads[i] = thread_create(rwlock_condvar_run_broad, NULL);
695: }
696:
697: sched_yield();
698:
699: rwlock->write_lock(rwlock);
700: sigcount = 1;
701: rwcond->broadcast(rwcond);
702: rwlock->unlock(rwlock);
703:
704: for (i = 0; i < THREADS; i++)
705: {
706: threads[i]->join(threads[i]);
707: }
708:
709: rwlock->destroy(rwlock);
710: rwcond->destroy(rwcond);
711: }
712: END_TEST
713:
714: START_TEST(test_rwlock_condvar_timed)
715: {
716: thread_t *thread;
717: timeval_t start, end, diff = { .tv_usec = 50000 };
718:
719: rwlock = rwlock_create(RWLOCK_TYPE_DEFAULT);
720: rwcond = rwlock_condvar_create();
721: sigcount = 0;
722:
723: rwlock->write_lock(rwlock);
724: while (TRUE)
725: {
726: time_monotonic(&start);
727: if (rwcond->timed_wait(rwcond, rwlock, diff.tv_usec / 1000))
728: {
729: break;
730: }
731: }
732: rwlock->unlock(rwlock);
733: time_monotonic(&end);
734: timersub(&end, &start, &end);
735: time_is_at_least(&diff, &end);
736:
737: thread = thread_create(rwlock_condvar_run, NULL);
738:
739: rwlock->write_lock(rwlock);
740: while (sigcount == 0)
741: {
742: ck_assert(!rwcond->timed_wait(rwcond, rwlock, 1000));
743: }
744: rwlock->unlock(rwlock);
745:
746: thread->join(thread);
747: rwlock->destroy(rwlock);
748: rwcond->destroy(rwcond);
749: }
750: END_TEST
751:
752: START_TEST(test_rwlock_condvar_timed_abs)
753: {
754: thread_t *thread;
755: timeval_t start, end, abso, diff = { .tv_usec = 50000 };
756:
757: rwlock = rwlock_create(RWLOCK_TYPE_DEFAULT);
758: rwcond = rwlock_condvar_create();
759: sigcount = 0;
760:
761: rwlock->write_lock(rwlock);
762: while (TRUE)
763: {
764: time_monotonic(&start);
765: timeradd(&start, &diff, &abso);
766: if (rwcond->timed_wait_abs(rwcond, rwlock, abso))
767: {
768: break;
769: }
770: }
771: rwlock->unlock(rwlock);
772: time_monotonic(&end);
773: time_is_at_least(&abso, &end);
774:
775: thread = thread_create(rwlock_condvar_run, NULL);
776:
777: time_monotonic(&start);
778: diff.tv_sec = 1;
779: timeradd(&start, &diff, &abso);
780: rwlock->write_lock(rwlock);
781: while (sigcount == 0)
782: {
783: ck_assert(!rwcond->timed_wait_abs(rwcond, rwlock, abso));
784: }
785: rwlock->unlock(rwlock);
786:
787: thread->join(thread);
788: rwlock->destroy(rwlock);
789: rwcond->destroy(rwcond);
790: }
791: END_TEST
792:
793: static void *rwlock_condvar_cancel_run(void *data)
794: {
795: thread_cancelability(FALSE);
796:
797: rwlock->write_lock(rwlock);
798:
799: sigcount++;
800: rwcond->broadcast(rwcond);
801:
802: thread_cleanup_push((void*)rwlock->unlock, rwlock);
803: thread_cancelability(TRUE);
804: while (TRUE)
805: {
806: rwcond->wait(rwcond, rwlock);
807: }
808: thread_cleanup_pop(TRUE);
809:
810: return NULL;
811: }
812:
813: START_TEST(test_rwlock_condvar_cancel)
814: {
815: thread_t *threads[THREADS];
816: int i;
817:
818: rwlock = rwlock_create(RWLOCK_TYPE_DEFAULT);
819: rwcond = rwlock_condvar_create();
820: sigcount = 0;
821:
822: for (i = 0; i < THREADS; i++)
823: {
824: threads[i] = thread_create(rwlock_condvar_cancel_run, NULL);
825: }
826:
827: /* wait for all threads */
828: rwlock->write_lock(rwlock);
829: while (sigcount < THREADS)
830: {
831: rwcond->wait(rwcond, rwlock);
832: }
833: rwlock->unlock(rwlock);
834:
835: for (i = 0; i < THREADS; i++)
836: {
837: threads[i]->cancel(threads[i]);
838: }
839: for (i = 0; i < THREADS; i++)
840: {
841: threads[i]->join(threads[i]);
842: }
843:
844: rwlock->destroy(rwlock);
845: rwcond->destroy(rwcond);
846: }
847: END_TEST
848:
849: /**
850: * Semaphore for different tests
851: */
852: static semaphore_t *semaphore;
853:
854: static void *semaphore_run(void *data)
855: {
856: semaphore->post(semaphore);
857: return NULL;
858: }
859:
860: START_TEST(test_semaphore)
861: {
862: thread_t *threads[THREADS];
863: int i, initial = 5;
864:
865: semaphore = semaphore_create(initial);
866:
867: for (i = 0; i < THREADS; i++)
868: {
869: threads[i] = thread_create(semaphore_run, NULL);
870: }
871: for (i = 0; i < THREADS + initial; i++)
872: {
873: semaphore->wait(semaphore);
874: }
875: for (i = 0; i < THREADS; i++)
876: {
877: threads[i]->join(threads[i]);
878: }
879:
880: semaphore->destroy(semaphore);
881: }
882: END_TEST
883:
884: START_TEST(test_semaphore_timed)
885: {
886: thread_t *thread;
887: timeval_t start, end, diff = { .tv_usec = 50000 };
888:
889: semaphore = semaphore_create(0);
890:
891: time_monotonic(&start);
892: ck_assert(semaphore->timed_wait(semaphore, diff.tv_usec / 1000));
893: time_monotonic(&end);
894: timersub(&end, &start, &end);
895: time_is_at_least(&diff, &end);
896:
897: thread = thread_create(semaphore_run, NULL);
898:
899: ck_assert(!semaphore->timed_wait(semaphore, 1000));
900:
901: thread->join(thread);
902: semaphore->destroy(semaphore);
903: }
904: END_TEST
905:
906: START_TEST(test_semaphore_timed_abs)
907: {
908: thread_t *thread;
909: timeval_t start, end, abso, diff = { .tv_usec = 50000 };
910:
911: semaphore = semaphore_create(0);
912:
913: time_monotonic(&start);
914: timeradd(&start, &diff, &abso);
915: ck_assert(semaphore->timed_wait_abs(semaphore, abso));
916: time_monotonic(&end);
917: time_is_at_least(&abso, &end);
918:
919: thread = thread_create(semaphore_run, NULL);
920:
921: time_monotonic(&start);
922: diff.tv_sec = 1;
923: timeradd(&start, &diff, &abso);
924: ck_assert(!semaphore->timed_wait_abs(semaphore, abso));
925:
926: thread->join(thread);
927: semaphore->destroy(semaphore);
928: }
929: END_TEST
930:
931: static void *semaphore_cancel_run(void *data)
932: {
933: refcount_t *ready = (refcount_t*)data;
934:
935: thread_cancelability(FALSE);
936: ref_get(ready);
937:
938: thread_cancelability(TRUE);
939: semaphore->wait(semaphore);
940:
941: ck_assert(FALSE);
942: return NULL;
943: }
944:
945: START_TEST(test_semaphore_cancel)
946: {
947: thread_t *threads[THREADS];
948: refcount_t ready = 0;
949: int i;
950:
951: semaphore = semaphore_create(0);
952:
953: for (i = 0; i < THREADS; i++)
954: {
955: threads[i] = thread_create(semaphore_cancel_run, &ready);
956: }
957: while (ready < THREADS)
958: {
959: sched_yield();
960: }
961: for (i = 0; i < THREADS; i++)
962: {
963: threads[i]->cancel(threads[i]);
964: }
965: for (i = 0; i < THREADS; i++)
966: {
967: threads[i]->join(threads[i]);
968: }
969:
970: semaphore->destroy(semaphore);
971: }
972: END_TEST
973:
974: static void *join_run(void *data)
975: {
976: /* force some context switches */
977: sched_yield();
978: return (void*)((uintptr_t)data + THREADS);
979: }
980:
981: START_TEST(test_join)
982: {
983: thread_t *threads[THREADS];
984: int i;
985:
986: for (i = 0; i < THREADS; i++)
987: {
988: threads[i] = thread_create(join_run, (void*)(uintptr_t)i);
989: }
990: for (i = 0; i < THREADS; i++)
991: {
992: ck_assert_int_eq((uintptr_t)threads[i]->join(threads[i]), i + THREADS);
993: }
994: }
995: END_TEST
996:
997: static void *exit_join_run(void *data)
998: {
999: sched_yield();
1000: thread_exit((void*)((uintptr_t)data + THREADS));
1001: /* not reached */
1002: ck_assert(FALSE);
1003: return NULL;
1004: }
1005:
1006: START_TEST(test_join_exit)
1007: {
1008: thread_t *threads[THREADS];
1009: int i;
1010:
1011: for (i = 0; i < THREADS; i++)
1012: {
1013: threads[i] = thread_create(exit_join_run, (void*)(uintptr_t)i);
1014: }
1015: for (i = 0; i < THREADS; i++)
1016: {
1017: ck_assert_int_eq((uintptr_t)threads[i]->join(threads[i]), i + THREADS);
1018: }
1019: }
1020: END_TEST
1021:
1022: static void *detach_run(void *data)
1023: {
1024: refcount_t *running = (refcount_t*)data;
1025:
1026: ignore_result(ref_put(running));
1027: return NULL;
1028: }
1029:
1030: START_TEST(test_detach)
1031: {
1032: thread_t *threads[THREADS];
1033: int i;
1034: refcount_t running = 0;
1035:
1036: for (i = 0; i < THREADS; i++)
1037: {
1038: ref_get(&running);
1039: threads[i] = thread_create(detach_run, &running);
1040: }
1041: for (i = 0; i < THREADS; i++)
1042: {
1043: threads[i]->detach(threads[i]);
1044: }
1045: while (running > 0)
1046: {
1047: sched_yield();
1048: }
1049: /* no checks done here, but we check that thread state gets cleaned
1050: * up with leak detective. give the threads time to clean up. */
1051: usleep(10000);
1052: }
1053: END_TEST
1054:
1055: static void *detach_exit_run(void *data)
1056: {
1057: refcount_t *running = (refcount_t*)data;
1058:
1059: ignore_result(ref_put(running));
1060: thread_exit(NULL);
1061: /* not reached */
1062: ck_assert(FALSE);
1063: return NULL;
1064: }
1065:
1066: START_TEST(test_detach_exit)
1067: {
1068: thread_t *threads[THREADS];
1069: int i;
1070: refcount_t running = 0;
1071:
1072: for (i = 0; i < THREADS; i++)
1073: {
1074: ref_get(&running);
1075: threads[i] = thread_create(detach_exit_run, &running);
1076: }
1077: for (i = 0; i < THREADS; i++)
1078: {
1079: threads[i]->detach(threads[i]);
1080: }
1081: while (running > 0)
1082: {
1083: sched_yield();
1084: }
1085: /* no checks done here, but we check that thread state gets cleaned
1086: * up with leak detective. give the threads time to clean up. */
1087: usleep(10000);
1088: }
1089: END_TEST
1090:
1091: static void *cancel_run(void *data)
1092: {
1093: /* default cancelability should be TRUE, so don't change it */
1094: while (TRUE)
1095: {
1096: sleep(10);
1097: }
1098: return NULL;
1099: }
1100:
1101: START_TEST(test_cancel)
1102: {
1103: thread_t *threads[THREADS];
1104: int i;
1105:
1106: for (i = 0; i < THREADS; i++)
1107: {
1108: threads[i] = thread_create(cancel_run, NULL);
1109: }
1110: for (i = 0; i < THREADS; i++)
1111: {
1112: threads[i]->cancel(threads[i]);
1113: }
1114: for (i = 0; i < THREADS; i++)
1115: {
1116: threads[i]->join(threads[i]);
1117: }
1118: }
1119: END_TEST
1120:
1121: static void *cancel_onoff_run(void *data)
1122: {
1123: bool *cancellable = (bool*)data;
1124:
1125: thread_cancelability(FALSE);
1126: *cancellable = FALSE;
1127:
1128: /* we should not get cancelled here */
1129: usleep(50000);
1130:
1131: *cancellable = TRUE;
1132: thread_cancelability(TRUE);
1133:
1134: /* but here */
1135: while (TRUE)
1136: {
1137: sleep(10);
1138: }
1139: return NULL;
1140: }
1141:
1142: START_TEST(test_cancel_onoff)
1143: {
1144: thread_t *threads[THREADS];
1145: bool cancellable[THREADS];
1146: int i;
1147:
1148: for (i = 0; i < THREADS; i++)
1149: {
1150: cancellable[i] = TRUE;
1151: threads[i] = thread_create(cancel_onoff_run, &cancellable[i]);
1152: }
1153: for (i = 0; i < THREADS; i++)
1154: {
1155: /* wait until thread has cleared its cancelability */
1156: while (cancellable[i])
1157: {
1158: sched_yield();
1159: }
1160: threads[i]->cancel(threads[i]);
1161: }
1162: for (i = 0; i < THREADS; i++)
1163: {
1164: threads[i]->join(threads[i]);
1165: ck_assert(cancellable[i]);
1166: }
1167: }
1168: END_TEST
1169:
1170: static void *cancel_point_run(void *data)
1171: {
1172: thread_cancelability(FALSE);
1173: while (TRUE)
1174: {
1175: /* implicitly enables cancelability */
1176: thread_cancellation_point();
1177: }
1178: return NULL;
1179: }
1180:
1181: START_TEST(test_cancel_point)
1182: {
1183: thread_t *threads[THREADS];
1184: int i;
1185:
1186: for (i = 0; i < THREADS; i++)
1187: {
1188: threads[i] = thread_create(cancel_point_run, NULL);
1189: }
1190: sched_yield();
1191: for (i = 0; i < THREADS; i++)
1192: {
1193: threads[i]->cancel(threads[i]);
1194: }
1195: for (i = 0; i < THREADS; i++)
1196: {
1197: threads[i]->join(threads[i]);
1198: }
1199: }
1200: END_TEST
1201:
1202: static void close_fd_ptr(void *fd)
1203: {
1204: close(*(int*)fd);
1205: }
1206:
1207: static void cancellation_recv()
1208: {
1209: int sv[2];
1210: char buf[1];
1211:
1212: ck_assert(socketpair(AF_UNIX, SOCK_STREAM, 0, sv) == 0);
1213:
1214: thread_cleanup_push(close_fd_ptr, &sv[0]);
1215: thread_cleanup_push(close_fd_ptr, &sv[1]);
1216:
1217: thread_cancelability(TRUE);
1218: while (TRUE)
1219: {
1220: ck_assert(recv(sv[0], buf, sizeof(buf), 0) == 1);
1221: }
1222: }
1223:
1224: static void cancellation_read()
1225: {
1226: int sv[2];
1227: char buf[1];
1228:
1229: ck_assert(socketpair(AF_UNIX, SOCK_STREAM, 0, sv) == 0);
1230:
1231: thread_cleanup_push(close_fd_ptr, &sv[0]);
1232: thread_cleanup_push(close_fd_ptr, &sv[1]);
1233:
1234: thread_cancelability(TRUE);
1235: while (TRUE)
1236: {
1237: ck_assert(read(sv[0], buf, sizeof(buf)) == 1);
1238: }
1239: }
1240:
1241: static void cancellation_select()
1242: {
1243: int sv[2];
1244: fd_set set;
1245:
1246: ck_assert(socketpair(AF_UNIX, SOCK_STREAM, 0, sv) == 0);
1247:
1248: thread_cleanup_push(close_fd_ptr, &sv[0]);
1249: thread_cleanup_push(close_fd_ptr, &sv[1]);
1250:
1251: FD_ZERO(&set);
1252: FD_SET(sv[0], &set);
1253: thread_cancelability(TRUE);
1254: while (TRUE)
1255: {
1256: ck_assert(select(sv[0] + 1, &set, NULL, NULL, NULL) == 1);
1257: }
1258: }
1259:
1260: static void cancellation_poll()
1261: {
1262: int sv[2];
1263: struct pollfd pfd;
1264:
1265: ck_assert(socketpair(AF_UNIX, SOCK_STREAM, 0, sv) == 0);
1266:
1267: thread_cleanup_push(close_fd_ptr, &sv[0]);
1268: thread_cleanup_push(close_fd_ptr, &sv[1]);
1269:
1270: pfd.fd = sv[0];
1271: pfd.events = POLLIN;
1272: thread_cancelability(TRUE);
1273: while (TRUE)
1274: {
1275: ck_assert(poll(&pfd, 1, -1) == 1);
1276: }
1277: }
1278:
1279: static void cancellation_accept()
1280: {
1281: host_t *host;
1282: int fd, c;
1283:
1284: fd = socket(AF_INET, SOCK_STREAM, 0);
1285: ck_assert(fd >= 0);
1286: host = host_create_from_string("127.0.0.1", 0);
1287: ck_assert_msg(bind(fd, host->get_sockaddr(host),
1288: *host->get_sockaddr_len(host)) == 0, "%m");
1289: host->destroy(host);
1290: ck_assert(listen(fd, 5) == 0);
1291:
1292: thread_cleanup_push(close_fd_ptr, &fd);
1293:
1294: thread_cancelability(TRUE);
1295: while (TRUE)
1296: {
1297: c = accept(fd, NULL, NULL);
1298: ck_assert(c >= 0);
1299: close(c);
1300: }
1301: }
1302:
1303: static void cancellation_cond()
1304: {
1305: mutex_t *mutex;
1306: condvar_t *cond;
1307:
1308: mutex = mutex_create(MUTEX_TYPE_DEFAULT);
1309: cond = condvar_create(CONDVAR_TYPE_DEFAULT);
1310: mutex->lock(mutex);
1311:
1312: thread_cleanup_push((void*)mutex->destroy, mutex);
1313: thread_cleanup_push((void*)cond->destroy, cond);
1314:
1315: thread_cancelability(TRUE);
1316: while (TRUE)
1317: {
1318: cond->wait(cond, mutex);
1319: }
1320: }
1321:
1322: static void cancellation_rwcond()
1323: {
1324: rwlock_t *lock;
1325: rwlock_condvar_t *cond;
1326:
1327: lock = rwlock_create(RWLOCK_TYPE_DEFAULT);
1328: cond = rwlock_condvar_create();
1329: lock->write_lock(lock);
1330:
1331: thread_cleanup_push((void*)lock->destroy, lock);
1332: thread_cleanup_push((void*)cond->destroy, cond);
1333:
1334: thread_cancelability(TRUE);
1335: while (TRUE)
1336: {
1337: cond->wait(cond, lock);
1338: }
1339: }
1340:
1341: static void (*cancellation_points[])() = {
1342: cancellation_read,
1343: cancellation_recv,
1344: cancellation_select,
1345: cancellation_poll,
1346: cancellation_accept,
1347: cancellation_cond,
1348: cancellation_rwcond,
1349: };
1350:
1351: static void* run_cancellation_point(void (*fn)())
1352: {
1353: fn();
1354: return NULL;
1355: }
1356:
1357: static void* run_cancellation_point_pre(void (*fn)())
1358: {
1359: usleep(5000);
1360: fn();
1361: return NULL;
1362: }
1363:
1364: START_TEST(test_cancellation_point)
1365: {
1366: thread_t *thread;
1367:
1368: thread = thread_create((void*)run_cancellation_point,
1369: cancellation_points[_i]);
1370: usleep(5000);
1371: thread->cancel(thread);
1372: thread->join(thread);
1373: }
1374: END_TEST
1375:
1376: START_TEST(test_cancellation_point_pre)
1377: {
1378: thread_t *thread;
1379:
1380: thread = thread_create((void*)run_cancellation_point_pre,
1381: cancellation_points[_i]);
1382: thread->cancel(thread);
1383: thread->join(thread);
1384: }
1385: END_TEST
1386:
1387: static void cleanup1(void *data)
1388: {
1389: uintptr_t *value = (uintptr_t*)data;
1390:
1391: ck_assert_int_eq(*value, 1);
1392: (*value)++;
1393: }
1394:
1395: static void cleanup2(void *data)
1396: {
1397: uintptr_t *value = (uintptr_t*)data;
1398:
1399: ck_assert_int_eq(*value, 2);
1400: (*value)++;
1401: }
1402:
1403: static void cleanup3(void *data)
1404: {
1405: uintptr_t *value = (uintptr_t*)data;
1406:
1407: ck_assert_int_eq(*value, 3);
1408: (*value)++;
1409: }
1410:
1411: static void *cleanup_run(void *data)
1412: {
1413: thread_cleanup_push(cleanup3, data);
1414: thread_cleanup_push(cleanup2, data);
1415: thread_cleanup_push(cleanup1, data);
1416: return NULL;
1417: }
1418:
1419: START_TEST(test_cleanup)
1420: {
1421: thread_t *threads[THREADS];
1422: uintptr_t values[THREADS];
1423: int i;
1424:
1425: for (i = 0; i < THREADS; i++)
1426: {
1427: values[i] = 1;
1428: threads[i] = thread_create(cleanup_run, &values[i]);
1429: }
1430: for (i = 0; i < THREADS; i++)
1431: {
1432: threads[i]->join(threads[i]);
1433: ck_assert_int_eq(values[i], 4);
1434: }
1435: }
1436: END_TEST
1437:
1438: static void *cleanup_exit_run(void *data)
1439: {
1440: thread_cleanup_push(cleanup3, data);
1441: thread_cleanup_push(cleanup2, data);
1442: thread_cleanup_push(cleanup1, data);
1443: thread_exit(NULL);
1444: ck_assert(FALSE);
1445: return NULL;
1446: }
1447:
1448: START_TEST(test_cleanup_exit)
1449: {
1450: thread_t *threads[THREADS];
1451: uintptr_t values[THREADS];
1452: int i;
1453:
1454: for (i = 0; i < THREADS; i++)
1455: {
1456: values[i] = 1;
1457: threads[i] = thread_create(cleanup_exit_run, &values[i]);
1458: }
1459: for (i = 0; i < THREADS; i++)
1460: {
1461: threads[i]->join(threads[i]);
1462: ck_assert_int_eq(values[i], 4);
1463: }
1464: }
1465: END_TEST
1466:
1467: static void *cleanup_cancel_run(void *data)
1468: {
1469: thread_cancelability(FALSE);
1470:
1471: barrier_wait(barrier);
1472:
1473: thread_cleanup_push(cleanup3, data);
1474: thread_cleanup_push(cleanup2, data);
1475: thread_cleanup_push(cleanup1, data);
1476:
1477: thread_cancelability(TRUE);
1478:
1479: while (TRUE)
1480: {
1481: sleep(1);
1482: }
1483: return NULL;
1484: }
1485:
1486: START_TEST(test_cleanup_cancel)
1487: {
1488: thread_t *threads[THREADS];
1489: uintptr_t values[THREADS];
1490: int i;
1491:
1492: barrier = barrier_create(THREADS+1);
1493: for (i = 0; i < THREADS; i++)
1494: {
1495: values[i] = 1;
1496: threads[i] = thread_create(cleanup_cancel_run, &values[i]);
1497: }
1498: barrier_wait(barrier);
1499: for (i = 0; i < THREADS; i++)
1500: {
1501: threads[i]->cancel(threads[i]);
1502: }
1503: for (i = 0; i < THREADS; i++)
1504: {
1505: threads[i]->join(threads[i]);
1506: ck_assert_int_eq(values[i], 4);
1507: }
1508: barrier_destroy(barrier);
1509: }
1510: END_TEST
1511:
1512: static void *cleanup_pop_run(void *data)
1513: {
1514: thread_cleanup_push(cleanup3, data);
1515: thread_cleanup_push(cleanup2, data);
1516: thread_cleanup_push(cleanup1, data);
1517:
1518: thread_cleanup_push(cleanup2, data);
1519: thread_cleanup_pop(FALSE);
1520:
1521: thread_cleanup_pop(TRUE);
1522: return NULL;
1523: }
1524:
1525: START_TEST(test_cleanup_pop)
1526: {
1527: thread_t *threads[THREADS];
1528: uintptr_t values[THREADS];
1529: int i;
1530:
1531: for (i = 0; i < THREADS; i++)
1532: {
1533: values[i] = 1;
1534: threads[i] = thread_create(cleanup_pop_run, &values[i]);
1535: }
1536: for (i = 0; i < THREADS; i++)
1537: {
1538: threads[i]->join(threads[i]);
1539: ck_assert_int_eq(values[i], 4);
1540: }
1541: }
1542: END_TEST
1543:
1544: static void *cleanup_popall_run(void *data)
1545: {
1546: thread_cleanup_push(cleanup3, data);
1547: thread_cleanup_push(cleanup2, data);
1548: thread_cleanup_push(cleanup1, data);
1549:
1550: thread_cleanup_popall();
1551: return NULL;
1552: }
1553:
1554: START_TEST(test_cleanup_popall)
1555: {
1556: thread_t *threads[THREADS];
1557: uintptr_t values[THREADS];
1558: int i;
1559:
1560: for (i = 0; i < THREADS; i++)
1561: {
1562: values[i] = 1;
1563: threads[i] = thread_create(cleanup_popall_run, &values[i]);
1564: }
1565: for (i = 0; i < THREADS; i++)
1566: {
1567: threads[i]->join(threads[i]);
1568: ck_assert_int_eq(values[i], 4);
1569: }
1570: }
1571: END_TEST
1572:
1573:
1574: static thread_value_t *tls[10];
1575:
1576: static void *tls_run(void *data)
1577: {
1578: uintptr_t value = (uintptr_t)data;
1579: int i, j;
1580:
1581: for (i = 0; i < countof(tls); i++)
1582: {
1583: ck_assert(tls[i]->get(tls[i]) == NULL);
1584: }
1585: for (i = 0; i < countof(tls); i++)
1586: {
1587: tls[i]->set(tls[i], (void*)(value * i));
1588: }
1589: for (j = 0; j < 1000; j++)
1590: {
1591: for (i = 0; i < countof(tls); i++)
1592: {
1593: tls[i]->set(tls[i], (void*)(value * i));
1594: ck_assert(tls[i]->get(tls[i]) == (void*)(value * i));
1595: }
1596: sched_yield();
1597: }
1598: for (i = 0; i < countof(tls); i++)
1599: {
1600: ck_assert(tls[i]->get(tls[i]) == (void*)(value * i));
1601: }
1602: return (void*)(value + 1);
1603: }
1604:
1605: START_TEST(test_tls)
1606: {
1607: thread_t *threads[THREADS];
1608: int i;
1609:
1610: for (i = 0; i < countof(tls); i++)
1611: {
1612: tls[i] = thread_value_create(NULL);
1613: }
1614: for (i = 0; i < THREADS; i++)
1615: {
1616: threads[i] = thread_create(tls_run, (void*)(uintptr_t)i);
1617: }
1618:
1619: ck_assert_int_eq((uintptr_t)tls_run((void*)(uintptr_t)(THREADS + 1)),
1620: THREADS + 2);
1621:
1622: for (i = 0; i < THREADS; i++)
1623: {
1624: ck_assert_int_eq((uintptr_t)threads[i]->join(threads[i]), i + 1);
1625: }
1626: for (i = 0; i < countof(tls); i++)
1627: {
1628: tls[i]->destroy(tls[i]);
1629: }
1630: }
1631: END_TEST
1632:
1633: static void tls_cleanup(void *data)
1634: {
1635: uintptr_t *value = (uintptr_t*)data;
1636:
1637: (*value)--;
1638: }
1639:
1640: static void *tls_cleanup_run(void *data)
1641: {
1642: int i;
1643:
1644: for (i = 0; i < countof(tls); i++)
1645: {
1646: tls[i]->set(tls[i], data);
1647: }
1648: return NULL;
1649: }
1650:
1651: START_TEST(test_tls_cleanup)
1652: {
1653: thread_t *threads[THREADS];
1654: uintptr_t values[THREADS], main_value = countof(tls);
1655: int i;
1656:
1657: for (i = 0; i < countof(tls); i++)
1658: {
1659: tls[i] = thread_value_create(tls_cleanup);
1660: }
1661: for (i = 0; i < THREADS; i++)
1662: {
1663: values[i] = countof(tls);
1664: threads[i] = thread_create(tls_cleanup_run, &values[i]);
1665: }
1666:
1667: tls_cleanup_run(&main_value);
1668:
1669: for (i = 0; i < THREADS; i++)
1670: {
1671: threads[i]->join(threads[i]);
1672: ck_assert_int_eq(values[i], 0);
1673: }
1674: for (i = 0; i < countof(tls); i++)
1675: {
1676: tls[i]->destroy(tls[i]);
1677: }
1678: ck_assert_int_eq(main_value, 0);
1679: }
1680: END_TEST
1681:
1682: Suite *threading_suite_create()
1683: {
1684: Suite *s;
1685: TCase *tc;
1686:
1687: s = suite_create("threading");
1688:
1689: tc = tcase_create("recursive mutex");
1690: tcase_add_test(tc, test_mutex);
1691: suite_add_tcase(s, tc);
1692:
1693: tc = tcase_create("spinlock");
1694: tcase_add_test(tc, test_spinlock);
1695: suite_add_tcase(s, tc);
1696:
1697: tc = tcase_create("condvar");
1698: tcase_add_test(tc, test_condvar);
1699: tcase_add_test(tc, test_condvar_recursive);
1700: tcase_add_test(tc, test_condvar_broad);
1701: tcase_add_test(tc, test_condvar_timed);
1702: tcase_add_test(tc, test_condvar_timed_abs);
1703: tcase_add_test(tc, test_condvar_cancel);
1704: suite_add_tcase(s, tc);
1705:
1706: tc = tcase_create("rwlock");
1707: tcase_add_test(tc, test_rwlock);
1708: tcase_add_test(tc, test_rwlock_try);
1709: suite_add_tcase(s, tc);
1710:
1711: tc = tcase_create("rwlock condvar");
1712: tcase_add_test(tc, test_rwlock_condvar);
1713: tcase_add_test(tc, test_rwlock_condvar_broad);
1714: tcase_add_test(tc, test_rwlock_condvar_timed);
1715: tcase_add_test(tc, test_rwlock_condvar_timed_abs);
1716: tcase_add_test(tc, test_rwlock_condvar_cancel);
1717: suite_add_tcase(s, tc);
1718:
1719: tc = tcase_create("semaphore");
1720: tcase_add_test(tc, test_semaphore);
1721: tcase_add_test(tc, test_semaphore_timed);
1722: tcase_add_test(tc, test_semaphore_timed_abs);
1723: tcase_add_test(tc, test_semaphore_cancel);
1724: suite_add_tcase(s, tc);
1725:
1726: tc = tcase_create("thread joining");
1727: tcase_add_test(tc, test_join);
1728: tcase_add_test(tc, test_join_exit);
1729: suite_add_tcase(s, tc);
1730:
1731: tc = tcase_create("thread detaching");
1732: tcase_add_test(tc, test_detach);
1733: tcase_add_test(tc, test_detach_exit);
1734: suite_add_tcase(s, tc);
1735:
1736: tc = tcase_create("thread cancellation");
1737: tcase_add_test(tc, test_cancel);
1738: tcase_add_test(tc, test_cancel_onoff);
1739: tcase_add_test(tc, test_cancel_point);
1740: suite_add_tcase(s, tc);
1741:
1742: tc = tcase_create("thread cancellation point");
1743: tcase_add_loop_test(tc, test_cancellation_point,
1744: 0, countof(cancellation_points));
1745: tcase_add_loop_test(tc, test_cancellation_point_pre,
1746: 0, countof(cancellation_points));
1747: suite_add_tcase(s, tc);
1748:
1749: tc = tcase_create("thread cleanup");
1750: tcase_add_test(tc, test_cleanup);
1751: tcase_add_test(tc, test_cleanup_exit);
1752: tcase_add_test(tc, test_cleanup_cancel);
1753: tcase_add_test(tc, test_cleanup_pop);
1754: tcase_add_test(tc, test_cleanup_popall);
1755: suite_add_tcase(s, tc);
1756:
1757: tc = tcase_create("thread local storage");
1758: tcase_add_test(tc, test_tls);
1759: tcase_add_test(tc, test_tls_cleanup);
1760: suite_add_tcase(s, tc);
1761:
1762: return s;
1763: }