socket.cpp
Go to the documentation of this file.
1 #include <catch2/catch_all.hpp>
2 #include <zmq.hpp>
3 #ifdef ZMQ_CPP11
4 #include <future>
5 #endif
6 
7 #if (__cplusplus >= 201703L)
8 static_assert(std::is_nothrow_swappable<zmq::socket_t>::value,
9  "socket_t should be nothrow swappable");
10 #endif
11 
12 TEST_CASE("socket default ctor", "[socket]")
13 {
14  zmq::socket_t socket;
15 }
16 
17 TEST_CASE("socket create destroy", "[socket]")
18 {
19  zmq::context_t context;
20  zmq::socket_t socket(context, ZMQ_ROUTER);
21 }
22 
23 #ifdef ZMQ_CPP11
24 TEST_CASE("socket create assign", "[socket]")
25 {
26  zmq::context_t context;
27  zmq::socket_t socket(context, ZMQ_ROUTER);
28  CHECK(static_cast<bool>(socket));
29  CHECK(socket.handle() != nullptr);
30  socket = {};
31  CHECK(!static_cast<bool>(socket));
32  CHECK(socket.handle() == nullptr);
33 }
34 
35 TEST_CASE("socket create by enum and destroy", "[socket]")
36 {
37  zmq::context_t context;
38  zmq::socket_t socket(context, zmq::socket_type::router);
39 }
40 
41 TEST_CASE("socket swap", "[socket]")
42 {
43  zmq::context_t context;
44  zmq::socket_t socket1(context, zmq::socket_type::router);
45  zmq::socket_t socket2(context, zmq::socket_type::dealer);
46  using std::swap;
47  swap(socket1, socket2);
48 }
49 
50 #ifdef ZMQ_CPP11
51 TEST_CASE("socket options", "[socket]")
52 {
53  zmq::context_t context;
54  zmq::socket_t socket(context, zmq::socket_type::router);
55 
56 #ifdef ZMQ_IMMEDIATE
57  socket.set(zmq::sockopt::immediate, 0);
58  socket.set(zmq::sockopt::immediate, false);
59  CHECK(socket.get(zmq::sockopt::immediate) == false);
60  // unit out of range
61  CHECK_THROWS_AS(socket.set(zmq::sockopt::immediate, 80), zmq::error_t);
62 #endif
63 #ifdef ZMQ_LINGER
64  socket.set(zmq::sockopt::linger, 55);
65  CHECK(socket.get(zmq::sockopt::linger) == 55);
66 #endif
67 #ifdef ZMQ_ROUTING_ID
68  const std::string id = "foobar";
69  socket.set(zmq::sockopt::routing_id, "foobar");
70  socket.set(zmq::sockopt::routing_id, zmq::buffer(id));
71  socket.set(zmq::sockopt::routing_id, id);
72 #if CPPZMQ_HAS_STRING_VIEW
73  socket.set(zmq::sockopt::routing_id, std::string_view{id});
74 #endif
75 
76  std::string id_ret(10, ' ');
77  auto size = socket.get(zmq::sockopt::routing_id, zmq::buffer(id_ret));
78  id_ret.resize(size);
79  CHECK(id == id_ret);
80  auto stropt = socket.get(zmq::sockopt::routing_id);
81  CHECK(id == stropt);
82 
83  std::string id_ret_small(3, ' ');
84  // truncated
85  CHECK_THROWS_AS(socket.get(zmq::sockopt::routing_id, zmq::buffer(id_ret_small)),
86  zmq::error_t);
87 #endif
88 }
89 
90 template<class T>
91 void check_array_opt(T opt,
92  zmq::socket_t &sock,
93  std::string info,
94  bool set_only = false)
95 {
96  const std::string val = "foobar";
97  INFO("setting " + info);
98  sock.set(opt, val);
99  if (set_only)
100  return;
101 
102  INFO("getting " + info);
103  auto s = sock.get(opt);
104  CHECK(s == val);
105 }
106 
107 template<class T>
108 void check_array_opt_get(T opt, zmq::socket_t &sock, std::string info)
109 {
110  INFO("getting " + info);
111  (void) sock.get(opt);
112 }
113 
114 #if ZMQ_VERSION >= ZMQ_MAKE_VERSION(4, 0, 0)
115 template<class T> void check_bin_z85(T opt, zmq::socket_t &sock, std::string str_val)
116 {
117  std::vector<uint8_t> bin_val(32);
118  const auto dret = zmq_z85_decode(bin_val.data(), str_val.c_str());
119  CHECK(dret != nullptr);
120 
121  sock.set(opt, str_val);
122  sock.set(opt, zmq::buffer(bin_val));
123  auto sv = sock.get(opt);
124  CHECK(sv == str_val);
125 
126  auto bv = sock.get(opt, 32);
127  REQUIRE(bv.size() == bin_val.size());
128  CHECK(std::memcmp(bv.data(), bin_val.data(), bin_val.size()) == 0);
129 }
130 #endif
131 
132 TEST_CASE("socket check array options", "[socket]")
133 {
134  zmq::context_t context;
135  zmq::socket_t router(context, zmq::socket_type::router);
136  zmq::socket_t xpub(context, zmq::socket_type::xpub);
137  zmq::socket_t sub(context, zmq::socket_type::sub);
138 
139 #ifdef ZMQ_BINDTODEVICE
140 // requires setting CAP_NET_RAW
141 //check_array_opt(zmq::sockopt::bindtodevice, router, "bindtodevice");
142 #endif
143 #ifdef ZMQ_CONNECT_ROUTING_ID
144  check_array_opt(zmq::sockopt::connect_routing_id, router, "connect_routing_id",
145  true);
146 #endif
147 #ifdef ZMQ_LAST_ENDPOINT
148  check_array_opt_get(zmq::sockopt::last_endpoint, router, "last_endpoint");
149 #endif
150 #ifdef ZMQ_METADATA
151  router.set(zmq::sockopt::metadata, zmq::str_buffer("X-foo:bar"));
152 #endif
153 #ifdef ZMQ_PLAIN_PASSWORD
154  check_array_opt(zmq::sockopt::plain_password, router, "plain_password");
155 #endif
156 #ifdef ZMQ_PLAIN_USERNAME
157  check_array_opt(zmq::sockopt::plain_username, router, "plain_username");
158 #endif
159 #ifdef ZMQ_ROUTING_ID
160  check_array_opt(zmq::sockopt::routing_id, router, "routing_id");
161 #endif
162 #ifdef ZMQ_SOCKS_PROXY
163  check_array_opt(zmq::sockopt::socks_proxy, router, "socks_proxy");
164 #endif
165 #ifdef ZMQ_SUBSCRIBE
166  check_array_opt(zmq::sockopt::subscribe, sub, "subscribe", true);
167 #endif
168 #ifdef ZMQ_UNSUBSCRIBE
169  check_array_opt(zmq::sockopt::unsubscribe, sub, "unsubscribe", true);
170 #endif
171 #ifdef ZMQ_XPUB_WELCOME_MSG
172  check_array_opt(zmq::sockopt::xpub_welcome_msg, xpub, "xpub_welcome_msg", true);
173 #endif
174 #ifdef ZMQ_ZAP_DOMAIN
175  check_array_opt(zmq::sockopt::zap_domain, router, "zap_domain");
176 #endif
177 
178 // curve
179 #if ZMQ_VERSION >= ZMQ_MAKE_VERSION(4, 0, 0) && defined(ZMQ_HAS_CAPABILITIES)
180  if (zmq_has("curve") == 1) {
181  const std::string spk = "rq:rM>}U?@Lns47E1%kR.o@n%FcmmsL/@{H8]yf7";
182  const std::string ssk = "JTKVSB%%)wK0E.X)V>+}o?pNmC{O&4W4b!Ni{Lh6";
183  const std::string cpk = "Yne@$w-vo<fVvi]a<NY6T1ed:M$fCG*[IaLV{hID";
184  const std::string csk = "D:)Q[IlAW!ahhC2ac:9*A}h:p?([4%wOTJ%JR%cs";
185 
186  zmq::socket_t curve_server(context, zmq::socket_type::router);
187  curve_server.set(zmq::sockopt::curve_server, true);
188  CHECK(curve_server.get(zmq::sockopt::curve_server));
189  check_bin_z85(zmq::sockopt::curve_secretkey, curve_server, ssk);
190 
191  zmq::socket_t curve_client(context, zmq::socket_type::router);
192  curve_client.set(zmq::sockopt::curve_server, false);
193  CHECK_FALSE(curve_client.get(zmq::sockopt::curve_server));
194  check_bin_z85(zmq::sockopt::curve_serverkey, curve_client, spk);
195  check_bin_z85(zmq::sockopt::curve_publickey, curve_client, cpk);
196  check_bin_z85(zmq::sockopt::curve_secretkey, curve_client, csk);
197  }
198 #endif
199 
200 // gssapi
201 #if ZMQ_VERSION >= ZMQ_MAKE_VERSION(4, 1, 0) && defined(ZMQ_HAS_CAPABILITIES)
202  if (zmq_has("gssapi") == 1 && false) // TODO enable
203  {
204  zmq::socket_t gss_server(context, zmq::socket_type::router);
205  gss_server.set(zmq::sockopt::gssapi_server, true);
206  CHECK(gss_server.get(zmq::sockopt::gssapi_server) == 1);
207  gss_server.set(zmq::sockopt::gssapi_plaintext, false);
208  CHECK(gss_server.get(zmq::sockopt::gssapi_plaintext) == 0);
209  check_array_opt(zmq::sockopt::gssapi_principal, gss_server,
210  "gssapi_principal");
211 
212  zmq::socket_t gss_client(context, zmq::socket_type::router);
213  CHECK(gss_client.get(zmq::sockopt::gssapi_server) == 0);
214  check_array_opt(zmq::sockopt::gssapi_principal, gss_client,
215  "gssapi_principal");
216  check_array_opt(zmq::sockopt::gssapi_service_principal, gss_client,
217  "gssapi_service_principal");
218  }
219 #endif
220 }
221 
222 template<class T, class Opt>
223 void check_integral_opt(Opt opt,
224  zmq::socket_t &sock,
225  std::string info,
226  bool set_only = false)
227 {
228  const T val = 1;
229  INFO("setting " + info);
230  sock.set(opt, val);
231  if (set_only)
232  return;
233 
234  INFO("getting " + info);
235  auto s = sock.get(opt);
236  CHECK(s == val);
237 }
238 
239 template<class T, class Opt>
240 void check_integral_opt_get(Opt opt, zmq::socket_t &sock, std::string info)
241 {
242  INFO("getting " + info);
243  (void) sock.get(opt);
244 }
245 
246 TEST_CASE("socket check integral options", "[socket]")
247 {
248  zmq::context_t context;
249  zmq::socket_t router(context, zmq::socket_type::router);
250  zmq::socket_t xpub(context, zmq::socket_type::xpub);
251  zmq::socket_t req(context, zmq::socket_type::req);
252 #ifdef ZMQ_STREAM_NOTIFY
253  zmq::socket_t stream(context, zmq::socket_type::stream);
254 #endif
255 
256 #ifdef ZMQ_AFFINITY
257  check_integral_opt<uint64_t>(zmq::sockopt::affinity, router, "affinity");
258 #endif
259 #ifdef ZMQ_BACKLOG
260  check_integral_opt<int>(zmq::sockopt::backlog, router, "backlog");
261 #endif
262 #ifdef ZMQ_CONFLATE
263  check_integral_opt<int>(zmq::sockopt::conflate, router, "conflate");
264 #endif
265 #ifdef ZMQ_CONNECT_TIMEOUT
266  check_integral_opt<int>(zmq::sockopt::connect_timeout, router,
267  "connect_timeout");
268 #endif
269 #ifdef ZMQ_EVENTS
270  check_integral_opt_get<int>(zmq::sockopt::events, router, "events");
271 #endif
272 #ifdef ZMQ_FD
273  check_integral_opt_get<zmq::fd_t>(zmq::sockopt::fd, router, "fd");
274 #endif
275 #ifdef ZMQ_HANDSHAKE_IVL
276  check_integral_opt<int>(zmq::sockopt::handshake_ivl, router, "handshake_ivl");
277 #endif
278 #ifdef ZMQ_HEARTBEAT_IVL
279  check_integral_opt<int>(zmq::sockopt::heartbeat_ivl, router, "heartbeat_ivl");
280 #endif
281 #ifdef ZMQ_HEARTBEAT_TIMEOUT
282  check_integral_opt<int>(zmq::sockopt::heartbeat_timeout, router,
283  "heartbeat_timeout");
284 #endif
285 #ifdef ZMQ_HEARTBEAT_TTL
286  router.set(zmq::sockopt::heartbeat_ttl, 100);
287  CHECK(router.get(zmq::sockopt::heartbeat_ttl) == 100);
288 #endif
289 #ifdef ZMQ_IMMEDIATE
290  check_integral_opt<int>(zmq::sockopt::immediate, router, "immediate");
291 #endif
292 #ifdef ZMQ_INVERT_MATCHING
293  check_integral_opt<int>(zmq::sockopt::invert_matching, router,
294  "invert_matching");
295 #endif
296 #ifdef ZMQ_IPV6
297  check_integral_opt<int>(zmq::sockopt::ipv6, router, "ipv6");
298 #endif
299 #ifdef ZMQ_LINGER
300  check_integral_opt<int>(zmq::sockopt::linger, router, "linger");
301 #endif
302 #ifdef ZMQ_MAXMSGSIZE
303  check_integral_opt<int64_t>(zmq::sockopt::maxmsgsize, router, "maxmsgsize");
304 #endif
305 #ifdef ZMQ_MECHANISM
306  check_integral_opt_get<int>(zmq::sockopt::mechanism, router, "mechanism");
307 #endif
308 #ifdef ZMQ_MULTICAST_HOPS
309  check_integral_opt<int>(zmq::sockopt::multicast_hops, router, "multicast_hops");
310 #endif
311 #ifdef ZMQ_MULTICAST_LOOP
312  check_integral_opt<int>(zmq::sockopt::multicast_loop, router, "multicast_loop");
313 #endif
314 #ifdef ZMQ_MULTICAST_MAXTPDU
315  check_integral_opt<int>(zmq::sockopt::multicast_maxtpdu, router,
316  "multicast_maxtpdu");
317 #endif
318 #ifdef ZMQ_PLAIN_SERVER
319  check_integral_opt<int>(zmq::sockopt::plain_server, router, "plain_server");
320 #endif
321 #ifdef ZMQ_USE_FD
322  check_integral_opt<int>(zmq::sockopt::use_fd, router, "use_fd");
323 #endif
324 #ifdef ZMQ_PROBE_ROUTER
325  check_integral_opt<int>(zmq::sockopt::probe_router, router, "probe_router",
326  true);
327 #endif
328 #ifdef ZMQ_RATE
329  check_integral_opt<int>(zmq::sockopt::rate, router, "rate");
330 #endif
331 #ifdef ZMQ_RCVBUF
332  check_integral_opt<int>(zmq::sockopt::rcvbuf, router, "rcvbuf");
333 #endif
334 #ifdef ZMQ_RCVHWM
335  check_integral_opt<int>(zmq::sockopt::rcvhwm, router, "rcvhwm");
336 #endif
337 #ifdef ZMQ_RCVMORE
338  check_integral_opt_get<int>(zmq::sockopt::rcvmore, router, "rcvmore");
339 #endif
340 #ifdef ZMQ_RCVTIMEO
341  check_integral_opt<int>(zmq::sockopt::rcvtimeo, router, "rcvtimeo");
342 #endif
343 #ifdef ZMQ_RECONNECT_IVL
344  check_integral_opt<int>(zmq::sockopt::reconnect_ivl, router, "reconnect_ivl");
345 #endif
346 #ifdef ZMQ_RECONNECT_IVL_MAX
347  check_integral_opt<int>(zmq::sockopt::reconnect_ivl_max, router,
348  "reconnect_ivl_max");
349 #endif
350 #ifdef ZMQ_RECOVERY_IVL
351  check_integral_opt<int>(zmq::sockopt::recovery_ivl, router, "recovery_ivl");
352 #endif
353 #ifdef ZMQ_REQ_CORRELATE
354  check_integral_opt<int>(zmq::sockopt::req_correlate, req, "req_correlate", true);
355 #endif
356 #ifdef ZMQ_REQ_RELAXED
357  check_integral_opt<int>(zmq::sockopt::req_relaxed, req, "req_relaxed", true);
358 #endif
359 #ifdef ZMQ_ROUTER_HANDOVER
360  check_integral_opt<int>(zmq::sockopt::router_handover, router, "router_handover",
361  true);
362 #endif
363 #ifdef ZMQ_ROUTER_MANDATORY
364  check_integral_opt<int>(zmq::sockopt::router_mandatory, router,
365  "router_mandatory", true);
366 #endif
367 #ifdef ZMQ_ROUTER_RAW
368  check_integral_opt<int>(zmq::sockopt::router_raw, router, "router_raw",
369  true);
370 #endif
371 #ifdef ZMQ_ROUTER_NOTIFY
372  check_integral_opt<int>(zmq::sockopt::router_notify, router, "router_notify");
373 #endif
374 #ifdef ZMQ_SNDBUF
375  check_integral_opt<int>(zmq::sockopt::sndbuf, router, "sndbuf");
376 #endif
377 #ifdef ZMQ_SNDHWM
378  check_integral_opt<int>(zmq::sockopt::sndhwm, router, "sndhwm");
379 #endif
380 #ifdef ZMQ_SNDTIMEO
381  check_integral_opt<int>(zmq::sockopt::sndtimeo, router, "sndtimeo");
382 #endif
383 #ifdef ZMQ_STREAM_NOTIFY
384  check_integral_opt<int>(zmq::sockopt::stream_notify, stream, "stream_notify",
385  true);
386 #endif
387 #ifdef ZMQ_TCP_KEEPALIVE
388  check_integral_opt<int>(zmq::sockopt::tcp_keepalive, router, "tcp_keepalive");
389 #endif
390 #ifdef ZMQ_TCP_KEEPALIVE_CNT
391  check_integral_opt<int>(zmq::sockopt::tcp_keepalive_cnt, router,
392  "tcp_keepalive_cnt");
393 #endif
394 #ifdef ZMQ_TCP_KEEPALIVE_IDLE
395  check_integral_opt<int>(zmq::sockopt::tcp_keepalive_idle, router,
396  "tcp_keepalive_idle");
397 #endif
398 #ifdef ZMQ_TCP_KEEPALIVE_INTVL
399  check_integral_opt<int>(zmq::sockopt::tcp_keepalive_intvl, router,
400  "tcp_keepalive_intvl");
401 #endif
402 #ifdef ZMQ_TCP_MAXRT
403  check_integral_opt<int>(zmq::sockopt::tcp_maxrt, router, "tcp_maxrt");
404 #endif
405 #ifdef ZMQ_THREAD_SAFE
406  check_integral_opt_get<bool>(zmq::sockopt::thread_safe, router, "thread_safe");
407 #endif
408 #ifdef ZMQ_TOS
409  check_integral_opt<int>(zmq::sockopt::tos, router, "tos");
410 #endif
411 #ifdef ZMQ_TYPE
412  check_integral_opt_get<int>(zmq::sockopt::type, router, "type");
413 #ifdef ZMQ_CPP11
414  check_integral_opt_get<zmq::socket_type>(zmq::sockopt::socket_type, router, "socket_type");
415 #endif // ZMQ_CPP11
416 #endif // ZMQ_TYPE
417 
418 #ifdef ZMQ_HAVE_VMCI
419 #ifdef ZMQ_VMCI_BUFFER_SIZE
420  check_integral_opt<uint64_t>(zmq::sockopt::vmci_buffer_size, router,
421  "vmci_buffer_size");
422 #endif
423 #ifdef ZMQ_VMCI_BUFFER_MIN_SIZE
424  check_integral_opt<uint64_t>(zmq::sockopt::vmci_buffer_min_size, router,
425  "vmci_buffer_min_size");
426 #endif
427 #ifdef ZMQ_VMCI_BUFFER_MAX_SIZE
428  check_integral_opt<uint64_t>(zmq::sockopt::vmci_buffer_max_size, router,
429  "vmci_buffer_max_size");
430 #endif
431 #ifdef ZMQ_VMCI_CONNECT_TIMEOUT
432  check_integral_opt<int>(zmq::sockopt::vmci_connect_timeout, router,
433  "vmci_connect_timeout");
434 #endif
435 #endif
436 
437 #ifdef ZMQ_XPUB_VERBOSE
438  check_integral_opt<int>(zmq::sockopt::xpub_verbose, xpub, "xpub_verbose", true);
439 #endif
440 #ifdef ZMQ_XPUB_VERBOSER
441  check_integral_opt<int>(zmq::sockopt::xpub_verboser, xpub, "xpub_verboser",
442  true);
443 #endif
444 #ifdef ZMQ_XPUB_MANUAL
445  check_integral_opt<int>(zmq::sockopt::xpub_manual, xpub, "xpub_manual", true);
446 #endif
447 #ifdef ZMQ_XPUB_NODROP
448  check_integral_opt<int>(zmq::sockopt::xpub_nodrop, xpub, "xpub_nodrop", true);
449 #endif
450 #ifdef ZMQ_ZAP_ENFORCE_DOMAIN
451  check_integral_opt<int>(zmq::sockopt::zap_enforce_domain, router,
452  "zap_enforce_domain");
453 #endif
454 }
455 
456 #endif
457 
458 TEST_CASE("socket flags", "[socket]")
459 {
460  CHECK((zmq::recv_flags::dontwait | zmq::recv_flags::none)
461  == static_cast<zmq::recv_flags>(ZMQ_DONTWAIT | 0));
462  CHECK((zmq::recv_flags::dontwait & zmq::recv_flags::none)
463  == static_cast<zmq::recv_flags>(ZMQ_DONTWAIT & 0));
464  CHECK((zmq::recv_flags::dontwait ^ zmq::recv_flags::none)
465  == static_cast<zmq::recv_flags>(ZMQ_DONTWAIT ^ 0));
466  CHECK(~zmq::recv_flags::dontwait == static_cast<zmq::recv_flags>(~ZMQ_DONTWAIT));
467 
468  CHECK((zmq::send_flags::dontwait | zmq::send_flags::sndmore)
469  == static_cast<zmq::send_flags>(ZMQ_DONTWAIT | ZMQ_SNDMORE));
470  CHECK((zmq::send_flags::dontwait & zmq::send_flags::sndmore)
471  == static_cast<zmq::send_flags>(ZMQ_DONTWAIT & ZMQ_SNDMORE));
472  CHECK((zmq::send_flags::dontwait ^ zmq::send_flags::sndmore)
473  == static_cast<zmq::send_flags>(ZMQ_DONTWAIT ^ ZMQ_SNDMORE));
474  CHECK(~zmq::send_flags::dontwait == static_cast<zmq::send_flags>(~ZMQ_DONTWAIT));
475 }
476 
477 TEST_CASE("socket readme example", "[socket]")
478 {
479  zmq::context_t ctx;
480  zmq::socket_t sock(ctx, zmq::socket_type::push);
481  sock.bind("inproc://test");
482  sock.send(zmq::str_buffer("Hello, world"), zmq::send_flags::dontwait);
483 }
484 #endif
485 
486 TEST_CASE("socket sends and receives const buffer", "[socket]")
487 {
488  zmq::context_t context;
489  zmq::socket_t sender(context, ZMQ_PAIR);
490  zmq::socket_t receiver(context, ZMQ_PAIR);
491  receiver.bind("inproc://test");
492  sender.connect("inproc://test");
493  const char *str = "Hi";
494 
495 #ifdef ZMQ_CPP11
496  CHECK(2 == *sender.send(zmq::buffer(str, 2)));
497  char buf[2];
498  const auto res = receiver.recv(zmq::buffer(buf));
499  CHECK(res);
500  CHECK(!res->truncated());
501  CHECK(2 == res->size);
502 #else
503  CHECK(2 == sender.send(str, 2));
504  char buf[2];
505  CHECK(2 == receiver.recv(buf, 2));
506 #endif
507  CHECK(0 == memcmp(buf, str, 2));
508 }
509 
510 #ifdef ZMQ_CPP11
511 
512 TEST_CASE("socket send none sndmore", "[socket]")
513 {
514  zmq::context_t context;
515  zmq::socket_t s(context, zmq::socket_type::router);
516  s.bind("inproc://test");
517 
518  std::vector<char> buf(4);
519  auto res = s.send(zmq::buffer(buf), zmq::send_flags::sndmore);
520  CHECK(res);
521  CHECK(*res == buf.size());
522  res = s.send(zmq::buffer(buf));
523  CHECK(res);
524  CHECK(*res == buf.size());
525 }
526 
527 TEST_CASE("socket send dontwait", "[socket]")
528 {
529  zmq::context_t context;
530  zmq::socket_t s(context, zmq::socket_type::push);
531  s.bind("inproc://test");
532 
533  std::vector<char> buf(4);
534  auto res = s.send(zmq::buffer(buf), zmq::send_flags::dontwait);
535  CHECK(!res);
536  res =
537  s.send(zmq::buffer(buf), zmq::send_flags::dontwait | zmq::send_flags::sndmore);
538  CHECK(!res);
539 
540  zmq::message_t msg;
541  auto resm = s.send(msg, zmq::send_flags::dontwait);
542  CHECK(!resm);
543  CHECK(msg.size() == 0);
544 }
545 
546 TEST_CASE("socket send exception", "[socket]")
547 {
548  zmq::context_t context;
549  zmq::socket_t s(context, zmq::socket_type::pull);
550  s.bind("inproc://test");
551 
552  std::vector<char> buf(4);
553  CHECK_THROWS_AS(s.send(zmq::buffer(buf)), zmq::error_t);
554 }
555 
556 TEST_CASE("socket recv none", "[socket]")
557 {
558  zmq::context_t context;
559  zmq::socket_t s(context, zmq::socket_type::pair);
560  zmq::socket_t s2(context, zmq::socket_type::pair);
561  s2.bind("inproc://test");
562  s.connect("inproc://test");
563 
564  std::vector<char> sbuf(4);
565  const auto res_send = s2.send(zmq::buffer(sbuf));
566  CHECK(res_send);
567  CHECK(res_send.has_value());
568 
569  std::vector<char> buf(2);
570  const auto res = s.recv(zmq::buffer(buf));
571  CHECK(res.has_value());
572  CHECK(res->truncated());
573  CHECK(res->untruncated_size == sbuf.size());
574  CHECK(res->size == buf.size());
575 
576  const auto res_send2 = s2.send(zmq::buffer(sbuf));
577  CHECK(res_send2.has_value());
578  std::vector<char> buf2(10);
579  const auto res2 = s.recv(zmq::buffer(buf2));
580  CHECK(res2.has_value());
581  CHECK(!res2->truncated());
582  CHECK(res2->untruncated_size == sbuf.size());
583  CHECK(res2->size == sbuf.size());
584 }
585 
586 TEST_CASE("socket send recv message_t", "[socket]")
587 {
588  zmq::context_t context;
589  zmq::socket_t s(context, zmq::socket_type::pair);
590  zmq::socket_t s2(context, zmq::socket_type::pair);
591  s2.bind("inproc://test");
592  s.connect("inproc://test");
593 
594  zmq::message_t smsg(10);
595  const auto res_send = s2.send(smsg, zmq::send_flags::none);
596  CHECK(res_send);
597  CHECK(*res_send == 10);
598  CHECK(smsg.size() == 0);
599 
600  zmq::message_t rmsg;
601  const auto res = s.recv(rmsg);
602  CHECK(res);
603  CHECK(*res == 10);
604  CHECK(res.value() == 10);
605  CHECK(rmsg.size() == *res);
606 }
607 
608 TEST_CASE("socket send recv message_t by pointer", "[socket]")
609 {
610  zmq::context_t context;
611  zmq::socket_t s(context, zmq::socket_type::pair);
612  zmq::socket_t s2(context, zmq::socket_type::pair);
613  s2.bind("inproc://test");
614  s.connect("inproc://test");
615 
616  zmq::message_t smsg(size_t{10});
617  const auto res_send = s2.send(smsg, zmq::send_flags::none);
618  CHECK(res_send);
619  CHECK(*res_send == 10);
620  CHECK(smsg.size() == 0);
621 
622  zmq::message_t rmsg;
623  const bool res = s.recv(&rmsg);
624  CHECK(res);
625 }
626 
627 TEST_CASE("socket recv dontwait", "[socket]")
628 {
629  zmq::context_t context;
630  zmq::socket_t s(context, zmq::socket_type::pull);
631  s.bind("inproc://test");
632 
633  std::vector<char> buf(4);
634  constexpr auto flags = zmq::recv_flags::none | zmq::recv_flags::dontwait;
635  auto res = s.recv(zmq::buffer(buf), flags);
636  CHECK(!res);
637 
638  zmq::message_t msg;
639  auto resm = s.recv(msg, flags);
640  CHECK(!resm);
641  CHECK_THROWS_AS(resm.value(), std::exception);
642  CHECK(msg.size() == 0);
643 }
644 
645 TEST_CASE("socket recv exception", "[socket]")
646 {
647  zmq::context_t context;
648  zmq::socket_t s(context, zmq::socket_type::push);
649  s.bind("inproc://test");
650 
651  std::vector<char> buf(4);
652  CHECK_THROWS_AS(s.recv(zmq::buffer(buf)), zmq::error_t);
653 }
654 
655 TEST_CASE("socket proxy", "[socket]")
656 {
657  zmq::context_t context;
658  zmq::socket_t front(context, ZMQ_ROUTER);
659  zmq::socket_t back(context, ZMQ_ROUTER);
660  zmq::socket_t capture(context, ZMQ_DEALER);
661  front.bind("inproc://test1");
662  back.bind("inproc://test2");
663  capture.bind("inproc://test3");
664  auto f = std::async(std::launch::async, [&]() {
665  auto s1 = std::move(front);
666  auto s2 = std::move(back);
667  auto s3 = std::move(capture);
668  try {
669  zmq::proxy(s1, s2, zmq::socket_ref(s3));
670  }
671  catch (const zmq::error_t &e) {
672  return e.num() == ETERM;
673  }
674  return false;
675  });
676  context.close();
677  CHECK(f.get());
678 }
679 
680 TEST_CASE("socket proxy steerable", "[socket]")
681 {
682  zmq::context_t context;
683  zmq::socket_t front(context, ZMQ_ROUTER);
684  zmq::socket_t back(context, ZMQ_ROUTER);
685  zmq::socket_t control(context, ZMQ_SUB);
686  front.bind("inproc://test1");
687  back.bind("inproc://test2");
688  control.connect("inproc://test3");
689  auto f = std::async(std::launch::async, [&]() {
690  auto s1 = std::move(front);
691  auto s2 = std::move(back);
692  auto s3 = std::move(control);
693  try {
694  zmq::proxy_steerable(s1, s2, zmq::socket_ref(), s3);
695  }
696  catch (const zmq::error_t &e) {
697  return e.num() == ETERM;
698  }
699  return false;
700  });
701  context.close();
702  CHECK(f.get());
703 }
704 #endif
INFO
const int INFO
Definition: log_severity.h:59
zmq::swap
void swap(message_t &a, message_t &b) ZMQ_NOTHROW
Definition: zmq.hpp:749
zmq::message_t
Definition: zmq.hpp:409
zmq::proxy
void proxy(void *frontend, void *backend, void *capture)
Definition: zmq.hpp:2274
zmq_z85_decode
ZMQ_EXPORT uint8_t * zmq_z85_decode(uint8_t *dest_, const char *string_)
Definition: zmq_utils.cpp:135
stream
GLuint GLuint stream
Definition: glcorearb.h:3946
sock
void * sock
Definition: test_connect_resolve.cpp:9
s
XmlRpcServer s
benchmarks.util.result_uploader.metadata
def metadata
Definition: result_uploader.py:97
zmq::socket_t
Definition: zmq.hpp:2188
zmq_has
ZMQ_EXPORT int zmq_has(const char *capability_)
Definition: zmq.cpp:1763
string
GLsizei const GLchar *const * string
Definition: glcorearb.h:3083
ZMQ_SUB
#define ZMQ_SUB
Definition: zmq.h:260
zmq::detail::socket_base::send
size_t send(const void *buf_, size_t len_, int flags_=0)
Definition: zmq.hpp:1923
T
#define T(upbtypeconst, upbtype, ctype, default_value)
zmq::context_t::close
void close() ZMQ_NOTHROW
Definition: zmq.hpp:867
zmq::socket_ref
Definition: zmq.hpp:2114
flags
GLbitfield flags
Definition: glcorearb.h:3585
zmq.hpp
zmq::context_t
Definition: zmq.hpp:799
ZMQ_DEALER
#define ZMQ_DEALER
Definition: zmq.h:263
buffer
GLuint buffer
Definition: glcorearb.h:2939
ZMQ_ROUTER
#define ZMQ_ROUTER
Definition: zmq.h:264
zmq::error_t::num
int num() const ZMQ_NOTHROW
Definition: zmq.hpp:299
update_failure_list.str
str
Definition: update_failure_list.py:41
ETERM
#define ETERM
Definition: zmq.h:161
std::swap
void swap(Json::Value &a, Json::Value &b)
Specialize std::swap() for Json::Value.
Definition: json.h:1226
CHECK
#define CHECK(x)
Definition: php/ext/google/protobuf/upb.c:8393
ZMQ_DONTWAIT
#define ZMQ_DONTWAIT
Definition: zmq.h:358
buf
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: glcorearb.h:4175
zmq::proxy_steerable
void proxy_steerable(void *frontend, void *backend, void *capture, void *control)
Definition: zmq.hpp:2292
void
typedef void(APIENTRY *GLDEBUGPROCARB)(GLenum source
type
GLenum type
Definition: glcorearb.h:2695
req
void * req
Definition: test_req_relaxed.cpp:10
ZMQ_PAIR
#define ZMQ_PAIR
Definition: zmq.h:258
size
GLsizeiptr size
Definition: glcorearb.h:2943
TEST_CASE
TEST_CASE("socket default ctor", "[socket]")
Definition: socket.cpp:12
zmq::detail::socket_base::connect
void connect(std::string const &addr)
Definition: zmq.hpp:1901
ZMQ_SNDMORE
#define ZMQ_SNDMORE
Definition: zmq.h:359
receiver
static void receiver(void *socket_)
Definition: test_ctx_destroy.cpp:16
push
static void push(tarjan *t, const upb_refcounted *r)
Definition: ruby/ext/google/protobuf_c/upb.c:5890
capture
static int capture(class zmq::socket_base_t *capture_, zmq::msg_t *msg_, int more_=0)
Definition: proxy.cpp:58
val
GLuint GLfloat * val
Definition: glcorearb.h:3604
f
GLfloat f
Definition: glcorearb.h:3964
value
GLsizei const GLfloat * value
Definition: glcorearb.h:3093
zmq::message_t::size
size_t size() const ZMQ_NOTHROW
Definition: zmq.hpp:601
zmq::error_t
Definition: zmq.hpp:290

libaditof
Author(s):
autogenerated on Wed May 21 2025 02:06:58