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 <sustrik@250bpm.com>

tests/test_hwm.cpp

@@ -18,51 +18,90 @@
     along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-#include "testutil.hpp"
-#include "../src/stdint.hpp"
 
-using namespace std;
-using namespace zmqtestutil;
+#include <assert.h>
+
+#include "../src/stdint.hpp"
+#include "testutil.hpp"
 
 int main (int argc, char *argv [])
 {
-    uint64_t hwm = 5;
-    int linger = 0;
+    void *ctx = zmq_init (1);
+    assert (ctx);
 
-    zmq::context_t context (1);
-    zmq::socket_t s1 (context, ZMQ_PULL);
-    zmq::socket_t s2 (context, ZMQ_PUSH);
+    //  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);
 
-    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 *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);
 
-        bool sent = s2.send (msg, ZMQ_NOBLOCK);
+        int rc = zmq_send (sc, &msg, ZMQ_NOBLOCK);
+        if (i < 4)
+            assert (rc == 0);
+        else
+            assert (rc != 0 && errno == EAGAIN);
 
-        // Anything below HWM should be sent
-        if (i < 5) {
-            assert (sent);
-        } else {
-            assert (!sent && errno == EAGAIN);
-        }
+        rc = zmq_msg_close (&msg);
+        assert (rc == 0);
     }
 
-    // There should be now 5 messages pending, consume one
-    zmq::message_t msg;
+    // There should be now 4 messages pending, consume them.
+    for (int i = 0; i != 4; i++) {
 
-    bool received = s1.recv (&msg, 0);
-    assert (received);
+        zmq_msg_t msg;
+        rc = zmq_msg_init (&msg);
+        assert (rc == 0);
 
-    // Now it should be possible to send one more
-    bool sent = s2.send (msg, 0);
-    assert (sent);
+        rc = zmq_recv (sb, &msg, 0);
+        assert (rc == 0);
+
+        rc = zmq_msg_close (&msg);
+        assert (rc == 0);
+    }
+
+    // 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;
 }

tests/test_pair_inproc.cpp

@@ -18,14 +18,34 @@
     along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
+#include <assert.h>
 #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 ;
 }

tests/test_pair_ipc.cpp

@@ -18,14 +18,34 @@
     along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
+#include <assert.h>
 #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 ;
 }

tests/test_pair_tcp.cpp

@@ -18,14 +18,34 @@
     along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
+#include <assert.h>
 #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 ;
 }

tests/test_reqrep_inproc.cpp

@@ -18,14 +18,34 @@
     along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
+#include <assert.h>
 #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 ;
 }

tests/test_reqrep_ipc.cpp

@@ -18,14 +18,34 @@
     along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
+#include <assert.h>
 #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 ;
 }

tests/test_reqrep_tcp.cpp

@@ -18,14 +18,34 @@
     along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
+#include <assert.h>
 #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 ;
 }

tests/test_shutdown_stress.cpp

@@ -23,7 +23,7 @@
 #include <pthread.h>
 #include <stddef.h>
 
-#define THREAD_COUNT 100
+#define THREAD_COUNT 10
 
 extern "C"
 {

tests/testutil.hpp

@@ -22,109 +22,48 @@
 #define __ZMQ_TEST_TESTUTIL_HPP_INCLUDED__
 
 #include <assert.h>
-#include <iostream>
-#include <string>
-#include <utility>
+#include <string.h>
 
-#include "../include/zmq.hpp"
+#include "../include/zmq.h"
 
-namespace zmqtestutil
+inline void bounce (void *sb, void *sc)
 {
+    const char *content = "12345678ABCDEFGH12345678abcdefgh";
 
-    using namespace std ;
+    //  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);
 
-    typedef std::pair <zmq::socket_t*, zmq::socket_t*> socket_pair;
+    //  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);
 
-    //  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);
-    }
+    //  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);
 
-    //  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;
+    //  Check whether the message is still the same.
+    assert (zmq_msg_size (&msg3) == 32);
+    assert (memcmp (zmq_msg_data (&msg3), content, 32) == 0);
 
-        //  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);
-    }
+    rc = zmq_msg_close (&msg3);
+    assert (rc == 0);
 }
 
+
 #endif