feedc0de/boost_mqtt5
1
0
Fork 0
forked from boostorg/mqtt5
Code Pull Requests Activity

Consistently use BOOST_TEST instead of BOOST_CHECK in tests

Browse Source 
Summary:
related to T13767
We used BOOST_CHECK in older tests and BOOST_TEST macro in newer tests.
Now we use BOOST_TEST consistently.

Reviewers: ivica!

Subscribers: iljazovic, miljen

Differential Revision: https://repo.mireo.local/D31701
This commit is contained in:
Korina Šimičević
2024-10-07 10:01:27 +02:00
parent 4cbae1056b
commit 0e62d8f8b3
16 changed files with 308 additions and 370 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
README.md
View File

@@ -43,7 +43,7 @@ Using the library
1. Download [Boost](https://www.boost.org/users/download/), and add it to your include path. 1. Download [Boost](https://www.boost.org/users/download/), and add it to your include path.
2. If you use SSL, download [OpenSSL](https://www.openssl.org/), link the library and add it to your include path. 2. If you use SSL, download [OpenSSL](https://www.openssl.org/), link the library and add it to your include path.
3. Additionally, you can add Async.MQTT5's `include` folder to your include path. 3. Add Async.MQTT5's `include` folder to your include path.
You can compile the example below with the following command line on Linux: You can compile the example below with the following command line on Linux:

23
example/hello_world_over_websocket_tls.cpp
View File

@@ -14,29 +14,10 @@
#include <boost/asio/ip/tcp.hpp> #include <boost/asio/ip/tcp.hpp>
#include <boost/beast/websocket.hpp> #include <boost/beast/websocket.hpp>
#include <boost/beast/ssl/ssl_stream.hpp> // async_teardown specialization for websocket ssl stream
#include <async_mqtt5.hpp> #include <async_mqtt5.hpp>
namespace boost::beast::websocket {
// boost::beast::websocket::async_teardown is a free function designed to initiate the asynchronous teardown of a connection.
// The specific behaviour of this function is based on the NextLayer type (Socket type) used to create the ``__WEBSOCKET_STREAM__``.
// ``__Beast__`` library includes an implementation of this function for ``__TCP_SOCKET__``.
// However, the callers are responsible for providing a suitable overload of this function for any other type,
// such as ``__SSL_STREAM__`` as shown in this example.
// See ``__BEAST_ASYNC_TEARDOWN__`` for more information.
template <typename TeardownHandler>
void async_teardown(
boost::beast::role_type role,
asio::ssl::stream<asio::ip::tcp::socket>& stream,
TeardownHandler&& handler
) {
return stream.async_shutdown(std::forward<TeardownHandler>(handler));
}
} // end namespace boost::beast::websocket
// External customization point. // External customization point.
namespace async_mqtt5 { namespace async_mqtt5 {
@@ -51,7 +32,7 @@ struct tls_handshake_type<boost::asio::ssl::stream<StreamBase>> {
template <typename StreamBase> template <typename StreamBase>
void assign_tls_sni( void assign_tls_sni(
const authority_path& ap, const authority_path& ap,
boost::asio::ssl::context& ctx, boost::asio::ssl::context& /*ctx*/,
boost::asio::ssl::stream<StreamBase>& stream boost::asio::ssl::stream<StreamBase>& stream
) { ) {
SSL_set_tlsext_host_name(stream.native_handle(), ap.host.c_str()); SSL_set_tlsext_host_name(stream.native_handle(), ap.host.c_str());

28
test/include/test_common/protocol_logging.hpp
View File

@@ -1,28 +0,0 @@
//
// Copyright (c) 2023-2024 Ivica Siladic, Bruno Iljazovic, Korina Simicevic
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE or copy at http://www.boost.org/LICENSE_1_0.txt)
//
#ifndef ASYNC_MQTT5_TEST_PROTOCOL_LOGGING_HPP
#define ASYNC_MQTT5_TEST_PROTOCOL_LOGGING_HPP
#include <string>
namespace async_mqtt5::test {
inline bool& logging_enabled() {
static bool enabled = false;
return enabled;
}
inline void log(const std::string& message) {
if (logging_enabled())
fprintf(stderr, "%s\n", message.c_str());
}
} // end namespace async_mqtt5::test
#endif // ASYNC_MQTT5_TEST_PROTOCOL_LOGGING_HPP

29
test/include/test_common/test_broker.hpp
View File

@@ -8,6 +8,12 @@
#ifndef ASYNC_MQTT5_TEST_TEST_BROKER_HPP #ifndef ASYNC_MQTT5_TEST_TEST_BROKER_HPP
#define ASYNC_MQTT5_TEST_TEST_BROKER_HPP #define ASYNC_MQTT5_TEST_TEST_BROKER_HPP
#include <boost/test/unit_test.hpp>
#include <boost/test/tools/interface.hpp>
#include <algorithm>
#include <cstdint>
#include <deque>
#include <memory> #include <memory>
#include <numeric> #include <numeric>
#include <string> #include <string>
@@ -17,18 +23,21 @@
#include <boost/asio/any_completion_handler.hpp> #include <boost/asio/any_completion_handler.hpp>
#include <boost/asio/any_io_executor.hpp> #include <boost/asio/any_io_executor.hpp>
#include <boost/asio/async_result.hpp>
#include <boost/asio/buffer.hpp>
#include <boost/asio/cancellation_signal.hpp> #include <boost/asio/cancellation_signal.hpp>
#include <boost/asio/dispatch.hpp>
#include <boost/asio/execution_context.hpp>
#include <boost/asio/post.hpp> #include <boost/asio/post.hpp>
#include <boost/asio/prepend.hpp> #include <boost/asio/prepend.hpp>
#include <boost/asio/ip/tcp.hpp> #include <boost/asio/ip/tcp.hpp>
#include <boost/system/error_code.hpp>
#include <async_mqtt5/types.hpp>
#include <async_mqtt5/impl/codecs/message_decoders.hpp> #include <async_mqtt5/impl/codecs/message_decoders.hpp>
#include "test_common/message_exchange.hpp" #include "test_common/message_exchange.hpp"
#include "test_common/packet_util.hpp" #include "test_common/packet_util.hpp"
#include "test_common/protocol_logging.hpp"
namespace async_mqtt5::test { namespace async_mqtt5::test {
@@ -157,16 +166,15 @@ public:
size_t buffers_size = std::distance( size_t buffers_size = std::distance(
asio::buffer_sequence_begin(buffers), asio::buffer_sequence_end(buffers) asio::buffer_sequence_begin(buffers), asio::buffer_sequence_end(buffers)
); );
BOOST_CHECK_EQUAL(buffers_size, expected.size()); BOOST_TEST(buffers_size == expected.size());
size_t num_packets = std::min(buffers_size, expected.size()); size_t num_packets = std::min(buffers_size, expected.size());
auto it = asio::buffer_sequence_begin(buffers); auto it = asio::buffer_sequence_begin(buffers);
for (size_t i = 0; i < num_packets; ++i, ++it) { for (size_t i = 0; i < num_packets; ++i, ++it) {
BOOST_CHECK_EQUAL(it->size(), expected[i].size()); BOOST_TEST(it->size() == expected[i].size());
size_t len = std::min(it->size(), expected[i].size()); size_t len = std::min(it->size(), expected[i].size());
if (memcmp(it->data(), expected[i].data(), len)) if (memcmp(it->data(), expected[i].data(), len))
BOOST_CHECK_MESSAGE( BOOST_TEST_MESSAGE(
false,
concat_strings( concat_strings(
"Packet mismatch!\nExpected: ", "Packet mismatch!\nExpected: ",
to_readable_packet(expected[i]), to_readable_packet(expected[i]),
@@ -176,12 +184,9 @@ public:
); );
} }
} else } else
BOOST_CHECK_MESSAGE( BOOST_TEST_MESSAGE(
false, "Broker side did not expect: " <<
concat_strings(
"Broker side did not expect: ",
boost::algorithm::join(to_readable_packets(buffers), ",") boost::algorithm::join(to_readable_packets(buffers), ",")
)
); );
auto complete_op = reply_action ? auto complete_op = reply_action ?

1
test/integration/async_sender.cpp
View File

@@ -15,6 +15,7 @@
#include <boost/asio/io_context.hpp> #include <boost/asio/io_context.hpp>
#include <boost/asio/steady_timer.hpp> #include <boost/asio/steady_timer.hpp>
#include <boost/asio/detached.hpp>
#include <async_mqtt5/mqtt_client.hpp> #include <async_mqtt5/mqtt_client.hpp>
#include <async_mqtt5/types.hpp> #include <async_mqtt5/types.hpp>

14
test/integration/client.cpp
View File

@@ -20,24 +20,12 @@
#include <boost/asio/ssl.hpp> #include <boost/asio/ssl.hpp>
#include <boost/beast/websocket.hpp> #include <boost/beast/websocket.hpp>
#include <boost/beast/ssl/ssl_stream.hpp> // async_teardown specialization for websocket ssl stream
#include <boost/system/error_code.hpp> #include <boost/system/error_code.hpp>
#include <async_mqtt5.hpp> #include <async_mqtt5.hpp>
namespace boost::beast::websocket {
template <typename TeardownHandler>
void async_teardown(
boost::beast::role_type /* role */,
asio::ssl::stream<asio::ip::tcp::socket>& stream,
TeardownHandler&& handler
) {
return stream.async_shutdown(std::forward<TeardownHandler>(handler));
}
} // end namespace boost::beast::websocket
namespace async_mqtt5 { namespace async_mqtt5 {
template <typename StreamBase> template <typename StreamBase>

2
test/integration/ping.cpp
View File

@@ -81,7 +81,7 @@ void run_test(
}); });
ioc.run(); ioc.run();
BOOST_CHECK(broker.received_all_expected()); BOOST_TEST(broker.received_all_expected());
} }
BOOST_FIXTURE_TEST_CASE(ping_pong_client_ka, shared_test_data) { BOOST_FIXTURE_TEST_CASE(ping_pong_client_ka, shared_test_data) {

2
test/integration/re_authentication.cpp
View File

@@ -99,7 +99,7 @@ void run_test(
}); });
ioc.run(); ioc.run();
BOOST_CHECK(broker.received_all_expected()); BOOST_TEST(broker.received_all_expected());
} }
BOOST_FIXTURE_TEST_CASE(successful_re_auth, shared_test_data) { BOOST_FIXTURE_TEST_CASE(successful_re_auth, shared_test_data) {

32
test/integration/sub_unsub.cpp
View File

@@ -93,9 +93,9 @@ void run_test(test::msg_exchange broker_side) {
[&handlers_called, &c](error_code ec, std::vector<reason_code> rcs, suback_props) { [&handlers_called, &c](error_code ec, std::vector<reason_code> rcs, suback_props) {
++handlers_called; ++handlers_called;
BOOST_CHECK(!ec); BOOST_TEST(!ec);
BOOST_ASSERT(rcs.size() == 1); BOOST_TEST_REQUIRE(rcs.size() == 1);
BOOST_CHECK_EQUAL(rcs[0], reason_codes::granted_qos_0); BOOST_TEST(rcs[0] == reason_codes::granted_qos_0);
c.cancel(); c.cancel();
} }
@@ -106,17 +106,17 @@ void run_test(test::msg_exchange broker_side) {
[&handlers_called, &c](error_code ec, std::vector<reason_code> rcs, unsuback_props) { [&handlers_called, &c](error_code ec, std::vector<reason_code> rcs, unsuback_props) {
++handlers_called; ++handlers_called;
BOOST_CHECK(!ec); BOOST_TEST(!ec);
BOOST_ASSERT(rcs.size() == 1); BOOST_TEST_REQUIRE(rcs.size() == 1);
BOOST_CHECK_EQUAL(rcs[0], reason_codes::success); BOOST_TEST(rcs[0] == reason_codes::success);
c.cancel(); c.cancel();
} }
); );
ioc.run_for(5s); ioc.run_for(5s);
BOOST_CHECK_EQUAL(handlers_called, expected_handlers_called); BOOST_TEST(handlers_called == expected_handlers_called);
BOOST_CHECK(broker.received_all_expected()); BOOST_TEST(broker.received_all_expected());
} }
// subscribe // subscribe
@@ -423,9 +423,9 @@ void run_cancellation_test(test::msg_exchange broker_side) {
[&handlers_called, &c](error_code ec, std::vector<reason_code> rcs, suback_props) { [&handlers_called, &c](error_code ec, std::vector<reason_code> rcs, suback_props) {
++handlers_called; ++handlers_called;
BOOST_CHECK(ec == asio::error::operation_aborted); BOOST_TEST(ec == asio::error::operation_aborted);
BOOST_ASSERT(rcs.size() == 1); BOOST_TEST_REQUIRE(rcs.size() == 1);
BOOST_CHECK_EQUAL(rcs[0], reason_codes::empty); BOOST_TEST(rcs[0] == reason_codes::empty);
c.cancel(); c.cancel();
} }
@@ -439,9 +439,9 @@ void run_cancellation_test(test::msg_exchange broker_side) {
[&handlers_called, &c](error_code ec, std::vector<reason_code> rcs, unsuback_props) { [&handlers_called, &c](error_code ec, std::vector<reason_code> rcs, unsuback_props) {
++handlers_called; ++handlers_called;
BOOST_CHECK(ec == asio::error::operation_aborted); BOOST_TEST(ec == asio::error::operation_aborted);
BOOST_ASSERT(rcs.size() == 1); BOOST_TEST_REQUIRE(rcs.size() == 1);
BOOST_CHECK_EQUAL(rcs[0], reason_codes::empty); BOOST_TEST(rcs[0] == reason_codes::empty);
c.cancel(); c.cancel();
} }
@@ -451,8 +451,8 @@ void run_cancellation_test(test::msg_exchange broker_side) {
cancel_signal.emit(asio::cancellation_type::total); cancel_signal.emit(asio::cancellation_type::total);
ioc.run_for(2s); ioc.run_for(2s);
BOOST_CHECK_EQUAL(handlers_called, expected_handlers_called); BOOST_TEST(handlers_called == expected_handlers_called);
BOOST_CHECK(broker.received_all_expected()); BOOST_TEST(broker.received_all_expected());
} }
BOOST_FIXTURE_TEST_CASE(cancel_resending_subscribe, shared_test_data) { BOOST_FIXTURE_TEST_CASE(cancel_resending_subscribe, shared_test_data) {

3
test/src/run_tests.cpp
View File

@@ -9,12 +9,9 @@
#include <boost/test/included/unit_test.hpp> #include <boost/test/included/unit_test.hpp>
#include <test_common/protocol_logging.hpp>
boost::unit_test::test_suite* init_tests( boost::unit_test::test_suite* init_tests(
int /*argc*/, char* /*argv*/[] int /*argc*/, char* /*argv*/[]
) { ) {
async_mqtt5::test::logging_enabled() = false;
return nullptr; return nullptr;
} }

6
test/unit/connect_op.cpp
View File

@@ -69,8 +69,8 @@ void run_unit_test(
).perform(eps, ap); ).perform(eps, ap);
ioc.run_for(1s); ioc.run_for(1s);
BOOST_CHECK_EQUAL(handlers_called, expected_handlers_called); BOOST_TEST(handlers_called == expected_handlers_called);
BOOST_CHECK(broker.received_all_expected()); BOOST_TEST(broker.received_all_expected());
} }
void run_unit_test( void run_unit_test(
@@ -121,7 +121,7 @@ BOOST_FIXTURE_TEST_CASE(fail_to_send_connect, shared_test_data) {
.complete_with(fail, after(2ms)); .complete_with(fail, after(2ms));
auto handler = [&](error_code ec) { auto handler = [&](error_code ec) {
BOOST_CHECK(ec == fail); BOOST_TEST(ec == fail);
}; };
run_unit_test(std::move(broker_side), std::move(handler)); run_unit_test(std::move(broker_side), std::move(handler));

429
test/unit/serialization.cpp
View File

@@ -83,51 +83,51 @@ BOOST_AUTO_TEST_CASE(test_connect) {
byte_citer it = msg.cbegin(), last = msg.cend(); byte_citer it = msg.cbegin(), last = msg.cend();
auto header = decoders::decode_fixed_header(it, last); auto header = decoders::decode_fixed_header(it, last);
BOOST_ASSERT(header); BOOST_TEST_REQUIRE(header.has_value());
const auto& [control_byte, remain_length] = *header; const auto& [control_byte, remain_length] = *header;
auto rv = decoders::decode_connect(remain_length, it); auto rv = decoders::decode_connect(remain_length, it);
BOOST_ASSERT(rv); BOOST_TEST_REQUIRE(rv.has_value());
const auto& [client_id_, uname_, password_, keep_alive_, clean_start_, cprops_, w_] = *rv; const auto& [client_id_, uname_, password_, keep_alive_, clean_start_, cprops_, w_] = *rv;
BOOST_CHECK_EQUAL(client_id_, client_id); BOOST_TEST(client_id_ == client_id);
BOOST_CHECK(uname_); BOOST_TEST_REQUIRE(uname_.has_value());
BOOST_CHECK_EQUAL(*uname_, uname); BOOST_TEST(*uname_ == uname);
BOOST_CHECK(password_ == password); BOOST_CHECK(password_ == password);
BOOST_CHECK_EQUAL(keep_alive_, keep_alive); BOOST_TEST(keep_alive_ == keep_alive);
BOOST_CHECK_EQUAL(clean_start_, clean_start); BOOST_TEST(clean_start_ == clean_start);
cprops_.visit([](const auto& prop, const auto&) { cprops_.visit([](const auto& prop, const auto&) {
(void)prop; BOOST_ASSERT(prop); (void)prop; BOOST_TEST_REQUIRE(prop);
return true; return true;
}); });
BOOST_CHECK_EQUAL(*cprops_[prop::session_expiry_interval], session_expiry_interval); BOOST_TEST(*cprops_[prop::session_expiry_interval] == session_expiry_interval);
BOOST_CHECK_EQUAL(*cprops_[prop::receive_maximum], receive_max); BOOST_TEST(*cprops_[prop::receive_maximum] == receive_max);
BOOST_CHECK_EQUAL(*cprops_[prop::maximum_packet_size], maximum_packet_size); BOOST_TEST(*cprops_[prop::maximum_packet_size] == maximum_packet_size);
BOOST_CHECK_EQUAL(*cprops_[prop::topic_alias_maximum], topic_alias_max); BOOST_TEST(*cprops_[prop::topic_alias_maximum] == topic_alias_max);
BOOST_CHECK_EQUAL(*cprops_[prop::request_response_information], request_response_information); BOOST_TEST(*cprops_[prop::request_response_information] == request_response_information);
BOOST_CHECK_EQUAL(*cprops_[prop::request_problem_information], request_problem_information); BOOST_TEST(*cprops_[prop::request_problem_information] == request_problem_information);
BOOST_ASSERT(cprops_[prop::user_property].size() == 1); BOOST_TEST_REQUIRE(cprops_[prop::user_property].size() == 1);
BOOST_CHECK_EQUAL(cprops_[prop::user_property][0].first, user_property_1); BOOST_TEST(cprops_[prop::user_property][0].first == user_property_1);
BOOST_CHECK_EQUAL(cprops_[prop::user_property][0].second, user_property_2); BOOST_TEST(cprops_[prop::user_property][0].second == user_property_2);
BOOST_CHECK_EQUAL(*cprops_[prop::authentication_method], auth_method); BOOST_TEST(*cprops_[prop::authentication_method] == auth_method);
BOOST_CHECK_EQUAL(*cprops_[prop::authentication_data], auth_data); BOOST_TEST(*cprops_[prop::authentication_data] == auth_data);
BOOST_CHECK(w_); BOOST_TEST_REQUIRE(w_.has_value());
const auto& will = *w_;
BOOST_TEST((will).topic() == will_topic);
BOOST_TEST((will).message() == will_message);
BOOST_CHECK_EQUAL((*w_).topic(), will_topic); (will).visit([](const auto& p, const auto&) { (void)p; BOOST_TEST_REQUIRE(p); return true; });
BOOST_CHECK_EQUAL((*w_).message(), will_message); BOOST_TEST(*(will)[prop::will_delay_interval] == will_delay_interval);
BOOST_TEST(*(will)[prop::payload_format_indicator] == will_payload_format_indicator);
(*w_).visit([](const auto& p, const auto&) { (void)p; BOOST_ASSERT(p); return true; }); BOOST_TEST(*(will)[prop::message_expiry_interval] == will_message_expiry_interval);
BOOST_CHECK_EQUAL(*(*w_)[prop::will_delay_interval], will_delay_interval); BOOST_TEST(*(will)[prop::content_type] == will_content_type);
BOOST_CHECK_EQUAL(*(*w_)[prop::payload_format_indicator], will_payload_format_indicator); BOOST_TEST(*(will)[prop::response_topic] == will_response_topic);
BOOST_CHECK_EQUAL(*(*w_)[prop::message_expiry_interval], will_message_expiry_interval); BOOST_TEST(*(will)[prop::correlation_data] == will_correlation_data);
BOOST_CHECK_EQUAL(*(*w_)[prop::content_type], will_content_type); BOOST_TEST_REQUIRE((will)[prop::user_property].size() == 1);
BOOST_CHECK_EQUAL(*(*w_)[prop::response_topic], will_response_topic); BOOST_TEST((will)[prop::user_property][0].first == will_user_property_1);
BOOST_CHECK_EQUAL(*(*w_)[prop::correlation_data], will_correlation_data); BOOST_TEST((will)[prop::user_property][0].second == will_user_property_2);
BOOST_ASSERT((*w_)[prop::user_property].size() == 1);
BOOST_CHECK_EQUAL((*w_)[prop::user_property][0].first, will_user_property_1);
BOOST_CHECK_EQUAL((*w_)[prop::user_property][0].second, will_user_property_2);
} }
BOOST_AUTO_TEST_CASE(test_connack) { BOOST_AUTO_TEST_CASE(test_connack) {
@@ -177,36 +177,36 @@ BOOST_AUTO_TEST_CASE(test_connack) {
byte_citer it = msg.cbegin(), last = msg.cend(); byte_citer it = msg.cbegin(), last = msg.cend();
auto header = decoders::decode_fixed_header(it, last); auto header = decoders::decode_fixed_header(it, last);
BOOST_ASSERT(header); BOOST_TEST_REQUIRE(header.has_value());
const auto& [control_byte, remain_length] = *header; const auto& [control_byte, remain_length] = *header;
auto rv = decoders::decode_connack(remain_length, it); auto rv = decoders::decode_connack(remain_length, it);
BOOST_ASSERT(rv); BOOST_TEST_REQUIRE(rv.has_value());
const auto& [session_present_, reason_code_, cprops_] = *rv; const auto& [session_present_, reason_code_, cprops_] = *rv;
BOOST_CHECK_EQUAL(session_present_, session_present); BOOST_TEST(session_present_ == session_present);
BOOST_CHECK_EQUAL(reason_code_, reason_code); BOOST_TEST(reason_code_ == reason_code);
cprops_.visit([](const auto& p, const auto&) { (void)p; BOOST_ASSERT(p); return true; }); cprops_.visit([](const auto& p, const auto&) { (void)p; BOOST_TEST_REQUIRE(p); return true; });
BOOST_CHECK_EQUAL(*cprops_[prop::session_expiry_interval], session_expiry_interval); BOOST_TEST(*cprops_[prop::session_expiry_interval] == session_expiry_interval);
BOOST_CHECK_EQUAL(*cprops_[prop::receive_maximum], receive_maximum); BOOST_TEST(*cprops_[prop::receive_maximum] == receive_maximum);
BOOST_CHECK_EQUAL(*cprops_[prop::maximum_qos], max_qos); BOOST_TEST(*cprops_[prop::maximum_qos] == max_qos);
BOOST_CHECK_EQUAL(*cprops_[prop::retain_available], retain_available); BOOST_TEST(*cprops_[prop::retain_available] == retain_available);
BOOST_CHECK_EQUAL(*cprops_[prop::maximum_packet_size], maximum_packet_sz); BOOST_TEST(*cprops_[prop::maximum_packet_size] == maximum_packet_sz);
BOOST_CHECK_EQUAL(*cprops_[prop::assigned_client_identifier], assigned_client_id); BOOST_TEST(*cprops_[prop::assigned_client_identifier] == assigned_client_id);
BOOST_CHECK_EQUAL(*cprops_[prop::topic_alias_maximum], topic_alias_max); BOOST_TEST(*cprops_[prop::topic_alias_maximum] == topic_alias_max);
BOOST_CHECK_EQUAL(*cprops_[prop::reason_string], reason_string); BOOST_TEST(*cprops_[prop::reason_string] == reason_string);
BOOST_ASSERT(cprops_[prop::user_property].size() == 1); BOOST_TEST_REQUIRE(cprops_[prop::user_property].size() == 1);
BOOST_CHECK_EQUAL(cprops_[prop::user_property][0].first, user_property_1); BOOST_TEST(cprops_[prop::user_property][0].first == user_property_1);
BOOST_CHECK_EQUAL(cprops_[prop::user_property][0].second, user_property_2); BOOST_TEST(cprops_[prop::user_property][0].second == user_property_2);
BOOST_CHECK_EQUAL(*cprops_[prop::wildcard_subscription_available], wildcard_sub); BOOST_TEST(*cprops_[prop::wildcard_subscription_available] == wildcard_sub);
BOOST_CHECK_EQUAL(*cprops_[prop::subscription_identifier_available], sub_id); BOOST_TEST(*cprops_[prop::subscription_identifier_available] == sub_id);
BOOST_CHECK_EQUAL(*cprops_[prop::shared_subscription_available], shared_sub); BOOST_TEST(*cprops_[prop::shared_subscription_available] == shared_sub);
BOOST_CHECK_EQUAL(*cprops_[prop::server_keep_alive], server_keep_alive); BOOST_TEST(*cprops_[prop::server_keep_alive] == server_keep_alive);
BOOST_CHECK_EQUAL(*cprops_[prop::response_information], response_information); BOOST_TEST(*cprops_[prop::response_information] == response_information);
BOOST_CHECK_EQUAL(*cprops_[prop::server_reference], server_reference); BOOST_TEST(*cprops_[prop::server_reference] == server_reference);
BOOST_CHECK_EQUAL(*cprops_[prop::authentication_method], authentication_method); BOOST_TEST(*cprops_[prop::authentication_method] == authentication_method);
BOOST_CHECK_EQUAL(*cprops_[prop::authentication_data], authentication_data); BOOST_TEST(*cprops_[prop::authentication_data] == authentication_data);
} }
BOOST_AUTO_TEST_CASE(test_publish) { BOOST_AUTO_TEST_CASE(test_publish) {
@@ -243,30 +243,30 @@ BOOST_AUTO_TEST_CASE(test_publish) {
byte_citer it = msg.cbegin(), last = msg.cend(); byte_citer it = msg.cbegin(), last = msg.cend();
auto header = decoders::decode_fixed_header(it, last); auto header = decoders::decode_fixed_header(it, last);
BOOST_ASSERT(header); BOOST_TEST_REQUIRE(header.has_value());
const auto& [control_byte, remain_length] = *header; const auto& [control_byte, remain_length] = *header;
auto rv = decoders::decode_publish(control_byte, remain_length, it); auto rv = decoders::decode_publish(control_byte, remain_length, it);
BOOST_ASSERT(rv); BOOST_TEST_REQUIRE(rv.has_value());
const auto& [topic_, packet_id_, flags, pprops_, payload_] = *rv; const auto& [topic_, packet_id_, flags, pprops_, payload_] = *rv;
BOOST_CHECK(packet_id); BOOST_TEST_REQUIRE(packet_id_.has_value());
BOOST_CHECK_EQUAL(*packet_id_, packet_id); BOOST_TEST(*packet_id_ == packet_id);
BOOST_CHECK_EQUAL(topic_, topic); BOOST_TEST(topic_ == topic);
BOOST_CHECK_EQUAL(payload_, payload); BOOST_TEST(payload_ == payload);
pprops_.visit([](const auto& p, const auto&) { (void)p; BOOST_ASSERT(p); return true; }); pprops_.visit([](const auto& p, const auto&) { (void)p; BOOST_TEST_REQUIRE(p); return true; });
BOOST_CHECK_EQUAL(*pprops_[prop::payload_format_indicator], payload_format_indicator); BOOST_TEST(*pprops_[prop::payload_format_indicator] == payload_format_indicator);
BOOST_CHECK_EQUAL(*pprops_[prop::message_expiry_interval], message_expiry_interval); BOOST_TEST(*pprops_[prop::message_expiry_interval] == message_expiry_interval);
BOOST_CHECK_EQUAL(*pprops_[prop::topic_alias], topic_alias); BOOST_TEST(*pprops_[prop::topic_alias] == topic_alias);
BOOST_CHECK_EQUAL(*pprops_[prop::response_topic], response_topic); BOOST_TEST(*pprops_[prop::response_topic] == response_topic);
BOOST_CHECK_EQUAL(*pprops_[prop::correlation_data], correlation_data); BOOST_TEST(*pprops_[prop::correlation_data] == correlation_data);
BOOST_ASSERT(pprops_[prop::user_property].size() == 1); BOOST_TEST_REQUIRE(pprops_[prop::user_property].size() == 1);
BOOST_CHECK_EQUAL(pprops_[prop::user_property][0].first, publish_prop_1); BOOST_TEST(pprops_[prop::user_property][0].first == publish_prop_1);
BOOST_CHECK_EQUAL(pprops_[prop::user_property][0].second, publish_prop_2); BOOST_TEST(pprops_[prop::user_property][0].second == publish_prop_2);
BOOST_ASSERT(pprops_[prop::subscription_identifier].size() == 1); BOOST_TEST_REQUIRE(pprops_[prop::subscription_identifier].size() == 1);
BOOST_CHECK_EQUAL(pprops_[prop::subscription_identifier][0], subscription_identifier); BOOST_TEST(pprops_[prop::subscription_identifier][0] == subscription_identifier);
BOOST_CHECK_EQUAL(*pprops_[prop::content_type], content_type); BOOST_TEST(*pprops_[prop::content_type] == content_type);
} }
BOOST_AUTO_TEST_CASE(test_large_publish) { BOOST_AUTO_TEST_CASE(test_large_publish) {
@@ -283,17 +283,17 @@ BOOST_AUTO_TEST_CASE(test_large_publish) {
byte_citer it = msg.cbegin(), last = msg.cend(); byte_citer it = msg.cbegin(), last = msg.cend();
auto header = decoders::decode_fixed_header(it, last); auto header = decoders::decode_fixed_header(it, last);
BOOST_ASSERT(header); BOOST_TEST_REQUIRE(header.has_value());
const auto& [control_byte, remain_length] = *header; const auto& [control_byte, remain_length] = *header;
auto rv = decoders::decode_publish(control_byte, remain_length, it); auto rv = decoders::decode_publish(control_byte, remain_length, it);
BOOST_ASSERT(rv); BOOST_TEST_REQUIRE(rv.has_value());
const auto& [topic_, packet_id_, flags, pprops, payload_] = *rv; const auto& [topic_, packet_id_, flags, pprops, payload_] = *rv;
BOOST_CHECK(packet_id); BOOST_TEST_REQUIRE(packet_id_.has_value());
BOOST_CHECK_EQUAL(*packet_id_, packet_id); BOOST_TEST(*packet_id_ == packet_id);
BOOST_CHECK_EQUAL(topic_, topic); BOOST_TEST(topic_ == topic);
BOOST_CHECK_EQUAL(payload_, large_payload); BOOST_TEST(payload_ == large_payload);
} }
BOOST_AUTO_TEST_CASE(test_puback) { BOOST_AUTO_TEST_CASE(test_puback) {
@@ -313,23 +313,23 @@ BOOST_AUTO_TEST_CASE(test_puback) {
byte_citer it = msg.cbegin(), last = msg.cend(); byte_citer it = msg.cbegin(), last = msg.cend();
auto header = decoders::decode_fixed_header(it, last); auto header = decoders::decode_fixed_header(it, last);
BOOST_ASSERT(header); BOOST_TEST_REQUIRE(header.has_value());
auto packet_id_ = decoders::decode_packet_id(it); auto packet_id_ = decoders::decode_packet_id(it);
BOOST_CHECK(packet_id); BOOST_TEST_REQUIRE(packet_id_.has_value());
BOOST_CHECK_EQUAL(*packet_id_, packet_id); BOOST_TEST(*packet_id_ == packet_id);
const auto& [control_byte, remain_length] = *header; const auto& [control_byte, remain_length] = *header;
auto rv = decoders::decode_puback(remain_length - sizeof(uint16_t), it); auto rv = decoders::decode_puback(remain_length - sizeof(uint16_t), it);
BOOST_ASSERT(rv); BOOST_TEST_REQUIRE(rv.has_value());
const auto& [reason_code_, pprops_] = *rv; const auto& [reason_code_, pprops_] = *rv;
pprops_.visit([](const auto& p, const auto&) { (void)p; BOOST_ASSERT(p); return true; }); pprops_.visit([](const auto& p, const auto&) { (void)p; BOOST_TEST_REQUIRE(p); return true; });
BOOST_CHECK_EQUAL(reason_code_, reason_code); BOOST_TEST(reason_code_ == reason_code);
BOOST_CHECK_EQUAL(*pprops_[prop::reason_string], reason_string); BOOST_TEST(*pprops_[prop::reason_string] == reason_string);
BOOST_ASSERT(pprops_[prop::user_property].size() == 1); BOOST_TEST_REQUIRE(pprops_[prop::user_property].size() == 1);
BOOST_CHECK_EQUAL(pprops_[prop::user_property][0].first, user_property_1); BOOST_TEST(pprops_[prop::user_property][0].first == user_property_1);
BOOST_CHECK_EQUAL(pprops_[prop::user_property][0].second, user_property_2); BOOST_TEST(pprops_[prop::user_property][0].second == user_property_2);
} }
BOOST_AUTO_TEST_CASE(test_pubrec) { BOOST_AUTO_TEST_CASE(test_pubrec) {
@@ -349,23 +349,23 @@ BOOST_AUTO_TEST_CASE(test_pubrec) {
byte_citer it = msg.cbegin(), last = msg.cend(); byte_citer it = msg.cbegin(), last = msg.cend();
auto header = decoders::decode_fixed_header(it, last); auto header = decoders::decode_fixed_header(it, last);
BOOST_ASSERT(header); BOOST_TEST_REQUIRE(header.has_value());
auto packet_id_ = decoders::decode_packet_id(it); auto packet_id_ = decoders::decode_packet_id(it);
BOOST_CHECK(packet_id); BOOST_TEST_REQUIRE(packet_id_.has_value());
BOOST_CHECK_EQUAL(*packet_id_, packet_id); BOOST_TEST(*packet_id_ == packet_id);
const auto& [control_byte, remain_length] = *header; const auto& [control_byte, remain_length] = *header;
auto rv = decoders::decode_pubrec(remain_length - sizeof(uint16_t), it); auto rv = decoders::decode_pubrec(remain_length - sizeof(uint16_t), it);
BOOST_ASSERT(rv); BOOST_TEST_REQUIRE(rv.has_value());
const auto& [reason_code_, pprops_] = *rv; const auto& [reason_code_, pprops_] = *rv;
pprops_.visit([](const auto& p, const auto&) { (void)p; BOOST_ASSERT(p); return true; }); pprops_.visit([](const auto& p, const auto&) { (void)p; BOOST_TEST_REQUIRE(p); return true; });
BOOST_CHECK_EQUAL(reason_code_, reason_code); BOOST_TEST(reason_code_ == reason_code);
BOOST_CHECK_EQUAL(*pprops_[prop::reason_string], reason_string); BOOST_TEST(*pprops_[prop::reason_string] == reason_string);
BOOST_ASSERT(pprops_[prop::user_property].size() == 1); BOOST_TEST_REQUIRE(pprops_[prop::user_property].size() == 1);
BOOST_CHECK_EQUAL(pprops_[prop::user_property][0].first, user_property_1); BOOST_TEST(pprops_[prop::user_property][0].first == user_property_1);
BOOST_CHECK_EQUAL(pprops_[prop::user_property][0].second, user_property_2); BOOST_TEST(pprops_[prop::user_property][0].second == user_property_2);
} }
BOOST_AUTO_TEST_CASE(test_pubrel) { BOOST_AUTO_TEST_CASE(test_pubrel) {
@@ -385,23 +385,23 @@ BOOST_AUTO_TEST_CASE(test_pubrel) {
byte_citer it = msg.cbegin(), last = msg.cend(); byte_citer it = msg.cbegin(), last = msg.cend();
auto header = decoders::decode_fixed_header(it, last); auto header = decoders::decode_fixed_header(it, last);
BOOST_ASSERT(header); BOOST_TEST_REQUIRE(header.has_value());
auto packet_id_ = decoders::decode_packet_id(it); auto packet_id_ = decoders::decode_packet_id(it);
BOOST_CHECK(packet_id); BOOST_TEST_REQUIRE(packet_id_.has_value());
BOOST_CHECK_EQUAL(*packet_id_, packet_id); BOOST_TEST(*packet_id_ == packet_id);
const auto& [control_byte, remain_length] = *header; const auto& [control_byte, remain_length] = *header;
auto rv = decoders::decode_pubrel(remain_length - sizeof(uint16_t), it); auto rv = decoders::decode_pubrel(remain_length - sizeof(uint16_t), it);
BOOST_ASSERT(rv); BOOST_TEST_REQUIRE(rv.has_value());
const auto& [reason_code_, pprops_] = *rv; const auto& [reason_code_, pprops_] = *rv;
pprops_.visit([](const auto& p, const auto&) { (void)p; BOOST_ASSERT(p); return true; }); pprops_.visit([](const auto& p, const auto&) { (void)p; BOOST_TEST_REQUIRE(p); return true; });
BOOST_CHECK_EQUAL(reason_code_, reason_code); BOOST_TEST(reason_code_ == reason_code);
BOOST_CHECK_EQUAL(*pprops_[prop::reason_string], reason_string); BOOST_TEST(*pprops_[prop::reason_string] == reason_string);
BOOST_ASSERT(pprops_[prop::user_property].size() == 1); BOOST_TEST_REQUIRE(pprops_[prop::user_property].size() == 1);
BOOST_CHECK_EQUAL(pprops_[prop::user_property][0].first, user_property_1); BOOST_TEST(pprops_[prop::user_property][0].first == user_property_1);
BOOST_CHECK_EQUAL(pprops_[prop::user_property][0].second, user_property_2); BOOST_TEST(pprops_[prop::user_property][0].second == user_property_2);
} }
BOOST_AUTO_TEST_CASE(test_pubcomp) { BOOST_AUTO_TEST_CASE(test_pubcomp) {
@@ -421,23 +421,23 @@ BOOST_AUTO_TEST_CASE(test_pubcomp) {
byte_citer it = msg.cbegin(), last = msg.cend(); byte_citer it = msg.cbegin(), last = msg.cend();
auto header = decoders::decode_fixed_header(it, last); auto header = decoders::decode_fixed_header(it, last);
BOOST_ASSERT(header); BOOST_TEST_REQUIRE(header.has_value());
auto packet_id_ = decoders::decode_packet_id(it); auto packet_id_ = decoders::decode_packet_id(it);
BOOST_CHECK(packet_id); BOOST_TEST_REQUIRE(packet_id_.has_value());
BOOST_CHECK_EQUAL(*packet_id_, packet_id); BOOST_TEST(*packet_id_ == packet_id);
const auto& [control_byte, remain_length] = *header; const auto& [control_byte, remain_length] = *header;
auto rv = decoders::decode_pubcomp(remain_length - sizeof(uint16_t), it); auto rv = decoders::decode_pubcomp(remain_length - sizeof(uint16_t), it);
BOOST_ASSERT(rv);; BOOST_TEST_REQUIRE(rv.has_value());
const auto& [reason_code_, pprops_] = *rv; const auto& [reason_code_, pprops_] = *rv;
pprops_.visit([](const auto& p, const auto&) { (void)p; BOOST_ASSERT(p); return true; }); pprops_.visit([](const auto& p, const auto&) { (void)p; BOOST_TEST_REQUIRE(p); return true; });
BOOST_CHECK_EQUAL(reason_code_, reason_code); BOOST_TEST(reason_code_ == reason_code);
BOOST_CHECK_EQUAL(*pprops_[prop::reason_string], reason_string); BOOST_TEST(*pprops_[prop::reason_string] == reason_string);
BOOST_ASSERT(pprops_[prop::user_property].size() == 1); BOOST_TEST_REQUIRE(pprops_[prop::user_property].size() == 1);
BOOST_CHECK_EQUAL(pprops_[prop::user_property][0].first, user_property_1); BOOST_TEST(pprops_[prop::user_property][0].first == user_property_1);
BOOST_CHECK_EQUAL(pprops_[prop::user_property][0].second, user_property_2); BOOST_TEST(pprops_[prop::user_property][0].second == user_property_2);
} }
BOOST_AUTO_TEST_CASE(test_subscribe) { BOOST_AUTO_TEST_CASE(test_subscribe) {
@@ -467,31 +467,31 @@ BOOST_AUTO_TEST_CASE(test_subscribe) {
byte_citer it = msg.cbegin(), last = msg.cend(); byte_citer it = msg.cbegin(), last = msg.cend();
auto header = decoders::decode_fixed_header(it, last); auto header = decoders::decode_fixed_header(it, last);
BOOST_ASSERT(header); BOOST_TEST_REQUIRE(header.has_value());
const auto& [control_byte, remain_length] = *header; const auto& [control_byte, remain_length] = *header;
auto packet_id_ = decoders::decode_packet_id(it); auto packet_id_ = decoders::decode_packet_id(it);
BOOST_CHECK(packet_id); BOOST_TEST_REQUIRE(packet_id_.has_value());
BOOST_CHECK_EQUAL(*packet_id_, packet_id); BOOST_TEST(*packet_id_ == packet_id);
auto rv = decoders::decode_subscribe(remain_length - sizeof(uint16_t), it); auto rv = decoders::decode_subscribe(remain_length - sizeof(uint16_t), it);
BOOST_ASSERT(rv); BOOST_TEST_REQUIRE(rv.has_value());
const auto& [sprops_, filters_] = *rv; const auto& [sprops_, filters_] = *rv;
const auto& filter_ = filters_[0]; const auto& filter_ = filters_[0];
BOOST_CHECK_EQUAL(std::get<0>(filter_), filters[0].topic_filter); BOOST_TEST(std::get<0>(filter_) == filters[0].topic_filter);
uint8_t options_ = std::get<1>(filter_); uint8_t options_ = std::get<1>(filter_);
uint8_t mask = (static_cast<uint8_t>(retain_handling) << 4) | uint8_t mask = (static_cast<uint8_t>(retain_handling) << 4) |
(static_cast<uint8_t>(retain_as_published) << 3) | (static_cast<uint8_t>(retain_as_published) << 3) |
(static_cast<uint8_t>(no_local) << 2) | (static_cast<uint8_t>(no_local) << 2) |
static_cast<uint8_t>(qos); static_cast<uint8_t>(qos);
BOOST_CHECK_EQUAL(options_, mask); BOOST_TEST(options_ == mask);
sprops_.visit([](const auto& p, const auto&) { (void)p; BOOST_ASSERT(p); return true; }); sprops_.visit([](const auto& p, const auto&) { (void)p; BOOST_TEST_REQUIRE(p); return true; });
BOOST_CHECK_EQUAL(*sprops_[prop::subscription_identifier], sub_id); BOOST_TEST(*sprops_[prop::subscription_identifier] == sub_id);
BOOST_ASSERT(sprops_[prop::user_property].size() == 1); BOOST_TEST_REQUIRE(sprops_[prop::user_property].size() == 1);
BOOST_CHECK_EQUAL(sprops_[prop::user_property][0].first, user_property_1); BOOST_TEST(sprops_[prop::user_property][0].first == user_property_1);
BOOST_CHECK_EQUAL(sprops_[prop::user_property][0].second, user_property_2); BOOST_TEST(sprops_[prop::user_property][0].second == user_property_2);
} }
BOOST_AUTO_TEST_CASE(test_suback) { BOOST_AUTO_TEST_CASE(test_suback) {
@@ -511,23 +511,23 @@ BOOST_AUTO_TEST_CASE(test_suback) {
byte_citer it = msg.cbegin(), last = msg.cend(); byte_citer it = msg.cbegin(), last = msg.cend();
auto header = decoders::decode_fixed_header(it, last); auto header = decoders::decode_fixed_header(it, last);
BOOST_ASSERT(header); BOOST_TEST_REQUIRE(header.has_value());
const auto& [control_byte, remain_length] = *header; const auto& [control_byte, remain_length] = *header;
auto packet_id_ = decoders::decode_packet_id(it); auto packet_id_ = decoders::decode_packet_id(it);
BOOST_CHECK(packet_id); BOOST_TEST_REQUIRE(packet_id_.has_value());
BOOST_CHECK_EQUAL(*packet_id_, packet_id); BOOST_TEST(*packet_id_ == packet_id);
auto rv = decoders::decode_suback(remain_length - sizeof(uint16_t), it); auto rv = decoders::decode_suback(remain_length - sizeof(uint16_t), it);
BOOST_ASSERT(rv); BOOST_TEST_REQUIRE(rv.has_value());
const auto& [sprops_, reason_codes_] = *rv; const auto& [sprops_, reason_codes_] = *rv;
BOOST_CHECK(reason_codes_ == reason_codes); BOOST_TEST(reason_codes_ == reason_codes);
sprops_.visit([](const auto& p, const auto&) { (void)p; BOOST_ASSERT(p); return true; }); sprops_.visit([](const auto& p, const auto&) { (void)p; BOOST_TEST_REQUIRE(p); return true; });
BOOST_CHECK_EQUAL(*sprops_[prop::reason_string], reason_string); BOOST_TEST(*sprops_[prop::reason_string] == reason_string);
BOOST_ASSERT(sprops_[prop::user_property].size() == 1); BOOST_TEST_REQUIRE(sprops_[prop::user_property].size() == 1);
BOOST_CHECK_EQUAL(sprops_[prop::user_property][0].first, user_property_1); BOOST_TEST(sprops_[prop::user_property][0].first == user_property_1);
BOOST_CHECK_EQUAL(sprops_[prop::user_property][0].second, user_property_2); BOOST_TEST(sprops_[prop::user_property][0].second == user_property_2);
} }
BOOST_AUTO_TEST_CASE(test_unsubscribe) { BOOST_AUTO_TEST_CASE(test_unsubscribe) {
@@ -545,22 +545,22 @@ BOOST_AUTO_TEST_CASE(test_unsubscribe) {
byte_citer it = msg.cbegin(), last = msg.cend(); byte_citer it = msg.cbegin(), last = msg.cend();
auto header = decoders::decode_fixed_header(it, last); auto header = decoders::decode_fixed_header(it, last);
BOOST_ASSERT(header); BOOST_TEST_REQUIRE(header.has_value());
const auto& [control_byte, remain_length] = *header; const auto& [control_byte, remain_length] = *header;
auto packet_id_ = decoders::decode_packet_id(it); auto packet_id_ = decoders::decode_packet_id(it);
BOOST_CHECK(packet_id); BOOST_TEST_REQUIRE(packet_id_.has_value());
BOOST_CHECK_EQUAL(*packet_id_, packet_id); BOOST_TEST(*packet_id_ == packet_id);
auto rv = decoders::decode_unsubscribe(remain_length - sizeof(uint16_t), it); auto rv = decoders::decode_unsubscribe(remain_length - sizeof(uint16_t), it);
BOOST_ASSERT(rv); BOOST_TEST_REQUIRE(rv.has_value());
const auto& [uprops_, topics_] = *rv; const auto& [uprops_, topics_] = *rv;
BOOST_CHECK(topics_ == topics); BOOST_TEST(topics_ == topics);
uprops_.visit([](const auto& p, const auto&) { (void)p; BOOST_ASSERT(p); return true; }); uprops_.visit([](const auto& p, const auto&) { (void)p; BOOST_TEST_REQUIRE(p); return true; });
BOOST_ASSERT(uprops_[prop::user_property].size() == 1); BOOST_TEST_REQUIRE(uprops_[prop::user_property].size() == 1);
BOOST_CHECK_EQUAL(uprops_[prop::user_property][0].first, user_property_1); BOOST_TEST(uprops_[prop::user_property][0].first == user_property_1);
BOOST_CHECK_EQUAL(uprops_[prop::user_property][0].second, user_property_2); BOOST_TEST(uprops_[prop::user_property][0].second == user_property_2);
} }
BOOST_AUTO_TEST_CASE(test_unsuback) { BOOST_AUTO_TEST_CASE(test_unsuback) {
@@ -580,23 +580,23 @@ BOOST_AUTO_TEST_CASE(test_unsuback) {
byte_citer it = msg.cbegin(), last = msg.cend(); byte_citer it = msg.cbegin(), last = msg.cend();
auto header = decoders::decode_fixed_header(it, last); auto header = decoders::decode_fixed_header(it, last);
BOOST_ASSERT(header); BOOST_TEST_REQUIRE(header.has_value());
const auto& [control_byte, remain_length] = *header; const auto& [control_byte, remain_length] = *header;
auto packet_id_ = decoders::decode_packet_id(it); auto packet_id_ = decoders::decode_packet_id(it);
BOOST_CHECK(packet_id); BOOST_TEST_REQUIRE(packet_id_.has_value());
BOOST_CHECK_EQUAL(*packet_id_, packet_id); BOOST_TEST(*packet_id_ == packet_id);
auto rv = decoders::decode_unsuback(remain_length - sizeof(uint16_t), it); auto rv = decoders::decode_unsuback(remain_length - sizeof(uint16_t), it);
BOOST_ASSERT(rv); BOOST_TEST_REQUIRE(rv.has_value());
const auto& [uprops_, reason_codes_] = *rv; const auto& [uprops_, reason_codes_] = *rv;
BOOST_CHECK(reason_codes_ == reason_codes); BOOST_TEST(reason_codes_ == reason_codes);
uprops_.visit([](const auto& p, const auto&) { (void)p; BOOST_ASSERT(p); return true; }); uprops_.visit([](const auto& p, const auto&) { (void)p; BOOST_TEST_REQUIRE(p); return true; });
BOOST_CHECK_EQUAL(*uprops_[prop::reason_string], reason_string); BOOST_TEST(*uprops_[prop::reason_string] == reason_string);
BOOST_ASSERT(uprops_[prop::user_property].size() == 1); BOOST_TEST_REQUIRE(uprops_[prop::user_property].size() == 1);
BOOST_CHECK_EQUAL(uprops_[prop::user_property][0].first, user_property_1); BOOST_TEST(uprops_[prop::user_property][0].first == user_property_1);
BOOST_CHECK_EQUAL(uprops_[prop::user_property][0].second, user_property_2); BOOST_TEST(uprops_[prop::user_property][0].second == user_property_2);
} }
BOOST_AUTO_TEST_CASE(test_disconnect) { BOOST_AUTO_TEST_CASE(test_disconnect) {
@@ -619,22 +619,22 @@ BOOST_AUTO_TEST_CASE(test_disconnect) {
byte_citer it = msg.cbegin(), last = msg.cend(); byte_citer it = msg.cbegin(), last = msg.cend();
auto header = decoders::decode_fixed_header(it, last); auto header = decoders::decode_fixed_header(it, last);
BOOST_ASSERT(header); BOOST_TEST_REQUIRE(header.has_value());
const auto& [control_byte, remain_length] = *header; const auto& [control_byte, remain_length] = *header;
auto rv = decoders::decode_disconnect(remain_length, it); auto rv = decoders::decode_disconnect(remain_length, it);
BOOST_ASSERT(rv); BOOST_TEST_REQUIRE(rv.has_value());
const auto& [reason_code_, dprops_] = *rv; const auto& [reason_code_, dprops_] = *rv;
BOOST_CHECK_EQUAL(reason_code_, reason_code); BOOST_TEST(reason_code_ == reason_code);
dprops_.visit([](const auto& p, const auto&) { (void)p; BOOST_ASSERT(p); return true; }); dprops_.visit([](const auto& p, const auto&) { (void)p; BOOST_TEST_REQUIRE(p); return true; });
BOOST_CHECK_EQUAL(*dprops_[prop::session_expiry_interval], session_expiry_interval); BOOST_TEST(*dprops_[prop::session_expiry_interval] == session_expiry_interval);
BOOST_CHECK_EQUAL(*dprops_[prop::reason_string], reason_string); BOOST_TEST(*dprops_[prop::reason_string] == reason_string);
BOOST_ASSERT(dprops_[prop::user_property].size() == 1); BOOST_TEST_REQUIRE(dprops_[prop::user_property].size() == 1);
BOOST_CHECK_EQUAL(dprops_[prop::user_property][0].first, user_property_1); BOOST_TEST(dprops_[prop::user_property][0].first == user_property_1);
BOOST_CHECK_EQUAL(dprops_[prop::user_property][0].second, user_property_2); BOOST_TEST(dprops_[prop::user_property][0].second == user_property_2);
BOOST_CHECK_EQUAL(*dprops_[prop::server_reference], server_reference); BOOST_TEST(*dprops_[prop::server_reference] == server_reference);
} }
BOOST_AUTO_TEST_CASE(test_auth) { BOOST_AUTO_TEST_CASE(test_auth) {
@@ -658,56 +658,55 @@ BOOST_AUTO_TEST_CASE(test_auth) {
byte_citer it = msg.cbegin(), last = msg.cend(); byte_citer it = msg.cbegin(), last = msg.cend();
auto header = decoders::decode_fixed_header(it, last); auto header = decoders::decode_fixed_header(it, last);
BOOST_ASSERT(header); BOOST_TEST_REQUIRE(header.has_value());
const auto& [control_byte, remain_length] = *header; const auto& [control_byte, remain_length] = *header;
auto rv = decoders::decode_auth(remain_length, it); auto rv = decoders::decode_auth(remain_length, it);
BOOST_ASSERT(rv); BOOST_TEST_REQUIRE(rv.has_value());
const auto& [reason_code_, aprops_] = *rv; const auto& [reason_code_, aprops_] = *rv;
BOOST_CHECK_EQUAL(reason_code_, reason_code); BOOST_TEST(reason_code_ == reason_code);
aprops_.visit([](const auto& p, const auto&) { (void)p; BOOST_ASSERT(p); return true; }); aprops_.visit([](const auto& p, const auto&) { (void)p; BOOST_TEST_REQUIRE(p); return true; });
BOOST_CHECK_EQUAL(*aprops_[prop::authentication_method], authentication_method); BOOST_TEST(*aprops_[prop::authentication_method] == authentication_method);
BOOST_CHECK_EQUAL(*aprops_[prop::authentication_data], authentication_data); BOOST_TEST(*aprops_[prop::authentication_data] == authentication_data);
BOOST_CHECK_EQUAL(*aprops_[prop::reason_string], reason_string); BOOST_TEST(*aprops_[prop::reason_string] == reason_string);
BOOST_ASSERT(aprops_[prop::user_property].size() == 1); BOOST_TEST_REQUIRE(aprops_[prop::user_property].size() == 1);
BOOST_CHECK_EQUAL(aprops_[prop::user_property][0].first, user_property_1); BOOST_TEST(aprops_[prop::user_property][0].first == user_property_1);
BOOST_CHECK_EQUAL(aprops_[prop::user_property][0].second, user_property_2); BOOST_TEST(aprops_[prop::user_property][0].second == user_property_2);
} }
BOOST_AUTO_TEST_CASE(test_pingreq) { BOOST_AUTO_TEST_CASE(test_pingreq) {
auto msg = encoders::encode_pingreq(); auto msg = encoders::encode_pingreq();
auto encoded_pingreq = std::string({ -64 /* 192 */, 0 }); auto encoded_pingreq = std::string({ -64 /* 192 */, 0 });
BOOST_CHECK_EQUAL(msg, encoded_pingreq); BOOST_TEST(msg == encoded_pingreq);
} }
BOOST_AUTO_TEST_CASE(test_pingresp) { BOOST_AUTO_TEST_CASE(test_pingresp) {
auto msg = encoders::encode_pingresp(); auto msg = encoders::encode_pingresp();
auto encoded_pingresp = std::string({ -48 /* 208 */, 0 }); auto encoded_pingresp = std::string({ -48 /* 208 */, 0 });
BOOST_CHECK_EQUAL(msg, encoded_pingresp); BOOST_TEST(msg == encoded_pingresp);
} }
BOOST_AUTO_TEST_CASE(subscription_identifiers) { BOOST_AUTO_TEST_CASE(subscription_identifiers) {
// check boost::container::small_vector interface // check boost::container::small_vector interface
BOOST_ASSERT(is_small_vector<prop::subscription_identifiers>); BOOST_TEST_REQUIRE(is_small_vector<prop::subscription_identifiers>);
// check optional interface // check optional interface
prop::subscription_identifiers sub_ids; prop::subscription_identifiers sub_ids;
sub_ids.emplace(40); sub_ids.emplace(40);
BOOST_CHECK(sub_ids); BOOST_TEST_REQUIRE(sub_ids.has_value());
BOOST_CHECK(sub_ids.has_value()); BOOST_TEST(*sub_ids == 40);
BOOST_CHECK_EQUAL(*sub_ids, 40);
*sub_ids = 41; *sub_ids = 41;
BOOST_CHECK_EQUAL(sub_ids.value(), 41); BOOST_TEST(sub_ids.value() == 41);
BOOST_CHECK_EQUAL(sub_ids.value_or(-1), 41); BOOST_TEST(sub_ids.value_or(-1) == 41);
sub_ids.reset(); sub_ids.reset();
BOOST_CHECK(!sub_ids); BOOST_TEST(!sub_ids);
BOOST_CHECK_EQUAL(sub_ids.value_or(-1), -1); BOOST_TEST(sub_ids.value_or(-1) == -1);
sub_ids.emplace(); sub_ids.emplace();
BOOST_CHECK_EQUAL(*sub_ids, 0); BOOST_TEST(*sub_ids == 0);
} }
BOOST_AUTO_TEST_CASE(empty_user_property) { BOOST_AUTO_TEST_CASE(empty_user_property) {
@@ -722,18 +721,18 @@ BOOST_AUTO_TEST_CASE(empty_user_property) {
byte_citer it = msg.cbegin(), last = msg.cend(); byte_citer it = msg.cbegin(), last = msg.cend();
auto header = decoders::decode_fixed_header(it, last); auto header = decoders::decode_fixed_header(it, last);
BOOST_ASSERT(header); BOOST_TEST_REQUIRE(header.has_value());
const auto& [control_byte, remain_length] = *header; const auto& [control_byte, remain_length] = *header;
auto rv = decoders::decode_publish(control_byte, remain_length, it); auto rv = decoders::decode_publish(control_byte, remain_length, it);
BOOST_ASSERT(rv); BOOST_TEST_REQUIRE(rv.has_value());
const auto& [topic_, packet_id_, flags, pprops_, payload_] = *rv; const auto& [topic_, packet_id_, flags, pprops_, payload_] = *rv;
auto user_props_ = pprops_[prop::user_property]; auto user_props_ = pprops_[prop::user_property];
BOOST_ASSERT(user_props_.size() == 1); BOOST_TEST_REQUIRE(user_props_.size() == 1);
BOOST_CHECK_EQUAL(user_props_[0].first, ""); BOOST_TEST(user_props_[0].first == "");
BOOST_CHECK_EQUAL(user_props_[0].second, ""); BOOST_TEST(user_props_[0].second == "");
} }
BOOST_AUTO_TEST_CASE(deserialize_user_property) { BOOST_AUTO_TEST_CASE(deserialize_user_property) {
@@ -745,18 +744,18 @@ BOOST_AUTO_TEST_CASE(deserialize_user_property) {
byte_citer it = msg.cbegin(), last = msg.cend(); byte_citer it = msg.cbegin(), last = msg.cend();
auto header = decoders::decode_fixed_header(it, last); auto header = decoders::decode_fixed_header(it, last);
BOOST_ASSERT(header); BOOST_TEST_REQUIRE(header.has_value());
auto packet_id_ = decoders::decode_packet_id(it); auto packet_id_ = decoders::decode_packet_id(it);
BOOST_ASSERT(packet_id_); BOOST_TEST_REQUIRE(packet_id_.has_value());
const auto& [control_byte, remain_length] = *header; const auto& [control_byte, remain_length] = *header;
auto rv = decoders::decode_puback(remain_length - sizeof(uint16_t), it); auto rv = decoders::decode_puback(remain_length - sizeof(uint16_t), it);
BOOST_ASSERT(rv); BOOST_TEST_REQUIRE(rv.has_value());
const auto& [reason_code_, pprops_] = *rv; const auto& [reason_code_, pprops_] = *rv;
auto user_props_ = pprops_[prop::user_property]; auto user_props_ = pprops_[prop::user_property];
BOOST_ASSERT(user_props_.size() == 1); BOOST_TEST_REQUIRE(user_props_.size() == 1);
BOOST_CHECK_EQUAL(user_props_[0].first, "key"); BOOST_TEST(user_props_[0].first == "key");
BOOST_CHECK_EQUAL(user_props_[0].second, "val"); BOOST_TEST(user_props_[0].second == "val");
} }
BOOST_AUTO_TEST_CASE(deserialize_empty_user_property) { BOOST_AUTO_TEST_CASE(deserialize_empty_user_property) {
@@ -768,18 +767,18 @@ BOOST_AUTO_TEST_CASE(deserialize_empty_user_property) {
byte_citer it = msg.cbegin(), last = msg.cend(); byte_citer it = msg.cbegin(), last = msg.cend();
auto header = decoders::decode_fixed_header(it, last); auto header = decoders::decode_fixed_header(it, last);
BOOST_ASSERT(header); BOOST_TEST_REQUIRE(header.has_value());
auto packet_id_ = decoders::decode_packet_id(it); auto packet_id_ = decoders::decode_packet_id(it);
BOOST_ASSERT(packet_id_); BOOST_TEST_REQUIRE(packet_id_.has_value());
const auto& [control_byte, remain_length] = *header; const auto& [control_byte, remain_length] = *header;
auto rv = decoders::decode_puback(remain_length - sizeof(uint16_t), it); auto rv = decoders::decode_puback(remain_length - sizeof(uint16_t), it);
BOOST_ASSERT(rv); BOOST_TEST_REQUIRE(rv.has_value());
const auto& [reason_code_, pprops_] = *rv; const auto& [reason_code_, pprops_] = *rv;
auto user_props_ = pprops_[prop::user_property]; auto user_props_ = pprops_[prop::user_property];
BOOST_ASSERT(user_props_.size() == 1); BOOST_TEST_REQUIRE(user_props_.size() == 1);
BOOST_CHECK_EQUAL(user_props_[0].first, ""); BOOST_TEST(user_props_[0].first == "");
BOOST_CHECK_EQUAL(user_props_[0].second, ""); BOOST_TEST(user_props_[0].second == "");
} }
BOOST_AUTO_TEST_CASE(malformed_user_property) { BOOST_AUTO_TEST_CASE(malformed_user_property) {
@@ -791,12 +790,12 @@ BOOST_AUTO_TEST_CASE(malformed_user_property) {
byte_citer it = msg.cbegin(), last = msg.cend(); byte_citer it = msg.cbegin(), last = msg.cend();
auto header = decoders::decode_fixed_header(it, last); auto header = decoders::decode_fixed_header(it, last);
BOOST_ASSERT(header); BOOST_TEST_REQUIRE(header.has_value());
auto packet_id_ = decoders::decode_packet_id(it); auto packet_id_ = decoders::decode_packet_id(it);
BOOST_ASSERT(packet_id_); BOOST_TEST_REQUIRE(packet_id_.has_value());
const auto& [control_byte, remain_length] = *header; const auto& [control_byte, remain_length] = *header;
auto rv = decoders::decode_puback(remain_length - sizeof(uint16_t), it); auto rv = decoders::decode_puback(remain_length - sizeof(uint16_t), it);
BOOST_CHECK(!rv); BOOST_TEST(!rv);
} }
BOOST_AUTO_TEST_CASE(malformed_reason_string) { BOOST_AUTO_TEST_CASE(malformed_reason_string) {
@@ -808,12 +807,12 @@ BOOST_AUTO_TEST_CASE(malformed_reason_string) {
byte_citer it = msg.cbegin(), last = msg.cend(); byte_citer it = msg.cbegin(), last = msg.cend();
auto header = decoders::decode_fixed_header(it, last); auto header = decoders::decode_fixed_header(it, last);
BOOST_ASSERT(header); BOOST_TEST_REQUIRE(header.has_value());
auto packet_id_ = decoders::decode_packet_id(it); auto packet_id_ = decoders::decode_packet_id(it);
BOOST_ASSERT(packet_id_); BOOST_TEST_REQUIRE(packet_id_.has_value());
const auto& [control_byte, remain_length] = *header; const auto& [control_byte, remain_length] = *header;
auto rv = decoders::decode_puback(remain_length - sizeof(uint16_t), it); auto rv = decoders::decode_puback(remain_length - sizeof(uint16_t), it);
BOOST_CHECK(!rv); BOOST_TEST(!rv);
} }
BOOST_AUTO_TEST_SUITE_END() BOOST_AUTO_TEST_SUITE_END()

16
test/unit/session.cpp
View File

@@ -25,17 +25,17 @@ BOOST_AUTO_TEST_SUITE(session/*, *boost::unit_test::disabled()*/)
BOOST_AUTO_TEST_CASE(session_state_session_present) { BOOST_AUTO_TEST_CASE(session_state_session_present) {
detail::session_state session_state; detail::session_state session_state;
BOOST_CHECK_EQUAL(session_state.session_present(), false); BOOST_TEST(session_state.session_present() == false);
session_state.session_present(true); session_state.session_present(true);
BOOST_CHECK_EQUAL(session_state.session_present(), true); BOOST_TEST(session_state.session_present() == true);
session_state.session_present(false); session_state.session_present(false);
BOOST_CHECK_EQUAL(session_state.session_present(), false); BOOST_TEST(session_state.session_present() == false);
BOOST_CHECK_EQUAL(session_state.subscriptions_present(), false); BOOST_TEST(session_state.subscriptions_present() == false);
session_state.subscriptions_present(true); session_state.subscriptions_present(true);
BOOST_CHECK_EQUAL(session_state.subscriptions_present(), true); BOOST_TEST(session_state.subscriptions_present() == true);
session_state.subscriptions_present(false); session_state.subscriptions_present(false);
BOOST_CHECK_EQUAL(session_state.subscriptions_present(), false); BOOST_TEST(session_state.subscriptions_present() == false);
} }
BOOST_AUTO_TEST_CASE(clear_waiting_on_pubrel) { BOOST_AUTO_TEST_CASE(clear_waiting_on_pubrel) {
@@ -54,10 +54,10 @@ BOOST_AUTO_TEST_CASE(clear_waiting_on_pubrel) {
asio::steady_timer timer(ioc.get_executor()); asio::steady_timer timer(ioc.get_executor());
timer.expires_after(std::chrono::milliseconds(50)); timer.expires_after(std::chrono::milliseconds(50));
timer.async_wait([&svc_ptr](error_code) { timer.async_wait([&svc_ptr](error_code) {
BOOST_CHECK_EQUAL(svc_ptr.use_count(), 2); BOOST_TEST(svc_ptr.use_count() == 2);
svc_ptr->update_session_state(); // session_present = false svc_ptr->update_session_state(); // session_present = false
// publish_rec_op should complete // publish_rec_op should complete
BOOST_CHECK_EQUAL(svc_ptr.use_count(), 1); BOOST_TEST(svc_ptr.use_count() == 1);
}); });
ioc.run(); ioc.run();

16
test/unit/subscribe_op.cpp
View File

@@ -35,9 +35,9 @@ BOOST_AUTO_TEST_CASE(pid_overrun) {
auto handler = [&handlers_called](error_code ec, std::vector<reason_code> rcs, suback_props) { auto handler = [&handlers_called](error_code ec, std::vector<reason_code> rcs, suback_props) {
++handlers_called; ++handlers_called;
BOOST_CHECK(ec == client::error::pid_overrun); BOOST_TEST(ec == client::error::pid_overrun);
BOOST_ASSERT(rcs.size() == 1); BOOST_TEST_REQUIRE(rcs.size() == 1);
BOOST_CHECK_EQUAL(rcs[0], reason_codes::empty); BOOST_TEST(rcs[0] == reason_codes::empty);
}; };
detail::subscribe_op< detail::subscribe_op<
@@ -48,7 +48,7 @@ BOOST_AUTO_TEST_CASE(pid_overrun) {
); );
ioc.run_for(std::chrono::milliseconds(500)); ioc.run_for(std::chrono::milliseconds(500));
BOOST_CHECK_EQUAL(handlers_called, expected_handlers_called); BOOST_TEST(handlers_called == expected_handlers_called);
} }
void run_test( void run_test(
@@ -66,11 +66,11 @@ void run_test(
(error_code ec, std::vector<reason_code> rcs, suback_props) { (error_code ec, std::vector<reason_code> rcs, suback_props) {
++handlers_called; ++handlers_called;
BOOST_CHECK(ec == expected_ec); BOOST_TEST(ec == expected_ec);
BOOST_ASSERT(rcs.size() == num_tp); BOOST_TEST_REQUIRE(rcs.size() == num_tp);
for (size_t i = 0; i < rcs.size(); ++i) for (size_t i = 0; i < rcs.size(); ++i)
BOOST_CHECK_EQUAL(rcs[i], reason_codes::empty); BOOST_TEST(rcs[i] == reason_codes::empty);
}; };
detail::subscribe_op< detail::subscribe_op<
@@ -79,7 +79,7 @@ void run_test(
.perform(topics, sprops); .perform(topics, sprops);
ioc.run_for(std::chrono::milliseconds(500)); ioc.run_for(std::chrono::milliseconds(500));
BOOST_CHECK_EQUAL(handlers_called, expected_handlers_called); BOOST_TEST(handlers_called == expected_handlers_called);
} }
void run_test( void run_test(

17
test/unit/traits.cpp
View File

@@ -8,8 +8,9 @@
#include <boost/test/unit_test.hpp> #include <boost/test/unit_test.hpp>
#include <string> #include <string>
#include <vector> #include <string_view>
#include <boost/asio/async_result.hpp>
#include <boost/asio/ip/tcp.hpp> #include <boost/asio/ip/tcp.hpp>
#include <boost/asio/ssl/stream.hpp> #include <boost/asio/ssl/stream.hpp>
#include <boost/asio/io_context.hpp> #include <boost/asio/io_context.hpp>
@@ -60,10 +61,9 @@ struct bad_authenticator {
} }
}; };
BOOST_AUTO_TEST_CASE(is_authenticator) {
BOOST_STATIC_ASSERT(detail::is_authenticator<good_authenticator>); BOOST_STATIC_ASSERT(detail::is_authenticator<good_authenticator>);
BOOST_STATIC_ASSERT(!detail::is_authenticator<bad_authenticator>); BOOST_STATIC_ASSERT(!detail::is_authenticator<bad_authenticator>);
}
namespace asio = boost::asio; namespace asio = boost::asio;
namespace beast = boost::beast; namespace beast = boost::beast;
@@ -73,32 +73,27 @@ using tls_layer = asio::ssl::stream<asio::ip::tcp::socket>;
using websocket_tcp_layer = beast::websocket::stream<tcp_layer>; using websocket_tcp_layer = beast::websocket::stream<tcp_layer>;
using websocket_tls_layer = beast::websocket::stream<tls_layer>; using websocket_tls_layer = beast::websocket::stream<tls_layer>;
BOOST_AUTO_TEST_CASE(has_next_layer) {
BOOST_STATIC_ASSERT(!detail::has_next_layer<tcp_layer>); BOOST_STATIC_ASSERT(!detail::has_next_layer<tcp_layer>);
BOOST_STATIC_ASSERT(detail::has_next_layer<tls_layer>); BOOST_STATIC_ASSERT(detail::has_next_layer<tls_layer>);
BOOST_STATIC_ASSERT(detail::has_next_layer<websocket_tcp_layer>); BOOST_STATIC_ASSERT(detail::has_next_layer<websocket_tcp_layer>);
BOOST_STATIC_ASSERT(detail::has_next_layer<websocket_tls_layer>); BOOST_STATIC_ASSERT(detail::has_next_layer<websocket_tls_layer>);
}
BOOST_AUTO_TEST_CASE(has_tls_layer) {
BOOST_STATIC_ASSERT(!detail::has_tls_layer<tcp_layer>); BOOST_STATIC_ASSERT(!detail::has_tls_layer<tcp_layer>);
BOOST_STATIC_ASSERT(detail::has_tls_layer<tls_layer>); BOOST_STATIC_ASSERT(detail::has_tls_layer<tls_layer>);
BOOST_STATIC_ASSERT(!detail::has_tls_layer<websocket_tcp_layer>); BOOST_STATIC_ASSERT(!detail::has_tls_layer<websocket_tcp_layer>);
BOOST_STATIC_ASSERT(detail::has_tls_layer<websocket_tls_layer>); BOOST_STATIC_ASSERT(detail::has_tls_layer<websocket_tls_layer>);
}
BOOST_AUTO_TEST_CASE(has_tls_handshake) {
BOOST_STATIC_ASSERT(!detail::has_tls_handshake<tcp_layer>); BOOST_STATIC_ASSERT(!detail::has_tls_handshake<tcp_layer>);
BOOST_STATIC_ASSERT(detail::has_tls_handshake<tls_layer>); BOOST_STATIC_ASSERT(detail::has_tls_handshake<tls_layer>);
BOOST_STATIC_ASSERT(!detail::has_tls_handshake<websocket_tcp_layer>); BOOST_STATIC_ASSERT(!detail::has_tls_handshake<websocket_tcp_layer>);
BOOST_STATIC_ASSERT(!detail::has_tls_handshake<websocket_tls_layer>); BOOST_STATIC_ASSERT(!detail::has_tls_handshake<websocket_tls_layer>);
}
BOOST_AUTO_TEST_CASE(has_ws_handskae) {
BOOST_STATIC_ASSERT(!detail::has_ws_handshake<tcp_layer>); BOOST_STATIC_ASSERT(!detail::has_ws_handshake<tcp_layer>);
BOOST_STATIC_ASSERT(!detail::has_ws_handshake<tls_layer>); BOOST_STATIC_ASSERT(!detail::has_ws_handshake<tls_layer>);
BOOST_STATIC_ASSERT(detail::has_ws_handshake<websocket_tcp_layer>); BOOST_STATIC_ASSERT(detail::has_ws_handshake<websocket_tcp_layer>);
BOOST_STATIC_ASSERT(detail::has_ws_handshake<websocket_tls_layer>); BOOST_STATIC_ASSERT(detail::has_ws_handshake<websocket_tls_layer>);
}
BOOST_AUTO_TEST_SUITE_END(); BOOST_AUTO_TEST_SUITE_END();

16
test/unit/unsubscribe_op.cpp
View File

@@ -35,9 +35,9 @@ BOOST_AUTO_TEST_CASE(pid_overrun) {
auto handler = [&handlers_called](error_code ec, std::vector<reason_code> rcs, unsuback_props) { auto handler = [&handlers_called](error_code ec, std::vector<reason_code> rcs, unsuback_props) {
++handlers_called; ++handlers_called;
BOOST_CHECK(ec == client::error::pid_overrun); BOOST_TEST(ec == client::error::pid_overrun);
BOOST_ASSERT(rcs.size() == 1); BOOST_TEST_REQUIRE(rcs.size() == 1);
BOOST_CHECK_EQUAL(rcs[0], reason_codes::empty); BOOST_TEST(rcs[0] == reason_codes::empty);
}; };
detail::unsubscribe_op< detail::unsubscribe_op<
@@ -46,7 +46,7 @@ BOOST_AUTO_TEST_CASE(pid_overrun) {
.perform({ "topic" }, unsubscribe_props {}); .perform({ "topic" }, unsubscribe_props {});
ioc.run_for(std::chrono::milliseconds(500)); ioc.run_for(std::chrono::milliseconds(500));
BOOST_CHECK_EQUAL(handlers_called, expected_handlers_called); BOOST_TEST(handlers_called == expected_handlers_called);
} }
void run_test( void run_test(
@@ -64,11 +64,11 @@ void run_test(
(error_code ec, std::vector<reason_code> rcs, unsuback_props) { (error_code ec, std::vector<reason_code> rcs, unsuback_props) {
++handlers_called; ++handlers_called;
BOOST_CHECK(ec == expected_ec); BOOST_TEST(ec == expected_ec);
BOOST_ASSERT(rcs.size() == num_tp); BOOST_TEST_REQUIRE(rcs.size() == num_tp);
for (size_t i = 0; i < rcs.size(); ++i) for (size_t i = 0; i < rcs.size(); ++i)
BOOST_CHECK_EQUAL(rcs[i], reason_codes::empty); BOOST_TEST(rcs[i] == reason_codes::empty);
}; };
detail::unsubscribe_op< detail::unsubscribe_op<
@@ -77,7 +77,7 @@ void run_test(
.perform(topics, uprops); .perform(topics, uprops);
ioc.run_for(std::chrono::milliseconds(500)); ioc.run_for(std::chrono::milliseconds(500));
BOOST_CHECK_EQUAL(handlers_called, expected_handlers_called); BOOST_TEST(handlers_called == expected_handlers_called);
} }
void run_test( void run_test(