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
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
|
/* SPDX-License-Identifier: MPL-2.0 */
#include "testutil.hpp"
#include "testutil_unity.hpp"
#include <unity.h>
const size_t services = 5;
void *req;
void *rep[services];
void setUp ()
{
setup_test_context ();
char my_endpoint[MAX_SOCKET_STRING];
req = test_context_socket (ZMQ_REQ);
int enabled = 1;
TEST_ASSERT_SUCCESS_ERRNO (
zmq_setsockopt (req, ZMQ_REQ_RELAXED, &enabled, sizeof (int)));
TEST_ASSERT_SUCCESS_ERRNO (
zmq_setsockopt (req, ZMQ_REQ_CORRELATE, &enabled, sizeof (int)));
bind_loopback_ipv4 (req, my_endpoint, sizeof (my_endpoint));
for (size_t peer = 0; peer < services; peer++) {
rep[peer] = test_context_socket (ZMQ_REP);
TEST_ASSERT_SUCCESS_ERRNO (zmq_connect (rep[peer], my_endpoint));
// These tests require strict ordering, so wait for the connections to
// happen before opening the next, so that messages flow in the
// expected direction
msleep (SETTLE_TIME);
}
}
void tearDown ()
{
test_context_socket_close_zero_linger (req);
for (size_t peer = 0; peer < services; peer++)
test_context_socket_close_zero_linger (rep[peer]);
teardown_test_context ();
}
static void bounce (void *socket_)
{
int more;
size_t more_size = sizeof (more);
do {
zmq_msg_t recv_part, sent_part;
TEST_ASSERT_SUCCESS_ERRNO (zmq_msg_init (&recv_part));
TEST_ASSERT_SUCCESS_ERRNO (zmq_msg_recv (&recv_part, socket_, 0));
TEST_ASSERT_SUCCESS_ERRNO (
zmq_getsockopt (socket_, ZMQ_RCVMORE, &more, &more_size));
zmq_msg_init (&sent_part);
zmq_msg_copy (&sent_part, &recv_part);
TEST_ASSERT_SUCCESS_ERRNO (
zmq_msg_send (&sent_part, socket_, more ? ZMQ_SNDMORE : 0));
zmq_msg_close (&recv_part);
} while (more);
}
static int get_events (void *socket_)
{
int events;
size_t events_size = sizeof (events);
TEST_ASSERT_SUCCESS_ERRNO (
zmq_getsockopt (socket_, ZMQ_EVENTS, &events, &events_size));
return events;
}
void test_case_1 ()
{
// Case 1: Second send() before a reply arrives in a pipe.
int events = get_events (req);
TEST_ASSERT_EQUAL_INT (ZMQ_POLLOUT, events);
// Send a request, ensure it arrives, don't send a reply
s_send_seq (req, "A", "B", SEQ_END);
s_recv_seq (rep[0], "A", "B", SEQ_END);
events = get_events (req);
TEST_ASSERT_EQUAL_INT (ZMQ_POLLOUT, events);
// Send another request on the REQ socket
s_send_seq (req, "C", "D", SEQ_END);
s_recv_seq (rep[1], "C", "D", SEQ_END);
events = get_events (req);
TEST_ASSERT_EQUAL_INT (ZMQ_POLLOUT, events);
// Send a reply to the first request - that should be discarded by the REQ
s_send_seq (rep[0], "WRONG", SEQ_END);
// Send the expected reply
s_send_seq (rep[1], "OK", SEQ_END);
s_recv_seq (req, "OK", SEQ_END);
// Another standard req-rep cycle, just to check
s_send_seq (req, "E", SEQ_END);
s_recv_seq (rep[2], "E", SEQ_END);
s_send_seq (rep[2], "F", "G", SEQ_END);
s_recv_seq (req, "F", "G", SEQ_END);
}
void test_case_2 ()
{
// Case 2: Second send() after a reply is already in a pipe on the REQ.
// TODO instead of rerunning the previous test cases, only do the relevant parts (or change the peer)
test_case_1 ();
// Send a request, ensure it arrives, send a reply
s_send_seq (req, "H", SEQ_END);
s_recv_seq (rep[3], "H", SEQ_END);
s_send_seq (rep[3], "BAD", SEQ_END);
// Wait for message to be there.
msleep (SETTLE_TIME);
// Without receiving that reply, send another request on the REQ socket
s_send_seq (req, "I", SEQ_END);
s_recv_seq (rep[4], "I", SEQ_END);
// Send the expected reply
s_send_seq (rep[4], "GOOD", SEQ_END);
s_recv_seq (req, "GOOD", SEQ_END);
}
void test_case_3 ()
{
// Case 3: Check issue #1690. Two send() in a row should not close the
// communication pipes. For example pipe from req to rep[0] should not be
// closed after executing Case 1. So rep[0] should be the next to receive,
// not rep[1].
// TODO instead of rerunning the previous test cases, only do the relevant parts (or change the peer)
test_case_2 ();
s_send_seq (req, "J", SEQ_END);
s_recv_seq (rep[0], "J", SEQ_END);
}
void test_case_4 ()
{
// TODO this test case does not use the sockets from setUp
// Case 4: Check issue #1695. As messages may pile up before a responder
// is available, we check that responses to messages other than the last
// sent one are correctly discarded by the REQ pipe
// Setup REQ socket as client
void *req = test_context_socket (ZMQ_REQ);
int enabled = 1;
TEST_ASSERT_SUCCESS_ERRNO (
zmq_setsockopt (req, ZMQ_REQ_RELAXED, &enabled, sizeof (int)));
TEST_ASSERT_SUCCESS_ERRNO (
zmq_setsockopt (req, ZMQ_REQ_CORRELATE, &enabled, sizeof (int)));
TEST_ASSERT_SUCCESS_ERRNO (zmq_connect (req, ENDPOINT_0));
// Setup ROUTER socket as server but do not bind it just yet
void *router = test_context_socket (ZMQ_ROUTER);
// Send two requests
s_send_seq (req, "TO_BE_DISCARDED", SEQ_END);
s_send_seq (req, "TO_BE_ANSWERED", SEQ_END);
// Bind server allowing it to receive messages
TEST_ASSERT_SUCCESS_ERRNO (zmq_bind (router, ENDPOINT_0));
// Read the two messages and send them back as is
bounce (router);
bounce (router);
// Read the expected correlated reply. As the ZMQ_REQ_CORRELATE is active,
// the expected answer is "TO_BE_ANSWERED", not "TO_BE_DISCARDED".
s_recv_seq (req, "TO_BE_ANSWERED", SEQ_END);
test_context_socket_close_zero_linger (req);
test_context_socket_close_zero_linger (router);
}
int main ()
{
setup_test_environment ();
UNITY_BEGIN ();
RUN_TEST (test_case_1);
RUN_TEST (test_case_2);
RUN_TEST (test_case_3);
RUN_TEST (test_case_4);
return UNITY_END ();
}
|
