libs/newlib-cygwin
libs/newlib-cygwin
4
0
Fork 0
mirror of git://sourceware.org/git/newlib-cygwin.git synced 2025-02-22 16:49:45 +08:00
Code Issues Projects Releases Wiki Activity

* winsup.api/pthread/cancel2.c: Use explicit initializer for mutex.

Browse Source 
* winsup.api/pthread/mutex4.c (main): Ditto.
* winsup.api/pthread/mutex5.c: Reflect change in cygwin default mutex type.
* winsup.api/pthread/mutex6d.c: Ditto.
This commit is contained in:
Christopher Faylor 2005-06-11 04:59:53 +00:00
parent 8556456790
commit 452e5c7297
5 changed files with 29 additions and 15 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
winsup/testsuite/ChangeLog
View File

@ -1,3 +1,10 @@
2005-06-11 Christopher Faylor <cgf@timesys.com>
* winsup.api/pthread/cancel2.c: Use explicit initializer for mutex.
* winsup.api/pthread/mutex4.c (main): Ditto.
* winsup.api/pthread/mutex5.c: Reflect change in cygwin default mutex type.
* winsup.api/pthread/mutex6d.c: Ditto.
2005-06-10 Christopher Faylor <cgf@timesys.com> 2005-06-10 Christopher Faylor <cgf@timesys.com>
* winsup.api/winsup.exp: Remove (temporarily?) -nostdinc from build * winsup.api/winsup.exp: Remove (temporarily?) -nostdinc from build

2
winsup/testsuite/winsup.api/pthread/cancel2.c
View File

@ -58,7 +58,7 @@ struct bag_t_ {
static bag_t threadbag[NUMTHREADS + 1]; static bag_t threadbag[NUMTHREADS + 1];
static pthread_mutex_t waitLock = PTHREAD_MUTEX_INITIALIZER; static pthread_mutex_t waitLock = PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP;
void * void *
mythread(void * arg) mythread(void * arg)

2
winsup/testsuite/winsup.api/pthread/mutex4.c
View File

@ -34,7 +34,7 @@ main()
assert(pthread_mutexattr_init(&ma) == 0); assert(pthread_mutexattr_init(&ma) == 0);
wasHere = 0; wasHere = 0;
assert(pthread_mutexattr_settype(&ma, PTHREAD_MUTEX_DEFAULT) == 0); assert(pthread_mutexattr_settype(&ma, PTHREAD_MUTEX_ERRORCHECK) == 0);
assert(pthread_mutex_init(&mutex1, &ma) == 0); assert(pthread_mutex_init(&mutex1, &ma) == 0);
assert(pthread_mutex_lock(&mutex1) == 0); assert(pthread_mutex_lock(&mutex1) == 0);
assert(pthread_create(&t, NULL, unlocker, (void *) EPERM) == 0); assert(pthread_create(&t, NULL, unlocker, (void *) EPERM) == 0);

2
winsup/testsuite/winsup.api/pthread/mutex5.c
View File

@ -15,7 +15,7 @@ main()
int mxType = -1; int mxType = -1;
int success = 0; /* Use to quell GNU compiler warnings. */ int success = 0; /* Use to quell GNU compiler warnings. */
assert(success = PTHREAD_MUTEX_DEFAULT == PTHREAD_MUTEX_ERRORCHECK); assert(success = PTHREAD_MUTEX_DEFAULT == PTHREAD_MUTEX_NORMAL);
assert(success = PTHREAD_MUTEX_DEFAULT != PTHREAD_MUTEX_RECURSIVE); assert(success = PTHREAD_MUTEX_DEFAULT != PTHREAD_MUTEX_RECURSIVE);
assert(success = PTHREAD_MUTEX_RECURSIVE != PTHREAD_MUTEX_ERRORCHECK); assert(success = PTHREAD_MUTEX_RECURSIVE != PTHREAD_MUTEX_ERRORCHECK);

31
winsup/testsuite/winsup.api/pthread/mutex6d.c
View File

@ -2,7 +2,8 @@
* mutex6d.c * mutex6d.c
* *
* Tests PTHREAD_MUTEX_DEFAULT mutex type. * Tests PTHREAD_MUTEX_DEFAULT mutex type.
* The thread should behave the same way than an errorchecking mutex. * Thread locks mutex twice (recursive lock).
* The thread should deadlock.
* *
* Depends on API functions: * Depends on API functions:
* pthread_create() * pthread_create()
@ -25,11 +26,12 @@ void * locker(void * arg)
{ {
assert(pthread_mutex_lock(&mutex) == 0); assert(pthread_mutex_lock(&mutex) == 0);
lockCount++; lockCount++;
assert(pthread_mutex_lock(&mutex) == EDEADLK);
/* Should wait here (deadlocked) */
assert(pthread_mutex_lock(&mutex) == 0);
lockCount++; lockCount++;
assert(pthread_mutex_unlock(&mutex) == 0); assert(pthread_mutex_unlock(&mutex) == 0);
assert(pthread_mutex_unlock(&mutex) == EPERM);
return (void *) 555; return (void *) 555;
} }
@ -37,26 +39,31 @@ int
main() main()
{ {
pthread_t t; pthread_t t;
int result = 0;
int mxType = -1; int mxType = -1;
assert(pthread_mutexattr_init(&mxAttr) == 0); assert(pthread_mutexattr_init(&mxAttr) == 0);
assert(pthread_mutexattr_settype(&mxAttr, PTHREAD_MUTEX_DEFAULT) == 0); assert(pthread_mutexattr_settype(&mxAttr, PTHREAD_MUTEX_DEFAULT) == 0);
assert(pthread_mutexattr_gettype(&mxAttr, &mxType) == 0); assert(pthread_mutexattr_gettype(&mxAttr, &mxType) == 0);
assert(mxType == PTHREAD_MUTEX_DEFAULT); assert(mxType == PTHREAD_MUTEX_NORMAL);
assert(pthread_mutex_init(&mutex, &mxAttr) == 0); assert(pthread_mutex_init(&mutex, &mxAttr) == 0);
assert(pthread_create(&t, NULL, locker, NULL) == 0); assert(pthread_create(&t, NULL, locker, NULL) == 0);
assert(pthread_join(t, (void **) &result) == 0); Sleep(1000);
assert(result == 555);
assert(lockCount == 1);
/*
* Should succeed even though we don't own the lock
* because FAST mutexes don't check ownership.
*/
assert(pthread_mutex_unlock(&mutex) == 0);
Sleep (1000);
assert(lockCount == 2); assert(lockCount == 2);
assert(pthread_mutex_destroy(&mutex) == 0);
assert(pthread_mutexattr_destroy(&mxAttr) == 0);
exit(0); exit(0);
/* Never reached */ /* Never reached */