From 5749a18faea208ad19f39612c3c55166ca409fef Mon Sep 17 00:00:00 2001
From: Martin Lucina <martin@lucina.net>
Date: Tue, 13 Mar 2012 12:19:31 +0100
Subject: xs_utils cleanup 1/2 (minimize exported api)
Reduced xs_utils to the minimum functions required (xs_stopwatch_*)
xs_sleep, xs_thread_* are internal to unit tests and have been moved
to testutil.hpp, useless use of xs_sleep in perf/ has been removed.
Signed-off-by: Martin Lucina <martin@lucina.net>
---
tests/polltimeo.cpp | 8 ++--
tests/reconnect.cpp | 4 +-
tests/shutdown_stress.cpp | 4 +-
tests/sub_forward.cpp | 2 +-
tests/testutil.hpp | 93 +++++++++++++++++++++++++++++++++++++++++++++++
tests/timeo.cpp | 8 ++--
6 files changed, 106 insertions(+), 13 deletions(-)
(limited to 'tests')
diff --git a/tests/polltimeo.cpp b/tests/polltimeo.cpp
index 3f7a233..087d125 100644
--- a/tests/polltimeo.cpp
+++ b/tests/polltimeo.cpp
@@ -26,12 +26,12 @@ extern "C"
{
// Worker thread connects after delay of 1 second. Then it waits
// for 1 more second, so that async connect has time to succeed.
- xs_sleep (1);
+ sleep (1);
void *sc = xs_socket (ctx_, XS_PUSH);
assert (sc);
int rc = xs_connect (sc, "inproc://timeout_test");
assert (rc == 0);
- xs_sleep (1);
+ sleep (1);
rc = xs_close (sc);
assert (rc == 0);
}
@@ -61,14 +61,14 @@ int XS_TEST_MAIN ()
assert (elapsed > 440000 && elapsed < 550000);
// Check whether connection during the wait doesn't distort the timeout.
- void *thread = xs_thread_create (polltimeo_worker, ctx);
+ void *thread = thread_create (polltimeo_worker, ctx);
assert (thread);
watch = xs_stopwatch_start ();
rc = xs_poll (&pi, 1, 2000);
assert (rc == 0);
elapsed = xs_stopwatch_stop (watch);
assert (elapsed > 1900000 && elapsed < 2100000);
- xs_thread_join (thread);
+ thread_join (thread);
// Clean-up.
rc = xs_close (sb);
diff --git a/tests/reconnect.cpp b/tests/reconnect.cpp
index c23d306..af8eda4 100644
--- a/tests/reconnect.cpp
+++ b/tests/reconnect.cpp
@@ -39,7 +39,7 @@ int XS_TEST_MAIN ()
assert (rc == 3);
// Wait a while for few attempts to reconnect to happen.
- xs_sleep (1);
+ sleep (1);
// Bind the peer and get the message.
rc = xs_bind (pull, "tcp://127.0.0.1:5560");
@@ -67,7 +67,7 @@ int XS_TEST_MAIN ()
assert (rc == 3);
// Wait a while for few attempts to reconnect to happen.
- xs_sleep (1);
+ sleep (1);
// Bind the peer and get the message.
rc = xs_bind (pull, "tcp://127.0.0.1:5560");
diff --git a/tests/shutdown_stress.cpp b/tests/shutdown_stress.cpp
index d7dffe8..27ab1f0 100644
--- a/tests/shutdown_stress.cpp
+++ b/tests/shutdown_stress.cpp
@@ -70,12 +70,12 @@ int XS_TEST_MAIN ()
for (i = 0; i != THREAD_COUNT; i++) {
s2 = xs_socket (ctx, XS_SUB);
assert (s2);
- threads [i] = xs_thread_create (shutdown_stress_worker, s2);
+ threads [i] = thread_create (shutdown_stress_worker, s2);
assert (threads [i]);
}
for (i = 0; i != THREAD_COUNT; i++)
- xs_thread_join (threads [i]);
+ thread_join (threads [i]);
rc = xs_close (s1);
assert (rc == 0);
diff --git a/tests/sub_forward.cpp b/tests/sub_forward.cpp
index cfff043..6d385de 100644
--- a/tests/sub_forward.cpp
+++ b/tests/sub_forward.cpp
@@ -62,7 +62,7 @@ int XS_TEST_MAIN ()
assert (rc >= 0);
// Wait a bit till the subscription gets to the publisher.
- xs_sleep (1);
+ sleep (1);
// Send an empty message.
rc = xs_send (pub, NULL, 0, 0);
diff --git a/tests/testutil.hpp b/tests/testutil.hpp
index 8935dc8..d3452e3 100644
--- a/tests/testutil.hpp
+++ b/tests/testutil.hpp
@@ -26,15 +26,108 @@
#include <string.h>
#include <stdio.h>
#include <stddef.h>
+#include <stdlib.h>
#include "../include/xs.h"
#include "../include/xs_utils.h"
#include "../src/platform.hpp"
+#if !defined XS_HAVE_WINDOWS
+#include <unistd.h>
+#include <pthread.h>
+#else
+#include "../src/windows.hpp"
+#endif
+
#if !defined XS_TEST_MAIN
#define XS_TEST_MAIN main
#endif
+#if defined XS_HAVE_WINDOWS
+#define sleep(s) Sleep ((s) * 1000)
+#endif
+
+#if defined XS_HAVE_WINDOWS
+
+struct arg_t
+{
+ HANDLE handle;
+ void (*fn) (void *arg);
+ void *arg;
+};
+
+extern "C"
+{
+ static unsigned int __stdcall thread_routine (void *arg_)
+ {
+ arg_t *arg = (arg_t*) arg_;
+ arg->fn (arg->arg);
+ return 0;
+ }
+}
+
+void *thread_create (void (*fn_) (void *arg_), void *arg_)
+{
+ arg_t *arg = (arg_t*) malloc (sizeof (arg_t));
+ assert (arg);
+ arg->fn = fn_;
+ arg->arg = arg_;
+ arg->handle = (HANDLE) _beginthreadex (NULL, 0,
+ &::thread_routine, (void*) arg, 0 , NULL);
+ win_assert (arg->handle != NULL);
+ return (void*) arg;
+}
+
+void thread_join (void *thread_)
+{
+ arg_t *arg = (arg_t*) thread_;
+ DWORD rc = WaitForSingleObject (arg->handle, INFINITE);
+ win_assert (rc != WAIT_FAILED);
+ BOOL rc2 = CloseHandle (arg->handle);
+ win_assert (rc2 != 0);
+ free (arg);
+}
+
+#else
+
+struct arg_t
+{
+ pthread_t handle;
+ void (*fn) (void *arg);
+ void *arg;
+};
+
+extern "C"
+{
+ static void *thread_routine (void *arg_)
+ {
+ arg_t *arg = (arg_t*) arg_;
+ arg->fn (arg->arg);
+ return NULL;
+ }
+}
+
+void *thread_create (void (*fn_) (void *arg_), void *arg_)
+{
+ arg_t *arg = (arg_t*) malloc (sizeof (arg_t));
+ assert (arg);
+ arg->fn = fn_;
+ arg->arg = arg_;
+ int rc = pthread_create (&arg->handle, NULL, thread_routine, (void*) arg);
+ assert (rc == 0);
+ return (void*) arg;
+}
+
+void thread_join (void *thread_)
+{
+ arg_t *arg = (arg_t*) thread_;
+ int rc = pthread_join (arg->handle, NULL);
+ assert (rc == 0);
+ free (arg);
+}
+
+#endif
+
inline void bounce (void *sb, void *sc)
{
const char *content = "12345678ABCDEFGH12345678abcdefgh";
diff --git a/tests/timeo.cpp b/tests/timeo.cpp
index 000e718..e2dcbb8 100644
--- a/tests/timeo.cpp
+++ b/tests/timeo.cpp
@@ -26,12 +26,12 @@ extern "C"
{
// Worker thread connects after delay of 1 second. Then it waits
// for 1 more second, so that async connect has time to succeed.
- xs_sleep (1);
+ sleep (1);
void *sc = xs_socket (ctx_, XS_PUSH);
assert (sc);
int rc = xs_connect (sc, "inproc://timeout_test");
assert (rc == 0);
- xs_sleep (1);
+ sleep (1);
rc = xs_close (sc);
assert (rc == 0);
}
@@ -72,7 +72,7 @@ int XS_TEST_MAIN ()
timeout = 2000;
rc = xs_setsockopt(sb, XS_RCVTIMEO, &timeout, timeout_size);
assert (rc == 0);
- void *thread = xs_thread_create (timeo_worker, ctx);
+ void *thread = thread_create (timeo_worker, ctx);
assert (thread);
watch = xs_stopwatch_start ();
rc = xs_recv (sb, buf, 32, 0);
@@ -80,7 +80,7 @@ int XS_TEST_MAIN ()
assert (xs_errno () == EAGAIN);
elapsed = xs_stopwatch_stop (watch);
assert (elapsed > 1900000 && elapsed < 2100000);
- xs_thread_join (thread);
+ thread_join (thread);
// Check that timeouts don't break normal message transfer.
void *sc = xs_socket (ctx, XS_PUSH);
--
cgit v1.2.3