summaryrefslogtreecommitdiff
path: root/tests/testutil.hpp
blob: 313fad479eea02cc470cc867c5955cdf60b7a751 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
/*
    Copyright (c) 2007-2010 iMatix Corporation

    This file is part of 0MQ.

    0MQ is free software; you can redistribute it and/or modify it under
    the terms of the Lesser GNU General Public License as published by
    the Free Software Foundation; either version 3 of the License, or
    (at your option) any later version.

    0MQ is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    Lesser GNU General Public License for more details.

    You should have received a copy of the Lesser GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

#ifndef __ZMQ_TEST_TESTUTIL_HPP_INCLUDED__
#define __ZMQ_TEST_TESTUTIL_HPP_INCLUDED__

#include <assert.h>
#include <iostream>
#include <string>
#include <utility>

#include "../include/zmq.hpp"

namespace zmqtestutil
{

    using namespace std ;

    typedef std::pair <zmq::socket_t*, zmq::socket_t*> 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);
    }
}

#endif