From 7d87db05290e3fd742f381b6f419eb69518ca8cf Mon Sep 17 00:00:00 2001 From: Martin Sustrik Date: Thu, 24 Mar 2011 10:03:49 +0100 Subject: Auto-tests modified to use C API instead of C++ binding As a side effect, broker HWM test was fixed. Signed-off-by: Martin Sustrik --- tests/test_hwm.cpp | 107 +++++++++++++++++++++---------- tests/test_pair_inproc.cpp | 30 +++++++-- tests/test_pair_ipc.cpp | 30 +++++++-- tests/test_pair_tcp.cpp | 30 +++++++-- tests/test_reqrep_inproc.cpp | 30 +++++++-- tests/test_reqrep_ipc.cpp | 30 +++++++-- tests/test_reqrep_tcp.cpp | 30 +++++++-- tests/test_shutdown_stress.cpp | 2 +- tests/testutil.hpp | 139 ++++++++++++----------------------------- 9 files changed, 263 insertions(+), 165 deletions(-) (limited to 'tests') diff --git a/tests/test_hwm.cpp b/tests/test_hwm.cpp index d73c25f..58d3a82 100644 --- a/tests/test_hwm.cpp +++ b/tests/test_hwm.cpp @@ -18,51 +18,90 @@ along with this program. If not, see . */ -#include "testutil.hpp" -#include "../src/stdint.hpp" -using namespace std; -using namespace zmqtestutil; +#include + +#include "../src/stdint.hpp" +#include "testutil.hpp" int main (int argc, char *argv []) { - uint64_t hwm = 5; - int linger = 0; - - zmq::context_t context (1); - zmq::socket_t s1 (context, ZMQ_PULL); - zmq::socket_t s2 (context, ZMQ_PUSH); - - s2.setsockopt (ZMQ_LINGER, &linger, sizeof (int)); - s2.setsockopt (ZMQ_HWM, &hwm, sizeof (uint64_t)); - - s1.bind ("tcp://127.0.0.1:5858"); - s2.connect ("tcp://127.0.0.1:5858"); - + void *ctx = zmq_init (1); + assert (ctx); + + // Create pair of socket, each with high watermark of 2. Thus the total + // buffer space should be 4 messages. + void *sb = zmq_socket (ctx, ZMQ_PULL); + assert (sb); + uint64_t hwm = 2; + int rc = zmq_setsockopt (sb, ZMQ_HWM, &hwm, sizeof (hwm)); + assert (rc == 0); + rc = zmq_bind (sb, "inproc://a"); + assert (rc == 0); + + void *sc = zmq_socket (ctx, ZMQ_PUSH); + assert (sc); + rc = zmq_setsockopt (sc, ZMQ_HWM, &hwm, sizeof (hwm)); + assert (rc == 0); + rc = zmq_connect (sc, "inproc://a"); + assert (rc == 0); + + // Try to send 10 messages. Only 4 should succeed. for (int i = 0; i < 10; i++) { - zmq::message_t msg (sizeof ("test") - 1); - memcpy (msg.data (), "test", sizeof ("test") - 1); + zmq_msg_t msg; + rc = zmq_msg_init (&msg); + assert (rc == 0); + + int rc = zmq_send (sc, &msg, ZMQ_NOBLOCK); + if (i < 4) + assert (rc == 0); + else + assert (rc != 0 && errno == EAGAIN); + + rc = zmq_msg_close (&msg); + assert (rc == 0); + } - bool sent = s2.send (msg, ZMQ_NOBLOCK); + // There should be now 4 messages pending, consume them. + for (int i = 0; i != 4; i++) { - // Anything below HWM should be sent - if (i < 5) { - assert (sent); - } else { - assert (!sent && errno == EAGAIN); - } - } + zmq_msg_t msg; + rc = zmq_msg_init (&msg); + assert (rc == 0); - // There should be now 5 messages pending, consume one - zmq::message_t msg; + rc = zmq_recv (sb, &msg, 0); + assert (rc == 0); - bool received = s1.recv (&msg, 0); - assert (received); + rc = zmq_msg_close (&msg); + assert (rc == 0); + } - // Now it should be possible to send one more - bool sent = s2.send (msg, 0); - assert (sent); + // Now it should be possible to send one more. + zmq_msg_t msg; + rc = zmq_msg_init (&msg); + assert (rc == 0); + rc = zmq_send (sc, &msg, 0); + assert (rc == 0); + rc = zmq_msg_close (&msg); + assert (rc == 0); + + // Consume the remaining message. + rc = zmq_msg_init (&msg); + assert (rc == 0); + rc = zmq_recv (sb, &msg, 0); + assert (rc == 0); + rc = zmq_msg_close (&msg); + assert (rc == 0); + + rc = zmq_close (sc); + assert (rc == 0); + + rc = zmq_close (sb); + assert (rc == 0); + + rc = zmq_term (ctx); + assert (rc == 0); return 0; } diff --git a/tests/test_pair_inproc.cpp b/tests/test_pair_inproc.cpp index 5736674..17c37e0 100644 --- a/tests/test_pair_inproc.cpp +++ b/tests/test_pair_inproc.cpp @@ -18,14 +18,34 @@ along with this program. If not, see . */ +#include #include "testutil.hpp" -using namespace std; -using namespace zmqtestutil; - int main (int argc, char *argv []) { - const char *transport = "inproc://tester" ; - basic_tests (transport, ZMQ_PAIR, ZMQ_PAIR); + void *ctx = zmq_init (1); + assert (ctx); + + void *sb = zmq_socket (ctx, ZMQ_PAIR); + assert (sb); + int rc = zmq_bind (sb, "inproc://a"); + assert (rc == 0); + + void *sc = zmq_socket (ctx, ZMQ_PAIR); + assert (sc); + rc = zmq_connect (sc, "inproc://a"); + assert (rc == 0); + + bounce (sb, sc); + + rc = zmq_close (sc); + assert (rc == 0); + + rc = zmq_close (sb); + assert (rc == 0); + + rc = zmq_term (ctx); + assert (rc == 0); + return 0 ; } diff --git a/tests/test_pair_ipc.cpp b/tests/test_pair_ipc.cpp index f8a4270..2c83a69 100644 --- a/tests/test_pair_ipc.cpp +++ b/tests/test_pair_ipc.cpp @@ -18,14 +18,34 @@ along with this program. If not, see . */ +#include #include "testutil.hpp" -using namespace std; -using namespace zmqtestutil; - int main (int argc, char *argv []) { - const char *transport = "ipc:///tmp/tester" ; - basic_tests (transport, ZMQ_PAIR, ZMQ_PAIR); + void *ctx = zmq_init (1); + assert (ctx); + + void *sb = zmq_socket (ctx, ZMQ_PAIR); + assert (sb); + int rc = zmq_bind (sb, "ipc:///tmp/tester"); + assert (rc == 0); + + void *sc = zmq_socket (ctx, ZMQ_PAIR); + assert (sc); + rc = zmq_connect (sc, "ipc:///tmp/tester"); + assert (rc == 0); + + bounce (sb, sc); + + rc = zmq_close (sc); + assert (rc == 0); + + rc = zmq_close (sb); + assert (rc == 0); + + rc = zmq_term (ctx); + assert (rc == 0); + return 0 ; } diff --git a/tests/test_pair_tcp.cpp b/tests/test_pair_tcp.cpp index e902f7f..453daca 100644 --- a/tests/test_pair_tcp.cpp +++ b/tests/test_pair_tcp.cpp @@ -18,14 +18,34 @@ along with this program. If not, see . */ +#include #include "testutil.hpp" -using namespace std; -using namespace zmqtestutil; - int main (int argc, char *argv []) { - const char *transport = "tcp://127.0.0.1:5555" ; - basic_tests (transport, ZMQ_PAIR, ZMQ_PAIR); + void *ctx = zmq_init (1); + assert (ctx); + + void *sb = zmq_socket (ctx, ZMQ_PAIR); + assert (sb); + int rc = zmq_bind (sb, "tcp://127.0.0.1:5555"); + assert (rc == 0); + + void *sc = zmq_socket (ctx, ZMQ_PAIR); + assert (sc); + rc = zmq_connect (sc, "tcp://127.0.0.1:5555"); + assert (rc == 0); + + bounce (sb, sc); + + rc = zmq_close (sc); + assert (rc == 0); + + rc = zmq_close (sb); + assert (rc == 0); + + rc = zmq_term (ctx); + assert (rc == 0); + return 0 ; } diff --git a/tests/test_reqrep_inproc.cpp b/tests/test_reqrep_inproc.cpp index b46f89c..7fd0e69 100644 --- a/tests/test_reqrep_inproc.cpp +++ b/tests/test_reqrep_inproc.cpp @@ -18,14 +18,34 @@ along with this program. If not, see . */ +#include #include "testutil.hpp" -using namespace std; -using namespace zmqtestutil; - int main (int argc, char *argv []) { - const char *transport = "inproc://tester" ; - basic_tests (transport, ZMQ_REQ, ZMQ_REP); + void *ctx = zmq_init (1); + assert (ctx); + + void *sb = zmq_socket (ctx, ZMQ_REP); + assert (sb); + int rc = zmq_bind (sb, "inproc://a"); + assert (rc == 0); + + void *sc = zmq_socket (ctx, ZMQ_REQ); + assert (sc); + rc = zmq_connect (sc, "inproc://a"); + assert (rc == 0); + + bounce (sb, sc); + + rc = zmq_close (sc); + assert (rc == 0); + + rc = zmq_close (sb); + assert (rc == 0); + + rc = zmq_term (ctx); + assert (rc == 0); + return 0 ; } diff --git a/tests/test_reqrep_ipc.cpp b/tests/test_reqrep_ipc.cpp index 4134b1c..af15998 100644 --- a/tests/test_reqrep_ipc.cpp +++ b/tests/test_reqrep_ipc.cpp @@ -18,14 +18,34 @@ along with this program. If not, see . */ +#include #include "testutil.hpp" -using namespace std; -using namespace zmqtestutil; - int main (int argc, char *argv []) { - const char *transport = "ipc:///tmp/tester" ; - basic_tests (transport, ZMQ_REQ, ZMQ_REP); + void *ctx = zmq_init (1); + assert (ctx); + + void *sb = zmq_socket (ctx, ZMQ_REP); + assert (sb); + int rc = zmq_bind (sb, "ipc:///tmp/tester"); + assert (rc == 0); + + void *sc = zmq_socket (ctx, ZMQ_REQ); + assert (sc); + rc = zmq_connect (sc, "ipc:///tmp/tester"); + assert (rc == 0); + + bounce (sb, sc); + + rc = zmq_close (sc); + assert (rc == 0); + + rc = zmq_close (sb); + assert (rc == 0); + + rc = zmq_term (ctx); + assert (rc == 0); + return 0 ; } diff --git a/tests/test_reqrep_tcp.cpp b/tests/test_reqrep_tcp.cpp index 9f1f3e6..9e00975 100644 --- a/tests/test_reqrep_tcp.cpp +++ b/tests/test_reqrep_tcp.cpp @@ -18,14 +18,34 @@ along with this program. If not, see . */ +#include #include "testutil.hpp" -using namespace std; -using namespace zmqtestutil; - int main (int argc, char *argv []) { - const char *transport = "tcp://127.0.0.1:5555" ; - basic_tests (transport, ZMQ_REQ, ZMQ_REP); + void *ctx = zmq_init (1); + assert (ctx); + + void *sb = zmq_socket (ctx, ZMQ_REP); + assert (sb); + int rc = zmq_bind (sb, "tcp://127.0.0.1:5555"); + assert (rc == 0); + + void *sc = zmq_socket (ctx, ZMQ_REQ); + assert (sc); + rc = zmq_connect (sc, "tcp://127.0.0.1:5555"); + assert (rc == 0); + + bounce (sb, sc); + + rc = zmq_close (sc); + assert (rc == 0); + + rc = zmq_close (sb); + assert (rc == 0); + + rc = zmq_term (ctx); + assert (rc == 0); + return 0 ; } diff --git a/tests/test_shutdown_stress.cpp b/tests/test_shutdown_stress.cpp index 85ba912..e63abe7 100644 --- a/tests/test_shutdown_stress.cpp +++ b/tests/test_shutdown_stress.cpp @@ -23,7 +23,7 @@ #include #include -#define THREAD_COUNT 100 +#define THREAD_COUNT 10 extern "C" { diff --git a/tests/testutil.hpp b/tests/testutil.hpp index 7f182c1..6879dff 100644 --- a/tests/testutil.hpp +++ b/tests/testutil.hpp @@ -22,109 +22,48 @@ #define __ZMQ_TEST_TESTUTIL_HPP_INCLUDED__ #include -#include -#include -#include +#include -#include "../include/zmq.hpp" +#include "../include/zmq.h" -namespace zmqtestutil +inline void bounce (void *sb, void *sc) { - - using namespace std ; - - typedef std::pair socket_pair; - - // Create a pair of sockets connected to each other. - socket_pair create_bound_pair (zmq::context_t *context_, - int t1_, int t2_, const char *transport_) - { - zmq::socket_t *s1 = new zmq::socket_t (*context_, t1_); - zmq::socket_t *s2 = new zmq::socket_t (*context_, t2_); - s1->bind (transport_); - s2->connect (transport_); - return socket_pair (s1, s2); - } - - // Send a message from one socket in the pair to the other and back. - std::string ping_pong (const socket_pair &sp_, const std::string &orig_msg_) - { - zmq::socket_t &s1 = *sp_.first; - zmq::socket_t &s2 = *sp_.second; - - // Construct message to send. - zmq::message_t ping (orig_msg_.size ()); - memcpy (ping.data (), orig_msg_.c_str (), orig_msg_.size ()); - - // Send ping out. - s1.send (ping, 0); - - // Get pong from connected socket. - zmq::message_t pong; - s2.recv (&pong, 0); - - // Send message via s2, so state is clean in case of req/rep. - std::string ret ((char*) pong.data(), pong.size ()); - s2.send (pong, 0); - - // Return received data as std::string. - return ret ; - } - - /* Run basic tests for the given transport. - - Basic tests are: - * ping pong as defined above. - * send receive where the receive is signalled by zmq::poll - */ - void basic_tests (const char *transport_, int t1_, int t2_) - { - zmq::context_t context (1); - - zmq::pollitem_t items [2]; - socket_pair p = create_bound_pair (&context, t1_, t2_, transport_); - - // First test simple ping pong. - const string expect ("XXX"); - - { - const string returned = zmqtestutil::ping_pong (p, expect); - assert (expect == returned); - - // Adjust socket state so that poll shows only 1 pending message. - zmq::message_t mx ; - p.first->recv (&mx, 0); - } - - { - // Now poll is used to singal that a message is ready to read. - zmq::message_t m1 (expect.size ()); - memcpy (m1.data (), expect.c_str (), expect.size ()); - items [0].socket = *p.first; - items [0].fd = 0; - items [0].events = ZMQ_POLLIN; - items [0].revents = 0; - items [1].socket = *p.second; - items [1].fd = 0; - items [1].events = ZMQ_POLLIN; - items [1].revents = 0; - - p.first->send (m1, 0); - - int rc = zmq::poll (&items [0], 2, -1); - assert (rc == 1); - assert ((items [1].revents & ZMQ_POLLIN) != 0); - - zmq::message_t m2; - p.second->recv (&m2, 0); - const string ret ((char*) m2.data (), m2.size ()); - assert (expect == ret); - } - - // Delete sockets. - delete (p.first); - delete (p.second); - } + const char *content = "12345678ABCDEFGH12345678abcdefgh"; + + // Send the message. + zmq_msg_t msg1; + int rc = zmq_msg_init_size (&msg1, 32); + memcpy (zmq_msg_data (&msg1), content, 32); + rc = zmq_send (sc, &msg1, 0); + assert (rc == 0); + rc = zmq_msg_close (&msg1); + assert (rc == 0); + + // Bounce the message back. + zmq_msg_t msg2; + rc = zmq_msg_init (&msg2); + assert (rc == 0); + rc = zmq_recv (sb, &msg2, 0); + assert (rc == 0); + rc = zmq_send (sb, &msg2, 0); + assert (rc == 0); + rc = zmq_msg_close (&msg2); + assert (rc == 0); + + // Receive the bounced message. + zmq_msg_t msg3; + rc = zmq_msg_init (&msg3); + assert (rc == 0); + rc = zmq_recv (sc, &msg3, 0); + assert (rc == 0); + + // Check whether the message is still the same. + assert (zmq_msg_size (&msg3) == 32); + assert (memcmp (zmq_msg_data (&msg3), content, 32) == 0); + + rc = zmq_msg_close (&msg3); + assert (rc == 0); } + #endif -- cgit v1.2.3