2007-11-27 Glenn Humphrey <glenn.humphrey@OARcorp.com>

* psxbarrier01/psxbarrier01.scn, psxbarrier01/test.c,
	psxrwlock01/psxrwlock01.scn, psxrwlock01/test.c: Added several test
	cases to improve test coverage.

testsuites/psxtests/ChangeLog

@@ -1,3 +1,9 @@
+2007-11-27	Glenn Humphrey <glenn.humphrey@OARcorp.com>
+
+	* psxbarrier01/psxbarrier01.scn, psxbarrier01/test.c,
+	psxrwlock01/psxrwlock01.scn, psxrwlock01/test.c: Added several test
+	cases to improve test coverage.
+
 2007-09-24	Joel Sherrill <joel.sherrill@oarcorp.com>
 
 	PR 1262/filesystem

testsuites/psxtests/psxbarrier01/psxbarrier01.scn

@@ -0,0 +1,41 @@
+*** POSIX BARRIER TEST 01 ***
+pthread_barrierattr_init( NULL ) -- EINVAL
+pthread_barrierattr_setpshared( NULL, private ) -- EINVAL
+pthread_barrierattr_setpshared( NULL, shared ) -- EINVAL
+pthread_barrierattr_getpshared( NULL, &p ) -- EINVAL
+pthread_barrierattr_destroy( NULL ) -- EINVAL
+pthread_barrierattr_setpshared( &attr, shared ) -- EINVAL
+pthread_barrierattr_getpshared( &attr, NULL ) -- EINVAL
+pthread_barrierattr_destroy( &attr ) -- EINVAL
+pthread_barrierattr_init( &attr ) -- OK
+pthread_barrierattr_setpshared( &attr, private ) -- OK
+pthread_barrierattr_getpshared( &attr, &p ) -- OK
+pthread_barrierattr_setpshared( &attr, shared ) -- OK
+pthread_barrierattr_getpshared( &attr, &p ) -- OK
+pthread_barrierattr_setpshared( &attr, private ) -- EINVAL
+pthread_barrierattr_destroy( &attr ) -- OK
+pthread_barrierattr_getpshared( &attr, &p ) destroyed -- EINVAL
+pthread_barrier_init( NULL, NULL, 2 ) -- EINVAL
+pthread_barrier_init( &barrier, &attr, 2 ) -- EINVAL
+pthread_barrierattr_init( &attr ) -- OK
+pthread_barrier_init( &barrier, &attr, 0 ) -- EINVAL
+pthread_barrier_init( &barrier, NULL, 1 ) -- OK
+pthread_barrier_init( &barrier, NULL, 1 ) -- EAGAIN
+pthread_barrier_destroy( &barrier ) -- OK
+pthread_barrierattr_destroy( &attr ) -- OK
+pthread_barrier_destroy( NULL ) -- EINVAL
+pthread_barrier_destroy( &bad_barrier ) -- EINVAL
+pthread_barrier_wait( NULL ) -- EINVAL
+pthread_barrier_wait( &bad_barrier ) -- EINVAL
+pthread_barrierattr_init( &attr ) -- OK
+pthread_barrier_init( &barrier, &attr, 2 ) -- OK
+pthread_barrier_destroy( &barrier ) -- OK
+pthread_barrier_init( &Barrier, &attr, NUMBER_THREADS ) -- OK
+Init: pthread_create - thread 1 OK
+pthread_barrier_wait( &Barrier ) for thread 0x0b010001
+pthread_barrier_destroy( &Barrier ) -- EBUSY
+Init: pthread_create - thread 2 OK
+pthread_barrier_wait( &Barrier ) for thread 0x0b010002
+pthread_barrier_wait - 0x0b010002 released
+pthread_barrier_wait - 0x0b010001 released
+*** END OF POSIX BARRIER TEST 01 ***

testsuites/psxtests/psxbarrier01/test.c

