generic-library/cppzmq
1
0
Fork 0
mirror of https://github.com/zeromq/cppzmq.git synced 2025-10-15 15:16:52 +02:00
Code Issues Projects Releases Wiki Activity

Reformat all files with clang-format

Browse Source
This commit is contained in:
Simon Giesecke
2020-01-26 10:09:20 +01:00
parent 47969cfdcf
commit b6c79eb0c8
13 changed files with 358 additions and 338 deletions
Download Patch File Download Diff File Expand all files Collapse all files

95
tests/active_poller.cpp
View File

@@ -14,9 +14,9 @@ TEST_CASE("create destroy", "[active_poller]")
}
static_assert(!std::is_copy_constructible<zmq::active_poller_t>::value,
"active_active_poller_t should not be copy-constructible");
"active_active_poller_t should not be copy-constructible");
static_assert(!std::is_copy_assignable<zmq::active_poller_t>::value,
"active_active_poller_t should not be copy-assignable");
"active_active_poller_t should not be copy-assignable");
TEST_CASE("move construct empty", "[active_poller]")
{
@@ -47,7 +47,9 @@ TEST_CASE("move construct non empty", "[active_poller]")
zmq::socket_t socket{context, zmq::socket_type::router};
zmq::active_poller_t a;
a.add(socket, zmq::event_flags::pollin, [](zmq::event_flags) {});
a.add(socket, zmq::event_flags::pollin, [](zmq::event_flags)
{
});
CHECK_FALSE(a.empty());
CHECK(1u == a.size());
zmq::active_poller_t b = std::move(a);
@@ -63,7 +65,9 @@ TEST_CASE("move assign non empty", "[active_poller]")
zmq::socket_t socket{context, zmq::socket_type::router};
zmq::active_poller_t a;
a.add(socket, zmq::event_flags::pollin, [](zmq::event_flags) {});
a.add(socket, zmq::event_flags::pollin, [](zmq::event_flags)
{
});
CHECK_FALSE(a.empty());
CHECK(1u == a.size());
zmq::active_poller_t b;
@@ -92,7 +96,9 @@ TEST_CASE("add handler invalid events type", "[active_poller]")
zmq::active_poller_t active_poller;
zmq::active_poller_t::handler_type handler;
short invalid_events_type = 2 << 10;
CHECK_THROWS_AS(active_poller.add(socket, static_cast<zmq::event_flags>(invalid_events_type), handler), const zmq::error_t&);
CHECK_THROWS_AS(
active_poller.add(socket, static_cast<zmq::event_flags>(invalid_events_type),
handler), const zmq::error_t&);
CHECK(active_poller.empty());
CHECK(0u == active_poller.size());
}
@@ -106,14 +112,16 @@ TEST_CASE("add handler twice throws", "[active_poller]")
zmq::active_poller_t::handler_type handler;
active_poller.add(socket, zmq::event_flags::pollin, handler);
/// \todo the actual error code should be checked
CHECK_THROWS_AS(active_poller.add(socket, zmq::event_flags::pollin, handler), const zmq::error_t&);
CHECK_THROWS_AS(active_poller.add(socket, zmq::event_flags::pollin, handler),
const zmq::error_t&);
}
TEST_CASE("wait with no handlers throws", "[active_poller]")
{
zmq::active_poller_t active_poller;
/// \todo the actual error code should be checked
CHECK_THROWS_AS(active_poller.wait(std::chrono::milliseconds{10}), const zmq::error_t&);
CHECK_THROWS_AS(active_poller.wait(std::chrono::milliseconds{10}),
const zmq::error_t&);
}
TEST_CASE("remove unregistered throws", "[active_poller]")
@@ -130,7 +138,8 @@ TEST_CASE("remove registered empty", "[active_poller]")
zmq::context_t context;
zmq::socket_t socket{context, zmq::socket_type::router};
zmq::active_poller_t active_poller;
active_poller.add(socket, zmq::event_flags::pollin, zmq::active_poller_t::handler_type{});
active_poller.add(socket, zmq::event_flags::pollin,
zmq::active_poller_t::handler_type{});
CHECK_NOTHROW(active_poller.remove(socket));
}
@@ -139,7 +148,9 @@ TEST_CASE("remove registered non empty", "[active_poller]")
zmq::context_t context;
zmq::socket_t socket{context, zmq::socket_type::router};
zmq::active_poller_t active_poller;
active_poller.add(socket, zmq::event_flags::pollin, [](zmq::event_flags) {});
active_poller.add(socket, zmq::event_flags::pollin, [](zmq::event_flags)
{
});
CHECK_NOTHROW(active_poller.remove(socket));
}
@@ -147,7 +158,10 @@ namespace
{
struct server_client_setup : common_server_client_setup
{
zmq::active_poller_t::handler_type handler = [&](zmq::event_flags e) { events = e; };
zmq::active_poller_t::handler_type handler = [&](zmq::event_flags e)
{
events = e;
};
zmq::event_flags events = zmq::event_flags::none;
};
@@ -161,7 +175,9 @@ TEST_CASE("poll basic", "[active_poller]")
zmq::active_poller_t active_poller;
bool message_received = false;
zmq::active_poller_t::handler_type handler = [&message_received](zmq::event_flags events) {
zmq::active_poller_t::handler_type handler = [&message_received
](zmq::event_flags events)
{
CHECK(zmq::event_flags::none != (events & zmq::event_flags::pollin));
message_received = true;
};
@@ -181,7 +197,8 @@ TEST_CASE("client server", "[active_poller]")
// Setup active_poller
zmq::active_poller_t active_poller;
zmq::event_flags events;
zmq::active_poller_t::handler_type handler = [&](zmq::event_flags e) {
zmq::active_poller_t::handler_type handler = [&](zmq::event_flags e)
{
if (zmq::event_flags::none != (e & zmq::event_flags::pollin)) {
zmq::message_t zmq_msg;
CHECK_NOTHROW(s.server.recv(zmq_msg)); // get message
@@ -204,7 +221,9 @@ TEST_CASE("client server", "[active_poller]")
// Re-add server socket with pollout flag
CHECK_NOTHROW(active_poller.remove(s.server));
CHECK_NOTHROW(active_poller.add(s.server, zmq::event_flags::pollin | zmq::event_flags::pollout, handler));
CHECK_NOTHROW(
active_poller.add(s.server, zmq::event_flags::pollin | zmq::event_flags::
pollout, handler));
CHECK(1 == active_poller.wait(std::chrono::milliseconds{-1}));
CHECK(events == zmq::event_flags::pollout);
}
@@ -215,8 +234,10 @@ TEST_CASE("add invalid socket throws", "[active_poller]")
zmq::active_poller_t active_poller;
zmq::socket_t a{context, zmq::socket_type::router};
zmq::socket_t b{std::move(a)};
CHECK_THROWS_AS(active_poller.add(a, zmq::event_flags::pollin, zmq::active_poller_t::handler_type{}),
const zmq::error_t&);
CHECK_THROWS_AS(
active_poller.add(a, zmq::event_flags::pollin, zmq::active_poller_t::
handler_type{}),
const zmq::error_t&);
}
TEST_CASE("remove invalid socket throws", "[active_poller]")
@@ -225,7 +246,8 @@ TEST_CASE("remove invalid socket throws", "[active_poller]")
zmq::socket_t socket{context, zmq::socket_type::router};
zmq::active_poller_t active_poller;
CHECK_NOTHROW(
active_poller.add(socket, zmq::event_flags::pollin, zmq::active_poller_t::handler_type{}));
active_poller.add(socket, zmq::event_flags::pollin, zmq::active_poller_t::
handler_type{}));
CHECK(1u == active_poller.size());
std::vector<zmq::socket_t> sockets;
sockets.emplace_back(std::move(socket));
@@ -248,7 +270,8 @@ TEST_CASE("modify empty throws", "[active_poller]")
zmq::context_t context;
zmq::socket_t socket{context, zmq::socket_type::push};
zmq::active_poller_t active_poller;
CHECK_THROWS_AS(active_poller.modify(socket, zmq::event_flags::pollin), const zmq::error_t&);
CHECK_THROWS_AS(active_poller.modify(socket, zmq::event_flags::pollin),
const zmq::error_t&);
}
TEST_CASE("modify invalid socket throws", "[active_poller]")
@@ -257,7 +280,8 @@ TEST_CASE("modify invalid socket throws", "[active_poller]")
zmq::socket_t a{context, zmq::socket_type::push};
zmq::socket_t b{std::move(a)};
zmq::active_poller_t active_poller;
CHECK_THROWS_AS(active_poller.modify(a, zmq::event_flags::pollin), const zmq::error_t&);
CHECK_THROWS_AS(active_poller.modify(a, zmq::event_flags::pollin),
const zmq::error_t&);
}
TEST_CASE("modify not added throws", "[active_poller]")
@@ -267,8 +291,10 @@ TEST_CASE("modify not added throws", "[active_poller]")
zmq::socket_t b{context, zmq::socket_type::push};
zmq::active_poller_t active_poller;
CHECK_NOTHROW(
active_poller.add(a, zmq::event_flags::pollin, zmq::active_poller_t::handler_type{}));
CHECK_THROWS_AS(active_poller.modify(b, zmq::event_flags::pollin), const zmq::error_t&);
active_poller.add(a, zmq::event_flags::pollin, zmq::active_poller_t::
handler_type{}));
CHECK_THROWS_AS(active_poller.modify(b, zmq::event_flags::pollin),
const zmq::error_t&);
}
TEST_CASE("modify simple", "[active_poller]")
@@ -277,8 +303,11 @@ TEST_CASE("modify simple", "[active_poller]")
zmq::socket_t a{context, zmq::socket_type::push};
zmq::active_poller_t active_poller;
CHECK_NOTHROW(
active_poller.add(a, zmq::event_flags::pollin, zmq::active_poller_t::handler_type{}));
CHECK_NOTHROW(active_poller.modify(a, zmq::event_flags::pollin | zmq::event_flags::pollout));
active_poller.add(a, zmq::event_flags::pollin, zmq::active_poller_t::
handler_type{}));
CHECK_NOTHROW(
active_poller.modify(a, zmq::event_flags::pollin | zmq::event_flags::pollout
));
}
TEST_CASE("poll client server", "[active_poller]")
@@ -298,7 +327,9 @@ TEST_CASE("poll client server", "[active_poller]")
CHECK(s.events == zmq::event_flags::pollin);
// Modify server socket with pollout flag
CHECK_NOTHROW(active_poller.modify(s.server, zmq::event_flags::pollin | zmq::event_flags::pollout));
CHECK_NOTHROW(
active_poller.modify(s.server, zmq::event_flags::pollin | zmq::event_flags::
pollout));
CHECK(1 == active_poller.wait(std::chrono::milliseconds{500}));
CHECK(s.events == (zmq::event_flags::pollin | zmq::event_flags::pollout));
}
@@ -313,7 +344,8 @@ TEST_CASE("wait one return", "[active_poller]")
// Setup active_poller
zmq::active_poller_t active_poller;
CHECK_NOTHROW(
active_poller.add(s.server, zmq::event_flags::pollin, [&count](zmq::event_flags) { ++count; }));
active_poller.add(s.server, zmq::event_flags::pollin, [&count](zmq::
event_flags) { ++count; }));
// client sends message
CHECK_NOTHROW(s.client.send(zmq::message_t{"Hi"}, zmq::send_flags::none));
@@ -359,7 +391,9 @@ TEST_CASE("received on move constructed active_poller", "[active_poller]")
int count = 0;
// Setup active_poller a
zmq::active_poller_t a;
CHECK_NOTHROW(a.add(s.server, zmq::event_flags::pollin, [&count](zmq::event_flags) { ++count; }));
CHECK_NOTHROW(
a.add(s.server, zmq::event_flags::pollin, [&count](zmq::event_flags) { ++
count; }));
// client sends message
CHECK_NOTHROW(s.client.send(zmq::message_t{"Hi"}, zmq::send_flags::none));
// wait for message and verify it is received
@@ -389,11 +423,12 @@ TEST_CASE("remove from handler", "[active_poller]")
int count = 0;
for (size_t i = 0; i < ITER_NO; ++i) {
CHECK_NOTHROW(
active_poller.add(setup_list[i].server, zmq::event_flags::pollin, [&, i](zmq::event_flags events) {
CHECK(events == zmq::event_flags::pollin);
active_poller.remove(setup_list[ITER_NO - i - 1].server);
CHECK((ITER_NO - i - 1) == active_poller.size());
}));
active_poller.add(setup_list[i].server, zmq::event_flags::pollin, [&, i](
zmq::event_flags events) {
CHECK(events == zmq::event_flags::pollin);
active_poller.remove(setup_list[ITER_NO - i - 1].server);
CHECK((ITER_NO - i - 1) == active_poller.size());
}));
++count;
}
CHECK(ITER_NO == active_poller.size());

