From ae1596490730f2d5963942cd8798bd985905e59d Mon Sep 17 00:00:00 2001 From: Pawel Kurdybacha Date: Sun, 23 Sep 2018 17:14:25 +0100 Subject: [PATCH] Problem: Dependency on googletest framework Currently cppzmq as relatively simple and header only library depends on rather complex unit test framework googletest. Current issues: - Googletest requires downloading and building it every time on travis as cache support is limited there - Googletest build is signifficant with comparison to cppzmq unittests total runtime Solution: Port existing tests to Catch - header only C++ framework and gain ~20% build speed up on travis. Why Catch? It is well know C++ header only testing framework. It works well, it is being kept up to date and maintainers seem to pay attention to community's comments and issues. We can not use Catch2 currently as we still support pre-C++11 compilers. --- README.md | 2 +- appveyor.yml | 2 +- external/gtest-demo/INFO.md | 1 - external/gtest-demo/LICENSE | 27 --- tests/CMakeLists.txt | 17 +- tests/active_poller.cpp | 249 +++++++++++++------------- tests/cmake/catch.cmake | 16 ++ tests/cmake/googletest-download.cmake | 20 --- tests/cmake/googletest.cmake | 38 ---- tests/context.cpp | 9 +- tests/main.cpp | 7 - tests/message.cpp | 81 +++++---- tests/monitor.cpp | 73 +++++--- tests/multipart.cpp | 4 +- tests/poller.cpp | 143 +++++++-------- tests/socket.cpp | 14 +- tests/testutil.hpp | 10 +- zmq.hpp | 8 +- 18 files changed, 332 insertions(+), 389 deletions(-) delete mode 100644 external/gtest-demo/INFO.md delete mode 100644 external/gtest-demo/LICENSE create mode 100644 tests/cmake/catch.cmake delete mode 100644 tests/cmake/googletest-download.cmake delete mode 100644 tests/cmake/googletest.cmake delete mode 100644 tests/main.cpp diff --git a/README.md b/README.md index 63ced44..32191eb 100644 --- a/README.md +++ b/README.md @@ -22,7 +22,7 @@ There are other C++ bindings for ZeroMQ with different design goals. In particul Supported platforms =================== - - Only a subset of the platforms that are supported by libzmq itself are supported. Some features already require a compiler supporting C++11. In the future, probably all features will require C++11. To build and run the tests, cmake and googletest are required. + - Only a subset of the platforms that are supported by libzmq itself are supported. Some features already require a compiler supporting C++11. In the future, probably all features will require C++11. To build and run the tests, CMake and Catch are required. - Tested libzmq versions are - 4.2.0 (without DRAFT API) - 4.2.5 (with and without DRAFT API) diff --git a/appveyor.yml b/appveyor.yml index 5768744..07f8e93 100644 --- a/appveyor.yml +++ b/appveyor.yml @@ -20,7 +20,7 @@ environment: cache: - libzmq -> appveyor.yml - - Build/tests/googletest -> tests/cmake/googletest-download.cmake + - Build/catch -> tests/cmake/catch.cmake before_build: - if not exist libzmq ( diff --git a/external/gtest-demo/INFO.md b/external/gtest-demo/INFO.md deleted file mode 100644 index 33c3184..0000000 --- a/external/gtest-demo/INFO.md +++ /dev/null @@ -1 +0,0 @@ -googletest integration into CMake and travis-ci was based on https://github.com/bast/gtest-demo diff --git a/external/gtest-demo/LICENSE b/external/gtest-demo/LICENSE deleted file mode 100644 index 9f7875e..0000000 --- a/external/gtest-demo/LICENSE +++ /dev/null @@ -1,27 +0,0 @@ -Copyright (c) 2015-2018, Radovan Bast -All rights reserved. - -Redistribution and use in source and binary forms, with or without -modification, are permitted provided that the following conditions are met: - -* Redistributions of source code must retain the above copyright notice, this - list of conditions and the following disclaimer. - -* Redistributions in binary form must reproduce the above copyright notice, - this list of conditions and the following disclaimer in the documentation - and/or other materials provided with the distribution. - -* Neither the name of gtest-demo nor the names of its - contributors may be used to endorse or promote products derived from - this software without specific prior written permission. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" -AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE -IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE -DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE -FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL -DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR -SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER -CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, -OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt index 62d1168..c2a13f0 100644 --- a/tests/CMakeLists.txt +++ b/tests/CMakeLists.txt @@ -9,11 +9,7 @@ set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/${CMAKE_INSTALL_LIBDIR}) set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/${CMAKE_INSTALL_LIBDIR}) set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/${CMAKE_INSTALL_BINDIR}) -include(cmake/googletest.cmake) -fetch_googletest( - ${PROJECT_SOURCE_DIR}/cmake - ${PROJECT_BINARY_DIR}/googletest - ) +include(cmake/catch.cmake) add_executable( unit_tests @@ -24,14 +20,15 @@ add_executable( active_poller.cpp multipart.cpp monitor.cpp - ) +) +add_dependencies(unit_tests catch) + +target_include_directories(unit_tests PUBLIC ${CATCH_INCLUDE_DIR}) target_link_libraries( unit_tests - PRIVATE gtest - PRIVATE gmock_main PRIVATE cppzmq - ) +) OPTION (COVERAGE "Enable gcda file generation needed by lcov" OFF) @@ -45,4 +42,4 @@ add_test( unit COMMAND ${CMAKE_BINARY_DIR}/${CMAKE_INSTALL_BINDIR}/unit_tests - ) +) diff --git a/tests/active_poller.cpp b/tests/active_poller.cpp index 7f7dcc2..2e921bb 100644 --- a/tests/active_poller.cpp +++ b/tests/active_poller.cpp @@ -7,10 +7,10 @@ #include #include -TEST(active_poller, create_destroy) +TEST_CASE("create destroy", "[active_poller]") { zmq::active_poller_t active_poller; - ASSERT_TRUE(active_poller.empty()); + CHECK(active_poller.empty()); } static_assert(!std::is_copy_constructible::value, @@ -18,72 +18,72 @@ static_assert(!std::is_copy_constructible::value, static_assert(!std::is_copy_assignable::value, "active_active_poller_t should not be copy-assignable"); -TEST(active_poller, move_construct_empty) +TEST_CASE("move construct empty", "[active_poller]") { zmq::active_poller_t a; - ASSERT_TRUE(a.empty()); + CHECK(a.empty()); zmq::active_poller_t b = std::move(a); - ASSERT_TRUE(b.empty()); - ASSERT_EQ(0u, a.size()); - ASSERT_EQ(0u, b.size()); + CHECK(b.empty()); + CHECK(0u == a.size()); + CHECK(0u == b.size()); } -TEST(active_poller, move_assign_empty) +TEST_CASE("move assign empty", "[active_poller]") { zmq::active_poller_t a; - ASSERT_TRUE(a.empty()); + CHECK(a.empty()); zmq::active_poller_t b; - ASSERT_TRUE(b.empty()); + CHECK(b.empty()); b = std::move(a); - ASSERT_EQ(0u, a.size()); - ASSERT_EQ(0u, b.size()); - ASSERT_TRUE(a.empty()); - ASSERT_TRUE(b.empty()); + CHECK(0u == a.size()); + CHECK(0u == b.size()); + CHECK(a.empty()); + CHECK(b.empty()); } -TEST(active_poller, move_construct_non_empty) +TEST_CASE("move construct non empty", "[active_poller]") { zmq::context_t context; zmq::socket_t socket{context, zmq::socket_type::router}; zmq::active_poller_t a; a.add(socket, ZMQ_POLLIN, [](short) {}); - ASSERT_FALSE(a.empty()); - ASSERT_EQ(1u, a.size()); + CHECK_FALSE(a.empty()); + CHECK(1u == a.size()); zmq::active_poller_t b = std::move(a); - ASSERT_TRUE(a.empty()); - ASSERT_EQ(0u, a.size()); - ASSERT_FALSE(b.empty()); - ASSERT_EQ(1u, b.size()); + CHECK(a.empty()); + CHECK(0u == a.size()); + CHECK_FALSE(b.empty()); + CHECK(1u == b.size()); } -TEST(active_poller, move_assign_non_empty) +TEST_CASE("move assign non empty", "[active_poller]") { zmq::context_t context; zmq::socket_t socket{context, zmq::socket_type::router}; zmq::active_poller_t a; a.add(socket, ZMQ_POLLIN, [](short) {}); - ASSERT_FALSE(a.empty()); - ASSERT_EQ(1u, a.size()); + CHECK_FALSE(a.empty()); + CHECK(1u == a.size()); zmq::active_poller_t b; b = std::move(a); - ASSERT_TRUE(a.empty()); - ASSERT_EQ(0u, a.size()); - ASSERT_FALSE(b.empty()); - ASSERT_EQ(1u, b.size()); + CHECK(a.empty()); + CHECK(0u == a.size()); + CHECK_FALSE(b.empty()); + CHECK(1u == b.size()); } -TEST(active_poller, add_handler) +TEST_CASE("add handler", "[active_poller]") { zmq::context_t context; zmq::socket_t socket{context, zmq::socket_type::router}; zmq::active_poller_t active_poller; zmq::active_poller_t::handler_t handler; - ASSERT_NO_THROW(active_poller.add(socket, ZMQ_POLLIN, handler)); + CHECK_NOTHROW(active_poller.add(socket, ZMQ_POLLIN, handler)); } -TEST(active_poller, add_handler_invalid_events_type) +TEST_CASE("add handler invalid events type", "[active_poller]") { /// \todo is it good that this is accepted? should probably already be /// checked by zmq_poller_add/modify in libzmq: @@ -93,12 +93,12 @@ TEST(active_poller, add_handler_invalid_events_type) zmq::active_poller_t active_poller; zmq::active_poller_t::handler_t handler; short invalid_events_type = 2 << 10; - ASSERT_NO_THROW(active_poller.add(socket, invalid_events_type, handler)); - ASSERT_FALSE(active_poller.empty()); - ASSERT_EQ(1u, active_poller.size()); + CHECK_NOTHROW(active_poller.add(socket, invalid_events_type, handler)); + CHECK_FALSE(active_poller.empty()); + CHECK(1u == active_poller.size()); } -TEST(active_poller, add_handler_twice_throws) +TEST_CASE("add handler twice throws", "[active_poller]") { zmq::context_t context; zmq::socket_t socket{context, zmq::socket_type::router}; @@ -106,41 +106,41 @@ TEST(active_poller, add_handler_twice_throws) zmq::active_poller_t::handler_t handler; active_poller.add(socket, ZMQ_POLLIN, handler); /// \todo the actual error code should be checked - ASSERT_THROW(active_poller.add(socket, ZMQ_POLLIN, handler), zmq::error_t); + CHECK_THROWS_AS(active_poller.add(socket, ZMQ_POLLIN, handler), zmq::error_t); } -TEST(active_poller, wait_with_no_handlers_throws) +TEST_CASE("wait with no handlers throws", "[active_poller]") { zmq::active_poller_t active_poller; /// \todo the actual error code should be checked - ASSERT_THROW(active_poller.wait(std::chrono::milliseconds{10}), zmq::error_t); + CHECK_THROWS_AS(active_poller.wait(std::chrono::milliseconds{10}), zmq::error_t); } -TEST(active_poller, remove_unregistered_throws) +TEST_CASE("remove unregistered throws", "[active_poller]") { zmq::context_t context; zmq::socket_t socket{context, zmq::socket_type::router}; zmq::active_poller_t active_poller; /// \todo the actual error code should be checked - ASSERT_THROW(active_poller.remove(socket), zmq::error_t); + CHECK_THROWS_AS(active_poller.remove(socket), zmq::error_t); } -TEST(active_poller, remove_registered_empty) +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_POLLIN, zmq::active_poller_t::handler_t{}); - ASSERT_NO_THROW(active_poller.remove(socket)); + CHECK_NOTHROW(active_poller.remove(socket)); } -TEST(active_poller, remove_registered_non_empty) +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_POLLIN, [](short) {}); - ASSERT_NO_THROW(active_poller.remove(socket)); + CHECK_NOTHROW(active_poller.remove(socket)); } namespace @@ -153,25 +153,25 @@ struct server_client_setup : common_server_client_setup }; } -TEST(active_poller, poll_basic) +TEST_CASE("poll basic", "[active_poller]") { server_client_setup s; - ASSERT_NO_THROW(s.client.send(zmq::message_t{"Hi"})); + CHECK_NOTHROW(s.client.send(zmq::message_t{"Hi"})); zmq::active_poller_t active_poller; bool message_received = false; zmq::active_poller_t::handler_t handler = [&message_received](short events) { - ASSERT_TRUE(0 != (events & ZMQ_POLLIN)); + CHECK(0 != (events & ZMQ_POLLIN)); message_received = true; }; - ASSERT_NO_THROW(active_poller.add(s.server, ZMQ_POLLIN, handler)); - ASSERT_EQ(1, active_poller.wait(std::chrono::milliseconds{-1})); - ASSERT_TRUE(message_received); + CHECK_NOTHROW(active_poller.add(s.server, ZMQ_POLLIN, handler)); + CHECK(1 == active_poller.wait(std::chrono::milliseconds{-1})); + CHECK(message_received); } /// \todo this contains multiple test cases that should be split up -TEST(active_poller, client_server) +TEST_CASE("client server", "[active_poller]") { const std::string send_msg = "Hi"; @@ -184,125 +184,126 @@ TEST(active_poller, client_server) zmq::active_poller_t::handler_t handler = [&](short e) { if (0 != (e & ZMQ_POLLIN)) { zmq::message_t zmq_msg; - ASSERT_NO_THROW(s.server.recv(&zmq_msg)); // get message + CHECK_NOTHROW(s.server.recv(&zmq_msg)); // get message std::string recv_msg(zmq_msg.data(), zmq_msg.size()); - ASSERT_EQ(send_msg, recv_msg); + CHECK(send_msg == recv_msg); } else if (0 != (e & ~ZMQ_POLLOUT)) { - ASSERT_TRUE(false) << "Unexpected event type " << events; + INFO("Unexpected event type " << events); + REQUIRE(false); } events = e; }; - ASSERT_NO_THROW(active_poller.add(s.server, ZMQ_POLLIN, handler)); + CHECK_NOTHROW(active_poller.add(s.server, ZMQ_POLLIN, handler)); // client sends message - ASSERT_NO_THROW(s.client.send(zmq::message_t{send_msg})); + CHECK_NOTHROW(s.client.send(zmq::message_t{send_msg})); - ASSERT_EQ(1, active_poller.wait(std::chrono::milliseconds{-1})); - ASSERT_EQ(events, ZMQ_POLLIN); + CHECK(1 == active_poller.wait(std::chrono::milliseconds{-1})); + CHECK(events == ZMQ_POLLIN); // Re-add server socket with pollout flag - ASSERT_NO_THROW(active_poller.remove(s.server)); - ASSERT_NO_THROW(active_poller.add(s.server, ZMQ_POLLIN | ZMQ_POLLOUT, handler)); - ASSERT_EQ(1, active_poller.wait(std::chrono::milliseconds{-1})); - ASSERT_EQ(events, ZMQ_POLLOUT); + CHECK_NOTHROW(active_poller.remove(s.server)); + CHECK_NOTHROW(active_poller.add(s.server, ZMQ_POLLIN | ZMQ_POLLOUT, handler)); + CHECK(1 == active_poller.wait(std::chrono::milliseconds{-1})); + CHECK(events == ZMQ_POLLOUT); } -TEST(active_poller, add_invalid_socket_throws) +TEST_CASE("add invalid socket throws", "[active_poller]") { zmq::context_t context; zmq::active_poller_t active_poller; zmq::socket_t a{context, zmq::socket_type::router}; zmq::socket_t b{std::move(a)}; - ASSERT_THROW(active_poller.add(a, ZMQ_POLLIN, zmq::active_poller_t::handler_t{}), + CHECK_THROWS_AS(active_poller.add(a, ZMQ_POLLIN, zmq::active_poller_t::handler_t{}), zmq::error_t); } -TEST(active_poller, remove_invalid_socket_throws) +TEST_CASE("remove invalid socket throws", "[active_poller]") { zmq::context_t context; zmq::socket_t socket{context, zmq::socket_type::router}; zmq::active_poller_t active_poller; - ASSERT_NO_THROW( + CHECK_NOTHROW( active_poller.add(socket, ZMQ_POLLIN, zmq::active_poller_t::handler_t{})); - ASSERT_EQ(1u, active_poller.size()); + CHECK(1u == active_poller.size()); std::vector sockets; sockets.emplace_back(std::move(socket)); - ASSERT_THROW(active_poller.remove(socket), zmq::error_t); - ASSERT_EQ(1u, active_poller.size()); + CHECK_THROWS_AS(active_poller.remove(socket), zmq::error_t); + CHECK(1u == active_poller.size()); } -TEST(active_poller, wait_on_added_empty_handler) +TEST_CASE("wait on added empty handler", "[active_poller]") { server_client_setup s; - ASSERT_NO_THROW(s.client.send(zmq::message_t{"Hi"})); + CHECK_NOTHROW(s.client.send(zmq::message_t{"Hi"})); zmq::active_poller_t active_poller; zmq::active_poller_t::handler_t handler; - ASSERT_NO_THROW(active_poller.add(s.server, ZMQ_POLLIN, handler)); - ASSERT_NO_THROW(active_poller.wait(std::chrono::milliseconds{-1})); + CHECK_NOTHROW(active_poller.add(s.server, ZMQ_POLLIN, handler)); + CHECK_NOTHROW(active_poller.wait(std::chrono::milliseconds{-1})); } -TEST(active_poller, modify_empty_throws) +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; - ASSERT_THROW(active_poller.modify(socket, ZMQ_POLLIN), zmq::error_t); + CHECK_THROWS_AS(active_poller.modify(socket, ZMQ_POLLIN), zmq::error_t); } -TEST(active_poller, modify_invalid_socket_throws) +TEST_CASE("modify invalid socket throws", "[active_poller]") { zmq::context_t context; zmq::socket_t a{context, zmq::socket_type::push}; zmq::socket_t b{std::move(a)}; zmq::active_poller_t active_poller; - ASSERT_THROW(active_poller.modify(a, ZMQ_POLLIN), zmq::error_t); + CHECK_THROWS_AS(active_poller.modify(a, ZMQ_POLLIN), zmq::error_t); } -TEST(active_poller, modify_not_added_throws) +TEST_CASE("modify not added throws", "[active_poller]") { zmq::context_t context; zmq::socket_t a{context, zmq::socket_type::push}; zmq::socket_t b{context, zmq::socket_type::push}; zmq::active_poller_t active_poller; - ASSERT_NO_THROW( + CHECK_NOTHROW( active_poller.add(a, ZMQ_POLLIN, zmq::active_poller_t::handler_t{})); - ASSERT_THROW(active_poller.modify(b, ZMQ_POLLIN), zmq::error_t); + CHECK_THROWS_AS(active_poller.modify(b, ZMQ_POLLIN), zmq::error_t); } -TEST(active_poller, modify_simple) +TEST_CASE("modify simple", "[active_poller]") { zmq::context_t context; zmq::socket_t a{context, zmq::socket_type::push}; zmq::active_poller_t active_poller; - ASSERT_NO_THROW( + CHECK_NOTHROW( active_poller.add(a, ZMQ_POLLIN, zmq::active_poller_t::handler_t{})); - ASSERT_NO_THROW(active_poller.modify(a, ZMQ_POLLIN | ZMQ_POLLOUT)); + CHECK_NOTHROW(active_poller.modify(a, ZMQ_POLLIN | ZMQ_POLLOUT)); } -TEST(active_poller, poll_client_server) +TEST_CASE("poll client server", "[active_poller]") { // Setup server and client server_client_setup s; // Setup active_poller zmq::active_poller_t active_poller; - ASSERT_NO_THROW(active_poller.add(s.server, ZMQ_POLLIN, s.handler)); + CHECK_NOTHROW(active_poller.add(s.server, ZMQ_POLLIN, s.handler)); // client sends message - ASSERT_NO_THROW(s.client.send(zmq::message_t{"Hi"})); + CHECK_NOTHROW(s.client.send(zmq::message_t{"Hi"})); // wait for message and verify events - ASSERT_NO_THROW(active_poller.wait(std::chrono::milliseconds{500})); - ASSERT_EQ(s.events, ZMQ_POLLIN); + CHECK_NOTHROW(active_poller.wait(std::chrono::milliseconds{500})); + CHECK(s.events == ZMQ_POLLIN); // Modify server socket with pollout flag - ASSERT_NO_THROW(active_poller.modify(s.server, ZMQ_POLLIN | ZMQ_POLLOUT)); - ASSERT_EQ(1, active_poller.wait(std::chrono::milliseconds{500})); - ASSERT_EQ(s.events, ZMQ_POLLIN | ZMQ_POLLOUT); + CHECK_NOTHROW(active_poller.modify(s.server, ZMQ_POLLIN | ZMQ_POLLOUT)); + CHECK(1 == active_poller.wait(std::chrono::milliseconds{500})); + CHECK(s.events == (ZMQ_POLLIN | ZMQ_POLLOUT)); } -TEST(active_poller, wait_one_return) +TEST_CASE("wait one return", "[active_poller]") { // Setup server and client server_client_setup s; @@ -311,70 +312,70 @@ TEST(active_poller, wait_one_return) // Setup active_poller zmq::active_poller_t active_poller; - ASSERT_NO_THROW( + CHECK_NOTHROW( active_poller.add(s.server, ZMQ_POLLIN, [&count](short) { ++count; })); // client sends message - ASSERT_NO_THROW(s.client.send(zmq::message_t{"Hi"})); + CHECK_NOTHROW(s.client.send(zmq::message_t{"Hi"})); // wait for message and verify events - ASSERT_EQ(1, active_poller.wait(std::chrono::milliseconds{500})); - ASSERT_EQ(1u, count); + CHECK(1 == active_poller.wait(std::chrono::milliseconds{500})); + CHECK(1u == count); } -TEST(active_poller, wait_on_move_constructed_active_poller) +TEST_CASE("wait on move constructed active_poller", "[active_poller]") { server_client_setup s; - ASSERT_NO_THROW(s.client.send(zmq::message_t{"Hi"})); + CHECK_NOTHROW(s.client.send(zmq::message_t{"Hi"})); zmq::active_poller_t a; zmq::active_poller_t::handler_t handler; - ASSERT_NO_THROW(a.add(s.server, ZMQ_POLLIN, handler)); + CHECK_NOTHROW(a.add(s.server, ZMQ_POLLIN, handler)); zmq::active_poller_t b{std::move(a)}; - ASSERT_EQ(1u, b.size()); + CHECK(1u == b.size()); /// \todo the actual error code should be checked - ASSERT_THROW(a.wait(std::chrono::milliseconds{10}), zmq::error_t); - ASSERT_TRUE(b.wait(std::chrono::milliseconds{-1})); + CHECK_THROWS_AS(a.wait(std::chrono::milliseconds{10}), zmq::error_t); + CHECK(b.wait(std::chrono::milliseconds{-1})); } -TEST(active_poller, wait_on_move_assigned_active_poller) +TEST_CASE("wait on move assigned active_poller", "[active_poller]") { server_client_setup s; - ASSERT_NO_THROW(s.client.send(zmq::message_t{"Hi"})); + CHECK_NOTHROW(s.client.send(zmq::message_t{"Hi"})); zmq::active_poller_t a; zmq::active_poller_t::handler_t handler; - ASSERT_NO_THROW(a.add(s.server, ZMQ_POLLIN, handler)); + CHECK_NOTHROW(a.add(s.server, ZMQ_POLLIN, handler)); zmq::active_poller_t b; b = {std::move(a)}; - ASSERT_EQ(1u, b.size()); + CHECK(1u == b.size()); /// \todo the actual error code should be checked - ASSERT_THROW(a.wait(std::chrono::milliseconds{10}), zmq::error_t); - ASSERT_TRUE(b.wait(std::chrono::milliseconds{-1})); + CHECK_THROWS_AS(a.wait(std::chrono::milliseconds{10}), zmq::error_t); + CHECK(b.wait(std::chrono::milliseconds{-1})); } -TEST(active_poller, received_on_move_constructed_active_poller) +TEST_CASE("received on move constructed active_poller", "[active_poller]") { // Setup server and client server_client_setup s; int count = 0; // Setup active_poller a zmq::active_poller_t a; - ASSERT_NO_THROW(a.add(s.server, ZMQ_POLLIN, [&count](short) { ++count; })); + CHECK_NOTHROW(a.add(s.server, ZMQ_POLLIN, [&count](short) { ++count; })); // client sends message - ASSERT_NO_THROW(s.client.send(zmq::message_t{"Hi"})); + CHECK_NOTHROW(s.client.send(zmq::message_t{"Hi"})); // wait for message and verify it is received - ASSERT_EQ(1, a.wait(std::chrono::milliseconds{500})); - ASSERT_EQ(1u, count); + CHECK(1 == a.wait(std::chrono::milliseconds{500})); + CHECK(1u == count); // Move construct active_poller b zmq::active_poller_t b{std::move(a)}; // client sends message again - ASSERT_NO_THROW(s.client.send(zmq::message_t{"Hi"})); + CHECK_NOTHROW(s.client.send(zmq::message_t{"Hi"})); // wait for message and verify it is received - ASSERT_EQ(1, b.wait(std::chrono::milliseconds{500})); - ASSERT_EQ(2u, count); + CHECK(1 == b.wait(std::chrono::milliseconds{500})); + CHECK(2u == count); } -TEST(active_poller, remove_from_handler) +TEST_CASE("remove from handler", "[active_poller]") { constexpr auto ITER_NO = 10; @@ -387,18 +388,18 @@ TEST(active_poller, remove_from_handler) zmq::active_poller_t active_poller; int count = 0; for (auto i = 0; i < ITER_NO; ++i) { - ASSERT_NO_THROW( + CHECK_NOTHROW( active_poller.add(setup_list[i].server, ZMQ_POLLIN, [&, i](short events) { - ASSERT_EQ(events, ZMQ_POLLIN); + CHECK(events == ZMQ_POLLIN); active_poller.remove(setup_list[ITER_NO - i - 1].server); - ASSERT_EQ(ITER_NO - i - 1, active_poller.size()); + CHECK((ITER_NO - i - 1) == active_poller.size()); })); ++count; } - ASSERT_EQ(ITER_NO, active_poller.size()); + CHECK(ITER_NO == active_poller.size()); // Clients send messages for (auto &s : setup_list) { - ASSERT_NO_THROW(s.client.send(zmq::message_t{"Hi"})); + CHECK_NOTHROW(s.client.send(zmq::message_t{"Hi"})); } // Wait for all servers to receive a message @@ -408,8 +409,8 @@ TEST(active_poller, remove_from_handler) } // Fire all handlers in one wait - ASSERT_EQ(ITER_NO, active_poller.wait(std::chrono::milliseconds{-1})); - ASSERT_EQ(ITER_NO, count); + CHECK(ITER_NO == active_poller.wait(std::chrono::milliseconds{-1})); + CHECK(ITER_NO == count); } #endif diff --git a/tests/cmake/catch.cmake b/tests/cmake/catch.cmake new file mode 100644 index 0000000..7de99dc --- /dev/null +++ b/tests/cmake/catch.cmake @@ -0,0 +1,16 @@ +include(ExternalProject) + +ExternalProject_Add( + catch + PREFIX ${CMAKE_BINARY_DIR}/catch + URL "https://raw.githubusercontent.com/catchorg/Catch2/Catch1.x/single_include/catch.hpp" + CONFIGURE_COMMAND "" + BUILD_COMMAND "" + INSTALL_COMMAND "" + TEST_COMMAND "" + DOWNLOAD_NO_EXTRACT ON +) + +# Expose variable CATCH_INCLUDE_DIR to parent scope +ExternalProject_Get_Property(catch DOWNLOAD_DIR) +set(CATCH_INCLUDE_DIR ${DOWNLOAD_DIR} CACHE INTERNAL "Path to include catch") diff --git a/tests/cmake/googletest-download.cmake b/tests/cmake/googletest-download.cmake deleted file mode 100644 index 4926683..0000000 --- a/tests/cmake/googletest-download.cmake +++ /dev/null @@ -1,20 +0,0 @@ -# code copied from https://crascit.com/2015/07/25/cmake-gtest/ -cmake_minimum_required(VERSION 3.5 FATAL_ERROR) - -project(googletest-download NONE) - -include(ExternalProject) - -ExternalProject_Add( - googletest - SOURCE_DIR "@GOOGLETEST_DOWNLOAD_ROOT@/googletest-src" - BINARY_DIR "@GOOGLETEST_DOWNLOAD_ROOT@/googletest-build" - GIT_REPOSITORY - https://github.com/google/googletest.git - GIT_TAG - release-1.8.0 - CONFIGURE_COMMAND "" - BUILD_COMMAND "" - INSTALL_COMMAND "" - TEST_COMMAND "" - ) diff --git a/tests/cmake/googletest.cmake b/tests/cmake/googletest.cmake deleted file mode 100644 index 7f6ec11..0000000 --- a/tests/cmake/googletest.cmake +++ /dev/null @@ -1,38 +0,0 @@ -# the following code to fetch googletest -# is inspired by and adapted after https://crascit.com/2015/07/25/cmake-gtest/ -# download and unpack googletest at configure time - -macro(fetch_googletest _download_module_path _download_root) - set(GOOGLETEST_DOWNLOAD_ROOT ${_download_root}) - configure_file( - ${_download_module_path}/googletest-download.cmake - ${_download_root}/CMakeLists.txt - @ONLY - ) - unset(GOOGLETEST_DOWNLOAD_ROOT) - - execute_process( - COMMAND - "${CMAKE_COMMAND}" -G "${CMAKE_GENERATOR}" . - WORKING_DIRECTORY - ${_download_root} - ) - execute_process( - COMMAND - "${CMAKE_COMMAND}" --build . - WORKING_DIRECTORY - ${_download_root} - ) - -if (MSVC) - set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /D_SILENCE_TR1_NAMESPACE_DEPRECATION_WARNING") - set(gtest_force_shared_crt ON CACHE BOOL "" FORCE) -endif() - - # adds the targers: gtest, gtest_main, gmock, gmock_main - add_subdirectory( - ${_download_root}/googletest-src - ${_download_root}/googletest-build - EXCLUDE_FROM_ALL - ) -endmacro() diff --git a/tests/context.cpp b/tests/context.cpp index c1468b8..135c9bd 100644 --- a/tests/context.cpp +++ b/tests/context.cpp @@ -1,15 +1,14 @@ -#include +#include #include -TEST(context, create_default_destroy) +TEST_CASE("context construct default and destroy", "[context]") { zmq::context_t context; } -TEST(context, create_close) +TEST_CASE("context create, close and destroy", "[context]") { zmq::context_t context; context.close(); - - ASSERT_EQ(NULL, (void *) context); + CHECK(NULL == (void *) context); } diff --git a/tests/main.cpp b/tests/main.cpp deleted file mode 100644 index 7b7d6f3..0000000 --- a/tests/main.cpp +++ /dev/null @@ -1,7 +0,0 @@ -#include "gtest/gtest.h" - -int main(int argc, char **argv) -{ - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/tests/message.cpp b/tests/message.cpp index 6ff81e1..6761ea3 100644 --- a/tests/message.cpp +++ b/tests/message.cpp @@ -1,4 +1,5 @@ -#include +#define CATCH_CONFIG_MAIN +#include #include #if defined(ZMQ_CPP11) @@ -8,129 +9,131 @@ static_assert(!std::is_copy_assignable::value, "message_t should not be copy-assignable"); #endif -TEST(message, constructor_default) +TEST_CASE("message default constructed", "[message]") { const zmq::message_t message; - ASSERT_EQ(0u, message.size()); + CHECK(0u == message.size()); } +namespace { const char *const data = "Hi"; +} -TEST(message, constructor_iterators) +TEST_CASE("message constructor with iterators", "[message]") { const std::string hi(data); const zmq::message_t hi_msg(hi.begin(), hi.end()); - ASSERT_EQ(2u, hi_msg.size()); - ASSERT_EQ(0, memcmp(data, hi_msg.data(), 2)); + CHECK(2u == hi_msg.size()); + CHECK(0 == memcmp(data, hi_msg.data(), 2)); } -TEST(message, constructor_pointer_size) +TEST_CASE("message constructor with buffer and size", "[message]") { const std::string hi(data); const zmq::message_t hi_msg(hi.data(), hi.size()); - ASSERT_EQ(2u, hi_msg.size()); - ASSERT_EQ(0, memcmp(data, hi_msg.data(), 2)); + CHECK(2u == hi_msg.size()); + CHECK(0 == memcmp(data, hi_msg.data(), 2)); } -TEST(message, constructor_char_array) +TEST_CASE("message constructor with char array", "[message]") { const zmq::message_t hi_msg(data, strlen(data)); - ASSERT_EQ(2u, hi_msg.size()); - ASSERT_EQ(0, memcmp(data, hi_msg.data(), 2)); + CHECK(2u == hi_msg.size()); + CHECK(0 == memcmp(data, hi_msg.data(), 2)); } #if defined(ZMQ_BUILD_DRAFT_API) && defined(ZMQ_CPP11) -TEST(message, constructor_container) +TEST_CASE("message constructor with container", "[message]") { const std::string hi(data); zmq::message_t hi_msg(hi); - ASSERT_EQ(2u, hi_msg.size()); - ASSERT_EQ(0, memcmp(data, hi_msg.data(), 2)); + CHECK(2u == hi_msg.size()); + CHECK(0 == memcmp(data, hi_msg.data(), 2)); } #endif #ifdef ZMQ_HAS_RVALUE_REFS -TEST(message, constructor_move) +TEST_CASE("message move constructor", "[message]") { zmq::message_t hi_msg(zmq::message_t(data, strlen(data))); } -TEST(message, assign_move_empty_before) +TEST_CASE("message assign move empty before", "[message]") { zmq::message_t hi_msg; hi_msg = zmq::message_t(data, strlen(data)); - ASSERT_EQ(2u, hi_msg.size()); - ASSERT_EQ(0, memcmp(data, hi_msg.data(), 2)); + CHECK(2u == hi_msg.size()); + CHECK(0 == memcmp(data, hi_msg.data(), 2)); } -TEST(message, assign_move_empty_after) +TEST_CASE("message assign move empty after", "[message]") { zmq::message_t hi_msg(data, strlen(data)); hi_msg = zmq::message_t(); - ASSERT_EQ(0u, hi_msg.size()); + CHECK(0u == hi_msg.size()); } -TEST(message, assign_move_empty_before_and_after) +TEST_CASE("message assign move empty before and after", "[message]") { zmq::message_t hi_msg; hi_msg = zmq::message_t(); - ASSERT_EQ(0u, hi_msg.size()); + CHECK(0u == hi_msg.size()); } #endif -TEST(message, equality_self) +TEST_CASE("message equality self", "[message]") { const zmq::message_t hi_msg(data, strlen(data)); - ASSERT_EQ(hi_msg, hi_msg); + CHECK(hi_msg == hi_msg); } -TEST(message, equality_equal) +TEST_CASE("message equality equal", "[message]") { const zmq::message_t hi_msg_a(data, strlen(data)); const zmq::message_t hi_msg_b(data, strlen(data)); - ASSERT_EQ(hi_msg_a, hi_msg_b); + CHECK(hi_msg_a == hi_msg_b); } -TEST(message, equality_equal_empty) +TEST_CASE("message equality equal empty", "[message]") { const zmq::message_t msg_a; const zmq::message_t msg_b; - ASSERT_EQ(msg_a, msg_b); + CHECK(msg_a == msg_b); } -TEST(message, equality_non_equal) +TEST_CASE("message equality non equal", "[message]") { const zmq::message_t msg_a("Hi", 2); const zmq::message_t msg_b("Hello", 5); - ASSERT_NE(msg_a, msg_b); + CHECK(msg_a != msg_b); } -TEST(message, equality_non_equal_rhs_empty) +TEST_CASE("message equality non equal rhs empty", "[message]") { const zmq::message_t msg_a("Hi", 2); const zmq::message_t msg_b; - ASSERT_NE(msg_a, msg_b); + CHECK(msg_a != msg_b); } -TEST(message, equality_non_equal_lhs_empty) +TEST_CASE("message equality non equal lhs empty", "[message]") { const zmq::message_t msg_a; const zmq::message_t msg_b("Hi", 2); - ASSERT_NE(msg_a, msg_b); + CHECK(msg_a != msg_b); } #if defined(ZMQ_BUILD_DRAFT_API) && ZMQ_VERSION >= ZMQ_MAKE_VERSION(4, 2, 0) -TEST(message, routing_id_persists) +TEST_CASE("message routing id persists", "[message]") { zmq::message_t msg; msg.set_routing_id(123); - ASSERT_EQ(123u, msg.routing_id()); + CHECK(123u == msg.routing_id()); } -TEST(message, group_persists) +TEST_CASE("message group persists", "[message]") { zmq::message_t msg; msg.set_group("mygroup"); - ASSERT_STREQ("mygroup", msg.group()); + CHECK(std::string(msg.group()) == "mygroup"); } #endif diff --git a/tests/monitor.cpp b/tests/monitor.cpp index 8c3d0c9..9de1f6b 100644 --- a/tests/monitor.cpp +++ b/tests/monitor.cpp @@ -1,26 +1,39 @@ #include "testutil.hpp" -#include #ifdef ZMQ_CPP11 #include #include #include -#endif class mock_monitor_t : public zmq::monitor_t { public: - MOCK_METHOD2(on_event_connect_delayed, void(const zmq_event_t &, const char *)); - MOCK_METHOD2(on_event_connected, void(const zmq_event_t &, const char *)); + void on_event_connect_delayed(const zmq_event_t &, const char *) ZMQ_OVERRIDE + { + ++connect_delayed; + ++total; + } + + void on_event_connected(const zmq_event_t &, const char *) ZMQ_OVERRIDE + { + ++connected; + ++total; + } + + int total{0}; + int connect_delayed{0}; + int connected{0}; }; -TEST(monitor, create_destroy) +#endif + +TEST_CASE("monitor create destroy", "[monitor]") { zmq::monitor_t monitor; } #if defined(ZMQ_CPP11) -TEST(monitor, init_check) +TEST_CASE("monitor init event count", "[monitor]") { common_server_client_setup s{false}; mock_monitor_t monitor; @@ -31,41 +44,48 @@ TEST(monitor, init_check) ++event_count; }; - EXPECT_CALL(monitor, on_event_connect_delayed(testing::_, testing::_)) - .Times(1) - .WillOnce(testing::Invoke(count_event)); - EXPECT_CALL(monitor, on_event_connected(testing::_, testing::_)) - .Times(1) - .WillOnce(testing::Invoke(count_event)); - monitor.init(s.client, "inproc://foo"); - ASSERT_FALSE(monitor.check_event(0)); + CHECK_FALSE(monitor.check_event(0)); s.init(); - while (monitor.check_event(100) && event_count < expected_event_count) { + while (monitor.check_event(100) && monitor.total < expected_event_count) { } + CHECK(monitor.connect_delayed == 1); + CHECK(monitor.connected == 1); } -TEST(monitor, init_abort) +TEST_CASE("monitor init abort", "[monitor]") { + class mock_monitor : public mock_monitor_t + { + public: + mock_monitor(std::function handle_connected) + : handle_connected{std::move(handle_connected)} + {} + + void on_event_connected(const zmq_event_t &e, const char *m) ZMQ_OVERRIDE + { + mock_monitor_t::on_event_connected(e, m); + handle_connected(); + } + + std::function handle_connected; + + }; + common_server_client_setup s(false); - mock_monitor_t monitor; - monitor.init(s.client, "inproc://foo"); std::mutex mutex; std::condition_variable cond_var; bool done{false}; - EXPECT_CALL(monitor, on_event_connect_delayed(testing::_, testing::_)) - .Times(1); - EXPECT_CALL(monitor, on_event_connected(testing::_, testing::_)) - .Times(1) - .WillOnce(testing::Invoke([&](const zmq_event_t &, const char *) { + mock_monitor monitor([&]() { std::lock_guard lock(mutex); done = true; cond_var.notify_one(); - })); + }); + monitor.init(s.client, "inproc://foo"); auto thread = std::thread([&monitor] { while (monitor.check_event(-1)) { @@ -75,10 +95,11 @@ TEST(monitor, init_abort) s.init(); { std::unique_lock lock(mutex); - EXPECT_TRUE(cond_var.wait_for(lock, std::chrono::seconds(1), + CHECK(cond_var.wait_for(lock, std::chrono::seconds(1), [&done] { return done; })); } - + CHECK(monitor.connect_delayed == 1); + CHECK(monitor.connected == 1); monitor.abort(); thread.join(); } diff --git a/tests/multipart.cpp b/tests/multipart.cpp index 521f2e6..1d6bca6 100644 --- a/tests/multipart.cpp +++ b/tests/multipart.cpp @@ -1,10 +1,10 @@ -#include +#include #include #ifdef ZMQ_HAS_RVALUE_REFS /// \todo split this up into separate test cases /// -TEST(multipart, legacy_test) +TEST_CASE("multipart legacy test", "[multipart]") { using namespace zmq; diff --git a/tests/poller.cpp b/tests/poller.cpp index 25abadd..a42fd66 100644 --- a/tests/poller.cpp +++ b/tests/poller.cpp @@ -5,7 +5,7 @@ #include #include -TEST(poller, create_destroy) +TEST_CASE("poller create destroy", "[poller]") { zmq::poller_t<> poller; } @@ -15,20 +15,20 @@ static_assert(!std::is_copy_constructible>::value, static_assert(!std::is_copy_assignable>::value, "poller_t should not be copy-assignable"); -TEST(poller, move_construct_empty) +TEST_CASE("poller move construct empty", "[poller]") { zmq::poller_t<> a; zmq::poller_t<> b = std::move(a); } -TEST(poller, move_assign_empty) +TEST_CASE("poller move assign empty", "[poller]") { zmq::poller_t<> a; zmq::poller_t<> b; b = std::move(a); } -TEST(poller, move_construct_non_empty) +TEST_CASE("poller move construct non empty", "[poller]") { zmq::context_t context; zmq::socket_t socket{context, zmq::socket_type::router}; @@ -38,7 +38,7 @@ TEST(poller, move_construct_non_empty) zmq::poller_t<> b = std::move(a); } -TEST(poller, move_assign_non_empty) +TEST_CASE("poller move assign non empty", "[poller]") { zmq::context_t context; zmq::socket_t socket{context, zmq::socket_type::router}; @@ -49,24 +49,24 @@ TEST(poller, move_assign_non_empty) b = std::move(a); } -TEST(poller, add_nullptr) +TEST_CASE("poller add nullptr", "[poller]") { zmq::context_t context; zmq::socket_t socket{context, zmq::socket_type::router}; zmq::poller_t<> poller; - ASSERT_NO_THROW(poller.add(socket, ZMQ_POLLIN, nullptr)); + CHECK_NOTHROW(poller.add(socket, ZMQ_POLLIN, nullptr)); } -TEST(poller, add_non_nullptr) +TEST_CASE("poller add non nullptr", "[poller]") { zmq::context_t context; zmq::socket_t socket{context, zmq::socket_type::router}; zmq::poller_t<> poller; int i; - ASSERT_NO_THROW(poller.add(socket, ZMQ_POLLIN, &i)); + CHECK_NOTHROW(poller.add(socket, ZMQ_POLLIN, &i)); } -TEST(poller, add_handler_invalid_events_type) +TEST_CASE("poller add handler invalid events type", "[poller]") { /// \todo is it good that this is accepted? should probably already be /// checked by zmq_poller_add/modify in libzmq: @@ -75,195 +75,196 @@ TEST(poller, add_handler_invalid_events_type) zmq::socket_t socket{context, zmq::socket_type::router}; zmq::poller_t<> poller; short invalid_events_type = 2 << 10; - ASSERT_NO_THROW(poller.add(socket, invalid_events_type, nullptr)); + CHECK_NOTHROW(poller.add(socket, invalid_events_type, nullptr)); } -TEST(poller, add_handler_twice_throws) +TEST_CASE("poller add handler twice throws", "[poller]") { zmq::context_t context; zmq::socket_t socket{context, zmq::socket_type::router}; zmq::poller_t<> poller; poller.add(socket, ZMQ_POLLIN, nullptr); /// \todo the actual error code should be checked - ASSERT_THROW(poller.add(socket, ZMQ_POLLIN, nullptr), zmq::error_t); + CHECK_THROWS_AS(poller.add(socket, ZMQ_POLLIN, nullptr), zmq::error_t); } -TEST(poller, wait_with_no_handlers_throws) +TEST_CASE("poller wait with no handlers throws", "[poller]") { zmq::poller_t<> poller; std::vector events; /// \todo the actual error code should be checked - ASSERT_THROW(poller.wait_all(events, std::chrono::milliseconds{10}), + CHECK_THROWS_AS(poller.wait_all(events, std::chrono::milliseconds{10}), zmq::error_t); } -TEST(poller, remove_unregistered_throws) +TEST_CASE("poller remove unregistered throws", "[poller]") { zmq::context_t context; zmq::socket_t socket{context, zmq::socket_type::router}; zmq::poller_t<> poller; /// \todo the actual error code should be checked - ASSERT_THROW(poller.remove(socket), zmq::error_t); + CHECK_THROWS_AS(poller.remove(socket), zmq::error_t); } -TEST(poller, remove_registered_empty) +TEST_CASE("poller remove registered empty", "[poller]") { zmq::context_t context; zmq::socket_t socket{context, zmq::socket_type::router}; zmq::poller_t<> poller; poller.add(socket, ZMQ_POLLIN, nullptr); - ASSERT_NO_THROW(poller.remove(socket)); + CHECK_NOTHROW(poller.remove(socket)); } -TEST(poller, remove_registered_non_empty) +TEST_CASE("poller remove registered non empty", "[poller]") { zmq::context_t context; zmq::socket_t socket{context, zmq::socket_type::router}; zmq::poller_t<> poller; - poller.add(socket, ZMQ_POLLIN, nullptr); - ASSERT_NO_THROW(poller.remove(socket)); + int empty{}; + poller.add(socket, ZMQ_POLLIN, &empty); + CHECK_NOTHROW(poller.remove(socket)); } -TEST(poller, poll_basic) +TEST_CASE("poller poll basic", "[poller]") { common_server_client_setup s; - ASSERT_NO_THROW(s.client.send(zmq::message_t{"Hi"})); + CHECK_NOTHROW(s.client.send(zmq::message_t{"Hi"})); zmq::poller_t poller; std::vector events{1}; int i = 0; - ASSERT_NO_THROW(poller.add(s.server, ZMQ_POLLIN, &i)); - ASSERT_EQ(1, poller.wait_all(events, std::chrono::milliseconds{-1})); - ASSERT_EQ(s.server, events[0].socket); - ASSERT_EQ(&i, events[0].user_data); + CHECK_NOTHROW(poller.add(s.server, ZMQ_POLLIN, &i)); + CHECK(1 == poller.wait_all(events, std::chrono::milliseconds{-1})); + CHECK(s.server == events[0].socket); + CHECK(&i == events[0].user_data); } -TEST(poller, add_invalid_socket_throws) +TEST_CASE("poller add invalid socket throws", "[poller]") { zmq::context_t context; zmq::poller_t<> poller; zmq::socket_t a{context, zmq::socket_type::router}; zmq::socket_t b{std::move(a)}; - ASSERT_THROW(poller.add(a, ZMQ_POLLIN, nullptr), zmq::error_t); + CHECK_THROWS_AS(poller.add(a, ZMQ_POLLIN, nullptr), zmq::error_t); } -TEST(poller, remove_invalid_socket_throws) +TEST_CASE("poller remove invalid socket throws", "[poller]") { zmq::context_t context; zmq::socket_t socket{context, zmq::socket_type::router}; zmq::poller_t<> poller; - ASSERT_NO_THROW(poller.add(socket, ZMQ_POLLIN, nullptr)); + CHECK_NOTHROW(poller.add(socket, ZMQ_POLLIN, nullptr)); std::vector sockets; sockets.emplace_back(std::move(socket)); - ASSERT_THROW(poller.remove(socket), zmq::error_t); - ASSERT_NO_THROW(poller.remove(sockets[0])); + CHECK_THROWS_AS(poller.remove(socket), zmq::error_t); + CHECK_NOTHROW(poller.remove(sockets[0])); } -TEST(poller, modify_empty_throws) +TEST_CASE("poller modify empty throws", "[poller]") { zmq::context_t context; zmq::socket_t socket{context, zmq::socket_type::push}; zmq::poller_t<> poller; - ASSERT_THROW(poller.modify(socket, ZMQ_POLLIN), zmq::error_t); + CHECK_THROWS_AS(poller.modify(socket, ZMQ_POLLIN), zmq::error_t); } -TEST(poller, modify_invalid_socket_throws) +TEST_CASE("poller modify invalid socket throws", "[poller]") { zmq::context_t context; zmq::socket_t a{context, zmq::socket_type::push}; zmq::socket_t b{std::move(a)}; zmq::poller_t<> poller; - ASSERT_THROW(poller.modify(a, ZMQ_POLLIN), zmq::error_t); + CHECK_THROWS_AS(poller.modify(a, ZMQ_POLLIN), zmq::error_t); } -TEST(poller, modify_not_added_throws) +TEST_CASE("poller modify not added throws", "[poller]") { zmq::context_t context; zmq::socket_t a{context, zmq::socket_type::push}; zmq::socket_t b{context, zmq::socket_type::push}; zmq::poller_t<> poller; - ASSERT_NO_THROW(poller.add(a, ZMQ_POLLIN, nullptr)); - ASSERT_THROW(poller.modify(b, ZMQ_POLLIN), zmq::error_t); + CHECK_NOTHROW(poller.add(a, ZMQ_POLLIN, nullptr)); + CHECK_THROWS_AS(poller.modify(b, ZMQ_POLLIN), zmq::error_t); } -TEST(poller, modify_simple) +TEST_CASE("poller modify simple", "[poller]") { zmq::context_t context; zmq::socket_t a{context, zmq::socket_type::push}; zmq::poller_t<> poller; - ASSERT_NO_THROW(poller.add(a, ZMQ_POLLIN, nullptr)); - ASSERT_NO_THROW(poller.modify(a, ZMQ_POLLIN | ZMQ_POLLOUT)); + CHECK_NOTHROW(poller.add(a, ZMQ_POLLIN, nullptr)); + CHECK_NOTHROW(poller.modify(a, ZMQ_POLLIN | ZMQ_POLLOUT)); } -TEST(poller, poll_client_server) +TEST_CASE("poller poll client server", "[poller]") { // Setup server and client common_server_client_setup s; // Setup poller zmq::poller_t<> poller; - ASSERT_NO_THROW(poller.add(s.server, ZMQ_POLLIN, s.server)); + CHECK_NOTHROW(poller.add(s.server, ZMQ_POLLIN, s.server)); // client sends message - ASSERT_NO_THROW(s.client.send(zmq::message_t{"Hi"})); + CHECK_NOTHROW(s.client.send(zmq::message_t{"Hi"})); // wait for message and verify events std::vector events(1); - ASSERT_EQ(1, poller.wait_all(events, std::chrono::milliseconds{500})); - ASSERT_EQ(ZMQ_POLLIN, events[0].events); + CHECK(1 == poller.wait_all(events, std::chrono::milliseconds{500})); + CHECK(ZMQ_POLLIN == events[0].events); // Modify server socket with pollout flag - ASSERT_NO_THROW(poller.modify(s.server, ZMQ_POLLIN | ZMQ_POLLOUT)); - ASSERT_EQ(1, poller.wait_all(events, std::chrono::milliseconds{500})); - ASSERT_EQ(ZMQ_POLLIN | ZMQ_POLLOUT, events[0].events); + CHECK_NOTHROW(poller.modify(s.server, ZMQ_POLLIN | ZMQ_POLLOUT)); + CHECK(1 == poller.wait_all(events, std::chrono::milliseconds{500})); + CHECK((ZMQ_POLLIN | ZMQ_POLLOUT) == events[0].events); } -TEST(poller, wait_one_return) +TEST_CASE("poller wait one return", "[poller]") { // Setup server and client common_server_client_setup s; // Setup poller zmq::poller_t<> poller; - ASSERT_NO_THROW(poller.add(s.server, ZMQ_POLLIN, nullptr)); + CHECK_NOTHROW(poller.add(s.server, ZMQ_POLLIN, nullptr)); // client sends message - ASSERT_NO_THROW(s.client.send(zmq::message_t{"Hi"})); + CHECK_NOTHROW(s.client.send(zmq::message_t{"Hi"})); // wait for message and verify events std::vector events(1); - ASSERT_EQ(1, poller.wait_all(events, std::chrono::milliseconds{500})); + CHECK(1 == poller.wait_all(events, std::chrono::milliseconds{500})); } -TEST(poller, wait_on_move_constructed_poller) +TEST_CASE("poller wait on move constructed", "[poller]") { common_server_client_setup s; - ASSERT_NO_THROW(s.client.send(zmq::message_t{"Hi"})); + CHECK_NOTHROW(s.client.send(zmq::message_t{"Hi"})); zmq::poller_t<> a; - ASSERT_NO_THROW(a.add(s.server, ZMQ_POLLIN, nullptr)); + CHECK_NOTHROW(a.add(s.server, ZMQ_POLLIN, nullptr)); zmq::poller_t<> b{std::move(a)}; std::vector events(1); /// \todo the actual error code should be checked - ASSERT_THROW(a.wait_all(events, std::chrono::milliseconds{10}), zmq::error_t); - ASSERT_EQ(1, b.wait_all(events, std::chrono::milliseconds{-1})); + CHECK_THROWS_AS(a.wait_all(events, std::chrono::milliseconds{10}), zmq::error_t); + CHECK(1 == b.wait_all(events, std::chrono::milliseconds{-1})); } -TEST(poller, wait_on_move_assigned_poller) +TEST_CASE("poller wait on move assigned", "[poller]") { common_server_client_setup s; - ASSERT_NO_THROW(s.client.send(zmq::message_t{"Hi"})); + CHECK_NOTHROW(s.client.send(zmq::message_t{"Hi"})); zmq::poller_t<> a; - ASSERT_NO_THROW(a.add(s.server, ZMQ_POLLIN, nullptr)); + CHECK_NOTHROW(a.add(s.server, ZMQ_POLLIN, nullptr)); zmq::poller_t<> b; b = {std::move(a)}; - /// \todo the actual error code should be checked + /// \todo the TEST_CASE error code should be checked std::vector events(1); - ASSERT_THROW(a.wait_all(events, std::chrono::milliseconds{10}), zmq::error_t); - ASSERT_EQ(1, b.wait_all(events, std::chrono::milliseconds{-1})); + CHECK_THROWS_AS(a.wait_all(events, std::chrono::milliseconds{10}), zmq::error_t); + CHECK(1 == b.wait_all(events, std::chrono::milliseconds{-1})); } -TEST(poller, remove_from_handler) +TEST_CASE("poller remove from handler", "[poller]") { constexpr auto ITER_NO = 10; @@ -275,11 +276,11 @@ TEST(poller, remove_from_handler) // Setup poller zmq::poller_t<> poller; for (auto i = 0; i < ITER_NO; ++i) { - ASSERT_NO_THROW(poller.add(setup_list[i].server, ZMQ_POLLIN, nullptr)); + CHECK_NOTHROW(poller.add(setup_list[i].server, ZMQ_POLLIN, nullptr)); } // Clients send messages for (auto &s : setup_list) { - ASSERT_NO_THROW(s.client.send(zmq::message_t{"Hi"})); + CHECK_NOTHROW(s.client.send(zmq::message_t{"Hi"})); } // Wait for all servers to receive a message @@ -290,7 +291,7 @@ TEST(poller, remove_from_handler) // Fire all handlers in one wait std::vector events(ITER_NO); - ASSERT_EQ(ITER_NO, poller.wait_all(events, std::chrono::milliseconds{-1})); + CHECK(ITER_NO == poller.wait_all(events, std::chrono::milliseconds{-1})); } #endif diff --git a/tests/socket.cpp b/tests/socket.cpp index c3cf9bc..b907e06 100644 --- a/tests/socket.cpp +++ b/tests/socket.cpp @@ -1,29 +1,29 @@ -#include +#include #include -TEST(socket, create_destroy) +TEST_CASE("socket create destroy", "[socket]") { zmq::context_t context; zmq::socket_t socket(context, ZMQ_ROUTER); } #ifdef ZMQ_CPP11 -TEST(socket, create_by_enum_destroy) +TEST_CASE("socket create by enum and destroy", "[socket]") { zmq::context_t context; zmq::socket_t socket(context, zmq::socket_type::router); } #endif -TEST(socket, send_receive_const_buffer) +TEST_CASE("socket sends and receives const buffer", "[socket]") { zmq::context_t context; zmq::socket_t sender(context, ZMQ_PAIR); zmq::socket_t receiver(context, ZMQ_PAIR); receiver.bind("inproc://test"); sender.connect("inproc://test"); - ASSERT_EQ(2, sender.send("Hi", 2)); + CHECK(2 == sender.send("Hi", 2)); char buf[2]; - ASSERT_EQ(2, receiver.recv(buf, 2)); - ASSERT_EQ(0, memcmp(buf, "Hi", 2)); + CHECK(2 == receiver.recv(buf, 2)); + CHECK(0 == memcmp(buf, "Hi", 2)); } diff --git a/tests/testutil.hpp b/tests/testutil.hpp index 0a3d644..dc7ce9f 100644 --- a/tests/testutil.hpp +++ b/tests/testutil.hpp @@ -1,6 +1,6 @@ #pragma once -#include +#include #include #if defined(ZMQ_CPP11) @@ -18,12 +18,12 @@ class loopback_ip4_binder // and constructor/destructor are not. void bind(zmq::socket_t &socket) { - ASSERT_NO_THROW(socket.bind("tcp://127.0.0.1:*")); + REQUIRE_NOTHROW(socket.bind("tcp://127.0.0.1:*")); std::array endpoint{}; size_t endpoint_size = endpoint.size(); - ASSERT_NO_THROW( + REQUIRE_NOTHROW( socket.getsockopt(ZMQ_LAST_ENDPOINT, endpoint.data(), &endpoint_size)); - ASSERT_TRUE(endpoint_size < endpoint.size()); + REQUIRE(endpoint_size < endpoint.size()); endpoint_ = std::string{endpoint.data()}; } std::string endpoint_; @@ -40,7 +40,7 @@ struct common_server_client_setup void init() { endpoint = loopback_ip4_binder{server}.endpoint(); - ASSERT_NO_THROW(client.connect(endpoint)); + REQUIRE_NOTHROW(client.connect(endpoint)); } zmq::context_t context; diff --git a/zmq.hpp b/zmq.hpp index c73e89e..38926d8 100644 --- a/zmq.hpp +++ b/zmq.hpp @@ -34,18 +34,16 @@ #define ZMQ_DEPRECATED(msg) __attribute__((deprecated(msg))) #endif -#if (__cplusplus >= 201103L) -#define ZMQ_CPP11 -#define ZMQ_NOTHROW noexcept -#define ZMQ_EXPLICIT explicit -#elif (defined(_MSC_VER) && (_MSC_VER >= 1900)) +#if (__cplusplus >= 201103L) || (defined(_MSC_VER) && (_MSC_VER >= 1900)) #define ZMQ_CPP11 #define ZMQ_NOTHROW noexcept #define ZMQ_EXPLICIT explicit +#define ZMQ_OVERRIDE override #else #define ZMQ_CPP03 #define ZMQ_NOTHROW #define ZMQ_EXPLICIT +#define ZMQ_OVERRIDE #endif #include