@@ -30,13 +30,8 @@ void *BarrierThread(void *arg)
 
   printf( "pthread_barrier_wait( &Barrier ) for thread 0x%08x\n", id );
   status = pthread_barrier_wait( &Barrier );
-  if ( id == ThreadIds[NUMBER_THREADS - 1] ) {
-    printf( "pthread_barrier_wait - 0x%08x auto released\n", id );
-    assert( status == PTHREAD_BARRIER_SERIAL_THREAD );
-  } else {
-    printf( "pthread_barrier_wait - 0x%08x released\n", id );
-    assert( status == 0 );
-  }
+  printf( "pthread_barrier_wait - 0x%08x released\n", id );
+  assert( (status == 0) || (status == PTHREAD_BARRIER_SERIAL_THREAD) );
 
   return NULL;
 }
@@ -54,6 +49,8 @@ int main(
 )
 #endif
 {
+  pthread_barrier_t     another_barrier;
+  pthread_barrier_t     bad_barrier = 100;
   pthread_barrier_t     barrier;
   pthread_barrierattr_t attr;
   int                   status;
@@ -138,8 +135,63 @@ int main(
   status = pthread_barrierattr_getpshared( &attr, &p );
   assert( status == EINVAL );
 
+  /*************** pthread_barrier_init ERROR CHECKs *********/
+  /* NULL barrier argument */
+  puts( "pthread_barrier_init( NULL, NULL, 2 ) -- EINVAL" );
+  status = pthread_barrier_init( NULL, NULL, 2 );
+  assert( status == EINVAL );
 
-  /* XXX _init error checks */
+  /* uninitialized attr argument */
+  puts( "pthread_barrier_init( &barrier, &attr, 2 ) -- EINVAL" );
+  status = pthread_barrier_init( &barrier, &attr, 2 );
+  assert( status == EINVAL );
+
+  /* zero count argument */
+  puts( "pthread_barrierattr_init( &attr ) -- OK" );
+  status = pthread_barrierattr_init( &attr );
+  assert( status == 0 );
+
+  puts( "pthread_barrier_init( &barrier, &attr, 0 ) -- EINVAL" );
+  status = pthread_barrier_init( &barrier, &attr, 0 );
+  assert( status == EINVAL );
+
+  /* allocating too many */
+  puts( "pthread_barrier_init( &barrier, NULL, 1 ) -- OK" );
+  status = pthread_barrier_init( &barrier, NULL, 1 );
+  assert( status == 0 );
+
+  puts( "pthread_barrier_init( &barrier, NULL, 1 ) -- EAGAIN" );
+  status = pthread_barrier_init( &barrier, NULL, 1 );
+  assert( status == EAGAIN );
+
+  /* clean up */
+  puts( "pthread_barrier_destroy( &barrier ) -- OK" );
+  status = pthread_barrier_destroy( &barrier );
+  assert( status == 0 );
+
+  puts( "pthread_barrierattr_destroy( &attr ) -- OK" );
+  status = pthread_barrierattr_destroy( &attr );
+  assert( status == 0 );
+
+  /*************** pthread_barrier_destroy ERROR CHECKs *********/
+  /* NULL barrier argument */
+  puts( "pthread_barrier_destroy( NULL ) -- EINVAL" );
+  status = pthread_barrier_destroy( NULL );
+  assert( status == EINVAL );
+
+  puts( "pthread_barrier_destroy( &bad_barrier ) -- EINVAL" );
+  status = pthread_barrier_destroy( &bad_barrier );
+  assert( status == EINVAL );
+
+  /*************** pthread_barrier_wait ERROR CHECKs *********/
+  /* NULL barrier argument */
+  puts( "pthread_barrier_wait( NULL ) -- EINVAL" );
+  status = pthread_barrier_wait( NULL );
+  assert( status == EINVAL );
+
+  puts( "pthread_barrier_wait( &bad_barrier ) -- EINVAL" );
+  status = pthread_barrier_wait( &bad_barrier );
+  assert( status == EINVAL );
 
   /*************** ACTUALLY CREATE ONE CHECK *****************/
   puts( "pthread_barrierattr_init( &attr ) -- OK" );
@@ -155,13 +207,22 @@ int main(
   status = pthread_barrier_destroy( &barrier );
   assert( status == 0 );
 
-  /*************** CREATE TESTS AND LET THEM RELEASE *****************/
-  puts( "pthread_barrier_init( &Barrier, &attr, 2 ) -- OK" );
-  status = pthread_barrier_init( &Barrier, &attr, 2 );
+  /*************** CREATE THREADS AND LET THEM RELEASE *****************/
+  puts( "pthread_barrier_init( &Barrier, &attr, NUMBER_THREADS ) -- OK" );
+  status = pthread_barrier_init( &Barrier, &attr, NUMBER_THREADS );
   assert( status == 0 );
   assert( barrier != 0 );
 
   for (i=0 ; i<NUMBER_THREADS ; i++ ) {
+
+    /* check for unable to destroy while threads waiting */
+    if (i == NUMBER_THREADS - 1) {
+      puts( "pthread_barrier_destroy( &Barrier ) -- EBUSY" );
+      status = pthread_barrier_destroy( &Barrier );
+      assert( status == EBUSY );
+    }
+
+    /* create a thread to block on the barrier */
     printf( "Init: pthread_create - thread %d OK\n", i+1 );
     status = pthread_create(&ThreadIds[i], NULL, BarrierThread, &ThreadIds[i]);
     assert( !status );

testsuites/psxtests/psxrwlock01/psxrwlock01.scn

@@ -0,0 +1,77 @@
+*** POSIX RWLOCK TEST 01 ***
+pthread_rwlockattr_init( NULL ) -- EINVAL
+pthread_rwlockattr_setpshared( NULL, private ) -- EINVAL
+pthread_rwlockattr_setpshared( NULL, shared ) -- EINVAL
+pthread_rwlockattr_getpshared( NULL, &p ) -- EINVAL
+pthread_rwlockattr_destroy( NULL ) -- EINVAL
+pthread_rwlockattr_setpshared( &attr, shared ) -- EINVAL
+pthread_rwlockattr_getpshared( &attr, NULL ) -- EINVAL
+pthread_rwlockattr_destroy( &attr ) -- EINVAL
+pthread_rwlockattr_setpshared( &attr, private ) -- EINVAL
+pthread_rwlockattr_init( &attr ) -- OK
+pthread_rwlockattr_setpshared( &attr, private ) -- OK
+pthread_rwlockattr_getpshared( &attr, &p ) -- OK
+pthread_rwlockattr_setpshared( &attr, shared ) -- OK
+pthread_rwlockattr_getpshared( &attr, &p ) -- OK
+pthread_rwlockattr_destroy( &attr ) -- OK
+pthread_rwlockattr_getpshared( &attr, &p ) destroyed -- EINVAL
+pthread_rwlock_init(NULL, &attr) -- EINVAL
+pthread_rwlock_init(&rwlock, NULL) -- EINVAL
+pthread_rwlock_destroy(NULL) -- EINVAL
+pthread_rwlock_rdlock(NULL) -- EINVAL
+pthread_rwlock_timedrdlock( NULL, &abstime) -- EINVAL
+pthread_rwlock_timedrdlock( &rwlock, NULL) -- EINVAL
+pthread_rwlock_tryrdlock(NULL) -- EINVAL
+pthread_rwlock_wrlock(NULL) -- EINVAL
+pthread_rwlock_timedwrlock( NULL, &abstime) -- EINVAL
+pthread_rwlock_timedwrlock( &rwlock, NULL) -- EINVAL
+pthread_rwlock_trywrlock(NULL) -- EINVAL
+pthread_rwlock_unlock(NULL) -- EINVAL
+clock_gettime(CLOCK_REALTIME, &abstime) -- OK
+pthread_rwlock_destroy(BadId) -- EINVAL
+pthread_rwlock_rdlock(BadId) -- EINVAL
+pthread_rwlock_timedrdlock(BadId, &abstime) -- EINVAL
+pthread_rwlock_tryrdlock(BadId) -- EINVAL
+pthread_rwlock_wrlock(BadId) -- EINVAL
+pthread_rwlock_timedwrlock(BadId, &abstime) -- EINVAL
+pthread_rwlock_trywrlock(BadId) -- EINVAL
+pthread_rwlock_unlock(BadId) -- EINVAL
+pthread_rwlockattr_init( &attr ) -- OK
+pthread_rwlock_init( &rwlock, &attr ) -- OK
+pthread_rwlock_init( &rwlock, &attr ) -- EAGAIN
+pthread_rwlock_destroy( &rwlock ) -- OK
+pthread_rwlock_init( &RWLock, &attr ) -- OK
+pthread_rwlock_tryrdlock(RWLock) -- OK
+Init: pthread_create - thread 1 OK
+ReadThread - pthread_rwlock_rdlock(RWLock) blocking -- OK
+ReadThread - pthread_rwlock_rdlock(RWLock) unblocked -- OK
+Init: pthread_create - thread 2 OK
+ReadThread - pthread_rwlock_rdlock(RWLock) blocking -- OK
+ReadThread - pthread_rwlock_rdlock(RWLock) unblocked -- OK
+pthread_rwlock_unlock(RWLock) -- OK
+pthread_rwlock_trywrlock(RWLock) -- OK
+pthread_rwlock_tryrdlock(&RWLock) -- EBUSY
+Init: pthread_create - thread 1 OK
+ReadThread - pthread_rwlock_rdlock(RWLock) blocking -- OK
+Init: pthread_create - thread 2 OK
+ReadThread - pthread_rwlock_rdlock(RWLock) blocking -- OK
+pthread_rwlock_destroy( &RWLock ) -- EBUSY
+pthread_rwlock_unlock(RWLock) -- OK
+ReadThread - pthread_rwlock_rdlock(RWLock) unblocked -- OK
+ReadThread - pthread_rwlock_rdlock(RWLock) unblocked -- OK
+pthread_rwlock_trywrlock(RWLock) -- OK
+pthread_rwlock_trywrlock(&RWLock) -- EBUSY
+Init: pthread_create - thread 1 OK
+WriteThread - pthread_rwlock_wrlock(RWLock) blocking -- OK
+Init: pthread_create - thread 2 OK
+WriteThread - pthread_rwlock_wrlock(RWLock) blocking -- OK
+pthread_rwlock_unlock(RWLock) -- OK
+WriteThread - pthread_rwlock_wrlock(RWLock) unblocked -- OK
+WriteThread - pthread_rwlock_unlock(RWLock) -- OK
+WriteThread - pthread_rwlock_wrlock(RWLock) unblocked -- OK
+clock_gettime(CLOCK_REALTIME, &abstime) -- OK
+pthread_rwlock_timedwrlock( &RWLock, &abstime) -- OK
+WriteThread - pthread_rwlock_unlock(RWLock) -- OK
+pthread_rwlock_timedrdlock( &RWLock, &abstime) -- OK
+pthread_rwlock_destroy( &RWLock ) -- OK
+*** END OF POSIX RWLOCK TEST 01 ***

testsuites/psxtests/psxrwlock01/test.c

@@ -119,9 +119,12 @@ int main(
   status = pthread_rwlockattr_destroy( &attr );
   assert( status == EINVAL );
 
+  /*************** BAD PSHARED CHECK *****************/
+  puts( "pthread_rwlockattr_setpshared( &attr, private ) -- EINVAL" );
+  status = pthread_rwlockattr_setpshared( &attr, ~PTHREAD_PROCESS_PRIVATE );
+  assert( status == EINVAL );
 
   /*************** ACTUALLY WORK THIS TIME *****************/
-
   puts( "pthread_rwlockattr_init( &attr ) -- OK" );
   status = pthread_rwlockattr_init( &attr );
   assert( status == 0 );
@@ -144,11 +147,6 @@ int main(
   assert( status == 0 );
   assert( p == PTHREAD_PROCESS_SHARED );
 
-  /*************** BAD PSHARED CHECK *****************/
-  puts( "pthread_rwlockattr_setpshared( &attr, private ) -- EINVAL" );
-  status = pthread_rwlockattr_setpshared( &attr, ~PTHREAD_PROCESS_PRIVATE );
-  assert( status == EINVAL );
-
   /*************** DESTROY/REUSE CHECK *****************/
   puts( "pthread_rwlockattr_destroy( &attr ) -- OK" );
   status = pthread_rwlockattr_destroy( &attr );
@@ -158,10 +156,10 @@ int main(
   status = pthread_rwlockattr_getpshared( &attr, &p );
   assert( status == EINVAL );
 
+  /*************** NULL ARGUMENT CHECKS *****************/
+  abstime.tv_sec = 0;
+  abstime.tv_nsec = 0;
 
-  /* XXX _init error checks */
-
-  /*************** NULL ID ARGUMENT CHECKS *****************/
   puts( "pthread_rwlock_init(NULL, &attr) -- EINVAL" );
   status = pthread_rwlock_init(NULL, &attr);
   assert( status == EINVAL );
@@ -178,10 +176,6 @@ int main(
   status = pthread_rwlock_rdlock(NULL);
   assert( status == EINVAL );
 
-  puts( "pthread_rwlock_tryrdlock(NULL) -- EINVAL" );
-  status = pthread_rwlock_tryrdlock(NULL);
-  assert( status == EINVAL );
-
   puts( "pthread_rwlock_timedrdlock( NULL, &abstime) -- EINVAL" );
   status = pthread_rwlock_timedrdlock( NULL, &abstime);
   assert( status == EINVAL );
@@ -190,18 +184,14 @@ int main(
   status = pthread_rwlock_timedrdlock( &rwlock, NULL);
   assert( status == EINVAL );
 
-  puts( "pthread_rwlock_timedrdlock( &rwlock, NULL) -- EINVAL" );
-  status = pthread_rwlock_timedrdlock( &rwlock, NULL);
+  puts( "pthread_rwlock_tryrdlock(NULL) -- EINVAL" );
+  status = pthread_rwlock_tryrdlock(NULL);
   assert( status == EINVAL );
 
   puts( "pthread_rwlock_wrlock(NULL) -- EINVAL" );
   status = pthread_rwlock_wrlock(NULL);
   assert( status == EINVAL );
 
-  puts( "pthread_rwlock_trywrlock(NULL) -- EINVAL" );
-  status = pthread_rwlock_trywrlock(NULL);
-  assert( status == EINVAL );
-
   puts( "pthread_rwlock_timedwrlock( NULL, &abstime) -- EINVAL" );
   status = pthread_rwlock_timedwrlock( NULL, &abstime );
   assert( status == EINVAL );
@@ -210,46 +200,52 @@ int main(
   status = pthread_rwlock_timedwrlock( &rwlock, NULL);
   assert( status == EINVAL );
 
+  puts( "pthread_rwlock_trywrlock(NULL) -- EINVAL" );
+  status = pthread_rwlock_trywrlock(NULL);
+  assert( status == EINVAL );
+
+  puts( "pthread_rwlock_unlock(NULL) -- EINVAL" );
+  status = pthread_rwlock_unlock(NULL);
+  assert( status == EINVAL );
 
   /*************** BAD ID CHECK *****************/
   rwlock = 1;
-
-  /* XXX make a valid abstime */
+  /* make a valid abstime */
+  puts( "clock_gettime(CLOCK_REALTIME, &abstime) -- OK" );
+  status = clock_gettime( CLOCK_REALTIME, &abstime );
+  assert( !status );
+  abstime.tv_sec += 5;
 
   puts( "pthread_rwlock_destroy(BadId) -- EINVAL" );
   status = pthread_rwlock_destroy(&rwlock);
   assert( status == EINVAL );
 
   puts( "pthread_rwlock_rdlock(BadId) -- EINVAL" );
-  status = pthread_rwlock_rdlock(NULL);
+  status = pthread_rwlock_rdlock(&rwlock);
+  assert( status == EINVAL );
+
+  puts( "pthread_rwlock_timedrdlock(BadId, &abstime) -- EINVAL" );
+  status = pthread_rwlock_timedrdlock( &rwlock, &abstime);
   assert( status == EINVAL );
 
   puts( "pthread_rwlock_tryrdlock(BadId) -- EINVAL" );
-  status = pthread_rwlock_tryrdlock(NULL);
-  assert( status == EINVAL );
-
-  puts( "pthread_rwlock_timedrdlock( BadId, &abstime) -- EINVAL" );
-  status = pthread_rwlock_timedrdlock( NULL, &abstime);
-  assert( status == EINVAL );
-
-  puts( "pthread_rwlock_timedrdlock( &rwlock, BadId) -- EINVAL" );
-  status = pthread_rwlock_timedrdlock( &rwlock, NULL);
-  assert( status == EINVAL );
-
-  puts( "pthread_rwlock_timedrdlock( &rwlock, BadId) -- EINVAL" );
-  status = pthread_rwlock_timedrdlock( &rwlock, NULL);
+  status = pthread_rwlock_tryrdlock(&rwlock);
   assert( status == EINVAL );
 
   puts( "pthread_rwlock_wrlock(BadId) -- EINVAL" );
-  status = pthread_rwlock_wrlock(NULL);
+  status = pthread_rwlock_wrlock(&rwlock);
+  assert( status == EINVAL );
+
+  puts( "pthread_rwlock_timedwrlock(BadId, &abstime) -- EINVAL" );
+  status = pthread_rwlock_timedwrlock( &rwlock, &abstime );
   assert( status == EINVAL );
 
   puts( "pthread_rwlock_trywrlock(BadId) -- EINVAL" );
-  status = pthread_rwlock_trywrlock(NULL);
+  status = pthread_rwlock_trywrlock(&rwlock);
   assert( status == EINVAL );
 
-  puts( "pthread_rwlock_timedwrlock( BadId, &abstime) -- EINVAL" );
-  status = pthread_rwlock_timedwrlock( &rwlock, &abstime );
+  puts( "pthread_rwlock_unlock(BadId) -- EINVAL" );
+  status = pthread_rwlock_unlock(&rwlock);
   assert( status == EINVAL );
 
   /*************** BAD ABSTIME CHECK *****************/
@@ -262,7 +258,7 @@ int main(
   abstime.tv_sec = 0;
   abstime.tv_nsec = 0x7fffffffL;
 
-
+  /* XXX do we need bad time check? */
 
   /*************** ACTUALLY CREATE ONE CHECK *****************/
   puts( "pthread_rwlockattr_init( &attr ) -- OK" );
@@ -274,18 +270,21 @@ int main(
   assert( status == 0 );
   assert( rwlock != 0 );
 
+  puts( "pthread_rwlock_init( &rwlock, &attr ) -- EAGAIN" );
+  status = pthread_rwlock_init( &rwlock, &attr );
+  assert( status == EAGAIN );
+
   puts( "pthread_rwlock_destroy( &rwlock ) -- OK" );
   status = pthread_rwlock_destroy( &rwlock );
   assert( status == 0 );
 
-  /*************** CREATE TESTS AND LET THEM OBTAIN READLOCK *****************/
+  /*************** CREATE THREADS AND LET THEM OBTAIN READLOCK ***************/
   puts( "pthread_rwlock_init( &RWLock, &attr ) -- OK" );
   status = pthread_rwlock_init( &RWLock, &attr );
   assert( status == 0 );
-  assert( rwlock != 0 );
 
-  puts( "pthread_rwlock_trywrlock(RWLock) -- OK" );
-  status = pthread_rwlock_trywrlock(&RWLock);
+  puts( "pthread_rwlock_tryrdlock(RWLock) -- OK" );
+  status = pthread_rwlock_tryrdlock(&RWLock);
   assert( !status );
 
   for (i=0 ; i<NUMBER_THREADS ; i++ ) {
@@ -302,12 +301,43 @@ int main(
 
   sleep(1);
 
- 
-  /*************** CREATE TESTS AND LET THEM OBTAIN WRITE LOCK ***************/
+  /*************** CREATE THREADS AND LET THEM OBTAIN READLOCK ***************/
   puts( "pthread_rwlock_trywrlock(RWLock) -- OK" );
   status = pthread_rwlock_trywrlock(&RWLock);
   assert( !status );
 
+  puts( "pthread_rwlock_tryrdlock(&RWLock) -- EBUSY" );
+  status = pthread_rwlock_tryrdlock(&RWLock);
+  assert( status == EBUSY );
+
+  for (i=0 ; i<NUMBER_THREADS ; i++ ) {
+    printf( "Init: pthread_create - thread %d OK\n", i+1 );
+    status = pthread_create(&ThreadIds[i], NULL, ReadLockThread, &ThreadIds[i]);
+    assert( !status );
+
+    sleep(1);
+  }
+
+  /* Attempt delete while threads are blocked */
+  puts( "pthread_rwlock_destroy( &RWLock ) -- EBUSY" );
+  status = pthread_rwlock_destroy( &RWLock );
+  assert( status == EBUSY );
+
+  puts( "pthread_rwlock_unlock(RWLock) -- OK" );
+  status = pthread_rwlock_unlock(&RWLock);
+  assert( !status );
+
+  sleep(2);
+ 
+  /*************** CREATE THREADS AND LET THEM OBTAIN WRITE LOCK *************/
+  puts( "pthread_rwlock_trywrlock(RWLock) -- OK" );
+  status = pthread_rwlock_trywrlock(&RWLock);
+  assert( !status );
+
+  puts( "pthread_rwlock_trywrlock(&RWLock) -- EBUSY" );
+  status = pthread_rwlock_trywrlock(&RWLock);
+  assert( status == EBUSY );
+
   for (i=0 ; i<NUMBER_THREADS ; i++ ) {
     printf( "Init: pthread_create - thread %d OK\n", i+1 );
     status =
@@ -321,13 +351,9 @@ int main(
   status = pthread_rwlock_unlock(&RWLock);
   assert( !status );
 
-  sleep( 3 );
-  puts( "pthread_rwlock_trywrlock(RWLock) -- OK" );
-  status = pthread_rwlock_trywrlock(&RWLock);
-  assert( !status );
+  sleep(2);
 
   /*************** TIMEOUT ON RWLOCK ***************/
-
   puts( "clock_gettime(CLOCK_REALTIME, &abstime) -- OK" );
   status = clock_gettime( CLOCK_REALTIME, &abstime );
   assert( !status );
@@ -335,16 +361,16 @@ int main(
   abstime.tv_sec += 1;
   puts( "pthread_rwlock_timedwrlock( &RWLock, &abstime) -- OK" );
   status = pthread_rwlock_timedwrlock( &RWLock, &abstime );
-  assert( !status );
+  assert( status == 0 );
 
   abstime.tv_sec += 1;
   puts( "pthread_rwlock_timedrdlock( &RWLock, &abstime) -- OK" );
   status = pthread_rwlock_timedrdlock( &RWLock, &abstime );
-  assert( !status );
+  assert( status == ETIMEDOUT );
 
   /*************** DESTROY RWLOCK ***************/
-  puts( "pthread_rwlock_destroy( &rwlock ) -- OK" );
-  status = pthread_rwlock_destroy( &rwlock );
+  puts( "pthread_rwlock_destroy( &RWLock ) -- OK" );
+  status = pthread_rwlock_destroy( &RWLock );
   assert( status == 0 );