int main()
{
int rc;
struct timespec abstime, reltime = { 0, NANOSEC_PER_SEC/2 };
assert(pthread_cond_init(&cnd, 0) == 0);
assert(pthread_mutex_init(&mtx, 0) == 0);
(void) pthread_win32_getabstime_np(&abstime, &reltime);
/* Here pthread_cond_timedwait should time out after one second. */
assert(pthread_mutex_lock(&mtx) == 0);
assert((rc = pthread_cond_timedwait(&cnd, &mtx, &abstime)) == ETIMEDOUT);
assert(pthread_mutex_unlock(&mtx) == 0);
/* Here, the condition variable is signalled, but there are no
threads waiting on it. The signal should be lost and
the next pthread_cond_timedwait should time out too. */
assert((rc = pthread_cond_signal(&cnd)) == 0);
assert(pthread_mutex_lock(&mtx) == 0);
(void) pthread_win32_getabstime_np(&abstime, &reltime);
assert((rc = pthread_cond_timedwait(&cnd, &mtx, &abstime)) == ETIMEDOUT);
assert(pthread_mutex_unlock(&mtx) == 0);
return 0;
}
int
main()
{
pthread_t t[NUMTHREADS];
struct timespec abstime, reltime = { 5, 0 };
assert((t[0] = pthread_self()).p != NULL);
assert(pthread_cond_init(&cv, NULL) == 0);
assert(pthread_mutex_init(&mutex, NULL) == 0);
assert(pthread_mutex_lock(&mutex) == 0);
assert(pthread_create(&t[1], NULL, mythread, (void *) 1) == 0);
(void) pthread_win32_getabstime_np(&abstime, &reltime);
while (! (shared > 0))
assert(pthread_cond_timedwait(&cv, &mutex, &abstime) == 0);
assert(shared > 0);
assert(pthread_mutex_unlock(&mutex) == 0);
assert(pthread_join(t[1], NULL) == 0);
assert(pthread_cond_destroy(&cv) == 0);
return 0;
}
int
main()
{
struct timespec abstime = { 0, 0 }, reltime = { 1, 0 };
assert(pthread_cond_init(&cv, NULL) == 0);
assert(pthread_mutex_init(&mutex, NULL) == 0);
assert(pthread_mutex_lock(&mutex) == 0);
(void) pthread_win32_getabstime_np(&abstime, &reltime);
assert(pthread_cond_timedwait(&cv, &mutex, &abstime) == ETIMEDOUT);
assert(pthread_mutex_unlock(&mutex) == 0);
{
int result = pthread_cond_destroy(&cv);
if (result != 0)
{
fprintf(stderr, "Result = %s\n", error_string[result]);
fprintf(stderr, "\tWaitersBlocked = %ld\n", cv->nWaitersBlocked);
fprintf(stderr, "\tWaitersGone = %ld\n", cv->nWaitersGone);
fprintf(stderr, "\tWaitersToUnblock = %ld\n", cv->nWaitersToUnblock);
fflush(stderr);
}
assert(result == 0);
}
return 0;
}
int
main(int argc, char * argv[])
{
pthread_t id;
struct timespec abstime, reltime = { 1, 0 };
void* result = (void*)-1;
assert(pthread_create(&id, NULL, func, (void *)(size_t)999) == 0);
/*
* Let thread start before we attempt to join it.
*/
Sleep(100);
(void) pthread_win32_getabstime_np(&abstime, &reltime);
/* Test for pthread_timedjoin_np timeout */
assert(pthread_timedjoin_np(id, &result, &abstime) == ETIMEDOUT);
assert((int)(size_t)result == -1);
/* Test for pthread_tryjoin_np behaviour before thread has exited */
assert(pthread_tryjoin_np(id, &result) == EBUSY);
assert((int)(size_t)result == -1);
Sleep(500);
/* Test for pthread_tryjoin_np behaviour after thread has exited */
assert(pthread_tryjoin_np(id, &result) == 0);
assert((int)(size_t)result == 999);
/* Success. */
return 0;
}
void *
slaveThread (void * arg)
{
struct timespec abstime, reltime;
pthread_barrier_wait(&startBarrier);
do
{
assert(pthread_mutex_lock(&control.mx) == 0);
reltime.tv_sec = (control.value / 1000);
reltime.tv_nsec = (control.value % 1000) * NANOSEC_PER_MILLISEC;
if (pthread_cond_timedwait(&control.cv,
&control.mx,
pthread_win32_getabstime_np(&abstime, &reltime)) == ETIMEDOUT)
{
timeoutCount++;
}
else
{
signalsTakenCount++;
}
assert(pthread_mutex_unlock(&control.mx) == 0);
pthread_barrier_wait(&holdBarrier);
pthread_barrier_wait(&readyBarrier);
}
while (!allExit);
return NULL;
}
int
main()
{
pthread_t t[NUMTHREADS];
struct timespec abstime, reltime = { 5, 0 };
cvthing.shared = 0;
assert((t[0] = pthread_self()).p != NULL);
assert(cvthing.notbusy == PTHREAD_COND_INITIALIZER);
assert(cvthing.lock == PTHREAD_MUTEX_INITIALIZER);
assert(pthread_mutex_lock(&cvthing.lock) == 0);
assert(cvthing.lock != PTHREAD_MUTEX_INITIALIZER);
(void) pthread_win32_getabstime_np(&abstime, &reltime);
assert(pthread_cond_timedwait(&cvthing.notbusy, &cvthing.lock, &abstime) == ETIMEDOUT);
assert(cvthing.notbusy != PTHREAD_COND_INITIALIZER);
assert(pthread_create(&t[1], NULL, mythread, (void *) 1) == 0);
(void) pthread_win32_getabstime_np(&abstime, &reltime);
while (! (cvthing.shared > 0))
assert(pthread_cond_timedwait(&cvthing.notbusy, &cvthing.lock, &abstime) == 0);
assert(cvthing.shared > 0);
assert(pthread_mutex_unlock(&cvthing.lock) == 0);
assert(pthread_join(t[1], NULL) == 0);
assert(pthread_mutex_destroy(&cvthing.lock) == 0);
assert(cvthing.lock == NULL);
assert(pthread_cond_destroy(&cvthing.notbusy) == 0);
assert(cvthing.notbusy == NULL);
return 0;
}
void * locker(void * arg)
{
struct timespec abstime, reltime = { 1, 0 };
(void) pthread_win32_getabstime_np(&abstime, &reltime);
assert(pthread_mutex_timedlock(&mutex, &abstime) == ETIMEDOUT);
lockCount++;
return 0;
}
int
main()
{
pthread_t t;
struct timespec abstime, reltime = { 1, 0 };
(void) pthread_win32_getabstime_np(&abstime, &reltime);
assert(pthread_rwlock_timedwrlock(&rwlock1, &abstime) == 0);
assert(pthread_create(&t, NULL, func, NULL) == 0);
Sleep(2000);
assert(pthread_rwlock_unlock(&rwlock1) == 0);
assert(washere == 1);
return 0;
}
int
main()
{
struct timespec abstime, reltime = { 1, 0 };
(void) pthread_win32_getabstime_np(&abstime, &reltime);
assert(rwlock == PTHREAD_RWLOCK_INITIALIZER);
assert(pthread_rwlock_timedrdlock(&rwlock, &abstime) == 0);
assert(rwlock != PTHREAD_RWLOCK_INITIALIZER);
assert(rwlock != NULL);
assert(pthread_rwlock_unlock(&rwlock) == 0);
assert(pthread_rwlock_destroy(&rwlock) == 0);
assert(rwlock == NULL);
return 0;
}
int
main()
{
int failed = 0;
int i;
int first, last;
pthread_t t[NUMTHREADS + 1];
assert((t[0] = pthread_self()).p != NULL);
assert(cvthing.notbusy == PTHREAD_COND_INITIALIZER);
assert(cvthing.lock == PTHREAD_MUTEX_INITIALIZER);
(void) pthread_win32_getabstime_np(&abstime, &reltime);
assert((t[0] = pthread_self()).p != NULL);
awoken = 0;
for (first = 1, last = NUMTHREADS / 2;
first < NUMTHREADS;
first = last + 1, last = NUMTHREADS)
{
assert(pthread_mutex_lock(&start_flag) == 0);
for (i = first; i <= last; i++)
{
threadbag[i].started = 0;
threadbag[i].threadnum = i;
assert(pthread_create(&t[i], NULL, mythread, (void *) &threadbag[i]) == 0);
}
/*
* Code to control or manipulate child threads should probably go here.
*/
cvthing.shared = 0;
assert(pthread_mutex_unlock(&start_flag) == 0);
/*
* Give threads time to start.
*/
Sleep(100);
assert(pthread_mutex_lock(&cvthing.lock) == 0);
cvthing.shared++;
assert(pthread_mutex_unlock(&cvthing.lock) == 0);
assert(pthread_cond_broadcast(&cvthing.notbusy) == 0);
/*
* Give threads time to complete.
*/
for (i = first; i <= last; i++)
{
assert(pthread_join(t[i], NULL) == 0);
}
assert(awoken == (i - 1));
}
/*
* Standard check that all threads started.
*/
for (i = 1; i <= NUMTHREADS; i++)
{
failed = !threadbag[i].started;
if (failed)
{
fprintf(stderr, "Thread %d: started %d\n", i, threadbag[i].started);
}
}
/*
* Cleanup the CV.
*/
assert(pthread_mutex_destroy(&cvthing.lock) == 0);
assert(cvthing.lock == NULL);
assert(pthread_cond_destroy(&cvthing.notbusy) == 0);
assert(cvthing.notbusy == NULL);
assert(!failed);
/*
* Check any results here.
*/
assert(awoken == NUMTHREADS);
/*
* Success.
*/
return 0;
}