12
tests/buffer.cpp
View File

@@ -35,10 +35,10 @@ TEST_CASE("buffer data ctor", "[buffer]")
CHECK(mb.size() == from_mut.size());
CHECK(mb.data() == from_mut.data());
const auto cmb = mb;
static_assert(std::is_same<decltype(cmb.data()), void*>::value, "");
static_assert(std::is_same<decltype(cmb.data()), void *>::value, "");
constexpr const void* cp = nullptr;
constexpr void* p = nullptr;
constexpr const void *cp = nullptr;
constexpr void *p = nullptr;
constexpr zmq::const_buffer cecb = zmq::buffer(p, 0);
constexpr zmq::mutable_buffer cemb = zmq::buffer(p, 0);
CHECK(cecb.data() == nullptr);
@@ -188,14 +188,14 @@ TEST_CASE("mutable_buffer creation vector", "[buffer]")
TEST_CASE("const_buffer creation vector", "[buffer]")
{
std::vector<BT> d(10);
zmq::const_buffer b = zmq::buffer(static_cast<const std::vector<BT>&>(d));
zmq::const_buffer b = zmq::buffer(static_cast<const std::vector<BT> &>(d));
CHECK(b.size() == d.size() * sizeof(BT));
CHECK(b.data() == d.data());
zmq::const_buffer b2 = zmq::buffer(static_cast<const std::vector<BT>&>(d), 4);
zmq::const_buffer b2 = zmq::buffer(static_cast<const std::vector<BT> &>(d), 4);
CHECK(b2.size() == 4);
CHECK(b2.data() == d.data());
d.clear();
b = zmq::buffer(static_cast<const std::vector<BT>&>(d));
b = zmq::buffer(static_cast<const std::vector<BT> &>(d));
CHECK(b.size() == 0);
CHECK(b.data() == nullptr);
}

