summaryrefslogtreecommitdiff
path: root/tests
diff options
context:
space:
mode:
Diffstat (limited to 'tests')
-rw-r--r--tests/ChangeLog6
-rw-r--r--tests/GNUmakefile11
-rw-r--r--tests/Makefile9
-rw-r--r--tests/condvar2.c21
-rw-r--r--tests/condvar2_1.c120
-rw-r--r--tests/condvar3_1.c144
-rw-r--r--tests/condvar3_2.c153
7 files changed, 453 insertions, 11 deletions
diff --git a/tests/ChangeLog b/tests/ChangeLog
index b1b3881..e7026f2 100644
--- a/tests/ChangeLog
+++ b/tests/ChangeLog
@@ -1,3 +1,9 @@
+2001-06-3 Ross Johnson <rpj@special.ise.canberra.edu.au>
+
+ * condvar2_1.c: New test.
+ * condvar3_1.c: New test.
+ * condvar3_2.c: New test.
+
2001-05-30 Ross Johnson <rpj@special.ise.canberra.edu.au>
* mutex1n.c: New test.
diff --git a/tests/GNUmakefile b/tests/GNUmakefile
index d38f982..b14db76 100644
--- a/tests/GNUmakefile
+++ b/tests/GNUmakefile
@@ -36,11 +36,12 @@ COPYFILES = $(HDR) $(LIB) $(DLL)
# stop.
TESTS = loadfree \
- self1 mutex5 mutex1 mutex1e mutex1n mutex1r condvar1 condvar2 exit1 create1 equal1 \
+ self1 mutex5 mutex1 mutex1e mutex1n mutex1r \
+ condvar1 condvar2 condvar2_1 exit1 create1 equal1 \
exit2 exit3 \
join0 join1 join2 mutex2 mutex3 mutex4 mutex6 mutex6n mutex6e mutex6r \
count1 once1 tsd1 self2 cancel1 cancel2 eyal1 \
- condvar3 condvar4 condvar5 condvar6 condvar7 condvar8 condvar9 \
+ condvar3 condvar3_1 condvar3_2 condvar4 condvar5 condvar6 condvar7 condvar8 condvar9 \
errno1 \
rwlock1 rwlock2 rwlock3 rwlock4 rwlock5 rwlock6 rwlock7 \
context1 cancel3 cancel4 cancel5 \
@@ -72,6 +73,7 @@ all-GCE: $(PASSES)
cancel1.pass: create1.pass
cancel2.pass: cancel1.pass
+cancel2_1.pass: cancel2.pass
cancel3.pass: context1.pass
cancel4.pass: cancel3.pass
cancel5.pass: cancel3.pass
@@ -81,7 +83,10 @@ cleanup2.pass: cleanup1.pass
cleanup3.pass: cleanup2.pass
condvar1.pass:
condvar2.pass: condvar1.pass
-condvar3.pass: create1.pass
+condvar2_1.pass: condvar2.pass join2.pass
+condvar3.pass: create1.pass condvar2.pass
+condvar3_1.pass: condvar3.pass join2.pass
+condvar3_2.pass: condvar3_1.pass
condvar4.pass: create1.pass
condvar5.pass: condvar4.pass
condvar6.pass: condvar5.pass
diff --git a/tests/Makefile b/tests/Makefile
index 5915d54..afcc156 100644
--- a/tests/Makefile
+++ b/tests/Makefile
@@ -39,7 +39,7 @@ EHFLAGS =
PASSES= loadfree.pass \
self1.pass mutex5.pass \
mutex1.pass mutex1n.pass mutex1e.pass mutex1r.pass mutex2.pass mutex3.pass \
- condvar1.pass condvar2.pass \
+ condvar1.pass condvar2.pass condvar2_1.pass \
exit1.pass create1.pass equal1.pass \
exit2.pass exit3.pass \
join0.pass join1.pass join2.pass \
@@ -48,7 +48,7 @@ PASSES= loadfree.pass \
self2.pass \
cancel1.pass cancel2.pass \
eyal1.pass \
- condvar3.pass condvar4.pass condvar5.pass condvar6.pass \
+ condvar3.pass condvar3_1.pass condvar3_2.pass condvar4.pass condvar5.pass condvar6.pass \
condvar7.pass condvar8.pass condvar9.pass \
errno1.pass \
rwlock1.pass rwlock2.pass rwlock3.pass rwlock4.pass rwlock5.pass rwlock6.pass rwlock7.pass \
@@ -125,7 +125,10 @@ cleanup2.pass: cleanup1.pass
cleanup3.pass: cleanup2.pass
condvar1.pass:
condvar2.pass: condvar1.pass
-condvar3.pass: create1.pass
+condvar2_1.pass: condvar2.pass join2.pass
+condvar3.pass: create1.pass condvar2.pass
+condvar3_1.pass: condvar3.pass join2.pass
+condvar3_2.pass: condvar3_1.pass
condvar4.pass: create1.pass
condvar5.pass: condvar4.pass
condvar6.pass: condvar5.pass
diff --git a/tests/condvar2.c b/tests/condvar2.c
index beae323..369cef6 100644
--- a/tests/condvar2.c
+++ b/tests/condvar2.c
@@ -1,5 +1,5 @@
/*
- * File: condvar1.c
+ * File: condvar2.c
*
* Test Synopsis:
* - Test timed wait on a CV.
@@ -47,6 +47,8 @@
pthread_cond_t cv;
pthread_mutex_t mutex;
+#include "../implement.h"
+
int
main()
{
@@ -72,10 +74,19 @@ main()
assert(pthread_mutex_unlock(&mutex) == 0);
- assert(pthread_cond_destroy(&cv) == 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, "\tWaitersUnblocked = %ld\n", cv->nWaitersUnblocked);
+ fprintf(stderr, "\tWaitersGone = %ld\n", cv->nWaitersGone);
+ fprintf(stderr, "\tWaitersToUnblock = %ld\n", cv->nWaitersToUnblock);
+ fflush(stderr);
+ }
+ assert(result == 0);
+ }
return 0;
}
-
-
-
diff --git a/tests/condvar2_1.c b/tests/condvar2_1.c
new file mode 100644
index 0000000..feae128
--- /dev/null
+++ b/tests/condvar2_1.c
@@ -0,0 +1,120 @@
+/*
+ * File: condvar2_1.c
+ *
+ * Test Synopsis:
+ * - Test timeout of multiple waits on a CV with no signal/broadcast.
+ *
+ * Test Method (Validation or Falsification):
+ * - Validation
+ *
+ * Requirements Tested:
+ * -
+ *
+ * Features Tested:
+ * -
+ *
+ * Cases Tested:
+ * -
+ *
+ * Description:
+ * - Because the CV is never signaled, we expect the waits to time out.
+ *
+ * Environment:
+ * -
+ *
+ * Input:
+ * - None.
+ *
+ * Output:
+ * - File name, Line number, and failed expression on failure.
+ * - No output on success.
+ *
+ * Assumptions:
+ * -
+ *
+ * Pass Criteria:
+ * - pthread_cond_timedwait returns ETIMEDOUT.
+ * - Process returns zero exit status.
+ *
+ * Fail Criteria:
+ * - pthread_cond_timedwait does not return ETIMEDOUT.
+ * - Process returns non-zero exit status.
+ */
+
+#include "test.h"
+#include <sys/timeb.h>
+
+static pthread_cond_t cv;
+static pthread_mutex_t mutex;
+static struct timespec abstime = { 0, 0 };
+
+enum {
+ NUMTHREADS = 60
+};
+
+void *
+mythread(void * arg)
+{
+ assert(pthread_mutex_lock(&mutex) == 0);
+
+ assert(pthread_cond_timedwait(&cv, &mutex, &abstime) == ETIMEDOUT);
+
+ assert(pthread_mutex_unlock(&mutex) == 0);
+
+ return arg;
+}
+
+#include "../implement.h"
+
+int
+main()
+{
+ int i;
+ pthread_t t[NUMTHREADS + 1];
+ int result = 0;
+ struct _timeb currSysTime;
+ const DWORD NANOSEC_PER_MILLISEC = 1000000;
+
+ assert(pthread_cond_init(&cv, NULL) == 0);
+
+ assert(pthread_mutex_init(&mutex, NULL) == 0);
+
+ /* get current system time */
+ _ftime(&currSysTime);
+
+ abstime.tv_sec = currSysTime.time;
+ abstime.tv_nsec = NANOSEC_PER_MILLISEC * currSysTime.millitm;
+
+ abstime.tv_sec += 5;
+
+ assert(pthread_mutex_lock(&mutex) == 0);
+
+ for (i = 1; i <= NUMTHREADS; i++)
+ {
+ assert(pthread_create(&t[i], NULL, mythread, (void *) i) == 0);
+ }
+
+ assert(pthread_mutex_unlock(&mutex) == 0);
+
+ for (i = 1; i <= NUMTHREADS; i++)
+ {
+ assert(pthread_join(t[i], (void **) &result) == 0);
+ assert(result == i);
+ }
+
+ {
+ 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, "\tWaitersUnblocked = %ld\n", cv->nWaitersUnblocked);
+ fprintf(stderr, "\tWaitersGone = %ld\n", cv->nWaitersGone);
+ fprintf(stderr, "\tWaitersToUnblock = %ld\n", cv->nWaitersToUnblock);
+ fflush(stderr);
+ }
+ assert(result == 0);
+ }
+
+ return 0;
+}
diff --git a/tests/condvar3_1.c b/tests/condvar3_1.c
new file mode 100644
index 0000000..f9bb0c6
--- /dev/null
+++ b/tests/condvar3_1.c
@@ -0,0 +1,144 @@
+/*
+ * File: condvar3_1.c
+ *
+ * Test Synopsis:
+ * - Test timeout of multiple waits on a CV with some signaled.
+ *
+ * Test Method (Validation or Falsification):
+ * - Validation
+ *
+ * Requirements Tested:
+ * -
+ *
+ * Features Tested:
+ * -
+ *
+ * Cases Tested:
+ * -
+ *
+ * Description:
+ * - Because some CVs are never signaled, we expect their waits to time out.
+ * Some are signaled, the rest time out. Pthread_cond_destroy() will fail
+ * unless all are accounted for, either signaled or timedout.
+ *
+ * Environment:
+ * -
+ *
+ * Input:
+ * - None.
+ *
+ * Output:
+ * - File name, Line number, and failed expression on failure.
+ * - No output on success.
+ *
+ * Assumptions:
+ * -
+ *
+ * Pass Criteria:
+ * - pthread_cond_timedwait returns ETIMEDOUT.
+ * - Process returns zero exit status.
+ *
+ * Fail Criteria:
+ * - pthread_cond_timedwait does not return ETIMEDOUT.
+ * - Process returns non-zero exit status.
+ */
+
+#include "test.h"
+#include <sys/timeb.h>
+
+static pthread_cond_t cv;
+static pthread_mutex_t mutex;
+static struct timespec abstime = { 0, 0 };
+static int timedout = 0;
+static int signaled = 0;
+static int awoken = 0;
+
+enum {
+ NUMTHREADS = 60
+};
+
+void *
+mythread(void * arg)
+{
+ int result;
+
+ assert(pthread_mutex_lock(&mutex) == 0);
+
+ result = pthread_cond_timedwait(&cv, &mutex, &abstime);
+ if (result == ETIMEDOUT)
+ {
+ timedout++;
+ }
+ else
+ {
+ awoken++;
+ }
+
+ assert(pthread_mutex_unlock(&mutex) == 0);
+
+ return arg;
+}
+
+#include "../implement.h"
+
+int
+main()
+{
+ int i;
+ pthread_t t[NUMTHREADS + 1];
+ int result = 0;
+ struct _timeb currSysTime;
+ const DWORD NANOSEC_PER_MILLISEC = 1000000;
+
+ assert(pthread_cond_init(&cv, NULL) == 0);
+
+ assert(pthread_mutex_init(&mutex, NULL) == 0);
+
+ /* get current system time */
+ _ftime(&currSysTime);
+
+ abstime.tv_sec = currSysTime.time;
+ abstime.tv_nsec = NANOSEC_PER_MILLISEC * currSysTime.millitm;
+
+ abstime.tv_sec += 5;
+
+ assert(pthread_mutex_lock(&mutex) == 0);
+
+ for (i = 1; i <= NUMTHREADS; i++)
+ {
+ assert(pthread_create(&t[i], NULL, mythread, (void *) i) == 0);
+ }
+
+ assert(pthread_mutex_unlock(&mutex) == 0);
+
+ for (i = NUMTHREADS/3; i <= 2*NUMTHREADS/3; i++)
+ {
+ assert(pthread_cond_signal(&cv) == 0);
+ signaled++;
+ }
+
+ for (i = 1; i <= NUMTHREADS; i++)
+ {
+ assert(pthread_join(t[i], (void **) &result) == 0);
+ assert(result == i);
+ }
+
+ assert(signaled == awoken);
+ assert(timedout == NUMTHREADS - signaled);
+
+ {
+ 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, "\tWaitersUnblocked = %ld\n", cv->nWaitersUnblocked);
+ fprintf(stderr, "\tWaitersGone = %ld\n", cv->nWaitersGone);
+ fprintf(stderr, "\tWaitersToUnblock = %ld\n", cv->nWaitersToUnblock);
+ fflush(stderr);
+ }
+ assert(result == 0);
+ }
+
+ return 0;
+}
diff --git a/tests/condvar3_2.c b/tests/condvar3_2.c
new file mode 100644
index 0000000..cd1565d
--- /dev/null
+++ b/tests/condvar3_2.c
@@ -0,0 +1,153 @@
+/*
+ * File: condvar3_2.c
+ *
+ * Test Synopsis:
+ * - Test timeout of multiple waits on a CV with remainder broadcast awoken.
+ *
+ * Test Method (Validation or Falsification):
+ * - Validation
+ *
+ * Requirements Tested:
+ * -
+ *
+ * Features Tested:
+ * -
+ *
+ * Cases Tested:
+ * -
+ *
+ * Description:
+ * - Because some CVs are never signaled, we expect their waits to time out.
+ * Some time out, the rest are broadcast signaled. Pthread_cond_destroy() will fail
+ * unless all are accounted for, either signaled or timedout.
+ *
+ * Environment:
+ * -
+ *
+ * Input:
+ * - None.
+ *
+ * Output:
+ * - File name, Line number, and failed expression on failure.
+ * - No output on success.
+ *
+ * Assumptions:
+ * -
+ *
+ * Pass Criteria:
+ * - pthread_cond_timedwait returns ETIMEDOUT.
+ * - Process returns zero exit status.
+ *
+ * Fail Criteria:
+ * - pthread_cond_timedwait does not return ETIMEDOUT.
+ * - Process returns non-zero exit status.
+ */
+
+#include "test.h"
+#include <sys/timeb.h>
+
+static pthread_cond_t cv;
+static pthread_mutex_t mutex;
+static struct timespec abstime = { 0, 0 };
+static struct timespec abstime2 = { 0, 0 };
+static int timedout = 0;
+static int signaled = 0;
+static int awoken = 0;
+
+enum {
+ NUMTHREADS = 60
+};
+
+void *
+mythread(void * arg)
+{
+ int result;
+
+ assert(pthread_mutex_lock(&mutex) == 0);
+
+ abstime2.tv_sec = abstime.tv_sec;
+
+ if ((int) arg % 3 == 0)
+ {
+ abstime2.tv_sec += 2;
+ }
+
+ result = pthread_cond_timedwait(&cv, &mutex, &abstime2);
+ if (result == ETIMEDOUT)
+ {
+ timedout++;
+ }
+ else
+ {
+ awoken++;
+ }
+
+ assert(pthread_mutex_unlock(&mutex) == 0);
+
+ return arg;
+}
+
+#include "../implement.h"
+
+int
+main()
+{
+ int i;
+ pthread_t t[NUMTHREADS + 1];
+ int result = 0;
+ struct _timeb currSysTime;
+ const DWORD NANOSEC_PER_MILLISEC = 1000000;
+
+ assert(pthread_cond_init(&cv, NULL) == 0);
+
+ assert(pthread_mutex_init(&mutex, NULL) == 0);
+
+ /* get current system time */
+ _ftime(&currSysTime);
+
+ abstime.tv_sec = abstime.tv_sec = currSysTime.time + 5;
+ abstime.tv_nsec = abstime2.tv_nsec = NANOSEC_PER_MILLISEC * currSysTime.millitm;
+
+ assert(pthread_mutex_lock(&mutex) == 0);
+
+ for (i = 1; i <= NUMTHREADS; i++)
+ {
+ assert(pthread_create(&t[i], NULL, mythread, (void *) i) == 0);
+ }
+
+ assert(pthread_mutex_unlock(&mutex) == 0);
+
+ for (i = 1; i <= NUMTHREADS; i++)
+ {
+ assert(pthread_join(t[i], (void **) &result) == 0);
+ assert(result == i);
+ /*
+ * Approximately 2/3rds of the threads are expected to time out.
+ * Signal the remainder after some threads have woken up and exited
+ * and while some are still waking up after timeout.
+ * Also tests that redundant broadcasts don't return errors.
+ */
+ if (awoken > NUMTHREADS/3)
+ {
+ assert(pthread_cond_broadcast(&cv) == 0);
+ }
+ }
+
+ assert(awoken == NUMTHREADS - timedout);
+
+ {
+ 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, "\tWaitersUnblocked = %ld\n", cv->nWaitersUnblocked);
+ fprintf(stderr, "\tWaitersGone = %ld\n", cv->nWaitersGone);
+ fprintf(stderr, "\tWaitersToUnblock = %ld\n", cv->nWaitersToUnblock);
+ fflush(stderr);
+ }
+ assert(result == 0);
+ }
+
+ return 0;
+}
generated by cgit v1.2.3 (git 2.39.1) at 2024-11-01 06:41:52 +0000