2010-08-27 21:13:45 +02:00
|
|
|
/*
|
2013-03-12 17:04:51 +01:00
|
|
|
Copyright (c) 2007-2013 Contributors as noted in the AUTHORS file
|
2010-08-27 21:13:45 +02:00
|
|
|
|
|
|
|
This file is part of 0MQ.
|
|
|
|
|
|
|
|
0MQ is free software; you can redistribute it and/or modify it under
|
2010-10-30 15:08:28 +02:00
|
|
|
the terms of the GNU Lesser General Public License as published by
|
2010-08-27 21:13:45 +02:00
|
|
|
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
|
2010-10-30 15:08:28 +02:00
|
|
|
GNU Lesser General Public License for more details.
|
2010-08-27 21:13:45 +02:00
|
|
|
|
2010-10-30 15:08:28 +02:00
|
|
|
You should have received a copy of the GNU Lesser General Public License
|
2010-08-27 21:13:45 +02:00
|
|
|
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
*/
|
|
|
|
|
2013-05-16 20:29:55 +02:00
|
|
|
#ifndef __TESTUTIL_HPP_INCLUDED__
|
|
|
|
#define __TESTUTIL_HPP_INCLUDED__
|
2010-08-27 21:13:45 +02:00
|
|
|
|
2012-08-23 22:40:30 +02:00
|
|
|
#include "../include/zmq.h"
|
2011-03-24 10:03:49 +01:00
|
|
|
#include <string.h>
|
2013-08-17 14:43:45 +02:00
|
|
|
|
2012-08-23 22:40:30 +02:00
|
|
|
#undef NDEBUG
|
|
|
|
#include <assert.h>
|
2013-07-02 15:04:31 +02:00
|
|
|
#include <stdarg.h>
|
2010-08-28 13:58:23 +02:00
|
|
|
|
2013-08-17 14:43:45 +02:00
|
|
|
#if defined _WIN32
|
2013-08-17 15:23:22 +02:00
|
|
|
#include <crtdbg.h>
|
2013-08-17 14:43:45 +02:00
|
|
|
#pragma warning(disable:4996)
|
|
|
|
#endif
|
|
|
|
|
2013-05-16 20:29:55 +02:00
|
|
|
// Bounce a message from client to server and back
|
|
|
|
// For REQ/REP or DEALER/DEALER pairs only
|
|
|
|
|
2013-07-02 15:04:31 +02:00
|
|
|
void
|
2013-05-16 20:29:55 +02:00
|
|
|
bounce (void *server, void *client)
|
2010-08-27 21:13:45 +02:00
|
|
|
{
|
2011-03-24 10:03:49 +01:00
|
|
|
const char *content = "12345678ABCDEFGH12345678abcdefgh";
|
|
|
|
|
2013-05-16 20:29:55 +02:00
|
|
|
// Send message from client to server
|
|
|
|
int rc = zmq_send (client, content, 32, ZMQ_SNDMORE);
|
2011-06-20 11:16:10 +02:00
|
|
|
assert (rc == 32);
|
2013-05-16 20:29:55 +02:00
|
|
|
rc = zmq_send (client, content, 32, 0);
|
2011-03-24 11:53:55 +01:00
|
|
|
assert (rc == 32);
|
2011-03-24 10:03:49 +01:00
|
|
|
|
2013-05-16 20:29:55 +02:00
|
|
|
// Receive message at server side
|
|
|
|
char buffer [32];
|
|
|
|
rc = zmq_recv (server, buffer, 32, 0);
|
2011-03-24 11:53:55 +01:00
|
|
|
assert (rc == 32);
|
2011-06-20 11:16:10 +02:00
|
|
|
int rcvmore;
|
|
|
|
size_t sz = sizeof (rcvmore);
|
2013-05-16 20:29:55 +02:00
|
|
|
rc = zmq_getsockopt (server, ZMQ_RCVMORE, &rcvmore, &sz);
|
2011-06-20 11:16:10 +02:00
|
|
|
assert (rc == 0);
|
|
|
|
assert (rcvmore);
|
2013-05-16 20:29:55 +02:00
|
|
|
rc = zmq_recv (server, buffer, 32, 0);
|
2011-06-20 11:16:10 +02:00
|
|
|
assert (rc == 32);
|
2013-05-16 20:29:55 +02:00
|
|
|
rc = zmq_getsockopt (server, ZMQ_RCVMORE, &rcvmore, &sz);
|
2011-06-20 11:16:10 +02:00
|
|
|
assert (rc == 0);
|
|
|
|
assert (!rcvmore);
|
2013-05-16 20:29:55 +02:00
|
|
|
|
|
|
|
// Send two parts back to client
|
|
|
|
rc = zmq_send (server, buffer, 32, ZMQ_SNDMORE);
|
2011-06-20 11:16:10 +02:00
|
|
|
assert (rc == 32);
|
2013-05-16 20:29:55 +02:00
|
|
|
rc = zmq_send (server, buffer, 32, 0);
|
2011-03-24 11:53:55 +01:00
|
|
|
assert (rc == 32);
|
2011-03-24 10:03:49 +01:00
|
|
|
|
2013-05-16 20:29:55 +02:00
|
|
|
// Receive the two parts at the client side
|
|
|
|
rc = zmq_recv (client, buffer, 32, 0);
|
2011-03-24 11:53:55 +01:00
|
|
|
assert (rc == 32);
|
2013-05-16 20:29:55 +02:00
|
|
|
rc = zmq_getsockopt (client, ZMQ_RCVMORE, &rcvmore, &sz);
|
2011-06-20 11:16:10 +02:00
|
|
|
assert (rc == 0);
|
|
|
|
assert (rcvmore);
|
2013-05-16 20:29:55 +02:00
|
|
|
rc = zmq_recv (client, buffer, 32, 0);
|
2011-06-20 11:16:10 +02:00
|
|
|
assert (rc == 32);
|
2013-05-16 20:29:55 +02:00
|
|
|
rc = zmq_getsockopt (client, ZMQ_RCVMORE, &rcvmore, &sz);
|
2011-06-20 11:16:10 +02:00
|
|
|
assert (rc == 0);
|
|
|
|
assert (!rcvmore);
|
2011-03-24 10:03:49 +01:00
|
|
|
|
2013-05-16 20:29:55 +02:00
|
|
|
// Check that message is still the same
|
|
|
|
assert (memcmp (buffer, content, 32) == 0);
|
2010-08-27 21:13:45 +02:00
|
|
|
}
|
|
|
|
|
2013-08-31 02:56:59 +02:00
|
|
|
// Same as bounce, but expect messages to never arrive
|
|
|
|
// for security or subscriber reasons.
|
|
|
|
|
|
|
|
void
|
|
|
|
expect_bounce_fail (void *server, void *client)
|
|
|
|
{
|
|
|
|
const char *content = "12345678ABCDEFGH12345678abcdefgh";
|
|
|
|
char buffer [32];
|
|
|
|
|
|
|
|
// Send message from client to server
|
|
|
|
int rc = zmq_send (client, content, 32, ZMQ_SNDMORE);
|
|
|
|
assert (rc == 32);
|
|
|
|
rc = zmq_send (client, content, 32, 0);
|
|
|
|
assert (rc == 32);
|
|
|
|
|
|
|
|
// Receive message at server side (should not succeed)
|
2013-09-02 17:22:24 +02:00
|
|
|
int timeout = 150;
|
|
|
|
rc = zmq_setsockopt (server, ZMQ_RCVTIMEO, &timeout, sizeof (int));
|
2013-08-31 02:56:59 +02:00
|
|
|
assert (rc == 0);
|
|
|
|
rc = zmq_recv (server, buffer, 32, 0);
|
|
|
|
assert (rc == -1);
|
2013-09-02 18:21:36 +02:00
|
|
|
assert (zmq_errno () == EAGAIN);
|
2013-08-31 02:56:59 +02:00
|
|
|
|
2013-09-02 18:21:36 +02:00
|
|
|
// Send message from server to client to test other direction
|
2013-08-31 02:56:59 +02:00
|
|
|
rc = zmq_send (server, content, 32, ZMQ_SNDMORE);
|
|
|
|
assert (rc == 32);
|
|
|
|
rc = zmq_send (server, content, 32, 0);
|
|
|
|
assert (rc == 32);
|
|
|
|
|
2013-09-02 18:21:36 +02:00
|
|
|
// Receive message at client side (should not succeed)
|
|
|
|
rc = zmq_setsockopt (client, ZMQ_RCVTIMEO, &timeout, sizeof (int));
|
|
|
|
assert (rc == 0);
|
2013-08-31 02:56:59 +02:00
|
|
|
rc = zmq_recv (client, buffer, 32, 0);
|
|
|
|
assert (rc == -1);
|
2013-09-02 18:21:36 +02:00
|
|
|
assert (zmq_errno () == EAGAIN);
|
2013-08-31 02:56:59 +02:00
|
|
|
}
|
|
|
|
|
2013-06-28 11:42:54 +02:00
|
|
|
// Receive 0MQ string from socket and convert into C string
|
|
|
|
// Caller must free returned string. Returns NULL if the context
|
|
|
|
// is being terminated.
|
|
|
|
char *
|
|
|
|
s_recv (void *socket) {
|
|
|
|
char buffer [256];
|
|
|
|
int size = zmq_recv (socket, buffer, 255, 0);
|
|
|
|
if (size == -1)
|
|
|
|
return NULL;
|
|
|
|
if (size > 255)
|
|
|
|
size = 255;
|
|
|
|
buffer [size] = 0;
|
|
|
|
return strdup (buffer);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Convert C string to 0MQ string and send to socket
|
|
|
|
int
|
|
|
|
s_send (void *socket, const char *string) {
|
|
|
|
int size = zmq_send (socket, string, strlen (string), 0);
|
|
|
|
return size;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Sends string as 0MQ string, as multipart non-terminal
|
|
|
|
int
|
|
|
|
s_sendmore (void *socket, const char *string) {
|
|
|
|
int size = zmq_send (socket, string, strlen (string), ZMQ_SNDMORE);
|
|
|
|
return size;
|
|
|
|
}
|
|
|
|
|
|
|
|
#define streq(s1,s2) (!strcmp ((s1), (s2)))
|
|
|
|
#define strneq(s1,s2) (strcmp ((s1), (s2)))
|
|
|
|
|
2013-07-07 12:49:24 +02:00
|
|
|
const char *SEQ_END = (const char *) 1;
|
2013-07-02 15:04:31 +02:00
|
|
|
|
|
|
|
// Sends a message composed of frames that are C strings or null frames.
|
|
|
|
// The list must be terminated by SEQ_END.
|
|
|
|
// Example: s_send_seq (req, "ABC", 0, "DEF", SEQ_END);
|
|
|
|
void s_send_seq (void *socket, ...)
|
|
|
|
{
|
|
|
|
va_list ap;
|
|
|
|
va_start (ap, socket);
|
|
|
|
const char * data = va_arg (ap, const char *);
|
|
|
|
while (true)
|
|
|
|
{
|
|
|
|
const char * prev = data;
|
|
|
|
data = va_arg (ap, const char *);
|
|
|
|
bool end = data == SEQ_END;
|
|
|
|
|
2013-07-07 12:49:24 +02:00
|
|
|
if (!prev) {
|
2013-07-02 15:04:31 +02:00
|
|
|
int rc = zmq_send (socket, 0, 0, end ? 0 : ZMQ_SNDMORE);
|
|
|
|
assert (rc != -1);
|
|
|
|
}
|
2013-07-07 12:49:24 +02:00
|
|
|
else {
|
2013-07-02 15:04:31 +02:00
|
|
|
int rc = zmq_send (socket, prev, strlen (prev)+1, end ? 0 : ZMQ_SNDMORE);
|
|
|
|
assert (rc != -1);
|
|
|
|
}
|
|
|
|
if (end)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
va_end (ap);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Receives message a number of frames long and checks that the frames have
|
|
|
|
// the given data which can be either C strings or 0 for a null frame.
|
|
|
|
// The list must be terminated by SEQ_END.
|
|
|
|
// Example: s_recv_seq (rep, "ABC", 0, "DEF", SEQ_END);
|
|
|
|
void s_recv_seq (void *socket, ...)
|
|
|
|
{
|
|
|
|
zmq_msg_t msg;
|
|
|
|
zmq_msg_init (&msg);
|
|
|
|
|
|
|
|
int more;
|
|
|
|
size_t more_size = sizeof(more);
|
|
|
|
|
|
|
|
va_list ap;
|
|
|
|
va_start (ap, socket);
|
|
|
|
const char * data = va_arg (ap, const char *);
|
2013-07-07 12:49:24 +02:00
|
|
|
|
|
|
|
while (true) {
|
2013-07-02 15:04:31 +02:00
|
|
|
int rc = zmq_msg_recv (&msg, socket, 0);
|
|
|
|
assert (rc != -1);
|
|
|
|
|
|
|
|
if (!data)
|
|
|
|
assert (zmq_msg_size (&msg) == 0);
|
|
|
|
else
|
|
|
|
assert (strcmp (data, (const char *)zmq_msg_data (&msg)) == 0);
|
|
|
|
|
|
|
|
data = va_arg (ap, const char *);
|
|
|
|
bool end = data == SEQ_END;
|
|
|
|
|
|
|
|
rc = zmq_getsockopt (socket, ZMQ_RCVMORE, &more, &more_size);
|
|
|
|
assert (rc == 0);
|
|
|
|
|
|
|
|
assert (!more == end);
|
|
|
|
if (end)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
va_end (ap);
|
|
|
|
|
|
|
|
zmq_msg_close (&msg);
|
|
|
|
}
|
|
|
|
|
2013-07-05 17:58:01 +02:00
|
|
|
|
|
|
|
// Sets a zero linger period on a socket and closes it.
|
|
|
|
void close_zero_linger (void *socket)
|
|
|
|
{
|
|
|
|
int linger = 0;
|
|
|
|
int rc = zmq_setsockopt (socket, ZMQ_LINGER, &linger, sizeof(linger));
|
2013-09-02 17:22:24 +02:00
|
|
|
assert (rc == 0 || errno == ETERM);
|
2013-07-05 17:58:01 +02:00
|
|
|
rc = zmq_close (socket);
|
|
|
|
assert (rc == 0);
|
|
|
|
}
|
|
|
|
|
2013-08-17 14:43:45 +02:00
|
|
|
void setup_test_environment()
|
|
|
|
{
|
|
|
|
#if defined _WIN32
|
|
|
|
_set_abort_behavior( 0, _WRITE_ABORT_MSG);
|
2013-08-17 15:23:22 +02:00
|
|
|
_CrtSetReportMode( _CRT_ASSERT, _CRTDBG_MODE_FILE );
|
|
|
|
_CrtSetReportFile( _CRT_ASSERT, _CRTDBG_FILE_STDERR );
|
2013-08-17 14:43:45 +02:00
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2010-08-27 21:13:45 +02:00
|
|
|
#endif
|