7
tests/message.cpp
View File

@@ -4,9 +4,9 @@
#if defined(ZMQ_CPP11)
static_assert(!std::is_copy_constructible<zmq::message_t>::value,
"message_t should not be copy-constructible");
"message_t should not be copy-constructible");
static_assert(!std::is_copy_assignable<zmq::message_t>::value,
"message_t should not be copy-assignable");
"message_t should not be copy-assignable");
#endif
#if (__cplusplus >= 201703L)
static_assert(std::is_nothrow_swappable<zmq::message_t>::value,
@@ -36,7 +36,8 @@ TEST_CASE("message swap", "[message]")
}
#endif
namespace {
namespace
{
const char *const data = "Hi";
}

39
tests/monitor.cpp
View File

@@ -8,7 +8,7 @@
class mock_monitor_t : public zmq::monitor_t
{
public:
public:
void on_event_connect_delayed(const zmq_event_t &, const char *) ZMQ_OVERRIDE
{
++connect_delayed;
@@ -38,13 +38,11 @@ TEST_CASE("monitor move construct", "[monitor]")
{
zmq::context_t ctx;
zmq::socket_t sock(ctx, ZMQ_DEALER);
SECTION("move ctor empty")
{
SECTION("move ctor empty") {
zmq::monitor_t monitor1;
zmq::monitor_t monitor2 = std::move(monitor1);
}
SECTION("move ctor init")
{
SECTION("move ctor init") {
zmq::monitor_t monitor1;
monitor1.init(sock, "inproc://monitor-client");
zmq::monitor_t monitor2 = std::move(monitor1);
@@ -55,21 +53,18 @@ TEST_CASE("monitor move assign", "[monitor]")
{
zmq::context_t ctx;
zmq::socket_t sock(ctx, ZMQ_DEALER);
SECTION("move assign empty")
{
zmq::monitor_t monitor1;
zmq::monitor_t monitor2;
monitor1 = std::move(monitor2);
SECTION("move assign empty") {
zmq::monitor_t monitor1;
zmq::monitor_t monitor2;
monitor1 = std::move(monitor2);
}
SECTION("move assign init")
{
SECTION("move assign init") {
zmq::monitor_t monitor1;
monitor1.init(sock, "inproc://monitor-client");
zmq::monitor_t monitor2;
monitor2 = std::move(monitor1);
}
SECTION("move assign init both")
{
SECTION("move assign init both") {
zmq::monitor_t monitor1;
monitor1.init(sock, "inproc://monitor-client");
zmq::monitor_t monitor2;
@@ -101,10 +96,11 @@ TEST_CASE("monitor init abort", "[monitor]")
{
class mock_monitor : public mock_monitor_t
{
public:
mock_monitor(std::function<void(void)> handle_connected)
: handle_connected{std::move(handle_connected)}
{}
public:
mock_monitor(std::function<void(void)> handle_connected) :
handle_connected{std::move(handle_connected)}
{
}
void on_event_connected(const zmq_event_t &e, const char *m) ZMQ_OVERRIDE
{
@@ -113,7 +109,6 @@ TEST_CASE("monitor init abort", "[monitor]")
}
std::function<void(void)> handle_connected;
};
common_server_client_setup s(false);
@@ -122,14 +117,16 @@ TEST_CASE("monitor init abort", "[monitor]")
std::condition_variable cond_var;
bool done{false};
mock_monitor monitor([&]() {
mock_monitor monitor([&]()
{
std::lock_guard<std::mutex> lock(mutex);
done = true;
cond_var.notify_one();
});
monitor.init(s.client, "inproc://foo");
auto thread = std::thread([&monitor] {
auto thread = std::thread([&monitor]
{
while (monitor.check_event(-1)) {
}
});

8
tests/multipart.cpp
View File

@@ -74,12 +74,12 @@ TEST_CASE("multipart legacy test", "[multipart]")
multipart.pushtyp(1.0f);
multipart.pushmem("Frame0", 6);
assert(multipart.size() == 10);
const message_t& front_msg = multipart.front();
const message_t &front_msg = multipart.front();
assert(multipart.size() == 10);
assert(std::string(front_msg.data<char>(), front_msg.size()) == "Frame0");
const message_t& back_msg = multipart.back();
const message_t &back_msg = multipart.back();
assert(multipart.size() == 10);
assert(std::string(back_msg.data<char>(), back_msg.size()) == "Frame9");

35
tests/poller.cpp
View File

@@ -9,15 +9,16 @@
static_assert(std::is_nothrow_swappable_v<zmq::poller_t<>>);
#endif
static_assert(sizeof(zmq_poller_event_t) == sizeof(zmq::poller_event<>), "");
static_assert(sizeof(zmq_poller_event_t) == sizeof(zmq::poller_event<zmq::no_user_data>), "");
static_assert(sizeof(zmq_poller_event_t) == sizeof(zmq::poller_event<zmq::
no_user_data>), "");
static_assert(sizeof(zmq_poller_event_t) == sizeof(zmq::poller_event<int>), "");
static_assert(alignof(zmq_poller_event_t) == alignof(zmq::poller_event<>), "");
static_assert(alignof(zmq_poller_event_t) == alignof(zmq::poller_event<int>), "");
static_assert(!std::is_copy_constructible<zmq::poller_t<>>::value,
"poller_t should not be copy-constructible");
"poller_t should not be copy-constructible");
static_assert(!std::is_copy_assignable<zmq::poller_t<>>::value,
"poller_t should not be copy-assignable");
"poller_t should not be copy-assignable");
TEST_CASE("event flags", "[poller]")
{
@@ -106,7 +107,9 @@ TEST_CASE("poller add handler invalid events type", "[poller]")
zmq::socket_t socket{context, zmq::socket_type::router};
zmq::poller_t<> poller;
short invalid_events_type = 2 << 10;
CHECK_THROWS_AS(poller.add(socket, static_cast<zmq::event_flags>(invalid_events_type)), const zmq::error_t&);
CHECK_THROWS_AS(
poller.add(socket, static_cast<zmq::event_flags>(invalid_events_type)),
const zmq::error_t&);
}
#endif
@@ -117,7 +120,8 @@ TEST_CASE("poller add handler twice throws", "[poller]")
zmq::poller_t<> poller;
poller.add(socket, zmq::event_flags::pollin);
/// \todo the actual error code should be checked
CHECK_THROWS_AS(poller.add(socket, zmq::event_flags::pollin), const zmq::error_t&);
CHECK_THROWS_AS(poller.add(socket, zmq::event_flags::pollin),
const zmq::error_t&);
}
TEST_CASE("poller wait with no handlers throws", "[poller]")
@@ -126,7 +130,7 @@ TEST_CASE("poller wait with no handlers throws", "[poller]")
std::vector<zmq::poller_event<>> events;
/// \todo the actual error code should be checked
CHECK_THROWS_AS(poller.wait_all(events, std::chrono::milliseconds{10}),
const zmq::error_t&);
const zmq::error_t&);
}
TEST_CASE("poller remove unregistered throws", "[poller]")
@@ -198,7 +202,8 @@ TEST_CASE("poller modify empty throws", "[poller]")
zmq::context_t context;
zmq::socket_t socket{context, zmq::socket_type::push};
zmq::poller_t<> poller;
CHECK_THROWS_AS(poller.modify(socket, zmq::event_flags::pollin), const zmq::error_t&);
CHECK_THROWS_AS(poller.modify(socket, zmq::event_flags::pollin),
const zmq::error_t&);
}
TEST_CASE("poller modify invalid socket throws", "[poller]")
@@ -226,7 +231,8 @@ TEST_CASE("poller modify simple", "[poller]")
zmq::socket_t a{context, zmq::socket_type::push};
zmq::poller_t<> poller;
CHECK_NOTHROW(poller.add(a, zmq::event_flags::pollin));
CHECK_NOTHROW(poller.modify(a, zmq::event_flags::pollin | zmq::event_flags::pollout));
CHECK_NOTHROW(
poller.modify(a, zmq::event_flags::pollin | zmq::event_flags::pollout));
}
TEST_CASE("poller poll client server", "[poller]")
@@ -247,9 +253,12 @@ TEST_CASE("poller poll client server", "[poller]")
CHECK(zmq::event_flags::pollin == events[0].events);
// Modify server socket with pollout flag
CHECK_NOTHROW(poller.modify(s.server, zmq::event_flags::pollin | zmq::event_flags::pollout));
CHECK_NOTHROW(
poller.modify(s.server, zmq::event_flags::pollin | zmq::event_flags::pollout
));
CHECK(1 == poller.wait_all(events, std::chrono::milliseconds{500}));
CHECK((zmq::event_flags::pollin | zmq::event_flags::pollout) == events[0].events);
CHECK((zmq::event_flags::pollin | zmq::event_flags::pollout) == events[0].events)
;
}
TEST_CASE("poller wait one return", "[poller]")
@@ -278,7 +287,8 @@ TEST_CASE("poller wait on move constructed", "[poller]")
zmq::poller_t<> b{std::move(a)};
std::vector<zmq::poller_event<>> events(1);
/// \todo the actual error code should be checked
CHECK_THROWS_AS(a.wait_all(events, std::chrono::milliseconds{10}), const zmq::error_t&);
CHECK_THROWS_AS(a.wait_all(events, std::chrono::milliseconds{10}),
const zmq::error_t&);
CHECK(1 == b.wait_all(events, std::chrono::milliseconds{-1}));
}
@@ -292,7 +302,8 @@ TEST_CASE("poller wait on move assigned", "[poller]")
b = {std::move(a)};
/// \todo the TEST_CASE error code should be checked
std::vector<zmq::poller_event<>> events(1);
CHECK_THROWS_AS(a.wait_all(events, std::chrono::milliseconds{10}), const zmq::error_t&);
CHECK_THROWS_AS(a.wait_all(events, std::chrono::milliseconds{10}),
const zmq::error_t&);
CHECK(1 == b.wait_all(events, std::chrono::milliseconds{-1}));
}

65
tests/recv_multipart.cpp
View File

@@ -10,8 +10,7 @@ TEST_CASE("recv_multipart test", "[recv_multipart]")
output.bind("inproc://multipart.test");
input.connect("inproc://multipart.test");
SECTION("send 1 message")
{
SECTION("send 1 message") {
input.send(zmq::str_buffer("hello"));
std::vector<zmq::message_t> msgs;
@@ -21,8 +20,7 @@ TEST_CASE("recv_multipart test", "[recv_multipart]")
REQUIRE(msgs.size() == 1);
CHECK(msgs[0].size() == 5);
}
SECTION("send 2 messages")
{
SECTION("send 2 messages") {
input.send(zmq::str_buffer("hello"), zmq::send_flags::sndmore);
input.send(zmq::str_buffer("world!"));
@@ -34,26 +32,27 @@ TEST_CASE("recv_multipart test", "[recv_multipart]")
CHECK(msgs[0].size() == 5);
CHECK(msgs[1].size() == 6);
}
SECTION("send no messages, dontwait")
{
SECTION("send no messages, dontwait") {
std::vector<zmq::message_t> msgs;
auto ret = zmq::recv_multipart(output, std::back_inserter(msgs), zmq::recv_flags::dontwait);
auto ret = zmq::recv_multipart(output, std::back_inserter(msgs),
zmq::recv_flags::dontwait);
CHECK_FALSE(ret);
REQUIRE(msgs.size() == 0);
}
SECTION("send 1 partial message, dontwait")
{
SECTION("send 1 partial message, dontwait") {
input.send(zmq::str_buffer("hello"), zmq::send_flags::sndmore);
std::vector<zmq::message_t> msgs;
auto ret = zmq::recv_multipart(output, std::back_inserter(msgs), zmq::recv_flags::dontwait);
auto ret = zmq::recv_multipart(output, std::back_inserter(msgs),
zmq::recv_flags::dontwait);
CHECK_FALSE(ret);
REQUIRE(msgs.size() == 0);
}
SECTION("recv with invalid socket")
{
SECTION("recv with invalid socket") {
std::vector<zmq::message_t> msgs;
CHECK_THROWS_AS(zmq::recv_multipart(zmq::socket_ref(), std::back_inserter(msgs)), const zmq::error_t &);
CHECK_THROWS_AS(
zmq::recv_multipart(zmq::socket_ref(), std::back_inserter(msgs)),
const zmq::error_t &);
}
}
@@ -65,8 +64,7 @@ TEST_CASE("recv_multipart_n test", "[recv_multipart]")
output.bind("inproc://multipart.test");
input.connect("inproc://multipart.test");
SECTION("send 1 message")
{
SECTION("send 1 message") {
input.send(zmq::str_buffer("hello"));
std::array<zmq::message_t, 1> msgs;
@@ -75,8 +73,7 @@ TEST_CASE("recv_multipart_n test", "[recv_multipart]")
CHECK(*ret == 1);
CHECK(msgs[0].size() == 5);
}
SECTION("send 1 message 2")
{
SECTION("send 1 message 2") {
input.send(zmq::str_buffer("hello"));
std::array<zmq::message_t, 2> msgs;
@@ -86,28 +83,25 @@ TEST_CASE("recv_multipart_n test", "[recv_multipart]")
CHECK(msgs[0].size() == 5);
CHECK(msgs[1].size() == 0);
}
SECTION("send 2 messages, recv 1")
{
SECTION("send 2 messages, recv 1") {
input.send(zmq::str_buffer("hello"), zmq::send_flags::sndmore);
input.send(zmq::str_buffer("world!"));
std::array<zmq::message_t, 1> msgs;
CHECK_THROWS_AS(
zmq::recv_multipart_n(output, msgs.data(), msgs.size()),
zmq::recv_multipart_n(output, msgs.data(), msgs.size()),
const std::runtime_error&);
}
SECTION("recv 0")
{
SECTION("recv 0") {
input.send(zmq::str_buffer("hello"), zmq::send_flags::sndmore);
input.send(zmq::str_buffer("world!"));
std::array<zmq::message_t, 1> msgs;
CHECK_THROWS_AS(
zmq::recv_multipart_n(output, msgs.data(), 0),
zmq::recv_multipart_n(output, msgs.data(), 0),
const std::runtime_error&);
}
SECTION("send 2 messages")
{
SECTION("send 2 messages") {
input.send(zmq::str_buffer("hello"), zmq::send_flags::sndmore);
input.send(zmq::str_buffer("world!"));
@@ -118,26 +112,27 @@ TEST_CASE("recv_multipart_n test", "[recv_multipart]")
CHECK(msgs[0].size() == 5);
CHECK(msgs[1].size() == 6);
}
SECTION("send no messages, dontwait")
{
SECTION("send no messages, dontwait") {
std::array<zmq::message_t, 1> msgs;
auto ret = zmq::recv_multipart_n(output, msgs.data(), msgs.size(), zmq::recv_flags::dontwait);
auto ret = zmq::recv_multipart_n(output, msgs.data(), msgs.size(),
zmq::recv_flags::dontwait);
CHECK_FALSE(ret);
REQUIRE(msgs[0].size() == 0);
}
SECTION("send 1 partial message, dontwait")
{
SECTION("send 1 partial message, dontwait") {
input.send(zmq::str_buffer("hello"), zmq::send_flags::sndmore);
std::array<zmq::message_t, 1> msgs;
auto ret = zmq::recv_multipart_n(output, msgs.data(), msgs.size(), zmq::recv_flags::dontwait);
auto ret = zmq::recv_multipart_n(output, msgs.data(), msgs.size(),
zmq::recv_flags::dontwait);
CHECK_FALSE(ret);
REQUIRE(msgs[0].size() == 0);
}
SECTION("recv with invalid socket")
{
SECTION("recv with invalid socket") {
std::array<zmq::message_t, 1> msgs;
CHECK_THROWS_AS(zmq::recv_multipart_n(zmq::socket_ref(), msgs.data(), msgs.size()), const zmq::error_t &);
CHECK_THROWS_AS(
zmq::recv_multipart_n(zmq::socket_ref(), msgs.data(), msgs.size()),
const zmq::error_t &);
}
}

41
tests/send_multipart.cpp
View File

@@ -12,15 +12,13 @@ TEST_CASE("send_multipart test", "[send_multipart]")
output.bind("inproc://multipart.test");
input.connect("inproc://multipart.test");
SECTION("send 0 messages")
{
SECTION("send 0 messages") {
std::vector<zmq::message_t> imsgs;
auto iret = zmq::send_multipart(input, imsgs);
REQUIRE(iret);
CHECK(*iret == 0);
}
SECTION("send 1 message")
{
SECTION("send 1 message") {
std::array<zmq::message_t, 1> imsgs = {zmq::message_t(3)};
auto iret = zmq::send_multipart(input, imsgs);
REQUIRE(iret);
@@ -33,8 +31,7 @@ TEST_CASE("send_multipart test", "[send_multipart]")
REQUIRE(omsgs.size() == 1);
CHECK(omsgs[0].size() == 3);
}
SECTION("send 2 messages")
{
SECTION("send 2 messages") {
std::array<zmq::message_t, 2> imsgs = {zmq::message_t(3), zmq::message_t(4)};
auto iret = zmq::send_multipart(input, imsgs);
REQUIRE(iret);
@@ -48,9 +45,9 @@ TEST_CASE("send_multipart test", "[send_multipart]")
CHECK(omsgs[0].size() == 3);
CHECK(omsgs[1].size() == 4);
}
SECTION("send 2 messages, const_buffer")
{
std::array<zmq::const_buffer, 2> imsgs = {zmq::str_buffer("foo"), zmq::str_buffer("bar!")};
SECTION("send 2 messages, const_buffer") {
std::array<zmq::const_buffer, 2> imsgs = {zmq::str_buffer("foo"),
zmq::str_buffer("bar!")};
auto iret = zmq::send_multipart(input, imsgs);
REQUIRE(iret);
CHECK(*iret == 2);
@@ -63,10 +60,10 @@ TEST_CASE("send_multipart test", "[send_multipart]")
CHECK(omsgs[0].size() == 3);
CHECK(omsgs[1].size() == 4);
}
SECTION("send 2 messages, mutable_buffer")
{
SECTION("send 2 messages, mutable_buffer") {
char buf[4] = {};
std::array<zmq::mutable_buffer, 2> imsgs = {zmq::buffer(buf, 3), zmq::buffer(buf)};
std::array<zmq::mutable_buffer, 2> imsgs = {
zmq::buffer(buf, 3), zmq::buffer(buf)};
auto iret = zmq::send_multipart(input, imsgs);
REQUIRE(iret);
CHECK(*iret == 2);
@@ -79,17 +76,15 @@ TEST_CASE("send_multipart test", "[send_multipart]")
CHECK(omsgs[0].size() == 3);
CHECK(omsgs[1].size() == 4);
}
SECTION("send 2 messages, dontwait")
{
SECTION("send 2 messages, dontwait") {
zmq::socket_t push(context, ZMQ_PUSH);
push.bind("inproc://multipart.test.push");
std::array<zmq::message_t, 2> imsgs = {zmq::message_t(3), zmq::message_t(4)};
auto iret = zmq::send_multipart(push, imsgs, zmq::send_flags::dontwait);
REQUIRE_FALSE(iret);
}
SECTION("send, misc. containers")
{
SECTION("send, misc. containers") {
std::vector<zmq::message_t> msgs_vec;
msgs_vec.emplace_back(3);
msgs_vec.emplace_back(4);
@@ -110,15 +105,17 @@ TEST_CASE("send_multipart test", "[send_multipart]")
REQUIRE(iret);
CHECK(*iret == 2);
// rvalue
iret = zmq::send_multipart(input,
std::initializer_list<zmq::const_buffer>{zmq::str_buffer("foo"), zmq::str_buffer("bar!")});
iret = zmq::send_multipart(input,
std::initializer_list<zmq::const_buffer>{
zmq::str_buffer("foo"),
zmq::str_buffer("bar!")});
REQUIRE(iret);
CHECK(*iret == 2);
}
SECTION("send with invalid socket")
{
SECTION("send with invalid socket") {
std::vector<zmq::message_t> msgs(1);
CHECK_THROWS_AS(zmq::send_multipart(zmq::socket_ref(), msgs), const zmq::error_t &);
CHECK_THROWS_AS(zmq::send_multipart(zmq::socket_ref(), msgs),
const zmq::error_t &);
}
}
#endif

40
tests/socket.cpp
View File

@@ -50,19 +50,19 @@ TEST_CASE("socket swap", "[socket]")
TEST_CASE("socket flags", "[socket]")
{
CHECK((zmq::recv_flags::dontwait | zmq::recv_flags::none)
== static_cast<zmq::recv_flags>(ZMQ_DONTWAIT | 0));
== static_cast<zmq::recv_flags>(ZMQ_DONTWAIT | 0));
CHECK((zmq::recv_flags::dontwait & zmq::recv_flags::none)
== static_cast<zmq::recv_flags>(ZMQ_DONTWAIT & 0));
== static_cast<zmq::recv_flags>(ZMQ_DONTWAIT & 0));
CHECK((zmq::recv_flags::dontwait ^ zmq::recv_flags::none)
== static_cast<zmq::recv_flags>(ZMQ_DONTWAIT ^ 0));
== static_cast<zmq::recv_flags>(ZMQ_DONTWAIT ^ 0));
CHECK(~zmq::recv_flags::dontwait == static_cast<zmq::recv_flags>(~ZMQ_DONTWAIT));
CHECK((zmq::send_flags::dontwait | zmq::send_flags::sndmore)
== static_cast<zmq::send_flags>(ZMQ_DONTWAIT | ZMQ_SNDMORE));
== static_cast<zmq::send_flags>(ZMQ_DONTWAIT | ZMQ_SNDMORE));
CHECK((zmq::send_flags::dontwait & zmq::send_flags::sndmore)
== static_cast<zmq::send_flags>(ZMQ_DONTWAIT & ZMQ_SNDMORE));
== static_cast<zmq::send_flags>(ZMQ_DONTWAIT & ZMQ_SNDMORE));
CHECK((zmq::send_flags::dontwait ^ zmq::send_flags::sndmore)
== static_cast<zmq::send_flags>(ZMQ_DONTWAIT ^ ZMQ_SNDMORE));
== static_cast<zmq::send_flags>(ZMQ_DONTWAIT ^ ZMQ_SNDMORE));
CHECK(~zmq::send_flags::dontwait == static_cast<zmq::send_flags>(~ZMQ_DONTWAIT));
}
@@ -82,20 +82,20 @@ TEST_CASE("socket sends and receives const buffer", "[socket]")
zmq::socket_t receiver(context, ZMQ_PAIR);
receiver.bind("inproc://test");
sender.connect("inproc://test");
const char* str = "Hi";
const char *str = "Hi";
#ifdef ZMQ_CPP11
#ifdef ZMQ_CPP11
CHECK(2 == *sender.send(zmq::buffer(str, 2)));
char buf[2];
const auto res = receiver.recv(zmq::buffer(buf));
CHECK(res);
CHECK(!res->truncated());
CHECK(2 == res->size);
#else
#else
CHECK(2 == sender.send(str, 2));
char buf[2];
CHECK(2 == receiver.recv(buf, 2));
#endif
#endif
CHECK(0 == memcmp(buf, str, 2));
}
@@ -126,7 +126,7 @@ TEST_CASE("socket send dontwait", "[socket]")
auto res = s.send(zmq::buffer(buf), zmq::send_flags::dontwait);
CHECK(!res);
res = s.send(zmq::buffer(buf),
zmq::send_flags::dontwait | zmq::send_flags::sndmore);
zmq::send_flags::dontwait | zmq::send_flags::sndmore);
CHECK(!res);
zmq::message_t msg;
@@ -253,16 +253,15 @@ TEST_CASE("socket proxy", "[socket]")
front.bind("inproc://test1");
back.bind("inproc://test2");
capture.bind("inproc://test3");
auto f = std::async(std::launch::async, [&]() {
auto f = std::async(std::launch::async, [&]()
{
auto s1 = std::move(front);
auto s2 = std::move(back);
auto s3 = std::move(capture);
try
{
try {
zmq::proxy(s1, s2, zmq::socket_ref(s3));
}
catch (const zmq::error_t& e)
{
catch (const zmq::error_t &e) {
return e.num() == ETERM;
}
return false;
@@ -280,16 +279,15 @@ TEST_CASE("socket proxy steerable", "[socket]")
front.bind("inproc://test1");
back.bind("inproc://test2");
control.connect("inproc://test3");
auto f = std::async(std::launch::async, [&]() {
auto f = std::async(std::launch::async, [&]()
{
auto s1 = std::move(front);
auto s2 = std::move(back);
auto s3 = std::move(control);
try
{
try {
zmq::proxy_steerable(s1, s2, zmq::socket_ref(), s3);
}
catch (const zmq::error_t& e)
{
catch (const zmq::error_t &e) {
return e.num() == ETERM;
}
return false;

4
tests/socket_ref.cpp
View File

@@ -8,7 +8,7 @@ static_assert(std::is_nothrow_swappable_v<zmq::socket_ref>);
static_assert(sizeof(zmq::socket_ref) == sizeof(void *), "size mismatch");
static_assert(alignof(zmq::socket_ref) == alignof(void *), "alignment mismatch");
static_assert(ZMQ_IS_TRIVIALLY_COPYABLE(zmq::socket_ref),
"needs to be trivially copyable");
"needs to be trivially copyable");
TEST_CASE("socket_ref default init", "[socket_ref]")
{
@@ -111,7 +111,7 @@ TEST_CASE("socket_ref type punning", "[socket_ref]")
CHECK(socket.handle() != nullptr);
svp.p = socket.handle();
// static_cast to silence incorrect warning
std::memcpy(static_cast<void*>(&ssr), &svp, sizeof(ssr));
std::memcpy(static_cast<void *>(&ssr), &svp, sizeof(ssr));
CHECK(ssr.sr == socket);
}

14
tests/utilities.cpp
View File

@@ -8,31 +8,38 @@ namespace test_ns
struct T_nr
{
};
struct T_mr
{
void *begin() const noexcept { return nullptr; }
void *end() const noexcept { return nullptr; }
};
struct T_fr
{
};
inline void *begin(const T_fr &) noexcept
{
return nullptr;
}
inline void *end(const T_fr &) noexcept
{
return nullptr;
}
struct T_mfr
{
void *begin() const noexcept { return nullptr; }
void *end() const noexcept { return nullptr; }
};
inline void *begin(const T_mfr &) noexcept
{
return nullptr;
}
inline void *end(const T_mfr &) noexcept
{
return nullptr;
@@ -42,31 +49,38 @@ inline void *end(const T_mfr &) noexcept
struct T_assoc_ns_nr : std::exception
{
};
struct T_assoc_ns_mr : std::exception
{
void *begin() const noexcept { return nullptr; }
void *end() const noexcept { return nullptr; }
};
struct T_assoc_ns_fr : std::exception
{
};
inline void *begin(const T_assoc_ns_fr &) noexcept
{
return nullptr;
}
inline void *end(const T_assoc_ns_fr &) noexcept
{
return nullptr;
}
struct T_assoc_ns_mfr : std::exception
{
void *begin() const noexcept { return nullptr; }
void *end() const noexcept { return nullptr; }
};
inline void *begin(const T_assoc_ns_mfr &) noexcept
{
return nullptr;
}
inline void *end(const T_assoc_ns_mfr &) noexcept
{
return nullptr;