Commit f0547cf7 authored by Dominik Charousset's avatar Dominik Charousset

Merge branch master into topic/neverlord/flow

parents a65918f3 bfa0f83d
......@@ -6,12 +6,12 @@ RUN yum update -y \
&& yum update -y \
&& yum install -y \
cmake3 \
devtoolset-7 \
devtoolset-7-libasan-devel \
devtoolset-7-libubsan-devel \
devtoolset-8 \
devtoolset-8-libasan-devel \
devtoolset-8-libubsan-devel \
git \
make \
openssl-devel \
&& yum clean all
ENV CXX=/opt/rh/devtoolset-7/root/usr/bin/g++
ENV CXX=/opt/rh/devtoolset-8/root/usr/bin/g++
......@@ -12,10 +12,45 @@ is based on [Keep a Changelog](https://keepachangelog.com).
destructor of the promise now checks for this case.
- Accessing URI fields now always returns the normalized string.
## [0.18.6]
### Added
- When adding CAF with exceptions enabled (default), the unit test framework now
offers new check macros:
- `CAF_CHECK_NOTHROW(expr)`
- `CAF_CHECK_THROWS_AS(expr, type)`
- `CAF_CHECK_THROWS_WITH(expr, str)`
- `CAF_CHECK_THROWS_WITH_AS(expr, str, type)`
### Fixed
- The DSL function `run_until` miscounted the number of executed events, also
causing `run_once` to report a wrong value. Both functions now return the
correct result.
- Using `allow(...).with(...)` in unit tests without a matching message crashed
the program. By adding a missing NULL-check, `allow` is now always safe to
use.
- Passing a response promise to a run-delayed continuation could result in a
heap-use-after-free if the actor terminates before the action runs. The
destructor of the promise now checks for this case.
- Fix OpenSSL 3.0 warnings when building the OpenSSL module by switching to
newer EC-curve API.
- When working with settings, `put`, `put_missing`, `get_if`, etc. now
gracefully handle the `global` category when explicitly using it.
- Messages created from a `message_builder` did not call the destructors for
their values, potentially causing memory leaks (#1321).
### Changed
- Since support of Qt 5 expired, we have ported the Qt examples to version 6.
Hence, building the Qt examples now requires Qt in version 6.
- When compiling CAF with exceptions enabled (default), `REQUIRE*` macros,
`expect` and `disallow` no longer call `abort()`. Instead, they throw an
exception that only stops the current test instead of stopping the entire test
program.
- Reporting of several unit test macros has been improved to show correct line
numbers and provide better diagnostic of test errors.
## [0.18.5] - 2021-07-16
......@@ -758,7 +793,8 @@ is based on [Keep a Changelog](https://keepachangelog.com).
- Setting the log level to `quiet` now properly suppresses any log output.
- Configuring colored terminal output should now print colored output.
[Unreleased]: https://github.com/actor-framework/actor-framework/compare/0.18.5...master
[Unreleased]: https://github.com/actor-framework/actor-framework/compare/0.18.6...master
[0.18.6]: https://github.com/actor-framework/actor-framework/releases/0.18.6
[0.18.5]: https://github.com/actor-framework/actor-framework/releases/0.18.5
[0.18.4]: https://github.com/actor-framework/actor-framework/releases/0.18.4
[0.18.3]: https://github.com/actor-framework/actor-framework/releases/0.18.3
......
......@@ -92,6 +92,8 @@ if(CMAKE_CXX_COMPILER_ID MATCHES "Clang" OR CMAKE_CXX_COMPILER_ID MATCHES "GNU")
target_compile_options(caf_internal INTERFACE
-Wno-missing-field-initializers)
endif()
elseif(MSVC)
target_compile_options(caf_internal INTERFACE /EHsc)
endif()
# -- unit testing setup / caf_add_test_suites function ------------------------
......
......@@ -20,6 +20,9 @@ endfunction()
add_core_example(. aout)
add_core_example(. hello_world)
# configuration API
add_core_example(config read-json)
# basic message passing primitives
add_core_example(message_passing calculator)
add_core_example(message_passing cell)
......
// Illustrates how to read custom data types from JSON files.
#include "caf/actor_system.hpp"
#include "caf/actor_system_config.hpp"
#include "caf/caf_main.hpp"
#include "caf/json_reader.hpp"
#include "caf/type_id.hpp"
#include <fstream>
#include <iostream>
#include <string>
#include <string_view>
constexpr std::string_view example_input = R"([
{
"id": 1,
"name": "John Doe"
},
{
"id": 2,
"name": "Jane Doe",
"email": "jane@doe.com"
}
])";
struct user {
uint32_t id;
std::string name;
std::optional<std::string> email;
};
template <class Inspector>
bool inspect(Inspector& f, user& x) {
return f.object(x).fields(f.field("id", x.id), f.field("name", x.name),
f.field("email", x.email));
}
using user_list = std::vector<user>;
CAF_BEGIN_TYPE_ID_BLOCK(example_app, caf::first_custom_type_id)
CAF_ADD_TYPE_ID(example_app, (user))
CAF_ADD_TYPE_ID(example_app, (user_list))
CAF_END_TYPE_ID_BLOCK(example_app)
int caf_main(caf::actor_system& sys) {
// Get file path from config (positional argument).
auto& cfg = sys.config();
if (cfg.remainder.size() != 1) {
std::cerr << "*** expected one positional argument: path to a JSON file\n";
return EXIT_FAILURE;
}
auto& file_path = cfg.remainder[0];
// Read file into a string.
std::ifstream input{file_path};
if (!input) {
std::cerr << "*** unable to open input file '" << file_path << "'\n";
return EXIT_FAILURE;
}
std::string json{std::istreambuf_iterator<char>{input},
std::istreambuf_iterator<char>{}};
// Parse the JSON-formatted text.
caf::json_reader reader;
if (!reader.load(json)) {
std::cerr << "*** failed to parse JSON input: "
<< to_string(reader.get_error()) << '\n';
return EXIT_FAILURE;
}
// Deserialize our user list from the parsed JSON.
user_list users;
if (!reader.apply(users)) {
std::cerr
<< "*** failed to deserialize the user list: "
<< to_string(reader.get_error())
<< "\n\nNote: expected a JSON list of user objects. For example:\n"
<< example_input << '\n';
return EXIT_FAILURE;
}
// Print the list in "CAF format".
std::cout << "Entries loaded from file:\n";
for (auto& entry : users)
std::cout << "- " << caf::deep_to_string(entry) << '\n';
return EXIT_SUCCESS;
}
CAF_MAIN(caf::id_block::example_app)
......@@ -271,6 +271,7 @@ caf_add_component(
detail.unique_function
detail.unordered_flat_map
dictionary
dsl
dynamic_spawn
error
expected
......
......@@ -22,7 +22,7 @@
/// Denotes version of CAF in the format {MAJOR}{MINOR}{PATCH},
/// whereas each number is a two-digit decimal number without
/// leading zeros (e.g. 900 is version 0.9.0).
#define CAF_VERSION 1805
#define CAF_VERSION 1806
/// Defined to the major version number of CAF.
#define CAF_MAJOR_VERSION (CAF_VERSION / 10000)
......@@ -191,8 +191,13 @@
# endif
#elif defined(__FreeBSD__)
# define CAF_BSD
# define CAF_FREE_BSD
#elif defined(__NetBSD__)
# define CAF_BSD
# define CAF_NET_BSD
#elif defined(__OpenBSD__)
# define CAF_BSD
# define CAF_OPEN_BSD
#elif defined(__CYGWIN__)
# define CAF_CYGWIN
#elif defined(WIN32) || defined(_WIN32)
......@@ -201,7 +206,7 @@
# error Platform and/or compiler not supported
#endif
#if defined(CAF_MACOS) || defined(CAF_LINUX) || defined(CAF_BSD) \
|| defined(CAF_CYGWIN)
|| defined(CAF_CYGWIN) || defined(CAF_NET_BSD)
# define CAF_POSIX
#endif
......
......@@ -17,6 +17,10 @@ namespace caf::detail {
/// later.
class CAF_CORE_EXPORT message_builder_element {
public:
message_builder_element() = default;
message_builder_element(const message_builder_element&) = delete;
message_builder_element& operator=(const message_builder_element&) = delete;
virtual ~message_builder_element();
/// Uses placement new to create a copy of the wrapped value at given memory
......@@ -34,10 +38,24 @@ public:
template <class T>
class message_builder_element_impl : public message_builder_element {
public:
message_builder_element_impl(T value) : value_(std::move(value)) {
template <class Value>
explicit message_builder_element_impl(Value&& value)
: value_(std::forward<Value>(value)) {
// nop
}
message_builder_element_impl() = delete;
message_builder_element_impl(message_builder_element_impl&&) = delete;
message_builder_element_impl(const message_builder_element_impl&) = delete;
message_builder_element_impl& operator=(message_builder_element_impl&&)
= delete;
message_builder_element_impl& operator=(const message_builder_element_impl&)
= delete;
byte* copy_init(byte* storage) const override {
new (storage) T(value_);
return storage + padded_size_v<T>;
......@@ -54,10 +72,4 @@ private:
using message_builder_element_ptr = std::unique_ptr<message_builder_element>;
template <class T>
auto make_message_builder_element(T&& x) {
using impl = message_builder_element_impl<std::decay_t<T>>;
return message_builder_element_ptr{new impl(std::forward<T>(x))};
}
} // namespace caf::detail
......@@ -45,12 +45,12 @@ public:
/// Adds `x` to the elements of the buffer.
template <class T>
message_builder& append(T&& x) {
using namespace detail;
using value_type = strip_and_convert_t<T>;
static_assert(sendable<value_type>);
storage_size_ += padded_size_v<value_type>;
using value_type = detail::strip_and_convert_t<T>;
static_assert(detail::sendable<value_type>);
using wrapper_type = detail::message_builder_element_impl<value_type>;
storage_size_ += detail::padded_size_v<value_type>;
types_.push_back(type_id_v<value_type>);
elements_.emplace_back(make_message_builder_element(std::forward<T>(x)));
elements_.emplace_back(std::make_unique<wrapper_type>(std::forward<T>(x)));
return *this;
}
......
......@@ -46,14 +46,18 @@ public:
}
/// Peeks into the mailbox of `next_job<scheduled_actor>()`.
template <class T>
const T& peek() {
template <class... Ts>
decltype(auto) peek() {
auto ptr = next_job<scheduled_actor>().mailbox().peek();
CAF_ASSERT(ptr != nullptr);
auto view = make_typed_message_view<T>(ptr->content());
if (!view)
CAF_RAISE_ERROR("Mailbox element does not match T.");
return get<0>(view);
if (auto view = make_const_typed_message_view<Ts...>(ptr->payload)) {
if constexpr (sizeof...(Ts) == 1)
return get<0>(view);
else
return to_tuple(view);
} else {
CAF_RAISE_ERROR("Mailbox element does not match.");
}
}
/// Puts `x` at the front of the queue unless it cannot be found in the queue.
......
......@@ -81,12 +81,7 @@ expected<T> get_as(const settings& xs, string_view name) {
}
/// @private
CAF_CORE_EXPORT config_value& put_impl(settings& dict,
const std::vector<string_view>& path,
config_value& value);
/// @private
CAF_CORE_EXPORT config_value& put_impl(settings& dict, string_view key,
CAF_CORE_EXPORT config_value& put_impl(settings& dict, string_view name,
config_value& value);
/// Converts `value` to a `config_value` and assigns it to `key`.
......
......@@ -45,6 +45,32 @@ std::string get_root_uuid() {
} // namespace detail
} // namespace caf
#elif defined(CAF_IOS) || defined(CAF_ANDROID) || defined(CAF_NET_BSD)
// Return a randomly-generated UUID on mobile devices or NetBSD (requires root
// access to get UUID from disk).
# include <random>
namespace caf {
namespace detail {
std::string get_root_uuid() {
std::random_device rd;
std::uniform_int_distribution<int> dist(0, 15);
std::string uuid = uuid_format;
for (auto& c : uuid) {
if (c != '-') {
auto n = dist(rd);
c = static_cast<char>((n < 10) ? n + '0' : (n - 10) + 'A');
}
}
return uuid;
}
} // namespace detail
} // namespace caf
#elif defined(CAF_LINUX) || defined(CAF_BSD) || defined(CAF_CYGWIN)
# include <algorithm>
......@@ -192,29 +218,4 @@ std::string get_root_uuid() {
} // namespace detail
} // namespace caf
#elif defined(CAF_IOS) || defined(CAF_ANDROID)
// return a randomly-generated UUID on mobile devices
# include <random>
namespace caf {
namespace detail {
std::string get_root_uuid() {
std::random_device rd;
std::uniform_int_distribution<int> dist(0, 15);
std::string uuid = uuid_format;
for (auto& c : uuid) {
if (c != '-') {
auto n = dist(rd);
c = static_cast<char>((n < 10) ? n + '0' : (n - 10) + 'A');
}
}
return uuid;
}
} // namespace detail
} // namespace caf
#endif // CAF_WINDOWS
......@@ -6,7 +6,11 @@
#include "caf/config.hpp"
#if defined(CAF_LINUX) || defined(CAF_MACOS)
#if defined(CAF_LINUX) || defined(CAF_MACOS) || defined(CAF_BSD)
# define CAF_HAS_CXX_ABI
#endif
#ifdef CAF_HAS_CXX_ABI
# include <cxxabi.h>
# include <sys/types.h>
# include <unistd.h>
......@@ -43,7 +47,7 @@ void prettify_type_name(std::string& class_name) {
}
void prettify_type_name(std::string& class_name, const char* c_class_name) {
#if defined(CAF_LINUX) || defined(CAF_MACOS)
#ifdef CAF_HAS_CXX_ABI
int stat = 0;
std::unique_ptr<char, decltype(free)*> real_class_name{nullptr, free};
auto tmp = abi::__cxa_demangle(c_class_name, nullptr, nullptr, &stat);
......
......@@ -12,7 +12,7 @@
#if defined(CAF_LINUX)
# include <sys/prctl.h>
#elif defined(CAF_BSD)
#elif defined(CAF_BSD) && !defined(CAF_NET_BSD)
# include <pthread_np.h>
#endif // defined(...)
......@@ -32,6 +32,8 @@ void set_thread_name(const char* name) {
pthread_setname_np(name);
# elif defined(CAF_LINUX)
prctl(PR_SET_NAME, name, 0, 0, 0);
# elif defined(CAF_NET_BSD)
pthread_setname_np(pthread_self(), name, NULL);
# elif defined(CAF_BSD)
pthread_set_name_np(pthread_self(), name);
# endif // defined(...)
......
......@@ -33,11 +33,14 @@ message to_message_impl(size_t storage_size, TypeListBuilder& types,
raw_ptr = new (vptr) message_data(types.copy_to_list());
intrusive_cow_ptr<message_data> ptr{raw_ptr, false};
auto storage = raw_ptr->storage();
for (auto& element : elements)
if constexpr (Policy == move_msg)
for (auto& element : elements) {
if constexpr (Policy == move_msg) {
storage = element->move_init(storage);
else
} else {
storage = element->copy_init(storage);
}
raw_ptr->inc_constructed_elements();
}
return message{std::move(ptr)};
}
......
......@@ -11,22 +11,32 @@ namespace caf {
// note: to_string is implemented in config_value.cpp
const config_value* get_if(const settings* xs, string_view name) {
// Access the key directly unless the user specified a dot-separated path.
auto pos = name.find('.');
if (pos == std::string::npos) {
auto i = xs->find(name);
if (i == xs->end())
return nullptr;
// We can't simply return the result here, because it might be a pointer.
return &i->second;
// The 'global' category is special in the sense that it refers back to the
// root. Somewhat like '::foo' in C++. This means we can just drop it here.
using namespace caf::literals;
auto gl = "global."_sv;
if (starts_with(name, gl))
name.remove_prefix(gl.size());
// Climb down the tree. In each step, we resolve `xs` and `name` to the next
// level until there is no category left to resolve. At that point it's a
// trivial name lookup.
for (;;) {
if (auto pos = name.find('.'); pos == std::string::npos) {
if (auto i = xs->find(name); i == xs->end())
return nullptr;
else
return &i->second;
} else {
auto category = name.substr(0, pos);
name.remove_prefix(pos + 1);
if (auto i = xs->find(category);
i == xs->end() || !holds_alternative<settings>(i->second)) {
return nullptr;
} else {
xs = std::addressof(get<settings>(i->second));
}
}
}
// We're dealing with a `<category>.<key>`-formatted string, extract the
// sub-settings by category and recurse.
auto i = xs->find(name.substr(0, pos));
if (i == xs->end() || !holds_alternative<config_value::dictionary>(i->second))
return nullptr;
return get_if(&get<config_value::dictionary>(i->second),
name.substr(pos + 1));
}
expected<std::string> get_or(const settings& xs, string_view name,
......@@ -41,8 +51,7 @@ config_value& put_impl(settings& dict, const std::vector<string_view>& path,
config_value& value) {
// Sanity check.
CAF_ASSERT(!path.empty());
// TODO: We implicitly swallow the `global.` suffix as a hotfix, but we
// actually should drop `global.` on the upper layers.
// Like in get_if: we always drop a 'global.' suffix.
if (path.front() == "global") {
std::vector<string_view> new_path{path.begin() + 1, path.end()};
return put_impl(dict, new_path, value);
......@@ -67,10 +76,33 @@ config_value& put_impl(settings& dict, const std::vector<string_view>& path,
return iter->second;
}
config_value& put_impl(settings& dict, string_view key, config_value& value) {
std::vector<string_view> path;
split(path, key, ".");
return put_impl(dict, path, value);
config_value& put_impl(settings& dict, string_view name, config_value& value) {
// Like in get_if: we always drop a 'global.' suffix.
using namespace caf::literals;
auto gl = "global."_sv;
if (starts_with(name, gl))
name.remove_prefix(gl.size());
// Climb down the tree, similar to get_if. Only this time, we create the
// necessary structure as we go until there is no category left to resolve. At
// that point it's a trivial insertion (override).
auto xs = &dict;
for (;;) {
if (auto pos = name.find('.'); pos == string_view::npos) {
return xs->insert_or_assign(name, std::move(value)).first->second;
} else {
auto category = name.substr(0, pos);
name.remove_prefix(pos + 1);
if (auto i = xs->find(category); i == xs->end()) {
auto j = xs->emplace(category, settings{}).first;
xs = std::addressof(get<settings>(j->second));
} else if (!holds_alternative<settings>(i->second)) {
i->second = settings{};
xs = std::addressof(get<settings>(i->second));
} else {
xs = std::addressof(get<settings>(i->second));
}
}
}
}
config_value::list& put_list(settings& xs, std::string name) {
......
......@@ -10,7 +10,7 @@
// -- detect supported platforms -----------------------------------------------
#if defined(CAF_MACOS) || defined(CAF_LINUX)
#if defined(CAF_MACOS) || defined(CAF_LINUX) || defined(CAF_NET_BSD)
# define CAF_HAS_PROCESS_METRICS
#endif
......@@ -117,19 +117,17 @@ sys_stats read_sys_stats() {
#endif // CAF_MACOS
// -- Linux-specific scraping logic --------------------------------------------
// -- helper for caching the result of a syscall -------------------------------
#ifdef CAF_LINUX
#if defined(CAF_LINUX) || defined(CAF_NET_BSD)
# include <cstdio>
# include <unistd.h>
namespace {
std::atomic<long> global_ticks_per_second;
std::atomic<long> global_page_size;
/// Caches the result from a `sysconf` call in a cache variable to avoid
/// frequent syscalls. Sets `cache_var` to -1 in case of an error. Initially,
/// `cache_var` must be 0 and we assume a successful syscall would always return
/// some value > 0. If `cache_var` is > 0 then this function simply returns the
/// cached value directly.
bool load_system_setting(std::atomic<long>& cache_var, long& var, int name,
[[maybe_unused]] const char* pretty_name) {
var = cache_var.load();
......@@ -143,9 +141,10 @@ bool load_system_setting(std::atomic<long>& cache_var, long& var, int name,
var = -1;
cache_var = var;
return false;
} else {
cache_var = var;
return true;
}
cache_var = var;
return true;
default:
return true;
}
......@@ -154,6 +153,20 @@ bool load_system_setting(std::atomic<long>& cache_var, long& var, int name,
# define TRY_LOAD(varname, confname) \
load_system_setting(global_##varname, varname, confname, #confname)
#endif
// -- Linux-specific scraping logic --------------------------------------------
#ifdef CAF_LINUX
# include <cstdio>
namespace {
std::atomic<long> global_ticks_per_second;
std::atomic<long> global_page_size;
sys_stats read_sys_stats() {
sys_stats result{0, 0, 0};
long ticks_per_second = 0;
......@@ -210,6 +223,41 @@ sys_stats read_sys_stats() {
} // namespace
// -- NetBSD-specific scraping logic -------------------------------------------
#elif defined(CAF_NET_BSD)
# include <sys/sysctl.h>
namespace {
std::atomic<long> global_page_size;
sys_stats read_sys_stats() {
auto result = sys_stats{0, 0, 0};
auto kip2 = kinfo_proc2{};
auto kip2_size = sizeof(kip2);
int mib[6] = {
CTL_KERN, KERN_PROC2, KERN_PROC_PID, getpid(), static_cast<int>(kip2_size),
1,
};
long page_size = 0;
if (!TRY_LOAD(page_size, _SC_PAGE_SIZE))
return result;
if (sysctl(mib, 6, &kip2, &kip2_size, nullptr, size_t{0}) != 0) {
CAF_LOG_ERROR("failed to call sysctl in read_sys_stats");
global_page_size = -1;
return result;
}
result.rss = static_cast<int64_t>(kip2.p_vm_rssize) * page_size;
result.vms = static_cast<int64_t>(kip2.p_vm_vsize) * page_size;
result.cpu_time = kip2.p_rtime_sec;
result.cpu_time += static_cast<double>(kip2.p_rtime_usec) / 1000000;
return result;
}
} // namespace
#endif // CAF_LINUX
namespace caf::telemetry::importer {
......
......@@ -63,19 +63,19 @@ struct fixture : test_coordinator_fixture<> {
} // namespace
CAF_TEST_FIXTURE_SCOPE(timer_tests, fixture)
BEGIN_FIXTURE_SCOPE(fixture)
CAF_TEST(run_delayed without dispose) {
// Have AUT call self->run_delayed().
self->send(aut, ok_atom_v);
expect((ok_atom), from(self).to(aut).with(_));
CAF_CHECK_EQUAL(t.actions.size(), 1u);
CHECK_EQ(t.actions.size(), 1u);
// Advance time to trigger timeout.
t.advance_time(10s);
CAF_CHECK_EQUAL(t.actions.size(), 0u);
CHECK_EQ(t.actions.size(), 0u);
// Have AUT receive the action.
expect((action), to(aut));
CAF_CHECK(state().run_delayed_called);
CHECK(state().run_delayed_called);
}
CAF_TEST(run_delayed with dispose before expire) {
......@@ -83,27 +83,27 @@ CAF_TEST(run_delayed with dispose before expire) {
self->send(aut, ok_atom_v);
expect((ok_atom), from(self).to(aut).with(_));
state().pending.dispose();
CAF_CHECK_EQUAL(t.actions.size(), 1u);
CHECK_EQ(t.actions.size(), 1u);
// Advance time, but the clock drops the disposed callback.
t.advance_time(10s);
CAF_CHECK_EQUAL(t.actions.size(), 0u);
CHECK_EQ(t.actions.size(), 0u);
// Have AUT receive the timeout.
disallow((action), to(aut));
CAF_CHECK(!state().run_delayed_called);
CHECK(!state().run_delayed_called);
}
CAF_TEST(run_delayed with dispose after expire) {
// Have AUT call self->run_delayed().
self->send(aut, ok_atom_v);
expect((ok_atom), from(self).to(aut).with(_));
CAF_CHECK_EQUAL(t.actions.size(), 1u);
CHECK_EQ(t.actions.size(), 1u);
// Advance time to send timeout message.
t.advance_time(10s);
CAF_CHECK_EQUAL(t.actions.size(), 0u);
CHECK_EQ(t.actions.size(), 0u);
// Have AUT receive the timeout but dispose it: turns into a nop.
state().pending.dispose();
expect((action), to(aut));
CAF_CHECK(!state().run_delayed_called);
CHECK(!state().run_delayed_called);
}
CAF_TEST(delay_actor_message) {
......@@ -113,10 +113,10 @@ CAF_TEST(delay_actor_message) {
t.schedule_message(n, autptr,
make_mailbox_element(autptr, make_message_id(), no_stages,
"foo"));
CAF_CHECK_EQUAL(t.actions.size(), 1u);
CHECK_EQ(t.actions.size(), 1u);
// Advance time to send the message.
t.advance_time(10s);
CAF_CHECK_EQUAL(t.actions.size(), 0u);
CHECK_EQ(t.actions.size(), 0u);
// Have AUT receive the message.
expect((std::string), from(aut).to(aut).with("foo"));
}
......@@ -130,10 +130,10 @@ CAF_TEST(delay_group_message) {
auto n = t.now() + 10s;
auto autptr = actor_cast<strong_actor_ptr>(aut);
t.schedule_message(n, std::move(grp), autptr, make_message("foo"));
CAF_CHECK_EQUAL(t.actions.size(), 1u);
CHECK_EQ(t.actions.size(), 1u);
// Advance time to send the message.
t.advance_time(10s);
CAF_CHECK_EQUAL(t.actions.size(), 0u);
CHECK_EQ(t.actions.size(), 0u);
// Have AUT receive the message.
expect((std::string), from(aut).to(aut).with("foo"));
// Kill AUT (necessary because the group keeps a reference around).
......@@ -141,4 +141,4 @@ CAF_TEST(delay_group_message) {
expect((exit_msg), from(self).to(aut).with(_));
}
CAF_TEST_FIXTURE_SCOPE_END()
END_FIXTURE_SCOPE()
......@@ -24,7 +24,7 @@ struct fixture {
void test_spawn(message args, bool expect_fail = false) {
actor_system system{cfg};
scoped_actor self{system};
CAF_MESSAGE("set aut");
MESSAGE("set aut");
strong_actor_ptr res;
std::set<std::string> ifs;
scoped_execution_unit context{&system};
......@@ -36,7 +36,7 @@ struct fixture {
}
CAF_REQUIRE(aut);
self->wait_for(*aut);
CAF_MESSAGE("aut done");
MESSAGE("aut done");
}
};
......@@ -46,42 +46,36 @@ struct test_actor_no_args : event_based_actor {
struct test_actor_one_arg : event_based_actor {
test_actor_one_arg(actor_config& conf, int value) : event_based_actor(conf) {
CAF_CHECK_EQUAL(value, 42);
CHECK_EQ(value, 42);
}
};
} // namespace
CAF_TEST_FIXTURE_SCOPE(add_actor_type_tests, fixture)
BEGIN_FIXTURE_SCOPE(fixture)
CAF_TEST(fun_no_args) {
auto test_actor_one_arg = [] {
CAF_MESSAGE("inside test_actor");
};
auto test_actor_one_arg = [] { MESSAGE("inside test_actor"); };
cfg.add_actor_type("test_actor", test_actor_one_arg);
test_spawn(make_message());
CAF_MESSAGE("test_spawn done");
MESSAGE("test_spawn done");
}
CAF_TEST(fun_no_args_selfptr) {
auto test_actor_one_arg = [](event_based_actor*) {
CAF_MESSAGE("inside test_actor");
MESSAGE("inside test_actor");
};
cfg.add_actor_type("test_actor", test_actor_one_arg);
test_spawn(make_message());
}
CAF_TEST(fun_one_arg) {
auto test_actor_one_arg = [](int i) {
CAF_CHECK_EQUAL(i, 42);
};
auto test_actor_one_arg = [](int i) { CHECK_EQ(i, 42); };
cfg.add_actor_type("test_actor", test_actor_one_arg);
test_spawn(make_message(42));
}
CAF_TEST(fun_one_arg_selfptr) {
auto test_actor_one_arg = [](event_based_actor*, int i) {
CAF_CHECK_EQUAL(i, 42);
};
auto test_actor_one_arg = [](event_based_actor*, int i) { CHECK_EQ(i, 42); };
cfg.add_actor_type("test_actor", test_actor_one_arg);
test_spawn(make_message(42));
}
......@@ -106,4 +100,4 @@ CAF_TEST(class_one_arg_valid) {
test_spawn(make_message(42));
}
CAF_TEST_FIXTURE_SCOPE_END()
END_FIXTURE_SCOPE()
......@@ -55,16 +55,16 @@ behavior tester(event_based_actor* self, const actor& aut) {
if (std::is_same<ExitMsgType, exit_msg>::value) {
self->set_exit_handler([self](exit_msg& msg) {
// must be still alive at this point
CAF_CHECK_EQUAL(s_testees.load(), 1);
CAF_CHECK_EQUAL(msg.reason, exit_reason::user_shutdown);
CHECK_EQ(s_testees.load(), 1);
CHECK_EQ(msg.reason, exit_reason::user_shutdown);
self->send(self, ok_atom_v);
});
self->link_to(aut);
} else {
self->set_down_handler([self](down_msg& msg) {
// must be still alive at this point
CAF_CHECK_EQUAL(s_testees.load(), 1);
CAF_CHECK_EQUAL(msg.reason, exit_reason::user_shutdown);
CHECK_EQ(s_testees.load(), 1);
CHECK_EQ(msg.reason, exit_reason::user_shutdown);
// testee might be still running its cleanup code in
// another worker thread; by waiting some milliseconds, we make sure
// testee had enough time to return control to the scheduler
......@@ -86,8 +86,8 @@ behavior tester(event_based_actor* self, const actor& aut) {
while (!s_testee_cleanup_done.load())
s_cv.wait(guard);
}
CAF_CHECK_EQUAL(s_testees.load(), 0);
CAF_CHECK_EQUAL(s_pending_on_exits.load(), 0);
CHECK_EQ(s_testees.load(), 0);
CHECK_EQ(s_pending_on_exits.load(), 0);
self->quit();
},
};
......@@ -166,11 +166,11 @@ CAF_TEST(destructor_call) {
actor_system system{cfg};
system.spawn<testee>();
}
CAF_CHECK_EQUAL(s_testees.load(), 0);
CAF_CHECK_EQUAL(s_pending_on_exits.load(), 0);
CHECK_EQ(s_testees.load(), 0);
CHECK_EQ(s_pending_on_exits.load(), 0);
}
CAF_TEST_FIXTURE_SCOPE(actor_lifetime_tests, fixture)
BEGIN_FIXTURE_SCOPE(fixture)
CAF_TEST(no_spawn_options_and_exit_msg) {
tst<exit_msg, no_spawn_options, no_spawn_options>();
......@@ -188,4 +188,4 @@ CAF_TEST(mixed_spawn_options_and_down_msg) {
tst<down_msg, detached, no_spawn_options>();
}
CAF_TEST_FIXTURE_SCOPE_END()
END_FIXTURE_SCOPE()
......@@ -59,7 +59,7 @@ struct fixture {
system.await_all_actors_done();
context.~scoped_execution_unit();
system.~actor_system();
CAF_CHECK_EQUAL(s_dtors.load(), s_ctors.load());
CHECK_EQ(s_dtors.load(), s_ctors.load());
}
};
......@@ -70,7 +70,7 @@ struct fixture {
} // namespace
CAF_TEST_FIXTURE_SCOPE(actor_pool_tests, fixture)
BEGIN_FIXTURE_SCOPE(fixture)
CAF_TEST(round_robin_actor_pool) {
scoped_actor self{system};
......@@ -82,28 +82,28 @@ CAF_TEST(round_robin_actor_pool) {
self->request(pool, infinite, i, i)
.receive(
[&](int32_t res) {
CAF_CHECK_EQUAL(res, i + i);
CHECK_EQ(res, i + i);
auto sender = actor_cast<strong_actor_ptr>(self->current_sender());
CAF_REQUIRE(sender);
workers.push_back(actor_cast<actor>(std::move(sender)));
},
HANDLE_ERROR);
}
CAF_CHECK_EQUAL(workers.size(), 6u);
CAF_CHECK(std::unique(workers.begin(), workers.end()) == workers.end());
CHECK_EQ(workers.size(), 6u);
CHECK(std::unique(workers.begin(), workers.end()) == workers.end());
self->request(pool, infinite, sys_atom_v, get_atom_v)
.receive(
[&](std::vector<actor>& ws) {
std::sort(workers.begin(), workers.end());
std::sort(ws.begin(), ws.end());
CAF_REQUIRE_EQUAL(workers.size(), ws.size());
CAF_CHECK(std::equal(workers.begin(), workers.end(), ws.begin()));
CHECK(std::equal(workers.begin(), workers.end(), ws.begin()));
},
HANDLE_ERROR);
CAF_MESSAGE("await last worker");
MESSAGE("await last worker");
anon_send_exit(workers.back(), exit_reason::user_shutdown);
self->wait_for(workers.back());
CAF_MESSAGE("last worker shut down");
MESSAGE("last worker shut down");
workers.pop_back();
// poll actor pool up to 10 times or until it removes the failed worker
bool success = false;
......@@ -115,7 +115,7 @@ CAF_TEST(round_robin_actor_pool) {
success = workers.size() == ws.size();
if (success) {
std::sort(ws.begin(), ws.end());
CAF_CHECK_EQUAL(workers, ws);
CHECK_EQ(workers, ws);
} else {
// wait a bit until polling again
std::this_thread::sleep_for(std::chrono::milliseconds(5));
......@@ -124,7 +124,7 @@ CAF_TEST(round_robin_actor_pool) {
HANDLE_ERROR);
}
CAF_REQUIRE_EQUAL(success, true);
CAF_MESSAGE("about to send exit to workers");
MESSAGE("about to send exit to workers");
self->send_exit(pool, exit_reason::user_shutdown);
self->wait_for(workers);
}
......@@ -135,18 +135,18 @@ CAF_TEST(broadcast_actor_pool) {
return actor_pool::make(&context, 5, fixture::spawn_worker,
actor_pool::broadcast());
};
CAF_CHECK_EQUAL(system.registry().running(), 1u);
CHECK_EQ(system.registry().running(), 1u);
auto pool = actor_pool::make(&context, 5, spawn5, actor_pool::broadcast());
CAF_CHECK_EQUAL(system.registry().running(), 32u);
CHECK_EQ(system.registry().running(), 32u);
self->send(pool, 1, 2);
std::vector<int> results;
int i = 0;
self->receive_for(i, 25)([&](int res) { results.push_back(res); },
after(std::chrono::milliseconds(250)) >>
[] { CAF_ERROR("didn't receive a result"); });
CAF_CHECK_EQUAL(results.size(), 25u);
CAF_CHECK(std::all_of(results.begin(), results.end(),
[](int res) { return res == 3; }));
CHECK_EQ(results.size(), 25u);
CHECK(std::all_of(results.begin(), results.end(),
[](int res) { return res == 3; }));
self->send_exit(pool, exit_reason::user_shutdown);
}
......@@ -155,9 +155,9 @@ CAF_TEST(random_actor_pool) {
auto pool = actor_pool::make(&context, 5, spawn_worker, actor_pool::random());
for (int i = 0; i < 5; ++i) {
self->request(pool, std::chrono::milliseconds(250), 1, 2)
.receive([&](int res) { CAF_CHECK_EQUAL(res, 3); }, HANDLE_ERROR);
.receive([&](int res) { CHECK_EQ(res, 3); }, HANDLE_ERROR);
}
self->send_exit(pool, exit_reason::user_shutdown);
}
CAF_TEST_FIXTURE_SCOPE_END()
END_FIXTURE_SCOPE()
......@@ -119,36 +119,36 @@ NAMED_ACTOR_STATE(worker);
} // namespace
CAF_TEST_FIXTURE_SCOPE(actor_profiler_tests, fixture)
BEGIN_FIXTURE_SCOPE(fixture)
CAF_TEST(profilers record actor construction) {
CAF_MESSAGE("fully initialize CAF, ignore system-internal actors");
MESSAGE("fully initialize CAF, ignore system-internal actors");
run();
rec.log.clear();
CAF_MESSAGE("spawn a foo and a bar");
MESSAGE("spawn a foo and a bar");
auto bar = [](stateful_actor<bar_state>*) {};
auto foo = [bar](stateful_actor<foo_state>* self) { self->spawn(bar); };
auto foo_actor = sys.spawn(foo);
run();
foo_actor = nullptr;
CAF_CHECK_EQUAL(string_list({
"new: foo",
"new: bar, parent: foo",
"delete: bar",
"delete: foo",
}),
rec.log);
CHECK_EQ(string_list({
"new: foo",
"new: bar, parent: foo",
"delete: bar",
"delete: foo",
}),
rec.log);
}
CAF_TEST(profilers record asynchronous messaging) {
CAF_MESSAGE("fully initialize CAF, ignore system-internal actors");
MESSAGE("fully initialize CAF, ignore system-internal actors");
run();
rec.log.clear();
CAF_MESSAGE("spawn a foo and a bar");
MESSAGE("spawn a foo and a bar");
auto bar = [](stateful_actor<bar_state>*) -> behavior {
return {
[](const std::string& str) {
CAF_CHECK_EQUAL(str, "hello bar");
CHECK_EQ(str, "hello bar");
return "hello foo";
},
};
......@@ -157,31 +157,31 @@ CAF_TEST(profilers record asynchronous messaging) {
auto b = self->spawn(bar);
self->send(b, "hello bar");
return {
[](const std::string& str) { CAF_CHECK_EQUAL(str, "hello foo"); },
[](const std::string& str) { CHECK_EQ(str, "hello foo"); },
};
};
sys.spawn(foo);
run();
CAF_CHECK_EQUAL(string_list({
R"__(new: foo)__",
R"__(new: bar, parent: foo)__",
R"__(foo sends: message("hello bar"))__",
R"__(bar got: message("hello bar"))__",
R"__(bar sends: message("hello foo"))__",
R"__(bar consumed the message)__",
R"__(foo got: message("hello foo"))__",
R"__(delete: bar)__",
R"__(foo consumed the message)__",
R"__(delete: foo)__",
}),
rec.log);
CHECK_EQ(string_list({
R"__(new: foo)__",
R"__(new: bar, parent: foo)__",
R"__(foo sends: message("hello bar"))__",
R"__(bar got: message("hello bar"))__",
R"__(bar sends: message("hello foo"))__",
R"__(bar consumed the message)__",
R"__(foo got: message("hello foo"))__",
R"__(delete: bar)__",
R"__(foo consumed the message)__",
R"__(delete: foo)__",
}),
rec.log);
}
CAF_TEST(profilers record request / response messaging) {
CAF_MESSAGE("fully initialize CAF, ignore system-internal actors");
MESSAGE("fully initialize CAF, ignore system-internal actors");
run();
rec.log.clear();
CAF_MESSAGE("spawn a client and a server with one worker");
MESSAGE("spawn a client and a server with one worker");
auto worker = [](stateful_actor<worker_state>*) -> behavior {
return {
[](int x, int y) { return x + y; },
......@@ -194,34 +194,34 @@ CAF_TEST(profilers record request / response messaging) {
};
auto client = [](stateful_actor<client_state>* self, actor serv) {
self->request(serv, infinite, 19, 23).then([](int result) {
CAF_CHECK_EQUAL(result, 42);
CHECK_EQ(result, 42);
});
};
sys.spawn(client, sys.spawn(server, sys.spawn(worker)));
run();
for (const auto& line : rec.log) {
CAF_MESSAGE(line);
MESSAGE(line);
}
CAF_CHECK_EQUAL(string_list({
"new: worker",
"new: server",
"new: client",
"client sends: message(19, 23)",
"server got: message(19, 23)",
"server sends: message(19, 23)",
"server consumed the message",
"delete: server",
"worker got: message(19, 23)",
"worker sends: message(42)",
"worker consumed the message",
"client got: message(42)",
"client consumed the message",
"delete: worker",
"delete: client",
}),
rec.log);
CHECK_EQ(string_list({
"new: worker",
"new: server",
"new: client",
"client sends: message(19, 23)",
"server got: message(19, 23)",
"server sends: message(19, 23)",
"server consumed the message",
"delete: server",
"worker got: message(19, 23)",
"worker sends: message(42)",
"worker consumed the message",
"client got: message(42)",
"client consumed the message",
"delete: worker",
"delete: client",
}),
rec.log);
}
CAF_TEST_FIXTURE_SCOPE_END()
END_FIXTURE_SCOPE()
#endif // CAF_ENABLE_ACTOR_PROFILER
......@@ -21,34 +21,34 @@ behavior dummy() {
} // namespace
CAF_TEST_FIXTURE_SCOPE(actor_registry_tests, test_coordinator_fixture<>)
BEGIN_FIXTURE_SCOPE(test_coordinator_fixture<>)
CAF_TEST(erase) {
// CAF registers a few actors by itself.
auto baseline = sys.registry().named_actors().size();
sys.registry().put("foo", sys.spawn(dummy));
CAF_CHECK_EQUAL(sys.registry().named_actors().size(), baseline + 1u);
CHECK_EQ(sys.registry().named_actors().size(), baseline + 1u);
self->send(sys.registry().get<actor>("foo"), 42);
run();
expect((int), from(_).to(self).with(42));
sys.registry().erase("foo");
CAF_CHECK_EQUAL(sys.registry().named_actors().size(), baseline);
CHECK_EQ(sys.registry().named_actors().size(), baseline);
}
CAF_TEST(serialization roundtrips go through the registry) {
auto hdl = sys.spawn(dummy);
CAF_MESSAGE("hdl.id: " << hdl->id());
MESSAGE("hdl.id: " << hdl->id());
byte_buffer buf;
binary_serializer sink{sys, buf};
if (!sink.apply(hdl))
CAF_FAIL("serialization failed: " << sink.get_error());
CAF_MESSAGE("buf: " << buf);
MESSAGE("buf: " << buf);
actor hdl2;
binary_deserializer source{sys, buf};
if (!source.apply(hdl2))
CAF_FAIL("deserialization failed: " << source.get_error());
CAF_CHECK_EQUAL(hdl, hdl2);
CHECK_EQ(hdl, hdl2);
anon_send_exit(hdl, exit_reason::user_shutdown);
}
CAF_TEST_FIXTURE_SCOPE_END()
END_FIXTURE_SCOPE()
......@@ -64,38 +64,38 @@ struct fixture {
} // namespace
CAF_TEST_FIXTURE_SCOPE(actor_system_config_tests, fixture)
BEGIN_FIXTURE_SCOPE(fixture)
CAF_TEST(parsing - without CLI arguments) {
auto text = "foo{\nbar=\"hello\"}";
options("?foo").add<std::string>("bar,b", "some string parameter");
parse(text);
CAF_CHECK(cfg.remainder.empty());
CAF_CHECK_EQUAL(get_or(cfg, "foo.bar", ""), "hello");
CHECK(cfg.remainder.empty());
CHECK_EQ(get_or(cfg, "foo.bar", ""), "hello");
auto [argc, argv] = cfg.c_args_remainder();
CAF_REQUIRE_EQUAL(argc, 1);
CAF_CHECK_EQUAL(argv[0], cfg.program_name);
CHECK_EQ(argv[0], cfg.program_name);
}
CAF_TEST(parsing - without CLI cfg.remainder) {
auto text = "foo{\nbar=\"hello\"}";
options("?foo").add<std::string>("bar,b", "some string parameter");
CAF_MESSAGE("CLI long name");
MESSAGE("CLI long name");
parse(text, {"--foo.bar=test"});
CAF_CHECK(cfg.remainder.empty());
CAF_CHECK_EQUAL(get_or(cfg, "foo.bar", ""), "test");
CAF_MESSAGE("CLI abbreviated long name");
CHECK(cfg.remainder.empty());
CHECK_EQ(get_or(cfg, "foo.bar", ""), "test");
MESSAGE("CLI abbreviated long name");
parse(text, {"--bar=test"});
CAF_CHECK(cfg.remainder.empty());
CAF_CHECK_EQUAL(get_or(cfg, "foo.bar", ""), "test");
CAF_MESSAGE("CLI short name");
CHECK(cfg.remainder.empty());
CHECK_EQ(get_or(cfg, "foo.bar", ""), "test");
MESSAGE("CLI short name");
parse(text, {"-b", "test"});
CAF_CHECK(cfg.remainder.empty());
CAF_CHECK_EQUAL(get_or(cfg, "foo.bar", ""), "test");
CAF_MESSAGE("CLI short name without whitespace");
CHECK(cfg.remainder.empty());
CHECK_EQ(get_or(cfg, "foo.bar", ""), "test");
MESSAGE("CLI short name without whitespace");
parse(text, {"-btest"});
CAF_CHECK(cfg.remainder.empty());
CAF_CHECK_EQUAL(get_or(cfg, "foo.bar", ""), "test");
CHECK(cfg.remainder.empty());
CHECK_EQ(get_or(cfg, "foo.bar", ""), "test");
}
CAF_TEST(parsing - with CLI cfg.remainder) {
......@@ -103,13 +103,13 @@ CAF_TEST(parsing - with CLI cfg.remainder) {
options("?foo").add<std::string>("bar,b", "some string parameter");
parse(text, {"-b", "test", "hello", "world"});
CAF_REQUIRE_EQUAL(cfg.remainder.size(), 2u);
CAF_CHECK_EQUAL(get_or(cfg, "foo.bar", ""), "test");
CAF_CHECK_EQUAL(cfg.remainder, string_list({"hello", "world"}));
CHECK_EQ(get_or(cfg, "foo.bar", ""), "test");
CHECK_EQ(cfg.remainder, string_list({"hello", "world"}));
auto [argc, argv] = cfg.c_args_remainder();
CAF_REQUIRE_EQUAL(argc, 3);
CAF_CHECK_EQUAL(argv[0], cfg.program_name);
CAF_CHECK_EQUAL(argv[1], cfg.remainder[0]);
CAF_CHECK_EQUAL(argv[2], cfg.remainder[1]);
CHECK_EQ(argv[0], cfg.program_name);
CHECK_EQ(argv[1], cfg.remainder[0]);
CHECK_EQ(argv[2], cfg.remainder[1]);
}
CAF_TEST(file input overrides defaults but CLI args always win) {
......@@ -137,17 +137,17 @@ CAF_TEST(file input overrides defaults but CLI args always win) {
string_list args{"--group1.arg2=123", "--group2.arg1=bye"};
std::istringstream input{file_input};
auto err = cfg.parse(std::move(args), input);
CAF_CHECK_EQUAL(err, error{});
CAF_CHECK_EQUAL(grp1.arg1, "foobar");
CAF_CHECK_EQUAL(grp1.arg2, 123);
CAF_CHECK_EQUAL(grp2.arg1, "bye");
CAF_CHECK_EQUAL(grp2.arg2, 2);
CHECK_EQ(err, error{});
CHECK_EQ(grp1.arg1, "foobar");
CHECK_EQ(grp1.arg2, 123);
CHECK_EQ(grp2.arg1, "bye");
CHECK_EQ(grp2.arg2, 2);
settings res;
put(res, "group1.arg1", "foobar");
put(res, "group1.arg2", 123);
put(res, "group2.arg1", "bye");
put(res, "group2.arg2", 2);
CAF_CHECK_EQUAL(content(cfg), res);
CHECK_EQ(content(cfg), res);
}
// Checks whether both a synced variable and the corresponding entry in
......@@ -156,9 +156,9 @@ CAF_TEST(file input overrides defaults but CLI args always win) {
do { \
using ref_value_type = std::decay_t<decltype(var)>; \
ref_value_type value{__VA_ARGS__}; \
CAF_CHECK_EQUAL(var, value); \
CHECK_EQ(var, value); \
if (auto maybe_val = get_as<decltype(var)>(cfg, #var)) { \
CAF_CHECK_EQUAL(*maybe_val, value); \
CHECK_EQ(*maybe_val, value); \
} else { \
auto cv = get_if(std::addressof(cfg.content), #var); \
CAF_ERROR("expected type " \
......@@ -169,7 +169,7 @@ CAF_TEST(file input overrides defaults but CLI args always win) {
// Checks whether an entry in content(cfg) is equal to `value`.
#define CHECK_TEXT_ONLY(type, var, value) \
CAF_CHECK_EQUAL(get_as<type>(cfg, #var), value)
CHECK_EQ(get_as<type>(cfg, #var), value)
#define ADD(var) add(var, #var, "...")
......@@ -271,21 +271,21 @@ CAF_TEST(basic and basic containers options) {
VAR(uri_map);
VAR(string_map);
parse(text);
CAF_MESSAGE("check primitive types");
MESSAGE("check primitive types");
CHECK_SYNCED(some_int, 42);
CHECK_SYNCED(some_bool, true);
CHECK_SYNCED(some_double, 1e23);
CHECK_SYNCED(some_timespan, 123_ms);
CHECK_SYNCED(some_uri, "foo:bar"_u);
CHECK_SYNCED(some_string, "string"s);
CAF_MESSAGE("check list types");
MESSAGE("check list types");
CHECK_SYNCED(some_int_list, 1, 2, 3);
CHECK_SYNCED(some_bool_list, false, true);
CHECK_SYNCED(some_double_list, 1., 2., 3.);
CHECK_SYNCED(some_timespan_list, 123_ms, 234_ms, 345_ms);
CHECK_SYNCED(some_uri_list, "foo:a"_u, "foo:b"_u, "foo:c"_u);
CHECK_SYNCED(some_string_list, "a", "b", "c");
CAF_MESSAGE("check dictionary types");
MESSAGE("check dictionary types");
CHECK_SYNCED(some_int_map, {"a", 1}, {"b", 2}, {"c", 3});
CHECK_SYNCED(some_bool_map, {"a", true}, {"b", false});
CHECK_SYNCED(some_double_map, {"a", 1.}, {"b", 2.}, {"c", 3.});
......@@ -335,4 +335,4 @@ SCENARIO("config files allow both nested and dot-separated values") {
}
}
CAF_TEST_FIXTURE_SCOPE_END()
END_FIXTURE_SCOPE()
......@@ -19,7 +19,7 @@ behavior mirror_impl(event_based_actor* self) {
};
}
struct fixture : test_coordinator_fixture<> {
struct fixture : test_coordinator_fixture<> {
actor mirror;
actor testee;
......@@ -41,7 +41,7 @@ struct fixture : test_coordinator_fixture<> {
} // namespace
CAF_TEST_FIXTURE_SCOPE(actor_termination_tests, fixture)
BEGIN_FIXTURE_SCOPE(fixture)
CAF_TEST(single_multiplexed_request) {
auto f = [&](event_based_actor* self, actor server) {
......@@ -78,11 +78,9 @@ CAF_TEST(multiple_multiplexed_requests) {
CAF_TEST(single_awaited_request) {
auto f = [&](event_based_actor* self, actor server) {
self->request(server, infinite, 42).await(
[=](int x) {
CAF_REQUIRE_EQUAL(x, 42);
}
);
self->request(server, infinite, 42).await([=](int x) {
CAF_REQUIRE_EQUAL(x, 42);
});
};
spawn(f, mirror);
// run initialization code of testee
......@@ -94,12 +92,10 @@ CAF_TEST(single_awaited_request) {
CAF_TEST(multiple_awaited_requests) {
auto f = [&](event_based_actor* self, actor server) {
for (int i = 0; i < 3; ++i)
self->request(server, infinite, i).await(
[=](int x) {
CAF_MESSAGE("received response #" << (i + 1));
CAF_REQUIRE_EQUAL(x, i);
}
);
self->request(server, infinite, i).await([=](int x) {
MESSAGE("received response #" << (i + 1));
CAF_REQUIRE_EQUAL(x, i);
});
};
spawn(f, mirror);
// run initialization code of testee
......@@ -114,4 +110,4 @@ CAF_TEST(multiple_awaited_requests) {
expect((down_msg), from(testee).to(self).with(_));
}
CAF_TEST_FIXTURE_SCOPE_END()
END_FIXTURE_SCOPE()
......@@ -42,23 +42,21 @@ struct fixture {
} // namespace
CAF_TEST_FIXTURE_SCOPE(adapter_tests, fixture)
BEGIN_FIXTURE_SCOPE(fixture)
CAF_TEST(redirect_aout_globally) {
self->join(system.groups().get_local(global_redirect));
actor_ostream::redirect_all(system, global_redirect);
system.spawn(chatty_actor);
self->receive(
[](const std::string& virtual_file, std::string& line) {
// drop trailing '\n'
if (!line.empty())
line.pop_back();
CAF_CHECK_EQUAL(virtual_file, ":test");
CAF_CHECK_EQUAL(line, chatty_line);
}
);
self->receive([](const std::string& virtual_file, std::string& line) {
// drop trailing '\n'
if (!line.empty())
line.pop_back();
CHECK_EQ(virtual_file, ":test");
CHECK_EQ(line, chatty_line);
});
self->await_all_other_actors_done();
CAF_CHECK_EQUAL(self->mailbox().size(), 0u);
CHECK_EQ(self->mailbox().size(), 0u);
}
CAF_TEST(global_and_local_redirect) {
......@@ -67,24 +65,19 @@ CAF_TEST(global_and_local_redirect) {
actor_ostream::redirect_all(system, global_redirect);
system.spawn(chatty_actor);
system.spawn(chattier_actor, local_redirect);
std::vector<std::pair<std::string, std::string>> expected {
{":test", chatty_line},
{":test", chatty_line},
{":test2", chattier_line}
};
std::vector<std::pair<std::string, std::string>> expected{
{":test", chatty_line}, {":test", chatty_line}, {":test2", chattier_line}};
std::vector<std::pair<std::string, std::string>> lines;
int i = 0;
self->receive_for(i, 3)(
[&](std::string& virtual_file, std::string& line) {
// drop trailing '\n'
if (!line.empty())
line.pop_back();
lines.emplace_back(std::move(virtual_file), std::move(line));
}
);
CAF_CHECK(std::is_permutation(lines.begin(), lines.end(), expected.begin()));
self->receive_for(i, 3)([&](std::string& virtual_file, std::string& line) {
// drop trailing '\n'
if (!line.empty())
line.pop_back();
lines.emplace_back(std::move(virtual_file), std::move(line));
});
CHECK(std::is_permutation(lines.begin(), lines.end(), expected.begin()));
self->await_all_other_actors_done();
CAF_CHECK_EQUAL(self->mailbox().size(), 0u);
CHECK_EQ(self->mailbox().size(), 0u);
}
CAF_TEST_FIXTURE_SCOPE_END()
END_FIXTURE_SCOPE()
......@@ -10,12 +10,12 @@
#include <functional>
#include "caf/send.hpp"
#include "caf/behavior.hpp"
#include "caf/actor_system.hpp"
#include "caf/message_handler.hpp"
#include "caf/event_based_actor.hpp"
#include "caf/actor_system_config.hpp"
#include "caf/behavior.hpp"
#include "caf/event_based_actor.hpp"
#include "caf/message_handler.hpp"
#include "caf/send.hpp"
using namespace caf;
......@@ -57,48 +57,43 @@ struct fixture {
} // namespace
CAF_TEST_FIXTURE_SCOPE(behavior_tests, fixture)
BEGIN_FIXTURE_SCOPE(fixture)
CAF_TEST(default_construct) {
behavior f;
CAF_CHECK_EQUAL(f(m1), none);
CAF_CHECK_EQUAL(f(m2), none);
CAF_CHECK_EQUAL(f(m3), none);
CHECK_EQ(f(m1), none);
CHECK_EQ(f(m2), none);
CHECK_EQ(f(m3), none);
}
CAF_TEST(nocopy_function_object) {
behavior f{nocopy_fun{}};
CAF_CHECK_EQUAL(f(m1), none);
CAF_CHECK_EQUAL(res_of(f, m2), 3);
CAF_CHECK_EQUAL(f(m3), none);
CHECK_EQ(f(m1), none);
CHECK_EQ(res_of(f, m2), 3);
CHECK_EQ(f(m3), none);
}
CAF_TEST(single_lambda_construct) {
behavior f{[](int x) { return x + 1; }};
CAF_CHECK_EQUAL(res_of(f, m1), 2);
CAF_CHECK_EQUAL(res_of(f, m2), none);
CAF_CHECK_EQUAL(res_of(f, m3), none);
CHECK_EQ(res_of(f, m1), 2);
CHECK_EQ(res_of(f, m2), none);
CHECK_EQ(res_of(f, m3), none);
}
CAF_TEST(multiple_lambda_construct) {
behavior f{
[](int x) { return x + 1; },
[](int x, int y) { return x * y; }
};
CAF_CHECK_EQUAL(res_of(f, m1), 2);
CAF_CHECK_EQUAL(res_of(f, m2), 2);
CAF_CHECK_EQUAL(res_of(f, m3), none);
behavior f{[](int x) { return x + 1; }, [](int x, int y) { return x * y; }};
CHECK_EQ(res_of(f, m1), 2);
CHECK_EQ(res_of(f, m2), 2);
CHECK_EQ(res_of(f, m3), none);
}
CAF_TEST(become_empty_behavior) {
actor_system_config cfg{};
actor_system sys{cfg};
auto make_bhvr = [](event_based_actor* self) -> behavior {
return {
[=](int) { self->become(behavior{}); }
};
return {[=](int) { self->become(behavior{}); }};
};
anon_send(sys.spawn(make_bhvr), int{5});
}
CAF_TEST_FIXTURE_SCOPE_END()
END_FIXTURE_SCOPE()
......@@ -60,16 +60,13 @@ struct fixture {
} // namespace
CAF_TEST_FIXTURE_SCOPE(binary_deserializer_tests, fixture)
BEGIN_FIXTURE_SCOPE(fixture)
#define SUBTEST(msg) \
CAF_MESSAGE(msg); \
for (int subtest_dummy = 0; subtest_dummy < 1; ++subtest_dummy)
MESSAGE(msg); \
if (true)
#define CHECK_EQ(lhs, rhs) CAF_CHECK_EQUAL(lhs, rhs)
#define CHECK_LOAD(type, value, ...) \
CAF_CHECK_EQUAL(load<type>({__VA_ARGS__}), value)
#define CHECK_LOAD(type, value, ...) CHECK_EQ(load<type>({__VA_ARGS__}), value)
CAF_TEST(binary deserializer handles all primitive types) {
SUBTEST("8-bit integers") {
......@@ -112,8 +109,8 @@ CAF_TEST(concatenation) {
int8_t x = 0;
int16_t y = 0;
load(byte_buffer({7_b, 0x80_b, 0x55_b}), x, y);
CAF_CHECK_EQUAL(x, 7);
CAF_CHECK_EQUAL(y, -32683);
CHECK_EQ(x, 7);
CHECK_EQ(y, -32683);
load(byte_buffer({0x80_b, 0x55_b, 7_b}), y, x);
load(byte_buffer({7_b, 0x80_b, 0x55_b}), x, y);
}
......@@ -136,9 +133,9 @@ CAF_TEST(concatenation) {
SUBTEST("arrays behave like tuples") {
arr xs{{0, 0, 0}};
load(byte_buffer({1_b, 2_b, 3_b}), xs);
CAF_CHECK_EQUAL(xs[0], 1);
CAF_CHECK_EQUAL(xs[1], 2);
CAF_CHECK_EQUAL(xs[2], 3);
CHECK_EQ(xs[0], 1);
CHECK_EQ(xs[1], 2);
CHECK_EQ(xs[2], 3);
}
}
......@@ -166,14 +163,14 @@ CAF_TEST(binary serializer picks up inspect functions) {
10_b, 11_b, 12_b, 13_b, 14_b, 15_b, 16_b, 17_b, 18_b, 19_b);
}
SUBTEST("custom struct") {
test_data value{
-345,
-1234567890123456789ll,
3.45,
54.3,
caf::timestamp{caf::timestamp::duration{1478715821 * 1000000000ll}},
test_enum::b,
"Lorem ipsum dolor sit amet."};
test_data value{-345,
-1234567890123456789ll,
3.45,
54.3,
caf::timestamp{
caf::timestamp::duration{1478715821 * 1000000000ll}},
test_enum::b,
"Lorem ipsum dolor sit amet."};
CHECK_LOAD(test_data, value,
// 32-bit i32_ member: -345
0xFF_b, 0xFF_b, 0xFE_b, 0xA7_b,
......@@ -199,4 +196,4 @@ CAF_TEST(binary serializer picks up inspect functions) {
}
}
CAF_TEST_FIXTURE_SCOPE_END()
END_FIXTURE_SCOPE()
......@@ -59,14 +59,14 @@ struct fixture {
} // namespace
CAF_TEST_FIXTURE_SCOPE(binary_serializer_tests, fixture)
BEGIN_FIXTURE_SCOPE(fixture)
#define SUBTEST(msg) \
CAF_MESSAGE(msg); \
for (int subtest_dummy = 0; subtest_dummy < 1; ++subtest_dummy)
MESSAGE(msg); \
if (true)
#define CHECK_SAVE(type, value, ...) \
CAF_CHECK_EQUAL(save(type{value}), byte_buffer({__VA_ARGS__}))
CHECK_EQ(save(type{value}), byte_buffer({__VA_ARGS__}))
CAF_TEST(primitive types) {
SUBTEST("8-bit integers") {
......@@ -106,17 +106,17 @@ CAF_TEST(primitive types) {
CAF_TEST(concatenation) {
SUBTEST("calling f(a, b) writes a and b into the buffer in order") {
CAF_CHECK_EQUAL(save(int8_t{7}, int16_t{-32683}),
byte_buffer({7_b, 0x80_b, 0x55_b}));
CAF_CHECK_EQUAL(save(int16_t{-32683}, int8_t{7}),
byte_buffer({0x80_b, 0x55_b, 7_b}));
CHECK_EQ(save(int8_t{7}, int16_t{-32683}),
byte_buffer({7_b, 0x80_b, 0x55_b}));
CHECK_EQ(save(int16_t{-32683}, int8_t{7}),
byte_buffer({0x80_b, 0x55_b, 7_b}));
}
SUBTEST("calling f(a) and then f(b) is equal to calling f(a, b)") {
byte_buffer data;
binary_serializer sink{nullptr, data};
save_to_buf(data, int8_t{7});
save_to_buf(data, int16_t{-32683});
CAF_CHECK_EQUAL(data, byte_buffer({7_b, 0x80_b, 0x55_b}));
CHECK_EQ(data, byte_buffer({7_b, 0x80_b, 0x55_b}));
}
SUBTEST("calling f(make_pair(a, b)) is equal to calling f(a, b)") {
using i8i16_pair = std::pair<int8_t, int16_t>;
......@@ -136,7 +136,7 @@ CAF_TEST(concatenation) {
}
SUBTEST("arrays behave like tuples") {
arr xs{{1, 2, 3}};
CAF_CHECK_EQUAL(save(xs), byte_buffer({1_b, 2_b, 3_b}));
CHECK_EQ(save(xs), byte_buffer({1_b, 2_b, 3_b}));
}
}
......@@ -165,13 +165,8 @@ CAF_TEST(binary serializer picks up inspect functions) {
}
SUBTEST("custom struct") {
caf::timestamp ts{caf::timestamp::duration{1478715821 * 1000000000ll}};
test_data value{-345,
-1234567890123456789ll,
3.45,
54.3,
ts,
test_enum::b,
"Lorem ipsum dolor sit amet."};
test_data value{-345, -1234567890123456789ll, 3.45, 54.3, ts,
test_enum::b, "Lorem ipsum dolor sit amet."};
CHECK_SAVE(test_data, value,
// 32-bit i32_ member: -345
0xFF_b, 0xFF_b, 0xFE_b, 0xA7_b,
......@@ -197,4 +192,4 @@ CAF_TEST(binary serializer picks up inspect functions) {
}
}
CAF_TEST_FIXTURE_SCOPE_END()
END_FIXTURE_SCOPE()
......@@ -24,28 +24,21 @@ struct fixture {
} // namespace
CAF_TEST_FIXTURE_SCOPE(blocking_actor_tests, fixture)
BEGIN_FIXTURE_SCOPE(fixture)
CAF_TEST(catch_all) {
self->send(self, 42);
self->receive([](float) { CAF_FAIL("received unexpected float"); },
others >> [](message& msg) -> skippable_result {
CAF_CHECK_EQUAL(to_tuple<int32_t>(msg), std::make_tuple(42));
CHECK_EQ(to_tuple<int32_t>(msg), std::make_tuple(42));
return make_error(sec::unexpected_message);
});
self->receive(
[](const error& err) {
CAF_CHECK_EQUAL(err, sec::unexpected_message);
}
);
[](const error& err) { CHECK_EQ(err, sec::unexpected_message); });
}
CAF_TEST(behavior_ref) {
behavior bhvr{
[](int i) {
CAF_CHECK_EQUAL(i, 42);
}
};
behavior bhvr{[](int i) { CHECK_EQ(i, 42); }};
self->send(self, 42);
self->receive(bhvr);
}
......@@ -53,12 +46,9 @@ CAF_TEST(behavior_ref) {
CAF_TEST(timeout_in_scoped_actor) {
bool timeout_called = false;
scoped_actor self{system};
self->receive(
after(std::chrono::milliseconds(20)) >> [&] {
timeout_called = true;
}
);
CAF_CHECK(timeout_called);
self->receive(after(std::chrono::milliseconds(20)) >>
[&] { timeout_called = true; });
CHECK(timeout_called);
}
CAF_TEST_FIXTURE_SCOPE_END()
END_FIXTURE_SCOPE()
......@@ -46,61 +46,61 @@ struct fixture {
} // namespace
CAF_TEST_FIXTURE_SCOPE(byte_tests, fixture)
BEGIN_FIXTURE_SCOPE(fixture)
CAF_TEST(to integer) {
CAF_CHECK_EQUAL(to_integer<int>("0110'1001"_b), 0x69);
CHECK_EQ(to_integer<int>("0110'1001"_b), 0x69);
}
CAF_TEST(left shift) {
auto x = "0000'0001"_b;
x <<= 1;
CAF_CHECK_EQUAL(x, "0000'0010"_b);
CAF_CHECK_EQUAL("0000'0010"_b << 1, "0000'0100"_b);
CAF_CHECK_EQUAL("0000'0010"_b << 2, "0000'1000"_b);
CAF_CHECK_EQUAL("0000'0010"_b << 3, "0001'0000"_b);
CAF_CHECK_EQUAL("0000'0010"_b << 4, "0010'0000"_b);
CAF_CHECK_EQUAL("0000'0010"_b << 5, "0100'0000"_b);
CAF_CHECK_EQUAL("0000'0010"_b << 6, "1000'0000"_b);
CAF_CHECK_EQUAL("0000'0010"_b << 7, "0000'0000"_b);
CHECK_EQ(x, "0000'0010"_b);
CHECK_EQ("0000'0010"_b << 1, "0000'0100"_b);
CHECK_EQ("0000'0010"_b << 2, "0000'1000"_b);
CHECK_EQ("0000'0010"_b << 3, "0001'0000"_b);
CHECK_EQ("0000'0010"_b << 4, "0010'0000"_b);
CHECK_EQ("0000'0010"_b << 5, "0100'0000"_b);
CHECK_EQ("0000'0010"_b << 6, "1000'0000"_b);
CHECK_EQ("0000'0010"_b << 7, "0000'0000"_b);
}
CAF_TEST(right shift) {
auto x = "0100'0000"_b;
x >>= 1;
CAF_CHECK_EQUAL(x, "0010'0000"_b);
CAF_CHECK_EQUAL("0100'0000"_b >> 1, "0010'0000"_b);
CAF_CHECK_EQUAL("0100'0000"_b >> 2, "0001'0000"_b);
CAF_CHECK_EQUAL("0100'0000"_b >> 3, "0000'1000"_b);
CAF_CHECK_EQUAL("0100'0000"_b >> 4, "0000'0100"_b);
CAF_CHECK_EQUAL("0100'0000"_b >> 5, "0000'0010"_b);
CAF_CHECK_EQUAL("0100'0000"_b >> 6, "0000'0001"_b);
CAF_CHECK_EQUAL("0100'0000"_b >> 7, "0000'0000"_b);
CHECK_EQ(x, "0010'0000"_b);
CHECK_EQ("0100'0000"_b >> 1, "0010'0000"_b);
CHECK_EQ("0100'0000"_b >> 2, "0001'0000"_b);
CHECK_EQ("0100'0000"_b >> 3, "0000'1000"_b);
CHECK_EQ("0100'0000"_b >> 4, "0000'0100"_b);
CHECK_EQ("0100'0000"_b >> 5, "0000'0010"_b);
CHECK_EQ("0100'0000"_b >> 6, "0000'0001"_b);
CHECK_EQ("0100'0000"_b >> 7, "0000'0000"_b);
}
CAF_TEST(bitwise or) {
auto x = "0001'1110"_b;
x |= "0111'1000"_b;
CAF_CHECK_EQUAL(x, "0111'1110"_b);
CAF_CHECK_EQUAL("0001'1110"_b | "0111'1000"_b, "0111'1110"_b);
CHECK_EQ(x, "0111'1110"_b);
CHECK_EQ("0001'1110"_b | "0111'1000"_b, "0111'1110"_b);
}
CAF_TEST(bitwise and) {
auto x = "0001'1110"_b;
x &= "0111'1000"_b;
CAF_CHECK_EQUAL(x, "0001'1000"_b);
CAF_CHECK_EQUAL("0001'1110"_b & "0111'1000"_b, "0001'1000"_b);
CHECK_EQ(x, "0001'1000"_b);
CHECK_EQ("0001'1110"_b & "0111'1000"_b, "0001'1000"_b);
}
CAF_TEST(bitwise xor) {
auto x = "0001'1110"_b;
x ^= "0111'1000"_b;
CAF_CHECK_EQUAL(x, "0110'0110"_b);
CAF_CHECK_EQUAL("0001'1110"_b ^ "0111'1000"_b, "0110'0110"_b);
CHECK_EQ(x, "0110'0110"_b);
CHECK_EQ("0001'1110"_b ^ "0111'1000"_b, "0110'0110"_b);
}
CAF_TEST(bitwise not) {
CAF_CHECK_EQUAL(~"0111'1110"_b, "1000'0001"_b);
CAF_TEST(bitwise not ) {
CHECK_EQ(~"0111'1110"_b, "1000'0001"_b);
}
CAF_TEST_FIXTURE_SCOPE_END()
END_FIXTURE_SCOPE()
......@@ -13,40 +13,24 @@ using namespace caf;
namespace {
behavior multiplier(int x) {
return {
[=](int y) {
return x * y;
},
[=](int y1, int y2) {
return x * y1 * y2;
}
};
return {[=](int y) { return x * y; },
[=](int y1, int y2) { return x * y1 * y2; }};
}
behavior adder(int x) {
return {
[=](int y) {
return x + y;
},
[=](int y1, int y2) {
return x + y1 + y2;
}
};
return {[=](int y) { return x + y; },
[=](int y1, int y2) { return x + y1 + y2; }};
}
behavior float_adder(float x) {
return {
[=](float y) {
return x + y;
}
};
return {[=](float y) { return x + y; }};
}
using fixture = test_coordinator_fixture<>;
} // namespace
CAF_TEST_FIXTURE_SCOPE(composition_tests, fixture)
BEGIN_FIXTURE_SCOPE(fixture)
CAF_TEST(depth2) {
auto stage1 = sys.spawn(multiplier, 4);
......@@ -79,4 +63,4 @@ CAF_TEST(depth2_type_mismatch) {
expect((error), from(stage2).to(self).with(sec::unexpected_message));
}
CAF_TEST_FIXTURE_SCOPE_END()
END_FIXTURE_SCOPE()
......@@ -10,9 +10,9 @@
#include <sstream>
#include "caf/make_config_option.hpp"
#include "caf/config_value.hpp"
#include "caf/expected.hpp"
#include "caf/make_config_option.hpp"
using namespace caf;
......@@ -173,12 +173,12 @@ constexpr string_view category = "category";
constexpr string_view name = "name";
constexpr string_view explanation = "explanation";
template<class T>
template <class T>
constexpr int64_t overflow() {
return static_cast<int64_t>(std::numeric_limits<T>::max()) + 1;
}
template<class T>
template <class T>
constexpr int64_t underflow() {
return static_cast<int64_t>(std::numeric_limits<T>::min()) - 1;
}
......@@ -201,9 +201,9 @@ void check_integer_options(std::true_type) {
// Run tests for positive integers.
T xzero = 0;
T xmax = std::numeric_limits<T>::max();
CAF_CHECK_EQUAL(read<T>(to_string(xzero)), xzero);
CAF_CHECK_EQUAL(read<T>(to_string(xmax)), xmax);
CAF_CHECK_EQUAL(read<T>(to_string(overflow<T>())), none);
CHECK_EQ(read<T>(to_string(xzero)), xzero);
CHECK_EQ(read<T>(to_string(xmax)), xmax);
CHECK_EQ(read<T>(to_string(overflow<T>())), none);
}
// Signed integers.
......@@ -215,8 +215,8 @@ void check_integer_options(std::false_type) {
check_integer_options<T>(tk);
// Run tests for negative integers.
auto xmin = std::numeric_limits<T>::min();
CAF_CHECK_EQUAL(read<T>(to_string(xmin)), xmin);
CAF_CHECK_EQUAL(read<T>(to_string(underflow<T>())), none);
CHECK_EQ(read<T>(to_string(xmin)), xmin);
CHECK_EQ(read<T>(to_string(underflow<T>())), none);
}
// only works with an integral types and double
......@@ -227,11 +227,11 @@ void check_integer_options() {
}
void compare(const config_option& lhs, const config_option& rhs) {
CAF_CHECK_EQUAL(lhs.category(), rhs.category());
CAF_CHECK_EQUAL(lhs.long_name(), rhs.long_name());
CAF_CHECK_EQUAL(lhs.short_names(), rhs.short_names());
CAF_CHECK_EQUAL(lhs.description(), rhs.description());
CAF_CHECK_EQUAL(lhs.full_name(), rhs.full_name());
CHECK_EQ(lhs.category(), rhs.category());
CHECK_EQ(lhs.long_name(), rhs.long_name());
CHECK_EQ(lhs.short_names(), rhs.short_names());
CHECK_EQ(lhs.description(), rhs.description());
CHECK_EQ(lhs.full_name(), rhs.full_name());
}
CAF_TEST(copy constructor) {
......@@ -248,10 +248,10 @@ CAF_TEST(copy assignment) {
}
CAF_TEST(type_bool) {
CAF_CHECK_EQUAL(read<bool>("true"), true);
CAF_CHECK_EQUAL(read<bool>("false"), false);
CAF_CHECK_EQUAL(read<bool>("0"), none);
CAF_CHECK_EQUAL(read<bool>("1"), none);
CHECK_EQ(read<bool>("true"), true);
CHECK_EQ(read<bool>("false"), false);
CHECK_EQ(read<bool>("0"), none);
CHECK_EQ(read<bool>("1"), none);
}
CAF_TEST(type int8_t) {
......@@ -279,74 +279,74 @@ CAF_TEST(type uint32_t) {
}
CAF_TEST(type uint64_t) {
CAF_CHECK_EQUAL(unbox(read<uint64_t>("0")), 0u);
CAF_CHECK_EQUAL(read<uint64_t>("-1"), none);
CHECK_EQ(unbox(read<uint64_t>("0")), 0u);
CHECK_EQ(read<uint64_t>("-1"), none);
}
CAF_TEST(type int64_t) {
CAF_CHECK_EQUAL(unbox(read<int64_t>("-1")), -1);
CAF_CHECK_EQUAL(unbox(read<int64_t>("0")), 0);
CAF_CHECK_EQUAL(unbox(read<int64_t>("1")), 1);
CHECK_EQ(unbox(read<int64_t>("-1")), -1);
CHECK_EQ(unbox(read<int64_t>("0")), 0);
CHECK_EQ(unbox(read<int64_t>("1")), 1);
}
CAF_TEST(type float) {
CAF_CHECK_EQUAL(unbox(read<float>("-1.0")), -1.0f);
CAF_CHECK_EQUAL(unbox(read<float>("-0.1")), -0.1f);
CAF_CHECK_EQUAL(read<float>("0"), 0.f);
CAF_CHECK_EQUAL(read<float>("\"0.1\""), none);
CHECK_EQ(unbox(read<float>("-1.0")), -1.0f);
CHECK_EQ(unbox(read<float>("-0.1")), -0.1f);
CHECK_EQ(read<float>("0"), 0.f);
CHECK_EQ(read<float>("\"0.1\""), none);
}
CAF_TEST(type double) {
CAF_CHECK_EQUAL(unbox(read<double>("-1.0")), -1.0);
CAF_CHECK_EQUAL(unbox(read<double>("-0.1")), -0.1);
CAF_CHECK_EQUAL(read<double>("0"), 0.);
CAF_CHECK_EQUAL(read<double>("\"0.1\""), none);
CHECK_EQ(unbox(read<double>("-1.0")), -1.0);
CHECK_EQ(unbox(read<double>("-0.1")), -0.1);
CHECK_EQ(read<double>("0"), 0.);
CHECK_EQ(read<double>("\"0.1\""), none);
}
CAF_TEST(type string) {
CAF_CHECK_EQUAL(unbox(read<string>("foo")), "foo");
CAF_CHECK_EQUAL(unbox(read<string>(R"_("foo")_")), R"_("foo")_");
CHECK_EQ(unbox(read<string>("foo")), "foo");
CHECK_EQ(unbox(read<string>(R"_("foo")_")), R"_("foo")_");
}
CAF_TEST(type timespan) {
timespan dur{500};
CAF_CHECK_EQUAL(read<timespan>("500ns"), dur);
CHECK_EQ(read<timespan>("500ns"), dur);
}
CAF_TEST(lists) {
using int_list = std::vector<int>;
CAF_CHECK_EQUAL(read<int_list>("[]"), int_list({}));
CAF_CHECK_EQUAL(read<int_list>("1, 2, 3"), int_list({1, 2, 3}));
CAF_CHECK_EQUAL(read<int_list>("[1, 2, 3]"), int_list({1, 2, 3}));
CHECK_EQ(read<int_list>("[]"), int_list({}));
CHECK_EQ(read<int_list>("1, 2, 3"), int_list({1, 2, 3}));
CHECK_EQ(read<int_list>("[1, 2, 3]"), int_list({1, 2, 3}));
}
CAF_TEST(flat CLI parsing) {
auto x = make_config_option<std::string>("?foo", "bar,b", "test option");
CAF_CHECK_EQUAL(x.category(), "foo");
CAF_CHECK_EQUAL(x.long_name(), "bar");
CAF_CHECK_EQUAL(x.short_names(), "b");
CAF_CHECK_EQUAL(x.full_name(), "foo.bar");
CAF_CHECK_EQUAL(x.has_flat_cli_name(), true);
CHECK_EQ(x.category(), "foo");
CHECK_EQ(x.long_name(), "bar");
CHECK_EQ(x.short_names(), "b");
CHECK_EQ(x.full_name(), "foo.bar");
CHECK_EQ(x.has_flat_cli_name(), true);
}
CAF_TEST(flat CLI parsing with nested categories) {
auto x = make_config_option<std::string>("?foo.goo", "bar,b", "test option");
CAF_CHECK_EQUAL(x.category(), "foo.goo");
CAF_CHECK_EQUAL(x.long_name(), "bar");
CAF_CHECK_EQUAL(x.short_names(), "b");
CAF_CHECK_EQUAL(x.full_name(), "foo.goo.bar");
CAF_CHECK_EQUAL(x.has_flat_cli_name(), true);
CHECK_EQ(x.category(), "foo.goo");
CHECK_EQ(x.long_name(), "bar");
CHECK_EQ(x.short_names(), "b");
CHECK_EQ(x.full_name(), "foo.goo.bar");
CHECK_EQ(x.has_flat_cli_name(), true);
}
CAF_TEST(find by long opt) {
auto needle = make_config_option<std::string>("?foo", "bar,b", "test option");
auto check = [&](std::vector<string> args, bool found_opt, bool has_opt) {
auto res = find_by_long_name(needle, std::begin(args), std::end(args));
CAF_CHECK_EQUAL(res.first != std::end(args), found_opt);
CHECK_EQ(res.first != std::end(args), found_opt);
if (has_opt)
CAF_CHECK_EQUAL(res.second, "val2");
CHECK_EQ(res.second, "val2");
else
CAF_CHECK(res.second.empty());
CHECK(res.second.empty());
};
// Well formed, find val2.
check({"--foo=val1", "--bar=val2", "--baz=val3"}, true, true);
......
This diff is collapsed.
......@@ -65,7 +65,7 @@ struct fixture {
} // namespace
CAF_TEST_FIXTURE_SCOPE(config_value_tests, fixture)
BEGIN_FIXTURE_SCOPE(fixture)
SCENARIO("default-constructed config values represent null") {
GIVEN("a default-constructed config value") {
......@@ -145,14 +145,14 @@ SCENARIO("get_as can convert config values to integers") {
auto x = config_value{-5};
WHEN("using get_as with integer types") {
THEN("conversion fails for all unsigned types") {
CAF_CHECK_EQUAL(get_as<uint64_t>(x), sec::conversion_failed);
CAF_CHECK_EQUAL(get_as<int64_t>(x), -5);
CAF_CHECK_EQUAL(get_as<uint32_t>(x), sec::conversion_failed);
CAF_CHECK_EQUAL(get_as<int32_t>(x), -5);
CAF_CHECK_EQUAL(get_as<uint16_t>(x), sec::conversion_failed);
CAF_CHECK_EQUAL(get_as<int16_t>(x), -5);
CAF_CHECK_EQUAL(get_as<uint8_t>(x), sec::conversion_failed);
CAF_CHECK_EQUAL(get_as<int8_t>(x), -5);
CHECK_EQ(get_as<uint64_t>(x), sec::conversion_failed);
CHECK_EQ(get_as<int64_t>(x), -5);
CHECK_EQ(get_as<uint32_t>(x), sec::conversion_failed);
CHECK_EQ(get_as<int32_t>(x), -5);
CHECK_EQ(get_as<uint16_t>(x), sec::conversion_failed);
CHECK_EQ(get_as<int16_t>(x), -5);
CHECK_EQ(get_as<uint8_t>(x), sec::conversion_failed);
CHECK_EQ(get_as<int8_t>(x), -5);
}
}
}
......@@ -160,14 +160,14 @@ SCENARIO("get_as can convert config values to integers") {
auto x = config_value{"50000"s};
WHEN("using get_as with integer types") {
THEN("CAF parses the string and performs a bound check") {
CAF_CHECK_EQUAL(get_as<uint64_t>(x), 50'000u);
CAF_CHECK_EQUAL(get_as<int64_t>(x), 50'000);
CAF_CHECK_EQUAL(get_as<uint32_t>(x), 50'000u);
CAF_CHECK_EQUAL(get_as<int32_t>(x), 50'000);
CAF_CHECK_EQUAL(get_as<uint16_t>(x), 50'000u);
CAF_CHECK_EQUAL(get_as<int16_t>(x), sec::conversion_failed);
CAF_CHECK_EQUAL(get_as<uint8_t>(x), sec::conversion_failed);
CAF_CHECK_EQUAL(get_as<int8_t>(x), sec::conversion_failed);
CHECK_EQ(get_as<uint64_t>(x), 50'000u);
CHECK_EQ(get_as<int64_t>(x), 50'000);
CHECK_EQ(get_as<uint32_t>(x), 50'000u);
CHECK_EQ(get_as<int32_t>(x), 50'000);
CHECK_EQ(get_as<uint16_t>(x), 50'000u);
CHECK_EQ(get_as<int16_t>(x), sec::conversion_failed);
CHECK_EQ(get_as<uint8_t>(x), sec::conversion_failed);
CHECK_EQ(get_as<int8_t>(x), sec::conversion_failed);
}
}
}
......@@ -865,7 +865,7 @@ SCENARIO("config_value::parse returns an error for invalid inputs") {
}
}
CAF_TEST_FIXTURE_SCOPE_END()
END_FIXTURE_SCOPE()
// -- end of scenario testing, here come several baseline checks for parsing ---
......
......@@ -6,7 +6,7 @@
#include "caf/config_value_reader.hpp"
#include "caf/test/dsl.hpp"
#include "core-test.hpp"
#include "inspector-tests.hpp"
......@@ -66,14 +66,14 @@ struct fixture {
} // namespace
CAF_TEST_FIXTURE_SCOPE(config_value_reader_tests, fixture)
BEGIN_FIXTURE_SCOPE(fixture)
CAF_TEST(readers deserialize builtin types from config values) {
std::string value;
auto& xs = x.as_dictionary();
put(xs, "foo", "bar");
deserialize(xs["foo"], value);
CAF_CHECK_EQUAL(value, "bar");
CHECK_EQ(value, "bar");
}
CAF_TEST(readers deserialize simple objects from configs) {
......@@ -82,12 +82,12 @@ CAF_TEST(readers deserialize simple objects from configs) {
put(xs, "bar", "world");
foobar fb;
deserialize(fb);
CAF_CHECK_EQUAL(fb.foo(), "hello"s);
CAF_CHECK_EQUAL(fb.bar(), "world"s);
CHECK_EQ(fb.foo(), "hello"s);
CHECK_EQ(fb.bar(), "world"s);
}
CAF_TEST(readers deserialize complex objects from configs) {
CAF_MESSAGE("fill a dictionary with data for a 'basics' object");
MESSAGE("fill a dictionary with data for a 'basics' object");
auto& xs = x.as_dictionary();
put(xs, "v1", settings{});
put(xs, "v2", 42_i64);
......@@ -108,26 +108,26 @@ CAF_TEST(readers deserialize complex objects from configs) {
put(xs, "v7.two", i64{2});
put(xs, "v7.three", i64{3});
put(xs, "v8", i64_list());
CAF_MESSAGE("deserialize and verify the 'basics' object");
MESSAGE("deserialize and verify the 'basics' object");
basics obj;
deserialize(obj);
CAF_CHECK_EQUAL(obj.v2, 42);
CAF_CHECK_EQUAL(obj.v3[0], 1);
CAF_CHECK_EQUAL(obj.v3[1], 2);
CAF_CHECK_EQUAL(obj.v3[2], 3);
CAF_CHECK_EQUAL(obj.v3[3], 4);
CAF_CHECK_EQUAL(obj.v4[0], dummy_message{{2.0}});
CAF_CHECK_EQUAL(obj.v4[1], dummy_message{{"foobar"s}});
CAF_CHECK_EQUAL(obj.v5[0], i64{10});
CAF_CHECK_EQUAL(obj.v5[1], i64{20});
CAF_CHECK_EQUAL(obj.v6, std::make_tuple(int32_t{123}, dummy_message{{2.0}}));
CAF_CHECK_EQUAL(obj.v7["one"], 1);
CAF_CHECK_EQUAL(obj.v7["two"], 2);
CAF_CHECK_EQUAL(obj.v7["three"], 3);
CHECK_EQ(obj.v2, 42);
CHECK_EQ(obj.v3[0], 1);
CHECK_EQ(obj.v3[1], 2);
CHECK_EQ(obj.v3[2], 3);
CHECK_EQ(obj.v3[3], 4);
CHECK_EQ(obj.v4[0], dummy_message{{2.0}});
CHECK_EQ(obj.v4[1], dummy_message{{"foobar"s}});
CHECK_EQ(obj.v5[0], i64{10});
CHECK_EQ(obj.v5[1], i64{20});
CHECK_EQ(obj.v6, std::make_tuple(int32_t{123}, dummy_message{{2.0}}));
CHECK_EQ(obj.v7["one"], 1);
CHECK_EQ(obj.v7["two"], 2);
CHECK_EQ(obj.v7["three"], 3);
}
CAF_TEST(readers deserialize objects from the output of writers) {
CAF_MESSAGE("serialize the 'line' object");
MESSAGE("serialize the 'line' object");
{
line l{{10, 20, 30}, {70, 60, 50}};
config_value tmp;
......@@ -138,17 +138,17 @@ CAF_TEST(readers deserialize objects from the output of writers) {
CAF_FAIL("writer failed to produce a dictionary");
x.as_dictionary() = std::move(caf::get<settings>(tmp));
}
CAF_MESSAGE("serialize and verify the 'line' object");
MESSAGE("serialize and verify the 'line' object");
{
line l{{0, 0, 0}, {0, 0, 0}};
deserialize(l);
CAF_CHECK_EQUAL(l.p1.x, 10);
CAF_CHECK_EQUAL(l.p1.y, 20);
CAF_CHECK_EQUAL(l.p1.z, 30);
CAF_CHECK_EQUAL(l.p2.x, 70);
CAF_CHECK_EQUAL(l.p2.y, 60);
CAF_CHECK_EQUAL(l.p2.z, 50);
CHECK_EQ(l.p1.x, 10);
CHECK_EQ(l.p1.y, 20);
CHECK_EQ(l.p1.z, 30);
CHECK_EQ(l.p2.x, 70);
CHECK_EQ(l.p2.y, 60);
CHECK_EQ(l.p2.z, 50);
}
}
CAF_TEST_FIXTURE_SCOPE_END()
END_FIXTURE_SCOPE()
......@@ -6,7 +6,7 @@
#include "caf/config_value_writer.hpp"
#include "caf/test/dsl.hpp"
#include "core-test.hpp"
#include "inspector-tests.hpp"
......@@ -47,22 +47,22 @@ struct fixture {
} // namespace
CAF_TEST_FIXTURE_SCOPE(config_value_writer_tests, fixture)
BEGIN_FIXTURE_SCOPE(fixture)
CAF_TEST(structs become dictionaries) {
set(foobar{"hello", "world"});
CAF_CHECK_EQUAL(get_as<std::string>(xs(), "foo"), "hello"s);
CAF_CHECK_EQUAL(get_as<std::string>(xs(), "bar"), "world"s);
CHECK_EQ(get_as<std::string>(xs(), "foo"), "hello"s);
CHECK_EQ(get_as<std::string>(xs(), "bar"), "world"s);
}
CAF_TEST(nested structs become nested dictionaries) {
set(line{{10, 20, 30}, {70, 60, 50}});
CAF_CHECK_EQUAL(get_as<i64>(xs(), "p1.x"), 10_i64);
CAF_CHECK_EQUAL(get_as<i64>(xs(), "p1.y"), 20_i64);
CAF_CHECK_EQUAL(get_as<i64>(xs(), "p1.z"), 30_i64);
CAF_CHECK_EQUAL(get_as<i64>(xs(), "p2.x"), 70_i64);
CAF_CHECK_EQUAL(get_as<i64>(xs(), "p2.y"), 60_i64);
CAF_CHECK_EQUAL(get_as<i64>(xs(), "p2.z"), 50_i64);
CHECK_EQ(get_as<i64>(xs(), "p1.x"), 10_i64);
CHECK_EQ(get_as<i64>(xs(), "p1.y"), 20_i64);
CHECK_EQ(get_as<i64>(xs(), "p1.z"), 30_i64);
CHECK_EQ(get_as<i64>(xs(), "p2.x"), 70_i64);
CHECK_EQ(get_as<i64>(xs(), "p2.y"), 60_i64);
CHECK_EQ(get_as<i64>(xs(), "p2.z"), 50_i64);
}
CAF_TEST(empty types and maps become dictionaries) {
......@@ -79,36 +79,36 @@ CAF_TEST(empty types and maps become dictionaries) {
tst.v7["two"] = 2;
tst.v7["three"] = 3;
set(tst);
CAF_CHECK_EQUAL(get_as<settings>(xs(), "v1"), settings{});
CAF_CHECK_EQUAL(get_as<i64>(xs(), "v2"), 42_i64);
CAF_CHECK_EQUAL(get_as<i64_list>(xs(), "v3"), i64_list({-1, -2, -3, -4}));
CHECK_EQ(get_as<settings>(xs(), "v1"), settings{});
CHECK_EQ(get_as<i64>(xs(), "v2"), 42_i64);
CHECK_EQ(get_as<i64_list>(xs(), "v3"), i64_list({-1, -2, -3, -4}));
if (auto v4 = get_as<config_value::list>(xs(), "v4");
CAF_CHECK(v4 && v4->size() == 2u)) {
if (auto v1 = v4->front(); CAF_CHECK(holds_alternative<settings>(v1))) {
CHECK(v4 && v4->size() == 2u)) {
if (auto v1 = v4->front(); CHECK(holds_alternative<settings>(v1))) {
auto& v1_xs = get<settings>(v1);
CAF_CHECK_EQUAL(get<double>(v1_xs, "content"), 0.0);
CAF_CHECK_EQUAL(get<std::string>(v1_xs, "@content-type"),
to_string(type_name_v<double>));
CHECK_EQ(get<double>(v1_xs, "content"), 0.0);
CHECK_EQ(get<std::string>(v1_xs, "@content-type"),
to_string(type_name_v<double>));
}
if (auto v2 = v4->back(); CAF_CHECK(holds_alternative<settings>(v2))) {
if (auto v2 = v4->back(); CHECK(holds_alternative<settings>(v2))) {
auto& v2_xs = get<settings>(v2);
CAF_CHECK_EQUAL(get<double>(v2_xs, "content"), 1.0);
CAF_CHECK_EQUAL(get<std::string>(v2_xs, "@content-type"),
to_string(type_name_v<double>));
CHECK_EQ(get<double>(v2_xs, "content"), 1.0);
CHECK_EQ(get<std::string>(v2_xs, "@content-type"),
to_string(type_name_v<double>));
}
}
CAF_CHECK_EQUAL(get_as<i64_list>(xs(), "v5"), i64_list({10, 20}));
CHECK_EQ(get_as<i64_list>(xs(), "v5"), i64_list({10, 20}));
// TODO: check v6
CAF_CHECK_EQUAL(get_as<i64>(xs(), "v7.one"), 1_i64);
CAF_CHECK_EQUAL(get_as<i64>(xs(), "v7.two"), 2_i64);
CAF_CHECK_EQUAL(get_as<i64>(xs(), "v7.three"), 3_i64);
CAF_CHECK_EQUAL(get_as<config_value::list>(xs(), "v8"), config_value::list());
CHECK_EQ(get_as<i64>(xs(), "v7.one"), 1_i64);
CHECK_EQ(get_as<i64>(xs(), "v7.two"), 2_i64);
CHECK_EQ(get_as<i64>(xs(), "v7.three"), 3_i64);
CHECK_EQ(get_as<config_value::list>(xs(), "v8"), config_value::list());
}
CAF_TEST(custom inspect overloads may produce single values) {
auto tue = weekday::tuesday;
set(tue);
CAF_CHECK_EQUAL(get_as<std::string>(x), "tuesday"s);
CHECK_EQ(get_as<std::string>(x), "tuesday"s);
}
CAF_TEST_FIXTURE_SCOPE_END()
END_FIXTURE_SCOPE()
......@@ -12,25 +12,25 @@
using namespace caf;
CAF_TEST_FIXTURE_SCOPE(message_tests, test_coordinator_fixture<>)
BEGIN_FIXTURE_SCOPE(test_coordinator_fixture<>)
CAF_TEST(const message views never detach their content) {
auto msg1 = make_message(1, 2, 3, "four");
auto msg2 = msg1;
CAF_REQUIRE(msg1.cptr() == msg2.cptr());
CAF_REQUIRE(msg1.match_elements<int, int, int, std::string>());
CAF_REQUIRE((msg1.match_elements<int, int, int, std::string>()));
const_typed_message_view<int, int, int, std::string> view{msg1};
CAF_REQUIRE(msg1.cptr() == msg2.cptr());
}
CAF_TEST(const message views allow access via get) {
auto msg = make_message(1, 2, 3, "four");
CAF_REQUIRE(msg.match_elements<int, int, int, std::string>());
CAF_REQUIRE((msg.match_elements<int, int, int, std::string>()));
const_typed_message_view<int, int, int, std::string> view{msg};
CAF_CHECK_EQUAL(get<0>(view), 1);
CAF_CHECK_EQUAL(get<1>(view), 2);
CAF_CHECK_EQUAL(get<2>(view), 3);
CAF_CHECK_EQUAL(get<3>(view), "four");
CHECK_EQ(get<0>(view), 1);
CHECK_EQ(get<1>(view), 2);
CHECK_EQ(get<2>(view), 3);
CHECK_EQ(get<3>(view), "four");
}
CAF_TEST_FIXTURE_SCOPE_END()
END_FIXTURE_SCOPE()
......@@ -21,7 +21,7 @@ public:
behavior make_behavior() override {
return {
[=](delete_atom) {
CAF_MESSAGE("testee received delete");
MESSAGE("testee received delete");
quit(exit_reason::user_shutdown);
},
};
......@@ -32,8 +32,8 @@ class spawner : public event_based_actor {
public:
spawner(actor_config& cfg) : event_based_actor(cfg), downs_(0) {
set_down_handler([=](down_msg& msg) {
CAF_CHECK_EQUAL(msg.reason, exit_reason::user_shutdown);
CAF_CHECK_EQUAL(msg.source, testee_.address());
CHECK_EQ(msg.reason, exit_reason::user_shutdown);
CHECK_EQ(msg.source, testee_.address());
if (++downs_ == 2)
quit(msg.reason);
});
......@@ -43,13 +43,13 @@ public:
testee_ = spawn<testee, monitored>(this);
return {
[=](ok_atom, const error& reason) {
CAF_CHECK_EQUAL(reason, exit_reason::user_shutdown);
CHECK_EQ(reason, exit_reason::user_shutdown);
if (++downs_ == 2) {
quit(reason);
}
},
[=](delete_atom x) {
CAF_MESSAGE("spawner received delete");
MESSAGE("spawner received delete");
return delegate(testee_, x);
},
};
......
......@@ -16,90 +16,90 @@ using namespace caf;
CAF_TEST(default_construction) {
cow_tuple<string, string> x;
CAF_CHECK_EQUAL(x.unique(), true);
CAF_CHECK_EQUAL(get<0>(x), "");
CAF_CHECK_EQUAL(get<1>(x), "");
CHECK_EQ(x.unique(), true);
CHECK_EQ(get<0>(x), "");
CHECK_EQ(get<1>(x), "");
}
CAF_TEST(value_construction) {
cow_tuple<int, int> x{1, 2};
CAF_CHECK_EQUAL(x.unique(), true);
CAF_CHECK_EQUAL(get<0>(x), 1);
CAF_CHECK_EQUAL(get<1>(x), 2);
CAF_CHECK_EQUAL(x, make_cow_tuple(1, 2));
CHECK_EQ(x.unique(), true);
CHECK_EQ(get<0>(x), 1);
CHECK_EQ(get<1>(x), 2);
CHECK_EQ(x, make_cow_tuple(1, 2));
}
CAF_TEST(copy_construction) {
cow_tuple<int, int> x{1, 2};
cow_tuple<int, int> y{x};
CAF_CHECK_EQUAL(x, y);
CAF_CHECK_EQUAL(x.ptr(), y.ptr());
CAF_CHECK_EQUAL(x.unique(), false);
CAF_CHECK_EQUAL(y.unique(), false);
CHECK_EQ(x, y);
CHECK_EQ(x.ptr(), y.ptr());
CHECK_EQ(x.unique(), false);
CHECK_EQ(y.unique(), false);
}
CAF_TEST(move_construction) {
cow_tuple<int, int> x{1, 2};
cow_tuple<int, int> y{std::move(x)};
CAF_CHECK_EQUAL(x.ptr(), nullptr);
CAF_CHECK_EQUAL(y, make_tuple(1, 2));
CAF_CHECK_EQUAL(y.unique(), true);
CHECK_EQ(x.ptr(), nullptr);
CHECK_EQ(y, make_tuple(1, 2));
CHECK_EQ(y.unique(), true);
}
CAF_TEST(copy_assignment) {
cow_tuple<int, int> x{1, 2};
cow_tuple<int, int> y{3, 4};
CAF_CHECK_NOT_EQUAL(x, y);
CHECK_NE(x, y);
x = y;
CAF_CHECK_EQUAL(x, y);
CAF_CHECK_EQUAL(x.ptr(), y.ptr());
CAF_CHECK_EQUAL(x.unique(), false);
CAF_CHECK_EQUAL(y.unique(), false);
CHECK_EQ(x, y);
CHECK_EQ(x.ptr(), y.ptr());
CHECK_EQ(x.unique(), false);
CHECK_EQ(y.unique(), false);
}
CAF_TEST(move_assignment) {
cow_tuple<int, int> x{1, 2};
cow_tuple<int, int> y{3, 4};
CAF_CHECK_NOT_EQUAL(x, y);
CHECK_NE(x, y);
x = std::move(y);
CAF_CHECK_EQUAL(x, make_tuple(3, 4));
CAF_CHECK_EQUAL(x.unique(), true);
CHECK_EQ(x, make_tuple(3, 4));
CHECK_EQ(x.unique(), true);
}
CAF_TEST(make_cow_tuple) {
cow_tuple<int, int> x{1, 2};
auto y = make_cow_tuple(1, 2);
CAF_CHECK_EQUAL(x, y);
CAF_CHECK_EQUAL(x.unique(), true);
CAF_CHECK_EQUAL(y.unique(), true);
CHECK_EQ(x, y);
CHECK_EQ(x.unique(), true);
CHECK_EQ(y.unique(), true);
}
CAF_TEST(unsharing) {
auto x = make_cow_tuple(string{"old"}, string{"school"});
auto y = x;
CAF_CHECK_EQUAL(x.unique(), false);
CAF_CHECK_EQUAL(y.unique(), false);
CHECK_EQ(x.unique(), false);
CHECK_EQ(y.unique(), false);
get<0>(y.unshared()) = "new";
CAF_CHECK_EQUAL(x.unique(), true);
CAF_CHECK_EQUAL(y.unique(), true);
CAF_CHECK_EQUAL(x.data(), make_tuple("old", "school"));
CAF_CHECK_EQUAL(y.data(), make_tuple("new", "school"));
CHECK_EQ(x.unique(), true);
CHECK_EQ(y.unique(), true);
CHECK_EQ(x.data(), make_tuple("old", "school"));
CHECK_EQ(y.data(), make_tuple("new", "school"));
}
CAF_TEST(to_string) {
auto x = make_cow_tuple(1, string{"abc"});
CAF_CHECK_EQUAL(deep_to_string(x), R"__([1, "abc"])__");
CHECK_EQ(deep_to_string(x), R"__([1, "abc"])__");
}
CAF_TEST_FIXTURE_SCOPE(cow_tuple_tests, test_coordinator_fixture<>)
BEGIN_FIXTURE_SCOPE(test_coordinator_fixture<>)
CAF_TEST(serialization) {
auto x = make_cow_tuple(1, 2, 3);
auto y = roundtrip(x);
CAF_CHECK_EQUAL(x, y);
CAF_CHECK_EQUAL(x.unique(), true);
CAF_CHECK_EQUAL(y.unique(), true);
CAF_CHECK_NOT_EQUAL(x.ptr(), y.ptr());
CHECK_EQ(x, y);
CHECK_EQ(x.unique(), true);
CHECK_EQ(y.unique(), true);
CHECK_NE(x.ptr(), y.ptr());
}
CAF_TEST_FIXTURE_SCOPE_END()
END_FIXTURE_SCOPE()
......@@ -51,7 +51,7 @@ CAF_TEST(the default exception handler includes the error message) {
[](const error& err) {
auto msg = err.context();
if (auto view = make_typed_message_view<string, string>(msg)) {
CAF_CHECK_EQUAL(get<1>(view), "whatever");
CHECK_EQ(get<1>(view), "whatever");
} else {
CAF_FAIL("unexpected error contest: " << err.context());
}
......@@ -64,11 +64,9 @@ CAF_TEST(actors can override the default exception handler) {
auto handler = [](std::exception_ptr& eptr) -> error {
try {
std::rethrow_exception(eptr);
}
catch (std::runtime_error&) {
} catch (std::runtime_error&) {
return exit_reason::normal;
}
catch (...) {
} catch (...) {
// "fall through"
}
return sec::runtime_error;
......
......@@ -6,7 +6,7 @@
#include "caf/decorator/sequencer.hpp"
#include "caf/test/unit_test.hpp"
#include "core-test.hpp"
#include "caf/all.hpp"
......@@ -60,7 +60,7 @@ struct fixture {
} // namespace
CAF_TEST_FIXTURE_SCOPE(sequencer_tests, fixture)
BEGIN_FIXTURE_SCOPE(fixture)
CAF_TEST(identity) {
actor_system_config cfg_g;
......@@ -69,14 +69,14 @@ CAF_TEST(identity) {
actor_system system_of_f{cfg_f};
auto g = system_of_g.spawn(typed_first_stage);
auto f = system_of_f.spawn(typed_second_stage);
CAF_CHECK_EQUAL(system_of_g.registry().running(), 1u);
CHECK_EQ(system_of_g.registry().running(), 1u);
auto h = f * g;
CAF_CHECK_EQUAL(system_of_g.registry().running(), 1u);
CAF_CHECK_EQUAL(&h->home_system(), &g->home_system());
CAF_CHECK_EQUAL(h->node(), g->node());
CAF_CHECK_NOT_EQUAL(h->id(), g->id());
CAF_CHECK_NOT_EQUAL(h.address(), g.address());
CAF_CHECK_EQUAL(h->message_types(), g->home_system().message_types(h));
CHECK_EQ(system_of_g.registry().running(), 1u);
CHECK_EQ(&h->home_system(), &g->home_system());
CHECK_EQ(h->node(), g->node());
CHECK_NE(h->id(), g->id());
CHECK_NE(h.address(), g.address());
CHECK_EQ(h->message_types(), g->home_system().message_types(h));
}
// spawned dead if `g` is already dead upon spawning
......@@ -86,7 +86,7 @@ CAF_TEST(lifetime_1a) {
anon_send_exit(g, exit_reason::kill);
self->wait_for(g);
auto h = f * g;
CAF_CHECK(exited(h));
CHECK(exited(h));
}
// spawned dead if `f` is already dead upon spawning
......@@ -96,7 +96,7 @@ CAF_TEST(lifetime_1b) {
anon_send_exit(f, exit_reason::kill);
self->wait_for(f);
auto h = f * g;
CAF_CHECK(exited(h));
CHECK(exited(h));
}
// `f.g` exits when `g` exits
......@@ -122,12 +122,12 @@ CAF_TEST(request_response_promise) {
auto f = system.spawn(testee);
auto h = f * g;
anon_send_exit(h, exit_reason::kill);
CAF_CHECK(exited(h));
CHECK(exited(h));
self->request(h, infinite, 1)
.receive([](int) { CAF_CHECK(false); },
.receive([](int) { CHECK(false); },
[](error err) {
CAF_CHECK_EQUAL(err.code(), static_cast<uint8_t>(
sec::request_receiver_down));
CHECK_EQ(err.code(),
static_cast<uint8_t>(sec::request_receiver_down));
});
}
......@@ -137,7 +137,7 @@ CAF_TEST(dot_composition_1) {
auto second = system.spawn(typed_second_stage);
auto first_then_second = second * first;
self->request(first_then_second, infinite, 42)
.receive([](double res) { CAF_CHECK_EQUAL(res, (42 * 2.0) * (42 * 4.0)); },
.receive([](double res) { CHECK_EQ(res, (42 * 2.0) * (42 * 4.0)); },
ERROR_HANDLER);
}
......@@ -146,7 +146,7 @@ CAF_TEST(dot_composition_2) {
auto dbl_actor = system.spawn(testee);
auto dbl_x4_actor = dbl_actor * dbl_actor * dbl_actor * dbl_actor;
self->request(dbl_x4_actor, infinite, 1)
.receive([](int v) { CAF_CHECK_EQUAL(v, 16); }, ERROR_HANDLER);
.receive([](int v) { CHECK_EQ(v, 16); }, ERROR_HANDLER);
}
CAF_TEST_FIXTURE_SCOPE_END()
END_FIXTURE_SCOPE()
......@@ -10,7 +10,7 @@
using namespace caf;
#define CHECK_DEEP_TO_STRING(val, str) CAF_CHECK_EQUAL(deep_to_string(val), str)
#define CHECK_DEEP_TO_STRING(val, str) CHECK_EQ(deep_to_string(val), str)
CAF_TEST(timespans use the highest unit available when printing) {
CHECK_EQ(to_string(config_value{timespan{0}}), "0s");
......@@ -50,15 +50,15 @@ CAF_TEST(pointers and optionals use dereference syntax) {
CAF_TEST(buffers) {
// Use `signed char` explicitly to make sure all compilers agree.
std::vector<signed char> buf;
CAF_CHECK_EQUAL(deep_to_string(buf), "[]");
CHECK_EQ(deep_to_string(buf), "[]");
buf.push_back(-1);
CAF_CHECK_EQUAL(deep_to_string(buf), "[-1]");
CHECK_EQ(deep_to_string(buf), "[-1]");
buf.push_back(0);
CAF_CHECK_EQUAL(deep_to_string(buf), "[-1, 0]");
CHECK_EQ(deep_to_string(buf), "[-1, 0]");
buf.push_back(127);
CAF_CHECK_EQUAL(deep_to_string(buf), "[-1, 0, 127]");
CHECK_EQ(deep_to_string(buf), "[-1, 0, 127]");
buf.push_back(10);
CAF_CHECK_EQUAL(deep_to_string(buf), "[-1, 0, 127, 10]");
CHECK_EQ(deep_to_string(buf), "[-1, 0, 127, 10]");
buf.push_back(16);
CAF_CHECK_EQUAL(deep_to_string(buf), "[-1, 0, 127, 10, 16]");
CHECK_EQ(deep_to_string(buf), "[-1, 0, 127, 10, 16]");
}
......@@ -6,7 +6,7 @@
#include "caf/detail/bounds_checker.hpp"
#include "caf/test/dsl.hpp"
#include "core-test.hpp"
namespace {
......@@ -18,26 +18,26 @@ bool check(int64_t x) {
} // namespace
CAF_TEST(small integers) {
CAF_CHECK_EQUAL(check<int8_t>(128), false);
CAF_CHECK_EQUAL(check<int8_t>(127), true);
CAF_CHECK_EQUAL(check<int8_t>(-128), true);
CAF_CHECK_EQUAL(check<int8_t>(-129), false);
CAF_CHECK_EQUAL(check<uint8_t>(-1), false);
CAF_CHECK_EQUAL(check<uint8_t>(0), true);
CAF_CHECK_EQUAL(check<uint8_t>(255), true);
CAF_CHECK_EQUAL(check<uint8_t>(256), false);
CAF_CHECK_EQUAL(check<int16_t>(-32769), false);
CAF_CHECK_EQUAL(check<int16_t>(-32768), true);
CAF_CHECK_EQUAL(check<int16_t>(32767), true);
CAF_CHECK_EQUAL(check<int16_t>(32768), false);
CAF_CHECK_EQUAL(check<uint16_t>(-1), false);
CAF_CHECK_EQUAL(check<uint16_t>(0), true);
CAF_CHECK_EQUAL(check<uint16_t>(65535), true);
CAF_CHECK_EQUAL(check<uint16_t>(65536), false);
CHECK_EQ(check<int8_t>(128), false);
CHECK_EQ(check<int8_t>(127), true);
CHECK_EQ(check<int8_t>(-128), true);
CHECK_EQ(check<int8_t>(-129), false);
CHECK_EQ(check<uint8_t>(-1), false);
CHECK_EQ(check<uint8_t>(0), true);
CHECK_EQ(check<uint8_t>(255), true);
CHECK_EQ(check<uint8_t>(256), false);
CHECK_EQ(check<int16_t>(-32769), false);
CHECK_EQ(check<int16_t>(-32768), true);
CHECK_EQ(check<int16_t>(32767), true);
CHECK_EQ(check<int16_t>(32768), false);
CHECK_EQ(check<uint16_t>(-1), false);
CHECK_EQ(check<uint16_t>(0), true);
CHECK_EQ(check<uint16_t>(65535), true);
CHECK_EQ(check<uint16_t>(65536), false);
}
CAF_TEST(large unsigned integers) {
CAF_CHECK_EQUAL(check<uint64_t>(-1), false);
CAF_CHECK_EQUAL(check<uint64_t>(0), true);
CAF_CHECK_EQUAL(check<uint64_t>(std::numeric_limits<int64_t>::max()), true);
CHECK_EQ(check<uint64_t>(-1), false);
CHECK_EQ(check<uint64_t>(0), true);
CHECK_EQ(check<uint64_t>(std::numeric_limits<int64_t>::max()), true);
}
......@@ -6,7 +6,7 @@
#include "caf/detail/config_consumer.hpp"
#include "caf/test/dsl.hpp"
#include "core-test.hpp"
#include "caf/detail/parser/read_config.hpp"
......@@ -59,39 +59,39 @@ struct fixture {
} // namespace
CAF_TEST_FIXTURE_SCOPE(config_consumer_tests, fixture)
BEGIN_FIXTURE_SCOPE(fixture)
CAF_TEST(config_consumer) {
string_view str = test_config1;
detail::config_consumer consumer{options, config};
string_parser_state res{str.begin(), str.end()};
detail::parser::read_config(res, consumer);
CAF_CHECK_EQUAL(res.code, pec::success);
CAF_CHECK_EQUAL(string_view(res.i, res.e), string_view());
CAF_CHECK_EQUAL(get_as<bool>(config, "is_server"), true);
CAF_CHECK_EQUAL(get_as<uint16_t>(config, "port"), 4242u);
CAF_CHECK_EQUAL(get_as<ls>(config, "nodes"), ls({"sun", "venus"}));
CAF_CHECK_EQUAL(get_as<string>(config, "logger.file-name"), "foobar.conf");
CAF_CHECK_EQUAL(get_as<timespan>(config, "scheduler.timing"), timespan(2000));
CHECK_EQ(res.code, pec::success);
CHECK_EQ(string_view(res.i, res.e), string_view());
CHECK_EQ(get_as<bool>(config, "is_server"), true);
CHECK_EQ(get_as<uint16_t>(config, "port"), 4242u);
CHECK_EQ(get_as<ls>(config, "nodes"), ls({"sun", "venus"}));
CHECK_EQ(get_as<string>(config, "logger.file-name"), "foobar.conf");
CHECK_EQ(get_as<timespan>(config, "scheduler.timing"), timespan(2000));
}
CAF_TEST(simplified syntax) {
CAF_MESSAGE("read test_config");
MESSAGE("read test_config");
{
detail::config_consumer consumer{options, config};
string_parser_state res{test_config1.begin(), test_config1.end()};
detail::parser::read_config(res, consumer);
CAF_CHECK_EQUAL(res.code, pec::success);
CHECK_EQ(res.code, pec::success);
}
settings config2;
CAF_MESSAGE("read test_config2");
MESSAGE("read test_config2");
{
detail::config_consumer consumer{options, config2};
string_parser_state res{test_config2.begin(), test_config2.end()};
detail::parser::read_config(res, consumer);
CAF_CHECK_EQUAL(res.code, pec::success);
CHECK_EQ(res.code, pec::success);
}
CAF_CHECK_EQUAL(config, config2);
CHECK_EQ(config, config2);
}
CAF_TEST_FIXTURE_SCOPE_END()
END_FIXTURE_SCOPE()
......@@ -120,7 +120,7 @@ struct fixture : test_coordinator_fixture<> {
} // namespace
CAF_TEST_FIXTURE_SCOPE(group_tunnel_tests, fixture)
BEGIN_FIXTURE_SCOPE(fixture)
SCENARIO("tunnels automatically subscribe to their origin on first subscribe") {
GIVEN("a group with two subscribers and a tunnel") {
......@@ -262,4 +262,4 @@ SCENARIO("tunnels cache messages until connected") {
}
}
CAF_TEST_FIXTURE_SCOPE_END()
END_FIXTURE_SCOPE()
......@@ -6,7 +6,7 @@
#include "caf/detail/ieee_754.hpp"
#include "caf/test/dsl.hpp"
#include "core-test.hpp"
#include <limits>
......@@ -26,15 +26,15 @@ using dlimits = std::numeric_limits<double>;
} // namespace
#define CHECK_RT(value) CAF_CHECK_EQUAL(roundtrip(value), value)
#define CHECK_RT(value) CHECK_EQ(roundtrip(value), value)
#define CHECK_PRED_RT(pred, value) CAF_CHECK(pred(roundtrip(value)))
#define CHECK_PRED_RT(pred, value) CHECK(pred(roundtrip(value)))
#define CHECK_SIGN_RT(value) \
CAF_CHECK_EQUAL(std::signbit(roundtrip(value)), std::signbit(value))
CHECK_EQ(std::signbit(roundtrip(value)), std::signbit(value))
CAF_TEST(packing and then unpacking floats returns the original value) {
CAF_MESSAGE("finite values compare equal");
MESSAGE("finite values compare equal");
CHECK_RT(0.f);
CHECK_RT(0xCAFp1);
CHECK_RT(flimits::epsilon());
......@@ -45,11 +45,11 @@ CAF_TEST(packing and then unpacking floats returns the original value) {
CHECK_RT(-flimits::epsilon());
CHECK_RT(-flimits::min());
CHECK_RT(-flimits::max());
CAF_MESSAGE("packing and unpacking preserves infinity and NaN");
MESSAGE("packing and unpacking preserves infinity and NaN");
CHECK_PRED_RT(std::isinf, flimits::infinity());
CHECK_PRED_RT(std::isinf, -flimits::infinity());
CHECK_PRED_RT(std::isnan, flimits::quiet_NaN());
CAF_MESSAGE("packing and unpacking preserves the sign bit");
MESSAGE("packing and unpacking preserves the sign bit");
CHECK_SIGN_RT(0.f);
CHECK_SIGN_RT(0xCAFp1);
CHECK_SIGN_RT(flimits::epsilon());
......@@ -65,7 +65,7 @@ CAF_TEST(packing and then unpacking floats returns the original value) {
}
CAF_TEST(packing and then unpacking doubles returns the original value) {
CAF_MESSAGE("finite values compare equal");
MESSAGE("finite values compare equal");
CHECK_RT(0.);
CHECK_RT(0xCAFp1);
CHECK_RT(dlimits::epsilon());
......@@ -76,11 +76,11 @@ CAF_TEST(packing and then unpacking doubles returns the original value) {
CHECK_RT(-dlimits::epsilon());
CHECK_RT(-dlimits::min());
CHECK_RT(-dlimits::max());
CAF_MESSAGE("packing and unpacking preserves infinity and NaN");
MESSAGE("packing and unpacking preserves infinity and NaN");
CHECK_PRED_RT(std::isinf, dlimits::infinity());
CHECK_PRED_RT(std::isinf, -dlimits::infinity());
CHECK_PRED_RT(std::isnan, dlimits::quiet_NaN());
CAF_MESSAGE("packing and unpacking preserves the sign bit");
MESSAGE("packing and unpacking preserves the sign bit");
CHECK_SIGN_RT(0.);
CHECK_SIGN_RT(0xCAFp1);
CHECK_SIGN_RT(dlimits::epsilon());
......
......@@ -6,7 +6,7 @@
#include "caf/detail/limited_vector.hpp"
#include "caf/test/unit_test.hpp"
#include "core-test.hpp"
#include <algorithm>
......@@ -24,39 +24,38 @@ CAF_TEST(basics) {
limited_vector<int, 2> vec5{3, 4};
vec4.insert(vec4.end(), vec5.begin(), vec5.end());
auto vec6 = vec4;
CAF_CHECK_EQUAL(vec1.size(), 4u);
CAF_CHECK_EQUAL(vec2.size(), 4u);
CAF_CHECK_EQUAL(vec3.size(), 4u);
CAF_CHECK_EQUAL(vec4.size(), 4u);
CAF_CHECK_EQUAL(vec5.size(), 2u);
CAF_CHECK_EQUAL(vec6.size(), 4u);
CAF_CHECK_EQUAL(vec1.full(), true);
CAF_CHECK_EQUAL(vec2.full(), false);
CAF_CHECK_EQUAL(vec3.full(), true);
CAF_CHECK_EQUAL(vec4.full(), true);
CAF_CHECK_EQUAL(vec5.full(), true);
CAF_CHECK_EQUAL(vec6.full(), true);
CAF_CHECK(std::equal(vec1.begin(), vec1.end(), arr1));
CAF_CHECK(std::equal(vec2.rbegin(), vec2.rend(), arr1));
CAF_CHECK(std::equal(vec4.begin(), vec4.end(), arr1));
CAF_CHECK(std::equal(vec6.begin(), vec6.end(), arr1));
CAF_CHECK(std::equal(vec6.begin(), vec6.end(), vec2.rbegin()));
CHECK_EQ(vec1.size(), 4u);
CHECK_EQ(vec2.size(), 4u);
CHECK_EQ(vec3.size(), 4u);
CHECK_EQ(vec4.size(), 4u);
CHECK_EQ(vec5.size(), 2u);
CHECK_EQ(vec6.size(), 4u);
CHECK_EQ(vec1.full(), true);
CHECK_EQ(vec2.full(), false);
CHECK_EQ(vec3.full(), true);
CHECK_EQ(vec4.full(), true);
CHECK_EQ(vec5.full(), true);
CHECK_EQ(vec6.full(), true);
CHECK(std::equal(vec1.begin(), vec1.end(), arr1));
CHECK(std::equal(vec2.rbegin(), vec2.rend(), arr1));
CHECK(std::equal(vec4.begin(), vec4.end(), arr1));
CHECK(std::equal(vec6.begin(), vec6.end(), arr1));
CHECK(std::equal(vec6.begin(), vec6.end(), vec2.rbegin()));
limited_vector<int, 10> vec7{5, 9};
limited_vector<int, 10> vec8{1, 2, 3, 4};
limited_vector<int, 10> vec9{6, 7, 8};
vec7.insert(vec7.begin() + 1, vec9.begin(), vec9.end());
vec7.insert(vec7.begin(), vec8.begin(), vec8.end());
CAF_CHECK_EQUAL(vec7.full(), false);
CHECK_EQ(vec7.full(), false);
limited_vector<int, 1> vec10{10};
vec7.insert(vec7.end(), vec10.begin(), vec10.end());
CAF_CHECK_EQUAL(vec7.full(), true);
CAF_CHECK((std::is_sorted(vec7.begin(), vec7.end())));
CHECK_EQ(vec7.full(), true);
CHECK((std::is_sorted(vec7.begin(), vec7.end())));
int arr2[]{1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
CAF_CHECK((std::equal(vec7.begin(), vec7.end(), std::begin(arr2))));
CHECK((std::equal(vec7.begin(), vec7.end(), std::begin(arr2))));
vec7.assign(std::begin(arr2), std::end(arr2));
CAF_CHECK((std::equal(vec7.begin(), vec7.end(), std::begin(arr2))));
CHECK((std::equal(vec7.begin(), vec7.end(), std::begin(arr2))));
vec7.assign(5, 0);
CAF_CHECK_EQUAL(vec7.size(), 5u);
CAF_CHECK(
(std::all_of(vec7.begin(), vec7.end(), [](int i) { return i == 0; })));
CHECK_EQ(vec7.size(), 5u);
CHECK((std::all_of(vec7.begin(), vec7.end(), [](int i) { return i == 0; })));
}
......@@ -48,78 +48,78 @@ struct fixture : test_coordinator_fixture<> {
} // namespace
CAF_TEST_FIXTURE_SCOPE(group_tests, fixture)
BEGIN_FIXTURE_SCOPE(fixture)
CAF_TEST(local groups are singletons) {
auto ptr1 = unbox(uut->get("test"));
auto ptr2 = unbox(uut->get("test"));
CAF_CHECK_EQUAL(ptr1.get(), ptr2.get());
CHECK_EQ(ptr1.get(), ptr2.get());
auto ptr3 = sys.groups().get_local("test");
CAF_CHECK_EQUAL(ptr1.get(), ptr3.get());
CHECK_EQ(ptr1.get(), ptr3.get());
}
CAF_TEST(local groups forward messages to all subscribers) {
CAF_MESSAGE("Given two subscribers to the group 'test'.");
MESSAGE("Given two subscribers to the group 'test'.");
auto grp = unbox(uut->get("test"));
auto t1 = sys.spawn_in_group(grp, testee_impl);
auto t2 = sys.spawn_in_group(grp, testee_impl);
{ // Subtest.
CAF_MESSAGE("When an actors sends to the group.");
MESSAGE("When an actors sends to the group.");
self->send(grp, put_atom_v, 42);
CAF_MESSAGE("Then both subscribers receive the message.");
MESSAGE("Then both subscribers receive the message.");
expect((put_atom, int), from(self).to(t1).with(_, 42));
expect((put_atom, int), from(self).to(t2).with(_, 42));
}
{ // Subtest.
CAF_MESSAGE("When an actors leaves the group.");
CAF_MESSAGE("And an actors sends to the group.");
MESSAGE("When an actors leaves the group.");
MESSAGE("And an actors sends to the group.");
grp->unsubscribe(actor_cast<actor_control_block*>(t1));
self->send(grp, put_atom_v, 23);
CAF_MESSAGE("Then only one remaining actor receives the message.");
MESSAGE("Then only one remaining actor receives the message.");
disallow((put_atom, int), from(self).to(t1).with(_, 23));
expect((put_atom, int), from(self).to(t2).with(_, 23));
}
}
CAF_TEST(local group intermediaries manage groups) {
CAF_MESSAGE("Given two subscribers to the group 'test'.");
MESSAGE("Given two subscribers to the group 'test'.");
auto grp = unbox(uut->get("test"));
auto intermediary = grp.get()->intermediary();
auto t1 = sys.spawn_in_group(grp, testee_impl);
auto t2 = sys.spawn_in_group(grp, testee_impl);
{ // Subtest.
CAF_MESSAGE("When an actors sends to the group's intermediary.");
MESSAGE("When an actors sends to the group's intermediary.");
inject((forward_atom, message),
from(self)
.to(intermediary)
.with(forward_atom_v, make_message(put_atom_v, 42)));
CAF_MESSAGE("Then both subscribers receive the message.");
MESSAGE("Then both subscribers receive the message.");
expect((put_atom, int), from(self).to(t1).with(_, 42));
expect((put_atom, int), from(self).to(t2).with(_, 42));
}
auto t3 = sys.spawn(testee_impl);
{ // Subtest.
CAF_MESSAGE("When an actor sends 'join' to the group's intermediary.");
CAF_MESSAGE("And an actors sends to the group's intermediary.");
MESSAGE("When an actor sends 'join' to the group's intermediary.");
MESSAGE("And an actors sends to the group's intermediary.");
inject((join_atom, strong_actor_ptr),
from(self)
.to(intermediary)
.with(join_atom_v, actor_cast<strong_actor_ptr>(t3)));
self->send(grp, put_atom_v, 23);
CAF_MESSAGE("Then all three subscribers receive the message.");
MESSAGE("Then all three subscribers receive the message.");
expect((put_atom, int), from(self).to(t1).with(_, 23));
expect((put_atom, int), from(self).to(t2).with(_, 23));
expect((put_atom, int), from(self).to(t3).with(_, 23));
}
{ // Subtest.
CAF_MESSAGE("When an actor sends 'leave' to the group's intermediary.");
CAF_MESSAGE("And an actors sends to the group's intermediary.");
MESSAGE("When an actor sends 'leave' to the group's intermediary.");
MESSAGE("And an actors sends to the group's intermediary.");
inject((leave_atom, strong_actor_ptr),
from(self)
.to(intermediary)
.with(leave_atom_v, actor_cast<strong_actor_ptr>(t3)));
self->send(grp, put_atom_v, 37337);
CAF_MESSAGE("Then only the two remaining subscribers receive the message.");
MESSAGE("Then only the two remaining subscribers receive the message.");
self->send(grp, put_atom_v, 37337);
expect((put_atom, int), from(self).to(t1).with(_, 37337));
expect((put_atom, int), from(self).to(t2).with(_, 37337));
......@@ -127,4 +127,4 @@ CAF_TEST(local group intermediaries manage groups) {
}
}
CAF_TEST_FIXTURE_SCOPE_END()
END_FIXTURE_SCOPE()
......@@ -35,15 +35,15 @@ struct fixture {
} // namespace
CAF_TEST_FIXTURE_SCOPE(meta_object_tests, fixture)
BEGIN_FIXTURE_SCOPE(fixture)
CAF_TEST(meta objects allow construction and destruction of objects) {
auto meta_i32_wrapper = make_meta_object<i32_wrapper>("i32_wrapper");
std::aligned_storage_t<sizeof(i32_wrapper), alignof(i32_wrapper)> storage;
meta_i32_wrapper.default_construct(&storage);
CAF_CHECK_EQUAL(i32_wrapper::instances, 1u);
CHECK_EQ(i32_wrapper::instances, 1u);
meta_i32_wrapper.destroy(&storage);
CAF_CHECK_EQUAL(i32_wrapper::instances, 0u);
CHECK_EQ(i32_wrapper::instances, 0u);
}
CAF_TEST(meta objects allow serialization of objects) {
......@@ -52,32 +52,32 @@ CAF_TEST(meta objects allow serialization of objects) {
std::aligned_storage_t<sizeof(i32_wrapper), alignof(i32_wrapper)> storage;
binary_serializer sink{nullptr, buf};
meta_i32_wrapper.default_construct(&storage);
CAF_CHECK_EQUAL(i32_wrapper::instances, 1u);
CAF_CHECK(meta_i32_wrapper.save_binary(sink, &storage));
CHECK_EQ(i32_wrapper::instances, 1u);
CHECK(meta_i32_wrapper.save_binary(sink, &storage));
i32_wrapper copy;
CAF_CHECK_EQUAL(i32_wrapper::instances, 2u);
CHECK_EQ(i32_wrapper::instances, 2u);
copy.value = 42;
binary_deserializer source{nullptr, buf};
CAF_CHECK(meta_i32_wrapper.load_binary(source, &copy));
CAF_CHECK_EQUAL(copy.value, 0);
CHECK(meta_i32_wrapper.load_binary(source, &copy));
CHECK_EQ(copy.value, 0);
meta_i32_wrapper.destroy(&storage);
CAF_CHECK_EQUAL(i32_wrapper::instances, 1u);
CHECK_EQ(i32_wrapper::instances, 1u);
}
CAF_TEST(init_global_meta_objects takes care of creating a meta object table) {
auto xs = global_meta_objects();
CAF_REQUIRE_EQUAL(xs.size(), caf::id_block::core_test::end);
CAF_CHECK_EQUAL(type_name_by_id_v<type_id_v<i32_wrapper>>, "i32_wrapper"s);
CAF_CHECK_EQUAL(type_name_by_id_v<type_id_v<i64_wrapper>>, "i64_wrapper"s);
CAF_CHECK_EQUAL(xs[type_id_v<i32_wrapper>].type_name, "i32_wrapper"s);
CAF_CHECK_EQUAL(xs[type_id_v<i64_wrapper>].type_name, "i64_wrapper"s);
CAF_MESSAGE("calling init_global_meta_objects again is a no-op");
CHECK_EQ(type_name_by_id_v<type_id_v<i32_wrapper>>, "i32_wrapper"s);
CHECK_EQ(type_name_by_id_v<type_id_v<i64_wrapper>>, "i64_wrapper"s);
CHECK_EQ(xs[type_id_v<i32_wrapper>].type_name, "i32_wrapper"s);
CHECK_EQ(xs[type_id_v<i64_wrapper>].type_name, "i64_wrapper"s);
MESSAGE("calling init_global_meta_objects again is a no-op");
init_global_meta_objects<id_block::core_test>();
auto ys = global_meta_objects();
auto same = [](const auto& x, const auto& y) {
return x.type_name == y.type_name;
};
CAF_CHECK(std::equal(xs.begin(), xs.end(), ys.begin(), ys.end(), same));
CHECK(std::equal(xs.begin(), xs.end(), ys.begin(), ys.end(), same));
}
CAF_TEST_FIXTURE_SCOPE_END()
END_FIXTURE_SCOPE()
......@@ -6,7 +6,7 @@
#include "caf/detail/parse.hpp"
#include "caf/test/dsl.hpp"
#include "core-test.hpp"
#include "caf/expected.hpp"
#include "caf/ipv4_address.hpp"
......@@ -56,13 +56,12 @@ expected<T> read(string_view str) {
} // namespace
#define CHECK_NUMBER(type, value) \
CAF_CHECK_EQUAL(read<type>(#value), type(value))
#define CHECK_NUMBER(type, value) CHECK_EQ(read<type>(#value), type(value))
#define CHECK_NUMBER_3(type, value, cpp_value) \
CAF_CHECK_EQUAL(read<type>(#value), type(cpp_value))
CHECK_EQ(read<type>(#value), type(cpp_value))
#define CHECK_INVALID(type, str, code) CAF_CHECK_EQUAL(read<type>(str), code)
#define CHECK_INVALID(type, str, code) CHECK_EQ(read<type>(str), code)
CAF_TEST(valid signed integers) {
CHECK_NUMBER(int8_t, -128);
......@@ -137,80 +136,76 @@ CAF_TEST(invalid floating point numbers) {
}
CAF_TEST(valid timespans) {
CAF_CHECK_EQUAL(read<timespan>("12ns"), 12_ns);
CAF_CHECK_EQUAL(read<timespan>("34us"), 34_us);
CAF_CHECK_EQUAL(read<timespan>("56ms"), 56_ms);
CAF_CHECK_EQUAL(read<timespan>("78s"), 78_s);
CAF_CHECK_EQUAL(read<timespan>("60min"), 1_h);
CAF_CHECK_EQUAL(read<timespan>("90h"), 90_h);
CHECK_EQ(read<timespan>("12ns"), 12_ns);
CHECK_EQ(read<timespan>("34us"), 34_us);
CHECK_EQ(read<timespan>("56ms"), 56_ms);
CHECK_EQ(read<timespan>("78s"), 78_s);
CHECK_EQ(read<timespan>("60min"), 1_h);
CHECK_EQ(read<timespan>("90h"), 90_h);
}
CAF_TEST(invalid timespans) {
CAF_CHECK_EQUAL(read<timespan>("12"), pec::unexpected_eof);
CAF_CHECK_EQUAL(read<timespan>("12nas"), pec::unexpected_character);
CAF_CHECK_EQUAL(read<timespan>("34usec"), pec::trailing_character);
CAF_CHECK_EQUAL(read<timespan>("56m"), pec::unexpected_eof);
CHECK_EQ(read<timespan>("12"), pec::unexpected_eof);
CHECK_EQ(read<timespan>("12nas"), pec::unexpected_character);
CHECK_EQ(read<timespan>("34usec"), pec::trailing_character);
CHECK_EQ(read<timespan>("56m"), pec::unexpected_eof);
}
CAF_TEST(strings) {
CAF_CHECK_EQUAL(read<std::string>(" foo\t "), "foo");
CAF_CHECK_EQUAL(read<std::string>(" \" foo\t\" "), " foo\t");
CHECK_EQ(read<std::string>(" foo\t "), "foo");
CHECK_EQ(read<std::string>(" \" foo\t\" "), " foo\t");
}
CAF_TEST(uris) {
if (auto x_res = read<uri>("foo:bar")) {
auto x = *x_res;
CAF_CHECK_EQUAL(x.scheme(), "foo");
CAF_CHECK_EQUAL(x.path(), "bar");
CHECK_EQ(x.scheme(), "foo");
CHECK_EQ(x.path(), "bar");
} else {
CAF_ERROR("my:path not recognized as URI");
}
}
CAF_TEST(IPv4 address) {
CAF_CHECK_EQUAL(read<ipv4_address>("1.2.3.4"), ipv4_address({1, 2, 3, 4}));
CAF_CHECK_EQUAL(read<ipv4_address>("127.0.0.1"),
ipv4_address({127, 0, 0, 1}));
CAF_CHECK_EQUAL(read<ipv4_address>("256.0.0.1"), pec::integer_overflow);
CHECK_EQ(read<ipv4_address>("1.2.3.4"), ipv4_address({1, 2, 3, 4}));
CHECK_EQ(read<ipv4_address>("127.0.0.1"), ipv4_address({127, 0, 0, 1}));
CHECK_EQ(read<ipv4_address>("256.0.0.1"), pec::integer_overflow);
}
CAF_TEST(IPv4 subnet) {
CAF_CHECK_EQUAL(read<ipv4_subnet>("1.2.3.0/24"),
ipv4_subnet(ipv4_address({1, 2, 3, 0}), 24));
CAF_CHECK_EQUAL(read<ipv4_subnet>("1.2.3.0/33"), pec::integer_overflow);
CHECK_EQ(read<ipv4_subnet>("1.2.3.0/24"),
ipv4_subnet(ipv4_address({1, 2, 3, 0}), 24));
CHECK_EQ(read<ipv4_subnet>("1.2.3.0/33"), pec::integer_overflow);
}
CAF_TEST(IPv4 endpoint) {
CAF_CHECK_EQUAL(read<ipv4_endpoint>("127.0.0.1:0"),
ipv4_endpoint(ipv4_address({127, 0, 0, 1}), 0));
CAF_CHECK_EQUAL(read<ipv4_endpoint>("127.0.0.1:65535"),
ipv4_endpoint(ipv4_address({127, 0, 0, 1}), 65535));
CAF_CHECK_EQUAL(read<ipv4_endpoint>("127.0.0.1:65536"),
pec::integer_overflow);
CHECK_EQ(read<ipv4_endpoint>("127.0.0.1:0"),
ipv4_endpoint(ipv4_address({127, 0, 0, 1}), 0));
CHECK_EQ(read<ipv4_endpoint>("127.0.0.1:65535"),
ipv4_endpoint(ipv4_address({127, 0, 0, 1}), 65535));
CHECK_EQ(read<ipv4_endpoint>("127.0.0.1:65536"), pec::integer_overflow);
}
CAF_TEST(IPv6 address) {
CAF_CHECK_EQUAL(read<ipv6_address>("1.2.3.4"), ipv4_address({1, 2, 3, 4}));
CAF_CHECK_EQUAL(read<ipv6_address>("1::"), ipv6_address({{1}, {}}));
CAF_CHECK_EQUAL(read<ipv6_address>("::2"), ipv6_address({{}, {2}}));
CAF_CHECK_EQUAL(read<ipv6_address>("1::2"), ipv6_address({{1}, {2}}));
CHECK_EQ(read<ipv6_address>("1.2.3.4"), ipv4_address({1, 2, 3, 4}));
CHECK_EQ(read<ipv6_address>("1::"), ipv6_address({{1}, {}}));
CHECK_EQ(read<ipv6_address>("::2"), ipv6_address({{}, {2}}));
CHECK_EQ(read<ipv6_address>("1::2"), ipv6_address({{1}, {2}}));
}
CAF_TEST(IPv6 subnet) {
CAF_CHECK_EQUAL(read<ipv6_subnet>("1.2.3.0/24"),
ipv6_subnet(ipv4_address({1, 2, 3, 0}), 24));
CAF_CHECK_EQUAL(read<ipv6_subnet>("1::/128"),
ipv6_subnet(ipv6_address({1}, {}), 128));
CAF_CHECK_EQUAL(read<ipv6_subnet>("1::/129"), pec::integer_overflow);
CHECK_EQ(read<ipv6_subnet>("1.2.3.0/24"),
ipv6_subnet(ipv4_address({1, 2, 3, 0}), 24));
CHECK_EQ(read<ipv6_subnet>("1::/128"),
ipv6_subnet(ipv6_address({1}, {}), 128));
CHECK_EQ(read<ipv6_subnet>("1::/129"), pec::integer_overflow);
}
CAF_TEST(IPv6 endpoint) {
CAF_CHECK_EQUAL(read<ipv6_endpoint>("127.0.0.1:0"),
ipv6_endpoint(ipv4_address({127, 0, 0, 1}), 0));
CAF_CHECK_EQUAL(read<ipv6_endpoint>("127.0.0.1:65535"),
ipv6_endpoint(ipv4_address({127, 0, 0, 1}), 65535));
CAF_CHECK_EQUAL(read<ipv6_endpoint>("127.0.0.1:65536"),
pec::integer_overflow);
CAF_CHECK_EQUAL(read<ipv6_endpoint>("[1::2]:8080"),
ipv6_endpoint({{1}, {2}}, 8080));
CHECK_EQ(read<ipv6_endpoint>("127.0.0.1:0"),
ipv6_endpoint(ipv4_address({127, 0, 0, 1}), 0));
CHECK_EQ(read<ipv6_endpoint>("127.0.0.1:65535"),
ipv6_endpoint(ipv4_address({127, 0, 0, 1}), 65535));
CHECK_EQ(read<ipv6_endpoint>("127.0.0.1:65536"), pec::integer_overflow);
CHECK_EQ(read<ipv6_endpoint>("[1::2]:8080"), ipv6_endpoint({{1}, {2}}, 8080));
}
......@@ -6,7 +6,7 @@
#include "caf/detail/parser/read_bool.hpp"
#include "caf/test/unit_test.hpp"
#include "core-test.hpp"
#include <string>
......@@ -45,26 +45,26 @@ struct fixture {
} // namespace
CAF_TEST_FIXTURE_SCOPE(read_bool_tests, fixture)
BEGIN_FIXTURE_SCOPE(fixture)
CAF_TEST(valid booleans) {
CAF_CHECK_EQUAL(p("true"), res_t{true});
CAF_CHECK_EQUAL(p("false"), res_t{false});
CHECK_EQ(p("true"), res_t{true});
CHECK_EQ(p("false"), res_t{false});
}
CAF_TEST(invalid booleans) {
CAF_CHECK_EQUAL(p(""), res_t{pec::unexpected_eof});
CAF_CHECK_EQUAL(p("t"), res_t{pec::unexpected_eof});
CAF_CHECK_EQUAL(p("tr"), res_t{pec::unexpected_eof});
CAF_CHECK_EQUAL(p("tru"), res_t{pec::unexpected_eof});
CAF_CHECK_EQUAL(p(" true"), res_t{pec::unexpected_character});
CAF_CHECK_EQUAL(p("f"), res_t{pec::unexpected_eof});
CAF_CHECK_EQUAL(p("fa"), res_t{pec::unexpected_eof});
CAF_CHECK_EQUAL(p("fal"), res_t{pec::unexpected_eof});
CAF_CHECK_EQUAL(p("fals"), res_t{pec::unexpected_eof});
CAF_CHECK_EQUAL(p(" false"), res_t{pec::unexpected_character});
CAF_CHECK_EQUAL(p("tr\nue"), res_t{pec::unexpected_newline});
CAF_CHECK_EQUAL(p("trues"), res_t{pec::trailing_character});
CHECK_EQ(p(""), res_t{pec::unexpected_eof});
CHECK_EQ(p("t"), res_t{pec::unexpected_eof});
CHECK_EQ(p("tr"), res_t{pec::unexpected_eof});
CHECK_EQ(p("tru"), res_t{pec::unexpected_eof});
CHECK_EQ(p(" true"), res_t{pec::unexpected_character});
CHECK_EQ(p("f"), res_t{pec::unexpected_eof});
CHECK_EQ(p("fa"), res_t{pec::unexpected_eof});
CHECK_EQ(p("fal"), res_t{pec::unexpected_eof});
CHECK_EQ(p("fals"), res_t{pec::unexpected_eof});
CHECK_EQ(p(" false"), res_t{pec::unexpected_character});
CHECK_EQ(p("tr\nue"), res_t{pec::unexpected_newline});
CHECK_EQ(p("trues"), res_t{pec::trailing_character});
}
CAF_TEST_FIXTURE_SCOPE_END()
END_FIXTURE_SCOPE()
......@@ -6,7 +6,7 @@
#include "caf/detail/parser/read_config.hpp"
#include "caf/test/dsl.hpp"
#include "core-test.hpp"
#include "caf/config_value.hpp"
#include "caf/parser_state.hpp"
......@@ -70,8 +70,8 @@ struct fixture {
string_parser_state res{str.begin(), str.end()};
detail::parser::read_config(res, f);
if ((res.code == pec::success) != expect_success) {
CAF_MESSAGE("unexpected parser result state: " << res.code);
CAF_MESSAGE("input remainder: " << std::string(res.i, res.e));
MESSAGE("unexpected parser result state: " << res.code);
MESSAGE("input remainder: " << std::string(res.i, res.e));
}
return std::move(f.log);
}
......@@ -213,11 +213,11 @@ const auto conf1_log = make_log(
} // namespace
CAF_TEST_FIXTURE_SCOPE(read_config_tests, fixture)
BEGIN_FIXTURE_SCOPE(fixture)
CAF_TEST(read_config feeds into a consumer) {
CAF_CHECK_EQUAL(parse(conf0), conf0_log);
CAF_CHECK_EQUAL(parse(conf1), conf1_log);
CHECK_EQ(parse(conf0), conf0_log);
CHECK_EQ(parse(conf1), conf1_log);
}
CAF_TEST_FIXTURE_SCOPE_END()
END_FIXTURE_SCOPE()
......@@ -6,7 +6,7 @@
#include "caf/detail/parser/read_floating_point.hpp"
#include "caf/test/dsl.hpp"
#include "core-test.hpp"
#include <string>
......@@ -40,51 +40,51 @@ optional<double> read(string_view str) {
} // namespace
CAF_TEST(predecimal only) {
CAF_CHECK_EQUAL(read("0"), 0.);
CAF_CHECK_EQUAL(read("+0"), 0.);
CAF_CHECK_EQUAL(read("-0"), 0.);
CAF_CHECK_EQUAL(read("1"), 1.);
CAF_CHECK_EQUAL(read("+1"), 1.);
CAF_CHECK_EQUAL(read("-1"), -1.);
CAF_CHECK_EQUAL(read("12"), 12.);
CAF_CHECK_EQUAL(read("+12"), 12.);
CAF_CHECK_EQUAL(read("-12"), -12.);
CHECK_EQ(read("0"), 0.);
CHECK_EQ(read("+0"), 0.);
CHECK_EQ(read("-0"), 0.);
CHECK_EQ(read("1"), 1.);
CHECK_EQ(read("+1"), 1.);
CHECK_EQ(read("-1"), -1.);
CHECK_EQ(read("12"), 12.);
CHECK_EQ(read("+12"), 12.);
CHECK_EQ(read("-12"), -12.);
}
CAF_TEST(trailing dot) {
CAF_CHECK_EQUAL(read("0."), 0.);
CAF_CHECK_EQUAL(read("1."), 1.);
CAF_CHECK_EQUAL(read("+1."), 1.);
CAF_CHECK_EQUAL(read("-1."), -1.);
CAF_CHECK_EQUAL(read("12."), 12.);
CAF_CHECK_EQUAL(read("+12."), 12.);
CAF_CHECK_EQUAL(read("-12."), -12.);
CHECK_EQ(read("0."), 0.);
CHECK_EQ(read("1."), 1.);
CHECK_EQ(read("+1."), 1.);
CHECK_EQ(read("-1."), -1.);
CHECK_EQ(read("12."), 12.);
CHECK_EQ(read("+12."), 12.);
CHECK_EQ(read("-12."), -12.);
}
CAF_TEST(leading dot) {
CAF_CHECK_EQUAL(read(".0"), .0);
CAF_CHECK_EQUAL(read(".1"), .1);
CAF_CHECK_EQUAL(read("+.1"), .1);
CAF_CHECK_EQUAL(read("-.1"), -.1);
CAF_CHECK_EQUAL(read(".12"), .12);
CAF_CHECK_EQUAL(read("+.12"), .12);
CAF_CHECK_EQUAL(read("-.12"), -.12);
CHECK_EQ(read(".0"), .0);
CHECK_EQ(read(".1"), .1);
CHECK_EQ(read("+.1"), .1);
CHECK_EQ(read("-.1"), -.1);
CHECK_EQ(read(".12"), .12);
CHECK_EQ(read("+.12"), .12);
CHECK_EQ(read("-.12"), -.12);
}
CAF_TEST(regular noation) {
CAF_CHECK_EQUAL(read("0.0"), .0);
CAF_CHECK_EQUAL(read("1.2"), 1.2);
CAF_CHECK_EQUAL(read("1.23"), 1.23);
CAF_CHECK_EQUAL(read("12.34"), 12.34);
CHECK_EQ(read("0.0"), .0);
CHECK_EQ(read("1.2"), 1.2);
CHECK_EQ(read("1.23"), 1.23);
CHECK_EQ(read("12.34"), 12.34);
}
CAF_TEST(scientific noation) {
CAF_CHECK_EQUAL(read("1e2"), 1e2);
CAF_CHECK_EQUAL(read("+1e2"), 1e2);
CAF_CHECK_EQUAL(read("+1e+2"), 1e2);
CAF_CHECK_EQUAL(read("-1e2"), -1e2);
CAF_CHECK_EQUAL(read("-1e+2"), -1e2);
CAF_CHECK_EQUAL(read("12e-3"), 12e-3);
CAF_CHECK_EQUAL(read("+12e-3"), 12e-3);
CAF_CHECK_EQUAL(read("-12e-3"), -12e-3);
CHECK_EQ(read("1e2"), 1e2);
CHECK_EQ(read("+1e2"), 1e2);
CHECK_EQ(read("+1e+2"), 1e2);
CHECK_EQ(read("-1e2"), -1e2);
CHECK_EQ(read("-1e+2"), -1e2);
CHECK_EQ(read("12e-3"), 12e-3);
CHECK_EQ(read("+12e-3"), 12e-3);
CHECK_EQ(read("-12e-3"), -12e-3);
}
......@@ -6,7 +6,7 @@
#include "caf/detail/parser/read_number.hpp"
#include "caf/test/unit_test.hpp"
#include "core-test.hpp"
#include <string>
......@@ -108,9 +108,9 @@ struct fixture {
} // namespace
#define CHECK_NUMBER(x) CAF_CHECK_EQUAL(p(#x), res(x))
#define CHECK_NUMBER(x) CHECK_EQ(p(#x), res(x))
CAF_TEST_FIXTURE_SCOPE(read_number_tests, fixture)
BEGIN_FIXTURE_SCOPE(fixture)
CAF_TEST(add ascii - unsigned) {
using detail::parser::add_ascii;
......@@ -122,9 +122,9 @@ CAF_TEST(add ascii - unsigned) {
return x;
};
for (int i = 0; i < 256; ++i)
CAF_CHECK_EQUAL(rd(std::to_string(i)), static_cast<uint8_t>(i));
CHECK_EQ(rd(std::to_string(i)), static_cast<uint8_t>(i));
for (int i = 256; i < 513; ++i)
CAF_CHECK_EQUAL(rd(std::to_string(i)), pec::integer_overflow);
CHECK_EQ(rd(std::to_string(i)), pec::integer_overflow);
}
CAF_TEST(add ascii - signed) {
......@@ -136,9 +136,9 @@ CAF_TEST(add ascii - signed) {
return x;
};
for (int i = 0; i < 128; ++i)
CAF_CHECK_EQUAL(rd(std::to_string(i)), static_cast<int8_t>(i));
CHECK_EQ(rd(std::to_string(i)), static_cast<int8_t>(i));
for (int i = 128; i < 513; ++i)
CAF_CHECK_EQUAL(rd(std::to_string(i)), pec::integer_overflow);
CHECK_EQ(rd(std::to_string(i)), pec::integer_overflow);
}
CAF_TEST(sub ascii) {
......@@ -152,9 +152,9 @@ CAF_TEST(sub ascii) {
// Using sub_ascii in this way behaves as if we'd prefix the number with a
// minus sign, i.e., "123" will result in -123.
for (int i = 1; i < 129; ++i)
CAF_CHECK_EQUAL(rd(std::to_string(i)), static_cast<int8_t>(-i));
CHECK_EQ(rd(std::to_string(i)), static_cast<int8_t>(-i));
for (int i = 129; i < 513; ++i)
CAF_CHECK_EQUAL(rd(std::to_string(i)), pec::integer_underflow);
CHECK_EQ(rd(std::to_string(i)), pec::integer_underflow);
}
CAF_TEST(binary numbers) {
......@@ -176,7 +176,7 @@ CAF_TEST(octal numbers) {
CHECK_NUMBER(-00);
CHECK_NUMBER(-0123);
// invalid numbers
CAF_CHECK_EQUAL(p("018"), pec::trailing_character);
CHECK_EQ(p("018"), pec::trailing_character);
}
CAF_TEST(decimal numbers) {
......@@ -197,11 +197,9 @@ CAF_TEST(hexadecimal numbers) {
CHECK_NUMBER(-0x123);
CHECK_NUMBER(-0xaf01);
// invalid numbers
CAF_CHECK_EQUAL(p("0xFG"), pec::trailing_character);
CAF_CHECK_EQUAL(p("0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"),
pec::integer_overflow);
CAF_CHECK_EQUAL(p("-0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"),
pec::integer_underflow);
CHECK_EQ(p("0xFG"), pec::trailing_character);
CHECK_EQ(p("0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"), pec::integer_overflow);
CHECK_EQ(p("-0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"), pec::integer_underflow);
}
CAF_TEST(floating point numbers) {
......@@ -252,8 +250,8 @@ CAF_TEST(integer mantissa with negative exponent) {
CHECK_NUMBER(1e-5);
CHECK_NUMBER(1e-6);
// invalid numbers
CAF_CHECK_EQUAL(p("-9.9999e-e511"), pec::unexpected_character);
CAF_CHECK_EQUAL(p("-9.9999e-511"), pec::exponent_underflow);
CHECK_EQ(p("-9.9999e-e511"), pec::unexpected_character);
CHECK_EQ(p("-9.9999e-511"), pec::exponent_underflow);
}
CAF_TEST(fractional mantissa with positive exponent) {
......@@ -279,7 +277,7 @@ CAF_TEST(fractional mantissa with negative exponent) {
}
#define CHECK_RANGE(expr, ...) \
CAF_CHECK_EQUAL(r(expr), std::vector<int64_t>({__VA_ARGS__}))
CHECK_EQ(r(expr), std::vector<int64_t>({__VA_ARGS__}))
CAF_TEST(a range from n to n is just n) {
CHECK_RANGE("0..0", 0);
......@@ -322,7 +320,7 @@ CAF_TEST(ranges can use signed integers) {
if (auto res = r(expr)) { \
CAF_FAIL("expected expression to produce to an error"); \
} else { \
CAF_CHECK_EQUAL(res.error(), enum_value); \
CHECK_EQ(res.error(), enum_value); \
}
CAF_TEST(the parser rejects invalid step values) {
......@@ -330,4 +328,4 @@ CAF_TEST(the parser rejects invalid step values) {
CHECK_ERR("+2..-2..+2", pec::invalid_range_expression);
}
CAF_TEST_FIXTURE_SCOPE_END()
END_FIXTURE_SCOPE()
......@@ -6,7 +6,7 @@
#include "caf/detail/parser/read_number_or_timespan.hpp"
#include "caf/test/unit_test.hpp"
#include "core-test.hpp"
#include <string>
......@@ -88,33 +88,33 @@ res_t res(std::chrono::duration<Rep, Period> x) {
} // namespace
CAF_TEST_FIXTURE_SCOPE(read_number_or_timespan_tests, fixture)
BEGIN_FIXTURE_SCOPE(fixture)
CAF_TEST(valid numbers and timespans) {
CAF_CHECK_EQUAL(p("123"), res(123));
CAF_CHECK_EQUAL(p("123.456"), res(123.456));
CAF_CHECK_EQUAL(p("123s"), res(seconds(123)));
CAF_CHECK_EQUAL(p("123ns"), res(nanoseconds(123)));
CAF_CHECK_EQUAL(p("123ms"), res(milliseconds(123)));
CAF_CHECK_EQUAL(p("123us"), res(microseconds(123)));
CAF_CHECK_EQUAL(p("123min"), res(minutes(123)));
CHECK_EQ(p("123"), res(123));
CHECK_EQ(p("123.456"), res(123.456));
CHECK_EQ(p("123s"), res(seconds(123)));
CHECK_EQ(p("123ns"), res(nanoseconds(123)));
CHECK_EQ(p("123ms"), res(milliseconds(123)));
CHECK_EQ(p("123us"), res(microseconds(123)));
CHECK_EQ(p("123min"), res(minutes(123)));
}
CAF_TEST(invalid timespans) {
CAF_CHECK_EQUAL(p("12.3s"), pec::fractional_timespan);
CAF_CHECK_EQUAL(p("12.3n"), pec::fractional_timespan);
CAF_CHECK_EQUAL(p("12.3ns"), pec::fractional_timespan);
CAF_CHECK_EQUAL(p("12.3m"), pec::fractional_timespan);
CAF_CHECK_EQUAL(p("12.3ms"), pec::fractional_timespan);
CAF_CHECK_EQUAL(p("12.3n"), pec::fractional_timespan);
CAF_CHECK_EQUAL(p("12.3ns"), pec::fractional_timespan);
CAF_CHECK_EQUAL(p("12.3mi"), pec::fractional_timespan);
CAF_CHECK_EQUAL(p("12.3min"), pec::fractional_timespan);
CAF_CHECK_EQUAL(p("123ss"), pec::trailing_character);
CAF_CHECK_EQUAL(p("123m"), pec::unexpected_eof);
CAF_CHECK_EQUAL(p("123mi"), pec::unexpected_eof);
CAF_CHECK_EQUAL(p("123u"), pec::unexpected_eof);
CAF_CHECK_EQUAL(p("123n"), pec::unexpected_eof);
CHECK_EQ(p("12.3s"), pec::fractional_timespan);
CHECK_EQ(p("12.3n"), pec::fractional_timespan);
CHECK_EQ(p("12.3ns"), pec::fractional_timespan);
CHECK_EQ(p("12.3m"), pec::fractional_timespan);
CHECK_EQ(p("12.3ms"), pec::fractional_timespan);
CHECK_EQ(p("12.3n"), pec::fractional_timespan);
CHECK_EQ(p("12.3ns"), pec::fractional_timespan);
CHECK_EQ(p("12.3mi"), pec::fractional_timespan);
CHECK_EQ(p("12.3min"), pec::fractional_timespan);
CHECK_EQ(p("123ss"), pec::trailing_character);
CHECK_EQ(p("123m"), pec::unexpected_eof);
CHECK_EQ(p("123mi"), pec::unexpected_eof);
CHECK_EQ(p("123u"), pec::unexpected_eof);
CHECK_EQ(p("123n"), pec::unexpected_eof);
}
CAF_TEST_FIXTURE_SCOPE_END()
END_FIXTURE_SCOPE()
......@@ -6,7 +6,7 @@
#include "caf/detail/parser/read_signed_integer.hpp"
#include "caf/test/dsl.hpp"
#include "core-test.hpp"
#include "caf/parser_state.hpp"
#include "caf/string_view.hpp"
......@@ -65,26 +65,25 @@ T max_val() {
} // namespace
#define ZERO_VALUE(type, literal) \
CAF_CHECK_EQUAL(read<type>(#literal), type(0));
#define ZERO_VALUE(type, literal) CHECK_EQ(read<type>(#literal), type(0));
#define MAX_VALUE(type, literal) \
CAF_CHECK_EQUAL(read<type>(#literal), max_val<type>());
CHECK_EQ(read<type>(#literal), max_val<type>());
#define MIN_VALUE(type, literal) \
CAF_CHECK_EQUAL(read<type>(#literal), min_val<type>());
CHECK_EQ(read<type>(#literal), min_val<type>());
#ifdef OVERFLOW
# undef OVERFLOW
#endif // OVERFLOW
#define OVERFLOW(type, literal) CAF_CHECK(overflow<type>(#literal));
#define OVERFLOW(type, literal) CHECK(overflow<type>(#literal));
#ifdef UNDERFLOW
# undef UNDERFLOW
#endif // UNDERFLOW
#define UNDERFLOW(type, literal) CAF_CHECK(underflow<type>(#literal));
#define UNDERFLOW(type, literal) CHECK(underflow<type>(#literal));
CAF_TEST(read zeros) {
ZERO_VALUE(int8_t, 0);
......
......@@ -6,7 +6,7 @@
#include "caf/detail/parser/read_string.hpp"
#include "caf/test/unit_test.hpp"
#include "core-test.hpp"
#include <string>
......@@ -44,59 +44,59 @@ struct fixture {
} // namespace
CAF_TEST_FIXTURE_SCOPE(read_string_tests, fixture)
BEGIN_FIXTURE_SCOPE(fixture)
CAF_TEST(empty string) {
CAF_CHECK_EQUAL(p(R"("")"), ""s);
CAF_CHECK_EQUAL(p(R"( "")"), ""s);
CAF_CHECK_EQUAL(p(R"( "")"), ""s);
CAF_CHECK_EQUAL(p(R"("" )"), ""s);
CAF_CHECK_EQUAL(p(R"("" )"), ""s);
CAF_CHECK_EQUAL(p(R"( "" )"), ""s);
CAF_CHECK_EQUAL(p("\t \"\" \t\t\t "), ""s);
CAF_CHECK_EQUAL(p(R"('')"), ""s);
CAF_CHECK_EQUAL(p(R"( '')"), ""s);
CAF_CHECK_EQUAL(p(R"( '')"), ""s);
CAF_CHECK_EQUAL(p(R"('' )"), ""s);
CAF_CHECK_EQUAL(p(R"('' )"), ""s);
CAF_CHECK_EQUAL(p(R"( '' )"), ""s);
CAF_CHECK_EQUAL(p("\t '' \t\t\t "), ""s);
CHECK_EQ(p(R"("")"), ""s);
CHECK_EQ(p(R"( "")"), ""s);
CHECK_EQ(p(R"( "")"), ""s);
CHECK_EQ(p(R"("" )"), ""s);
CHECK_EQ(p(R"("" )"), ""s);
CHECK_EQ(p(R"( "" )"), ""s);
CHECK_EQ(p("\t \"\" \t\t\t "), ""s);
CHECK_EQ(p(R"('')"), ""s);
CHECK_EQ(p(R"( '')"), ""s);
CHECK_EQ(p(R"( '')"), ""s);
CHECK_EQ(p(R"('' )"), ""s);
CHECK_EQ(p(R"('' )"), ""s);
CHECK_EQ(p(R"( '' )"), ""s);
CHECK_EQ(p("\t '' \t\t\t "), ""s);
}
CAF_TEST(nonempty quoted string) {
CAF_CHECK_EQUAL(p(R"("abc")"), "abc"s);
CAF_CHECK_EQUAL(p(R"("a b c")"), "a b c"s);
CAF_CHECK_EQUAL(p(R"( "abcdefABCDEF" )"), "abcdefABCDEF"s);
CAF_CHECK_EQUAL(p(R"('abc')"), "abc"s);
CAF_CHECK_EQUAL(p(R"('a b c')"), "a b c"s);
CAF_CHECK_EQUAL(p(R"( 'abcdefABCDEF' )"), "abcdefABCDEF"s);
CHECK_EQ(p(R"("abc")"), "abc"s);
CHECK_EQ(p(R"("a b c")"), "a b c"s);
CHECK_EQ(p(R"( "abcdefABCDEF" )"), "abcdefABCDEF"s);
CHECK_EQ(p(R"('abc')"), "abc"s);
CHECK_EQ(p(R"('a b c')"), "a b c"s);
CHECK_EQ(p(R"( 'abcdefABCDEF' )"), "abcdefABCDEF"s);
}
CAF_TEST(quoted string with escaped characters) {
CAF_CHECK_EQUAL(p(R"("a\tb\tc")"), "a\tb\tc"s);
CAF_CHECK_EQUAL(p(R"("a\nb\r\nc")"), "a\nb\r\nc"s);
CAF_CHECK_EQUAL(p(R"("a\\b")"), "a\\b"s);
CAF_CHECK_EQUAL(p("\"'hello' \\\"world\\\"\""), "'hello' \"world\""s);
CAF_CHECK_EQUAL(p(R"('a\tb\tc')"), "a\tb\tc"s);
CAF_CHECK_EQUAL(p(R"('a\nb\r\nc')"), "a\nb\r\nc"s);
CAF_CHECK_EQUAL(p(R"('a\\b')"), "a\\b"s);
CAF_CHECK_EQUAL(p(R"('\'hello\' "world"')"), "'hello' \"world\""s);
CHECK_EQ(p(R"("a\tb\tc")"), "a\tb\tc"s);
CHECK_EQ(p(R"("a\nb\r\nc")"), "a\nb\r\nc"s);
CHECK_EQ(p(R"("a\\b")"), "a\\b"s);
CHECK_EQ(p("\"'hello' \\\"world\\\"\""), "'hello' \"world\""s);
CHECK_EQ(p(R"('a\tb\tc')"), "a\tb\tc"s);
CHECK_EQ(p(R"('a\nb\r\nc')"), "a\nb\r\nc"s);
CHECK_EQ(p(R"('a\\b')"), "a\\b"s);
CHECK_EQ(p(R"('\'hello\' "world"')"), "'hello' \"world\""s);
}
CAF_TEST(unquoted strings) {
CAF_CHECK_EQUAL(p(R"(foo)"), "foo"s);
CAF_CHECK_EQUAL(p(R"( foo )"), "foo"s);
CAF_CHECK_EQUAL(p(R"( 123 )"), "123"s);
CHECK_EQ(p(R"(foo)"), "foo"s);
CHECK_EQ(p(R"( foo )"), "foo"s);
CHECK_EQ(p(R"( 123 )"), "123"s);
}
CAF_TEST(invalid strings) {
CAF_CHECK_EQUAL(p(R"("abc)"), pec::unexpected_eof);
CAF_CHECK_EQUAL(p(R"('abc)"), pec::unexpected_eof);
CAF_CHECK_EQUAL(p("\"ab\nc\""), pec::unexpected_newline);
CAF_CHECK_EQUAL(p("'ab\nc'"), pec::unexpected_newline);
CAF_CHECK_EQUAL(p(R"("abc" def)"), pec::trailing_character);
CAF_CHECK_EQUAL(p(R"('abc' def)"), pec::trailing_character);
CAF_CHECK_EQUAL(p(R"( 123, )"), pec::trailing_character);
CHECK_EQ(p(R"("abc)"), pec::unexpected_eof);
CHECK_EQ(p(R"('abc)"), pec::unexpected_eof);
CHECK_EQ(p("\"ab\nc\""), pec::unexpected_newline);
CHECK_EQ(p("'ab\nc'"), pec::unexpected_newline);
CHECK_EQ(p(R"("abc" def)"), pec::trailing_character);
CHECK_EQ(p(R"('abc' def)"), pec::trailing_character);
CHECK_EQ(p(R"( 123, )"), pec::trailing_character);
}
CAF_TEST_FIXTURE_SCOPE_END()
END_FIXTURE_SCOPE()
......@@ -6,7 +6,7 @@
#include "caf/detail/parser/read_timespan.hpp"
#include "caf/test/dsl.hpp"
#include "core-test.hpp"
#include <chrono>
......@@ -62,10 +62,10 @@ optional<timespan> read(string_view str) {
} // namespace
CAF_TEST(todo) {
CAF_CHECK_EQUAL(read("12ns"), 12_ns);
CAF_CHECK_EQUAL(read("34us"), 34_us);
CAF_CHECK_EQUAL(read("56ms"), 56_ms);
CAF_CHECK_EQUAL(read("78s"), 78_s);
CAF_CHECK_EQUAL(read("60min"), 1_h);
CAF_CHECK_EQUAL(read("90h"), 90_h);
CHECK_EQ(read("12ns"), 12_ns);
CHECK_EQ(read("34us"), 34_us);
CHECK_EQ(read("56ms"), 56_ms);
CHECK_EQ(read("78s"), 78_s);
CHECK_EQ(read("60min"), 1_h);
CHECK_EQ(read("90h"), 90_h);
}
......@@ -6,7 +6,7 @@
#include "caf/detail/parser/read_unsigned_integer.hpp"
#include "caf/test/dsl.hpp"
#include "core-test.hpp"
#include "caf/parser_state.hpp"
#include "caf/string_view.hpp"
......@@ -52,17 +52,16 @@ T max_val() {
} // namespace
#define ZERO_VALUE(type, literal) \
CAF_CHECK_EQUAL(read<type>(#literal), type(0));
#define ZERO_VALUE(type, literal) CHECK_EQ(read<type>(#literal), type(0));
#define MAX_VALUE(type, literal) \
CAF_CHECK_EQUAL(read<type>(#literal), max_val<type>());
CHECK_EQ(read<type>(#literal), max_val<type>());
#ifdef OVERFLOW
# undef OVERFLOW
#endif // OVERFLOW
#define OVERFLOW(type, literal) CAF_CHECK(overflow<type>(#literal));
#define OVERFLOW(type, literal) CHECK(overflow<type>(#literal));
CAF_TEST(read zeros) {
ZERO_VALUE(uint8_t, 0);
......
......@@ -26,7 +26,7 @@
using namespace caf;
CAF_TEST_FIXTURE_SCOPE(private_thread_pool_tests, test_coordinator_fixture<>)
BEGIN_FIXTURE_SCOPE(test_coordinator_fixture<>)
SCENARIO("private threads count towards detached actors") {
GIVEN("an actor system with a private thread pool") {
......@@ -97,4 +97,4 @@ SCENARIO("private threads rerun their resumable when it returns resume_later") {
}
}
CAF_TEST_FIXTURE_SCOPE_END()
END_FIXTURE_SCOPE()
......@@ -6,7 +6,7 @@
#include "caf/detail/ringbuffer.hpp"
#include "caf/test/dsl.hpp"
#include "core-test.hpp"
#include <algorithm>
......@@ -39,33 +39,33 @@ struct fixture {
} // namespace
CAF_TEST_FIXTURE_SCOPE(ringbuffer_tests, fixture)
BEGIN_FIXTURE_SCOPE(fixture)
CAF_TEST(construction) {
CAF_CHECK_EQUAL(buf.empty(), true);
CAF_CHECK_EQUAL(buf.full(), false);
CAF_CHECK_EQUAL(buf.size(), 0u);
CHECK_EQ(buf.empty(), true);
CHECK_EQ(buf.full(), false);
CHECK_EQ(buf.size(), 0u);
}
CAF_TEST(push_back) {
CAF_MESSAGE("add one element");
MESSAGE("add one element");
buf.push_back(42);
CAF_CHECK_EQUAL(buf.empty(), false);
CAF_CHECK_EQUAL(buf.full(), false);
CAF_CHECK_EQUAL(buf.size(), 1u);
CAF_CHECK_EQUAL(buf.front(), 42);
CAF_MESSAGE("remove element");
CHECK_EQ(buf.empty(), false);
CHECK_EQ(buf.full(), false);
CHECK_EQ(buf.size(), 1u);
CHECK_EQ(buf.front(), 42);
MESSAGE("remove element");
buf.pop_front();
CAF_CHECK_EQUAL(buf.empty(), true);
CAF_CHECK_EQUAL(buf.full(), false);
CAF_CHECK_EQUAL(buf.size(), 0u);
CAF_MESSAGE("fill buffer");
CHECK_EQ(buf.empty(), true);
CHECK_EQ(buf.full(), false);
CHECK_EQ(buf.size(), 0u);
MESSAGE("fill buffer");
for (int i = 0; i < static_cast<int>(buf_size - 1); ++i)
buf.push_back(std::move(i));
CAF_CHECK_EQUAL(buf.empty(), false);
CAF_CHECK_EQUAL(buf.full(), true);
CAF_CHECK_EQUAL(buf.size(), buf_size - 1);
CAF_CHECK_EQUAL(buf.front(), 0);
CHECK_EQ(buf.empty(), false);
CHECK_EQ(buf.full(), true);
CHECK_EQ(buf.size(), buf_size - 1);
CHECK_EQ(buf.front(), 0);
}
CAF_TEST(get all) {
......@@ -77,29 +77,29 @@ CAF_TEST(get all) {
auto e = buf.get_all(i);
return vector_type(i, e);
};
CAF_MESSAGE("add five element");
MESSAGE("add five element");
for (int i = 0; i < 5; ++i)
buf.push_back(std::move(i));
CAF_CHECK_EQUAL(buf.empty(), false);
CAF_CHECK_EQUAL(buf.full(), false);
CAF_CHECK_EQUAL(buf.size(), 5u);
CAF_CHECK_EQUAL(buf.front(), 0);
CAF_MESSAGE("drain elements");
CAF_CHECK_EQUAL(fetch_all(), vector_type({0, 1, 2, 3, 4}));
CAF_CHECK_EQUAL(buf.empty(), true);
CAF_CHECK_EQUAL(buf.full(), false);
CAF_CHECK_EQUAL(buf.size(), 0u);
CAF_MESSAGE("add 60 elements (wraps around)");
CHECK_EQ(buf.empty(), false);
CHECK_EQ(buf.full(), false);
CHECK_EQ(buf.size(), 5u);
CHECK_EQ(buf.front(), 0);
MESSAGE("drain elements");
CHECK_EQ(fetch_all(), vector_type({0, 1, 2, 3, 4}));
CHECK_EQ(buf.empty(), true);
CHECK_EQ(buf.full(), false);
CHECK_EQ(buf.size(), 0u);
MESSAGE("add 60 elements (wraps around)");
vector_type expected;
for (int i = 0; i < 60; ++i) {
expected.push_back(i);
buf.push_back(std::move(i));
}
CAF_CHECK_EQUAL(buf.size(), 60u);
CAF_CHECK_EQUAL(fetch_all(), expected);
CAF_CHECK_EQUAL(buf.empty(), true);
CAF_CHECK_EQUAL(buf.full(), false);
CAF_CHECK_EQUAL(buf.size(), 0u);
CHECK_EQ(buf.size(), 60u);
CHECK_EQ(fetch_all(), expected);
CHECK_EQ(buf.empty(), true);
CHECK_EQ(buf.full(), false);
CHECK_EQ(buf.size(), 0u);
}
CAF_TEST(concurrent access) {
......@@ -109,12 +109,12 @@ CAF_TEST(concurrent access) {
producers.emplace_back(producer, std::ref(buf), 200, 300);
auto vec = consumer(buf, 300);
std::sort(vec.begin(), vec.end());
CAF_CHECK(std::is_sorted(vec.begin(), vec.end()));
CAF_CHECK_EQUAL(vec.size(), 300u);
CAF_CHECK_EQUAL(vec.front(), 0);
CAF_CHECK_EQUAL(vec.back(), 299);
CHECK(std::is_sorted(vec.begin(), vec.end()));
CHECK_EQ(vec.size(), 300u);
CHECK_EQ(vec.front(), 0);
CHECK_EQ(vec.back(), 299);
for (auto& t : producers)
t.join();
}
CAF_TEST_FIXTURE_SCOPE_END()
END_FIXTURE_SCOPE()
......@@ -6,7 +6,7 @@
#include "caf/detail/ripemd_160.hpp"
#include "caf/test/unit_test.hpp"
#include "core-test.hpp"
#include <iomanip>
#include <iostream>
......@@ -31,20 +31,20 @@ std::string str_hash(const std::string& what) {
// verify ripemd implementation with example hash results from
// http://homes.esat.kuleuven.be/~bosselae/ripemd160.html
CAF_TEST(hash_results) {
CAF_CHECK_EQUAL("9c1185a5c5e9fc54612808977ee8f548b2258d31", str_hash(""));
CAF_CHECK_EQUAL("0bdc9d2d256b3ee9daae347be6f4dc835a467ffe", str_hash("a"));
CAF_CHECK_EQUAL("8eb208f7e05d987a9b044a8e98c6b087f15a0bfc", str_hash("abc"));
CAF_CHECK_EQUAL("5d0689ef49d2fae572b881b123a85ffa21595f36",
str_hash("message digest"));
CAF_CHECK_EQUAL("f71c27109c692c1b56bbdceb5b9d2865b3708dbc",
str_hash("abcdefghijklmnopqrstuvwxyz"));
CAF_CHECK_EQUAL("12a053384a9c0c88e405a06c27dcf49ada62eb2b",
str_hash("abcdbcdecdefdefgefghfghighij"
"hijkijkljklmklmnlmnomnopnopq"));
CAF_CHECK_EQUAL("b0e20b6e3116640286ed3a87a5713079b21f5189",
str_hash("ABCDEFGHIJKLMNOPQRSTUVWXYZabcde"
"fghijklmnopqrstuvwxyz0123456789"));
CAF_CHECK_EQUAL("9b752e45573d4b39f4dbd3323cab82bf63326bfb",
str_hash("1234567890123456789012345678901234567890"
"1234567890123456789012345678901234567890"));
CHECK_EQ("9c1185a5c5e9fc54612808977ee8f548b2258d31", str_hash(""));
CHECK_EQ("0bdc9d2d256b3ee9daae347be6f4dc835a467ffe", str_hash("a"));
CHECK_EQ("8eb208f7e05d987a9b044a8e98c6b087f15a0bfc", str_hash("abc"));
CHECK_EQ("5d0689ef49d2fae572b881b123a85ffa21595f36",
str_hash("message digest"));
CHECK_EQ("f71c27109c692c1b56bbdceb5b9d2865b3708dbc",
str_hash("abcdefghijklmnopqrstuvwxyz"));
CHECK_EQ("12a053384a9c0c88e405a06c27dcf49ada62eb2b",
str_hash("abcdbcdecdefdefgefghfghighij"
"hijkijkljklmklmnlmnomnopnopq"));
CHECK_EQ("b0e20b6e3116640286ed3a87a5713079b21f5189",
str_hash("ABCDEFGHIJKLMNOPQRSTUVWXYZabcde"
"fghijklmnopqrstuvwxyz0123456789"));
CHECK_EQ("9b752e45573d4b39f4dbd3323cab82bf63326bfb",
str_hash("1234567890123456789012345678901234567890"
"1234567890123456789012345678901234567890"));
}
......@@ -6,7 +6,7 @@
#include "caf/detail/serialized_size.hpp"
#include "caf/test/dsl.hpp"
#include "core-test.hpp"
#include <vector>
......@@ -34,9 +34,9 @@ struct fixture : test_coordinator_fixture<> {
} // namespace
#define CHECK_SAME_SIZE(value) \
CAF_CHECK_EQUAL(serialized_size(value), actual_size(value))
CHECK_EQ(serialized_size(value), actual_size(value))
CAF_TEST_FIXTURE_SCOPE(serialized_size_tests, fixture)
BEGIN_FIXTURE_SCOPE(fixture)
CAF_TEST(numbers) {
CHECK_SAME_SIZE(int8_t{42});
......@@ -63,4 +63,4 @@ CAF_TEST(messages) {
CHECK_SAME_SIZE(make_message("hello", "world"));
}
CAF_TEST_FIXTURE_SCOPE_END()
END_FIXTURE_SCOPE()
......@@ -18,7 +18,7 @@
#include "caf/detail/tick_emitter.hpp"
#include "caf/test/unit_test.hpp"
#include "core-test.hpp"
#include <vector>
......@@ -43,22 +43,22 @@ CAF_TEST(start_and_stop) {
detail::tick_emitter y{time_point{timespan{100}}};
detail::tick_emitter z;
z.start(time_point{timespan{100}});
CAF_CHECK_EQUAL(x.started(), false);
CAF_CHECK_EQUAL(y.started(), true);
CAF_CHECK_EQUAL(z.started(), true);
CHECK_EQ(x.started(), false);
CHECK_EQ(y.started(), true);
CHECK_EQ(z.started(), true);
for (auto t : {&x, &y, &z})
t->stop();
CAF_CHECK_EQUAL(x.started(), false);
CAF_CHECK_EQUAL(y.started(), false);
CAF_CHECK_EQUAL(z.started(), false);
CHECK_EQ(x.started(), false);
CHECK_EQ(y.started(), false);
CHECK_EQ(z.started(), false);
}
CAF_TEST(ticks) {
auto cycle = detail::gcd(credit_interval.count(),
force_batch_interval.count());
CAF_CHECK_EQUAL(cycle, 50);
auto force_batch_frequency = static_cast<size_t>(force_batch_interval.count()
/ cycle);
CHECK_EQ(cycle, 50);
auto force_batch_frequency
= static_cast<size_t>(force_batch_interval.count() / cycle);
auto credit_frequency = static_cast<size_t>(credit_interval.count() / cycle);
detail::tick_emitter tctrl{time_point{timespan{100}}};
tctrl.interval(timespan{cycle});
......@@ -72,16 +72,16 @@ CAF_TEST(ticks) {
if (tick_id % credit_frequency == 0)
++credit_triggers;
};
CAF_MESSAGE("trigger 4 ticks");
MESSAGE("trigger 4 ticks");
tctrl.update(time_point{timespan{300}}, f);
CAF_CHECK_EQUAL(deep_to_string(ticks), "[1, 2, 3, 4]");
CAF_CHECK_EQUAL(force_batch_triggers, 4lu);
CAF_CHECK_EQUAL(credit_triggers, 1lu);
CAF_MESSAGE("trigger 3 more ticks");
CHECK_EQ(deep_to_string(ticks), "[1, 2, 3, 4]");
CHECK_EQ(force_batch_triggers, 4lu);
CHECK_EQ(credit_triggers, 1lu);
MESSAGE("trigger 3 more ticks");
tctrl.update(time_point{timespan{475}}, f);
CAF_CHECK_EQUAL(deep_to_string(ticks), "[1, 2, 3, 4, 5, 6, 7]");
CAF_CHECK_EQUAL(force_batch_triggers, 7lu);
CAF_CHECK_EQUAL(credit_triggers, 1lu);
CHECK_EQ(deep_to_string(ticks), "[1, 2, 3, 4, 5, 6, 7]");
CHECK_EQ(force_batch_triggers, 7lu);
CHECK_EQ(credit_triggers, 1lu);
}
CAF_TEST(timeouts) {
......@@ -90,26 +90,26 @@ CAF_TEST(timeouts) {
auto now = start;
detail::tick_emitter tctrl{now};
tctrl.interval(interval);
CAF_MESSAGE("advance until the first 5-tick-period ends");
MESSAGE("advance until the first 5-tick-period ends");
now += interval * 5;
auto bitmask = tctrl.timeouts(now, {5, 7});
CAF_CHECK_EQUAL(bitmask, 0x01u);
CAF_MESSAGE("advance until the first 7-tick-period ends");
CHECK_EQ(bitmask, 0x01u);
MESSAGE("advance until the first 7-tick-period ends");
now += interval * 2;
bitmask = tctrl.timeouts(now, {5, 7});
CAF_CHECK_EQUAL(bitmask, 0x02u);
CAF_MESSAGE("advance until both tick period ends");
CHECK_EQ(bitmask, 0x02u);
MESSAGE("advance until both tick period ends");
now += interval * 7;
bitmask = tctrl.timeouts(now, {5, 7});
CAF_CHECK_EQUAL(bitmask, 0x03u);
CAF_MESSAGE("advance until both tick period end multiple times");
CHECK_EQ(bitmask, 0x03u);
MESSAGE("advance until both tick period end multiple times");
now += interval * 21;
bitmask = tctrl.timeouts(now, {5, 7});
CAF_CHECK_EQUAL(bitmask, 0x03u);
CAF_MESSAGE("advance without any timeout");
CHECK_EQ(bitmask, 0x03u);
MESSAGE("advance without any timeout");
now += interval * 1;
bitmask = tctrl.timeouts(now, {5, 7});
CAF_CHECK_EQUAL(bitmask, 0x00u);
CHECK_EQ(bitmask, 0x00u);
}
CAF_TEST(next_timeout) {
......@@ -118,19 +118,19 @@ CAF_TEST(next_timeout) {
auto now = start;
detail::tick_emitter tctrl{now};
tctrl.interval(interval);
CAF_MESSAGE("advance until the first 5-tick-period ends");
MESSAGE("advance until the first 5-tick-period ends");
auto next = tctrl.next_timeout(now, {5, 7});
CAF_CHECK_EQUAL(next, start + timespan(5 * interval));
CAF_MESSAGE("advance until the first 7-tick-period ends");
CHECK_EQ(next, start + timespan(5 * interval));
MESSAGE("advance until the first 7-tick-period ends");
now = start + timespan(5 * interval);
next = tctrl.next_timeout(now, {5, 7});
CAF_CHECK_EQUAL(next, start + timespan(7 * interval));
CAF_MESSAGE("advance until the second 5-tick-period ends");
CHECK_EQ(next, start + timespan(7 * interval));
MESSAGE("advance until the second 5-tick-period ends");
now = start + timespan(7 * interval);
next = tctrl.next_timeout(now, {5, 7});
CAF_CHECK_EQUAL(next, start + timespan((2 * 5) * interval));
CAF_MESSAGE("advance until the second 7-tick-period ends");
CHECK_EQ(next, start + timespan((2 * 5) * interval));
MESSAGE("advance until the second 7-tick-period ends");
now = start + timespan(11 * interval);
next = tctrl.next_timeout(now, {5, 7});
CAF_CHECK_EQUAL(next, start + timespan((2 * 7) * interval));
CHECK_EQ(next, start + timespan((2 * 7) * interval));
}
......@@ -6,7 +6,7 @@
#include "caf/detail/type_id_list_builder.hpp"
#include "caf/test/dsl.hpp"
#include "core-test.hpp"
using namespace caf;
......@@ -16,10 +16,10 @@ struct fixture {};
} // namespace
CAF_TEST_FIXTURE_SCOPE(type_id_list_builder_tests, fixture)
BEGIN_FIXTURE_SCOPE(fixture)
CAF_TEST(todo) {
// implement me
}
CAF_TEST_FIXTURE_SCOPE_END()
END_FIXTURE_SCOPE()
......@@ -6,7 +6,7 @@
#include "caf/detail/unique_function.hpp"
#include "caf/test/dsl.hpp"
#include "core-test.hpp"
namespace {
......@@ -38,22 +38,22 @@ private:
} // namespace
#define CHECK_VALID(f) \
CAF_CHECK(!f.is_nullptr()); \
CAF_CHECK(f); \
CAF_CHECK(f != nullptr); \
CAF_CHECK(nullptr != f); \
CAF_CHECK(!(f == nullptr)); \
CAF_CHECK(!(nullptr == f)); \
CAF_CHECK(f() == 42)
CHECK(!f.is_nullptr()); \
CHECK(f); \
CHECK_NE(f, nullptr); \
CHECK_NE(nullptr, f); \
CHECK(!(f == nullptr)); \
CHECK(!(nullptr == f)); \
CHECK_EQ(f(), 42)
#define CHECK_INVALID(f) \
CAF_CHECK(f.is_nullptr()); \
CAF_CHECK(!f); \
CAF_CHECK(f == nullptr); \
CAF_CHECK(nullptr == f); \
CAF_CHECK(!(f != nullptr)); \
CAF_CHECK(!(nullptr != f)); \
CAF_CHECK(!f.holds_wrapper())
CHECK(f.is_nullptr()); \
CHECK(!f); \
CHECK_EQ(f, nullptr); \
CHECK_EQ(nullptr, f); \
CHECK(!(f != nullptr)); \
CHECK(!(nullptr != f)); \
CHECK(!f.holds_wrapper())
CAF_TEST(default construction) {
int_fun f;
......@@ -68,14 +68,14 @@ CAF_TEST(raw function pointer construction) {
CAF_TEST(stateless lambda construction) {
int_fun f{[] { return 42; }};
CHECK_VALID(f);
CAF_CHECK(!f.holds_wrapper());
CHECK(!f.holds_wrapper());
}
CAF_TEST(stateful lambda construction) {
int i = 42;
int_fun f{[=] { return i; }};
CHECK_VALID(f);
CAF_CHECK(f.holds_wrapper());
CHECK(f.holds_wrapper());
}
CAF_TEST(custom wrapper construction) {
......@@ -83,10 +83,10 @@ CAF_TEST(custom wrapper construction) {
{ // lifetime scope of our counting wrapper
int_fun f{new instance_counting_wrapper(&instances)};
CHECK_VALID(f);
CAF_CHECK(f.holds_wrapper());
CAF_CHECK(instances == 1);
CHECK(f.holds_wrapper());
CHECK(instances == 1);
}
CAF_CHECK(instances == 0);
CHECK(instances == 0);
}
CAF_TEST(function move construction) {
......@@ -94,7 +94,7 @@ CAF_TEST(function move construction) {
int_fun g{std::move(f)};
CHECK_INVALID(f);
CHECK_VALID(g);
CAF_CHECK(!g.holds_wrapper());
CHECK(!g.holds_wrapper());
}
CAF_TEST(stateful lambda move construction) {
......@@ -103,7 +103,7 @@ CAF_TEST(stateful lambda move construction) {
int_fun g{std::move(f)};
CHECK_INVALID(f);
CHECK_VALID(g);
CAF_CHECK(g.holds_wrapper());
CHECK(g.holds_wrapper());
}
CAF_TEST(custom wrapper move construction) {
......@@ -113,10 +113,10 @@ CAF_TEST(custom wrapper move construction) {
int_fun g{std::move(f)};
CHECK_INVALID(f);
CHECK_VALID(g);
CAF_CHECK(g.holds_wrapper());
CAF_CHECK(instances == 1);
CHECK(g.holds_wrapper());
CHECK(instances == 1);
}
CAF_CHECK(instances == 0);
CHECK(instances == 0);
}
CAF_TEST(function assign) {
......@@ -124,14 +124,14 @@ CAF_TEST(function assign) {
int_fun f;
int_fun g{forty_two};
int_fun h{new instance_counting_wrapper(&instances)};
CAF_CHECK(instances == 1);
CHECK(instances == 1);
CHECK_INVALID(f);
CHECK_VALID(g);
CHECK_VALID(h);
f = forty_two;
g = forty_two;
h = forty_two;
CAF_CHECK(instances == 0);
CHECK(instances == 0);
CHECK_VALID(f);
CHECK_VALID(g);
CHECK_VALID(h);
......@@ -142,22 +142,22 @@ CAF_TEST(move assign) {
int_fun f;
int_fun g{forty_two};
int_fun h{new instance_counting_wrapper(&instances)};
CAF_CHECK(instances == 1);
CHECK(instances == 1);
CHECK_INVALID(f);
CHECK_VALID(g);
CHECK_VALID(h);
g = std::move(h);
CAF_CHECK(instances == 1);
CHECK(instances == 1);
CHECK_INVALID(f);
CHECK_VALID(g);
CHECK_INVALID(h);
f = std::move(g);
CAF_CHECK(instances == 1);
CHECK(instances == 1);
CHECK_VALID(f);
CHECK_INVALID(g);
CHECK_INVALID(h);
f = int_fun{};
CAF_CHECK(instances == 0);
CHECK(instances == 0);
CHECK_INVALID(f);
CHECK_INVALID(g);
CHECK_INVALID(h);
......
......@@ -6,7 +6,7 @@
#include "caf/detail/unordered_flat_map.hpp"
#include "caf/test/unit_test.hpp"
#include "core-test.hpp"
#include <string>
#include <utility>
......@@ -80,36 +80,36 @@ struct fixture {
} // namespace
CAF_TEST_FIXTURE_SCOPE(unordered_flat_map_tests, fixture)
BEGIN_FIXTURE_SCOPE(fixture)
CAF_TEST(default_constructed) {
// A default-constructed map must be empty, i.e., have size 0.
CAF_CHECK_EQUAL(xs.empty(), true);
CAF_CHECK_EQUAL(xs.size(), 0u);
CHECK_EQ(xs.empty(), true);
CHECK_EQ(xs.size(), 0u);
// The begin() and end() iterators must compare equal.
CAF_CHECK_EQUAL(xs.begin(), xs.end());
CAF_CHECK_EQUAL(xs.cbegin(), xs.begin());
CAF_CHECK_EQUAL(xs.cend(), xs.end());
CAF_CHECK_EQUAL(xs.cbegin(), xs.cend());
CAF_CHECK_EQUAL(xs.rbegin(), xs.rend());
CHECK_EQ(xs.begin(), xs.end());
CHECK_EQ(xs.cbegin(), xs.begin());
CHECK_EQ(xs.cend(), xs.end());
CHECK_EQ(xs.cbegin(), xs.cend());
CHECK_EQ(xs.rbegin(), xs.rend());
// Calling begin() and end() on a const reference must return the same as
// cbegin() and cend().
const auto& cxs = xs;
CAF_CHECK_EQUAL(cxs.begin(), xs.cbegin());
CAF_CHECK_EQUAL(cxs.end(), xs.cend());
CHECK_EQ(cxs.begin(), xs.cbegin());
CHECK_EQ(cxs.end(), xs.cend());
}
CAF_TEST(initializer_list_constructed) {
unordered_flat_map<int, int> zs{{1, 10}, {2, 20}, {3, 30}, {4, 40}};
CAF_CHECK_EQUAL(zs.size(), 4u);
CAF_CHECK_EQUAL(zs, ivec({{1, 10}, {2, 20}, {3, 30}, {4, 40}}));
CHECK_EQ(zs.size(), 4u);
CHECK_EQ(zs, ivec({{1, 10}, {2, 20}, {3, 30}, {4, 40}}));
}
CAF_TEST(range_constructed) {
kvp_vec<int> tmp{{1, 10}, {2, 20}, {3, 30}, {4, 40}};
unordered_flat_map<int, int> zs(tmp.begin(), tmp.end());
CAF_CHECK_EQUAL(zs.size(), 4u);
CAF_CHECK_EQUAL(zs, tmp);
CHECK_EQ(zs.size(), 4u);
CHECK_EQ(zs, tmp);
}
CAF_TEST(integer_insertion) {
......@@ -118,34 +118,34 @@ CAF_TEST(integer_insertion) {
xs.insert(xs.cbegin(), kvp(1, 10));
xs.emplace(5, 50);
xs.emplace_hint(xs.cend() - 1, 4, 40);
CAF_CHECK_EQUAL(xs, ivec({{1, 10}, {2, 20}, {3, 30}, {4, 40}, {5, 50}}));
CHECK_EQ(xs, ivec({{1, 10}, {2, 20}, {3, 30}, {4, 40}, {5, 50}}));
}
CAF_TEST(integer_removal) {
fill_xs();
CAF_CHECK_EQUAL(xs, ivec({{1, 10}, {2, 20}, {3, 30}, {4, 40}}));
CHECK_EQ(xs, ivec({{1, 10}, {2, 20}, {3, 30}, {4, 40}}));
xs.erase(xs.begin());
CAF_CHECK_EQUAL(xs, ivec({{2, 20}, {3, 30}, {4, 40}}));
CHECK_EQ(xs, ivec({{2, 20}, {3, 30}, {4, 40}}));
xs.erase(xs.begin(), xs.begin() + 2);
CAF_CHECK_EQUAL(xs, ivec({{4, 40}}));
CHECK_EQ(xs, ivec({{4, 40}}));
xs.erase(4);
CAF_CHECK_EQUAL(xs.empty(), true);
CAF_CHECK_EQUAL(xs.size(), 0u);
CHECK_EQ(xs.empty(), true);
CHECK_EQ(xs.size(), 0u);
}
CAF_TEST(lookup) {
fill_xs();
CAF_CHECK_EQUAL(xs.count(2), 1u);
CAF_CHECK_EQUAL(xs.count(6), 0u);
CHECK_EQ(xs.count(2), 1u);
CHECK_EQ(xs.count(6), 0u);
// trigger non-const member functions
CAF_CHECK_EQUAL(xs.at(3), 30);
CAF_CHECK_EQUAL(xs.find(1), xs.begin());
CAF_CHECK_EQUAL(xs.find(2), xs.begin() + 1);
CHECK_EQ(xs.at(3), 30);
CHECK_EQ(xs.find(1), xs.begin());
CHECK_EQ(xs.find(2), xs.begin() + 1);
// trigger const member functions
const auto& cxs = xs;
CAF_CHECK_EQUAL(cxs.at(2), 20);
CAF_CHECK_EQUAL(cxs.find(4), xs.end() - 1);
CAF_CHECK_EQUAL(cxs.find(5), xs.end());
CHECK_EQ(cxs.at(2), 20);
CHECK_EQ(cxs.find(4), xs.end() - 1);
CHECK_EQ(cxs.find(5), xs.end());
}
#ifdef CAF_ENABLE_EXCEPTIONS
......@@ -155,7 +155,7 @@ CAF_TEST(exceptions) {
auto x = xs.at(10);
CAF_FAIL("got an unexpected value: " << x);
} catch (std::out_of_range&) {
CAF_MESSAGE("got expected out_of_range exception");
MESSAGE("got expected out_of_range exception");
} catch (...) {
CAF_FAIL("got an expected exception");
}
......@@ -172,19 +172,19 @@ CAF_TEST(string_insertion) {
ys.emplace(5, "e");
ys.emplace_hint(ys.cend() - 1, 4, "d");
kvp_vec<string> tmp{{1, "a"}, {2, "b"}, {3, "c"}, {4, "d"}, {5, "e"}};
CAF_CHECK_EQUAL(ys, tmp);
CHECK_EQ(ys, tmp);
}
CAF_TEST(string_removal) {
fill_ys();
CAF_CHECK_EQUAL(ys, svec({{1, "a"}, {2, "b"}, {3, "c"}, {4, "d"}}));
CHECK_EQ(ys, svec({{1, "a"}, {2, "b"}, {3, "c"}, {4, "d"}}));
ys.erase(ys.begin());
CAF_CHECK_EQUAL(ys, svec({{2, "b"}, {3, "c"}, {4, "d"}}));
CHECK_EQ(ys, svec({{2, "b"}, {3, "c"}, {4, "d"}}));
ys.erase(ys.begin(), ys.begin() + 2);
CAF_CHECK_EQUAL(ys, svec({{4, "d"}}));
CHECK_EQ(ys, svec({{4, "d"}}));
ys.erase(4);
CAF_CHECK_EQUAL(ys.empty(), true);
CAF_CHECK_EQUAL(ys.size(), 0u);
CHECK_EQ(ys.empty(), true);
CHECK_EQ(ys.size(), 0u);
}
CAF_TEST_FIXTURE_SCOPE_END()
END_FIXTURE_SCOPE()
......@@ -18,20 +18,20 @@ using int_dict = dictionary<int>;
CAF_TEST(construction and comparison) {
int_dict xs;
CAF_CHECK_EQUAL(xs.empty(), true);
CAF_CHECK_EQUAL(xs.size(), 0u);
CHECK_EQ(xs.empty(), true);
CHECK_EQ(xs.size(), 0u);
int_dict ys{{"foo", 1}, {"bar", 2}};
CAF_CHECK_EQUAL(ys.empty(), false);
CAF_CHECK_EQUAL(ys.size(), 2u);
CAF_CHECK_NOT_EQUAL(xs, ys);
CHECK_EQ(ys.empty(), false);
CHECK_EQ(ys.size(), 2u);
CHECK_NE(xs, ys);
int_dict zs{ys.begin(), ys.end()};
CAF_CHECK_EQUAL(zs.empty(), false);
CAF_CHECK_EQUAL(zs.size(), 2u);
CAF_CHECK_EQUAL(ys, zs);
CHECK_EQ(zs.empty(), false);
CHECK_EQ(zs.size(), 2u);
CHECK_EQ(ys, zs);
zs.clear();
CAF_CHECK_EQUAL(zs.empty(), true);
CAF_CHECK_EQUAL(zs.size(), 0u);
CAF_CHECK_EQUAL(xs, zs);
CHECK_EQ(zs.empty(), true);
CHECK_EQ(zs.size(), 0u);
CHECK_EQ(xs, zs);
}
CAF_TEST(iterators) {
......@@ -39,44 +39,44 @@ CAF_TEST(iterators) {
using vector_type = std::vector<int_dict::value_type>;
int_dict xs{{"a", 1}, {"b", 2}, {"c", 3}};
vector_type ys{{"a", 1}, {"b", 2}, {"c", 3}};
CAF_CHECK(equal(xs.begin(), xs.end(), ys.begin()));
CAF_CHECK(equal(xs.cbegin(), xs.cend(), ys.cbegin()));
CAF_CHECK(equal(xs.rbegin(), xs.rend(), ys.rbegin()));
CAF_CHECK(equal(xs.crbegin(), xs.crend(), ys.crbegin()));
CHECK(equal(xs.begin(), xs.end(), ys.begin()));
CHECK(equal(xs.cbegin(), xs.cend(), ys.cbegin()));
CHECK(equal(xs.rbegin(), xs.rend(), ys.rbegin()));
CHECK(equal(xs.crbegin(), xs.crend(), ys.crbegin()));
}
CAF_TEST(swapping) {
int_dict xs{{"foo", 1}, {"bar", 2}};
int_dict ys;
int_dict zs{{"foo", 1}, {"bar", 2}};
CAF_CHECK_NOT_EQUAL(xs, ys);
CAF_CHECK_NOT_EQUAL(ys, zs);
CAF_CHECK_EQUAL(xs, zs);
CHECK_NE(xs, ys);
CHECK_NE(ys, zs);
CHECK_EQ(xs, zs);
xs.swap(ys);
CAF_CHECK_NOT_EQUAL(xs, ys);
CAF_CHECK_EQUAL(ys, zs);
CAF_CHECK_NOT_EQUAL(xs, zs);
CHECK_NE(xs, ys);
CHECK_EQ(ys, zs);
CHECK_NE(xs, zs);
}
CAF_TEST(emplacing) {
int_dict xs;
CAF_CHECK_EQUAL(xs.emplace("x", 1).second, true);
CAF_CHECK_EQUAL(xs.emplace("y", 2).second, true);
CAF_CHECK_EQUAL(xs.emplace("y", 3).second, false);
CHECK_EQ(xs.emplace("x", 1).second, true);
CHECK_EQ(xs.emplace("y", 2).second, true);
CHECK_EQ(xs.emplace("y", 3).second, false);
}
CAF_TEST(insertion) {
int_dict xs;
CAF_CHECK_EQUAL(xs.insert("a", 1).second, true);
CAF_CHECK_EQUAL(xs.insert("b", 2).second, true);
CAF_CHECK_EQUAL(xs.insert("c", 3).second, true);
CAF_CHECK_EQUAL(xs.insert("c", 4).second, false);
CHECK_EQ(xs.insert("a", 1).second, true);
CHECK_EQ(xs.insert("b", 2).second, true);
CHECK_EQ(xs.insert("c", 3).second, true);
CHECK_EQ(xs.insert("c", 4).second, false);
int_dict ys;
CAF_CHECK_EQUAL(ys.insert_or_assign("a", 1).second, true);
CAF_CHECK_EQUAL(ys.insert_or_assign("b", 2).second, true);
CAF_CHECK_EQUAL(ys.insert_or_assign("c", 0).second, true);
CAF_CHECK_EQUAL(ys.insert_or_assign("c", 3).second, false);
CAF_CHECK_EQUAL(xs, ys);
CHECK_EQ(ys.insert_or_assign("a", 1).second, true);
CHECK_EQ(ys.insert_or_assign("b", 2).second, true);
CHECK_EQ(ys.insert_or_assign("c", 0).second, true);
CHECK_EQ(ys.insert_or_assign("c", 3).second, false);
CHECK_EQ(xs, ys);
}
CAF_TEST(insertion with hint) {
......@@ -98,32 +98,32 @@ CAF_TEST(insertion with hint) {
ys_insert_or_assign("c", 0);
ys_insert_or_assign("b", 2);
ys_insert_or_assign("c", 3);
CAF_CHECK_EQUAL(xs, ys);
CHECK_EQ(xs, ys);
}
CAF_TEST(bounds) {
int_dict xs{{"a", 1}, {"b", 2}, {"c", 3}, {"d", 4}};
const int_dict& const_xs = xs;
CAF_CHECK_EQUAL(xs.lower_bound("c")->first, "c");
CAF_CHECK_EQUAL(xs.upper_bound("c")->first, "d");
CAF_CHECK_EQUAL(const_xs.lower_bound("c")->first, "c");
CAF_CHECK_EQUAL(const_xs.upper_bound("c")->first, "d");
CHECK_EQ(xs.lower_bound("c")->first, "c");
CHECK_EQ(xs.upper_bound("c")->first, "d");
CHECK_EQ(const_xs.lower_bound("c")->first, "c");
CHECK_EQ(const_xs.upper_bound("c")->first, "d");
}
CAF_TEST(find) {
int_dict xs{{"a", 1}, {"b", 2}, {"c", 3}, {"d", 4}};
const int_dict& const_xs = xs;
CAF_CHECK_EQUAL(xs.find("e"), xs.end());
CAF_CHECK_EQUAL(xs.find("a")->second, 1);
CAF_CHECK_EQUAL(xs.find("c")->second, 3);
CAF_CHECK_EQUAL(const_xs.find("e"), xs.end());
CAF_CHECK_EQUAL(const_xs.find("a")->second, 1);
CAF_CHECK_EQUAL(const_xs.find("c")->second, 3);
CHECK_EQ(xs.find("e"), xs.end());
CHECK_EQ(xs.find("a")->second, 1);
CHECK_EQ(xs.find("c")->second, 3);
CHECK_EQ(const_xs.find("e"), xs.end());
CHECK_EQ(const_xs.find("a")->second, 1);
CHECK_EQ(const_xs.find("c")->second, 3);
}
CAF_TEST(element access) {
int_dict xs{{"a", 1}, {"b", 2}, {"c", 3}, {"d", 4}};
CAF_CHECK_EQUAL(xs["a"], 1);
CAF_CHECK_EQUAL(xs["b"], 2);
CAF_CHECK_EQUAL(xs["e"], 0);
CHECK_EQ(xs["a"], 1);
CHECK_EQ(xs["b"], 2);
CHECK_EQ(xs["e"], 0);
}
This diff is collapsed.
......@@ -75,7 +75,7 @@ actor spawn_event_testee2(scoped_actor& parent) {
return {
after(std::chrono::milliseconds(1)) >>
[=] {
CAF_MESSAGE("remaining: " << std::to_string(remaining));
MESSAGE("remaining: " << std::to_string(remaining));
if (remaining == 1) {
send(parent, ok_atom_v);
quit();
......@@ -191,7 +191,7 @@ public:
behavior master(event_based_actor* self) {
return {
[=](ok_atom) {
CAF_MESSAGE("master: received done");
MESSAGE("master: received done");
self->quit(exit_reason::user_shutdown);
},
};
......@@ -200,7 +200,7 @@ behavior master(event_based_actor* self) {
behavior slave(event_based_actor* self, const actor& master) {
self->link_to(master);
self->set_exit_handler([=](exit_msg& msg) {
CAF_MESSAGE("slave: received exit message");
MESSAGE("slave: received exit message");
self->quit(msg.reason);
});
return {
......@@ -224,11 +224,11 @@ public:
for (int i = 0; i < 100; ++i) {
send(this, ok_atom_v);
}
CAF_CHECK_EQUAL(mailbox().size(), 100u);
CHECK_EQ(mailbox().size(), 100u);
for (int i = 0; i < 100; ++i) {
send(this, ok_atom_v);
}
CAF_CHECK_EQUAL(mailbox().size(), 200u);
CHECK_EQ(mailbox().size(), 200u);
return {};
}
};
......@@ -248,21 +248,20 @@ struct fixture {
system.~actor_system();
// destructor of actor_system must make sure all
// destructors of all actors have been run
CAF_CHECK_EQUAL(s_actor_instances.load(), 0);
CAF_MESSAGE("max. # of actor instances: " << s_max_actor_instances.load());
CHECK_EQ(s_actor_instances.load(), 0);
MESSAGE("max. # of actor instances: " << s_max_actor_instances.load());
}
};
} // namespace
CAF_TEST_FIXTURE_SCOPE(dynamic_spawn_tests, test_coordinator_fixture<>)
BEGIN_FIXTURE_SCOPE(test_coordinator_fixture<>)
CAF_TEST(mirror) {
auto mirror = self->spawn<simple_mirror>();
auto dummy = self->spawn([=](event_based_actor* ptr) -> behavior {
ptr->send(mirror, "hello mirror");
return {
[](const std::string& msg) { CAF_CHECK_EQUAL(msg, "hello mirror"); }};
return {[](const std::string& msg) { CHECK_EQ(msg, "hello mirror"); }};
});
run();
/*
......@@ -270,15 +269,15 @@ CAF_TEST(mirror) {
run();
self->receive (
[](const std::string& msg) {
CAF_CHECK_EQUAL(msg, "hello mirror");
CHECK_EQ(msg, "hello mirror");
}
);
*/
}
CAF_TEST_FIXTURE_SCOPE_END()
END_FIXTURE_SCOPE()
CAF_TEST_FIXTURE_SCOPE(atom_tests, fixture)
BEGIN_FIXTURE_SCOPE(fixture)
CAF_TEST(count_mailbox) {
system.spawn<counting_actor>();
......@@ -306,18 +305,17 @@ CAF_TEST(detached_mirror) {
scoped_actor self{system};
auto mirror = self->spawn<simple_mirror, detached>();
self->send(mirror, "hello mirror");
self->receive(
[](const std::string& msg) { CAF_CHECK_EQUAL(msg, "hello mirror"); });
self->receive([](const std::string& msg) { CHECK_EQ(msg, "hello mirror"); });
}
CAF_TEST(send_to_self) {
scoped_actor self{system};
self->send(self, 1, 2, 3, true);
self->receive([](int a, int b, int c, bool d) {
CAF_CHECK_EQUAL(a, 1);
CAF_CHECK_EQUAL(b, 2);
CAF_CHECK_EQUAL(c, 3);
CAF_CHECK_EQUAL(d, true);
CHECK_EQ(a, 1);
CHECK_EQ(b, 2);
CHECK_EQ(c, 3);
CHECK_EQ(d, true);
});
self->send(self, message{});
self->receive([] {});
......@@ -327,17 +325,16 @@ CAF_TEST(echo_actor_messaging) {
scoped_actor self{system};
auto mecho = system.spawn<echo_actor>();
self->send(mecho, "hello echo");
self->receive(
[](const std::string& arg) { CAF_CHECK_EQUAL(arg, "hello echo"); });
self->receive([](const std::string& arg) { CHECK_EQ(arg, "hello echo"); });
}
CAF_TEST(delayed_send) {
scoped_actor self{system};
self->delayed_send(self, std::chrono::milliseconds(1), 1, 2, 3);
self->receive([](int a, int b, int c) {
CAF_CHECK_EQUAL(a, 1);
CAF_CHECK_EQUAL(b, 2);
CAF_CHECK_EQUAL(c, 3);
CHECK_EQ(a, 1);
CHECK_EQ(b, 2);
CHECK_EQ(c, 3);
});
}
......@@ -350,7 +347,7 @@ CAF_TEST(delayed_spawn) {
CAF_TEST(spawn_event_testee2_test) {
scoped_actor self{system};
spawn_event_testee2(self);
self->receive([](ok_atom) { CAF_MESSAGE("Received 'ok'"); });
self->receive([](ok_atom) { MESSAGE("Received 'ok'"); });
}
CAF_TEST(function_spawn) {
......@@ -361,12 +358,11 @@ CAF_TEST(function_spawn) {
auto a1 = system.spawn(f, "alice");
auto a2 = system.spawn(f, "bob");
self->send(a1, get_atom_v);
self->receive([&](name_atom, const std::string& name) {
CAF_CHECK_EQUAL(name, "alice");
});
self->receive(
[&](name_atom, const std::string& name) { CHECK_EQ(name, "alice"); });
self->send(a2, get_atom_v);
self->receive(
[&](name_atom, const std::string& name) { CAF_CHECK_EQUAL(name, "bob"); });
[&](name_atom, const std::string& name) { CHECK_EQ(name, "bob"); });
self->send_exit(a1, exit_reason::user_shutdown);
self->send_exit(a2, exit_reason::user_shutdown);
}
......@@ -375,7 +371,7 @@ using typed_testee = typed_actor<replies_to<abc_atom>::with<std::string>>;
typed_testee::behavior_type testee() {
return {[](abc_atom) {
CAF_MESSAGE("received 'abc'");
MESSAGE("received 'abc'");
return "abc";
}};
}
......@@ -383,7 +379,7 @@ typed_testee::behavior_type testee() {
CAF_TEST(typed_await) {
scoped_actor self{system};
auto f = make_function_view(system.spawn(testee));
CAF_CHECK_EQUAL(f(abc_atom_v), "abc");
CHECK_EQ(f(abc_atom_v), "abc");
}
// tests attach_functor() inside of an actor's constructor
......@@ -418,7 +414,7 @@ CAF_TEST(constructor_attach) {
downs_(0),
testee_(spawn<testee, monitored>(this)) {
set_down_handler([=](down_msg& msg) {
CAF_CHECK_EQUAL(msg.reason, exit_reason::user_shutdown);
CHECK_EQ(msg.reason, exit_reason::user_shutdown);
if (++downs_ == 2)
quit(msg.reason);
});
......@@ -429,7 +425,7 @@ CAF_TEST(constructor_attach) {
behavior make_behavior() override {
return {
[=](ok_atom, const error& reason) {
CAF_CHECK_EQUAL(reason, exit_reason::user_shutdown);
CHECK_EQ(reason, exit_reason::user_shutdown);
if (++downs_ == 2)
quit(reason);
},
......@@ -437,7 +433,7 @@ CAF_TEST(constructor_attach) {
}
void on_exit() override {
CAF_MESSAGE("spawner::on_exit()");
MESSAGE("spawner::on_exit()");
destroy(testee_);
}
......@@ -477,7 +473,7 @@ CAF_TEST(move_only_argument) {
};
};
auto f = make_function_view(system.spawn(wrapper, std::move(uptr)));
CAF_CHECK_EQUAL(to_tuple<int>(unbox(f(1.f))), std::make_tuple(42));
CHECK_EQ(to_tuple<int>(unbox(f(1.f))), std::make_tuple(42));
}
CAF_TEST(move - only function object) {
......@@ -496,4 +492,4 @@ CAF_TEST(move - only function object) {
sys.spawn(std::move(f));
}
CAF_TEST_FIXTURE_SCOPE_END()
END_FIXTURE_SCOPE()
......@@ -74,43 +74,43 @@ struct fixture {
} // namespace
CAF_TEST_FIXTURE_SCOPE(function_view_tests, fixture)
BEGIN_FIXTURE_SCOPE(fixture)
CAF_TEST(empty_function_fiew) {
function_view<calculator> f;
CAF_CHECK_EQUAL(f(10, 20), sec::bad_function_call);
CHECK_EQ(f(10, 20), sec::bad_function_call);
}
CAF_TEST(single_res_function_view) {
auto f = make_function_view(system.spawn(adder));
CAF_CHECK_EQUAL(f(3, 4), 7);
CAF_CHECK(f != nullptr);
CAF_CHECK(nullptr != f);
CHECK_EQ(f(3, 4), 7);
CHECK(f != nullptr);
CHECK(nullptr != f);
function_view<calculator> g;
g = std::move(f);
CAF_CHECK(f == nullptr);
CAF_CHECK(nullptr == f);
CAF_CHECK(g != nullptr);
CAF_CHECK(nullptr != g);
CAF_CHECK_EQUAL(g(10, 20), 30);
CHECK(f == nullptr);
CHECK(nullptr == f);
CHECK(g != nullptr);
CHECK(nullptr != g);
CHECK_EQ(g(10, 20), 30);
g.assign(system.spawn(multiplier));
CAF_CHECK_EQUAL(g(10, 20), 200);
CHECK_EQ(g(10, 20), 200);
g.assign(system.spawn(divider));
CAF_CHECK(!g(1, 0));
CHECK(!g(1, 0));
g.assign(system.spawn(divider));
CAF_CHECK_EQUAL(g(4, 2), 2);
CHECK_EQ(g(4, 2), 2);
}
CAF_TEST(tuple_res_function_view) {
auto f = make_function_view(system.spawn(simple_doubler));
CAF_CHECK_EQUAL(f(10), std::make_tuple(10, 10));
CHECK_EQ(f(10), std::make_tuple(10, 10));
}
CAF_TEST(cell_function_view) {
auto f = make_function_view(system.spawn(simple_cell));
CAF_CHECK_EQUAL(f(get_atom_v), 0);
CHECK_EQ(f(get_atom_v), 0);
f(put_atom_v, 1024);
CAF_CHECK_EQUAL(f(get_atom_v), 1024);
CHECK_EQ(f(get_atom_v), 1024);
}
CAF_TEST_FIXTURE_SCOPE_END()
END_FIXTURE_SCOPE()
This diff is collapsed.
......@@ -6,7 +6,7 @@
#include "caf/hash/fnv.hpp"
#include "caf/test/dsl.hpp"
#include "core-test.hpp"
#include <string>
......@@ -26,25 +26,25 @@ auto fnv64_hash(Ts&&... xs) {
CAF_TEST(FNV hashes build incrementally) {
hash::fnv<uint32_t> f;
CAF_CHECK_EQUAL(f.result, 0x811C9DC5u);
CHECK_EQ(f.result, 0x811C9DC5u);
f.value('a');
CAF_CHECK_EQUAL(f.result, 0xE40C292Cu);
CHECK_EQ(f.result, 0xE40C292Cu);
f.value('b');
CAF_CHECK_EQUAL(f.result, 0x4D2505CAu);
CHECK_EQ(f.result, 0x4D2505CAu);
f.value('c');
CAF_CHECK_EQUAL(f.result, 0x1A47E90Bu);
CHECK_EQ(f.result, 0x1A47E90Bu);
f.value('d');
CAF_CHECK_EQUAL(f.result, 0xCE3479BDu);
CHECK_EQ(f.result, 0xCE3479BDu);
}
CAF_TEST(FNV supports uint32 hashing) {
CAF_CHECK_EQUAL(fnv32_hash(), 0x811C9DC5u);
CAF_CHECK_EQUAL(fnv32_hash("abcd"s), 0xCE3479BDu);
CAF_CHECK_EQUAL(fnv32_hash("C++ Actor Framework"s), 0x2FF91FE5u);
CHECK_EQ(fnv32_hash(), 0x811C9DC5u);
CHECK_EQ(fnv32_hash("abcd"s), 0xCE3479BDu);
CHECK_EQ(fnv32_hash("C++ Actor Framework"s), 0x2FF91FE5u);
}
CAF_TEST(FNV supports uint64 hashing) {
CAF_CHECK_EQUAL(fnv64_hash(), 0xCBF29CE484222325ull);
CAF_CHECK_EQUAL(fnv64_hash("abcd"s), 0xFC179F83EE0724DDull);
CAF_CHECK_EQUAL(fnv64_hash("C++ Actor Framework"s), 0xA229A760C3AF69C5ull);
CHECK_EQ(fnv64_hash(), 0xCBF29CE484222325ull);
CHECK_EQ(fnv64_hash("abcd"s), 0xFC179F83EE0724DDull);
CHECK_EQ(fnv64_hash("C++ Actor Framework"s), 0xA229A760C3AF69C5ull);
}
......@@ -6,7 +6,7 @@
#include "caf/hash/sha1.hpp"
#include "caf/test/dsl.hpp"
#include "core-test.hpp"
using namespace caf;
......@@ -21,7 +21,7 @@ auto make_hash(Ts... xs) {
} // namespace
#define CHECK_HASH_EQ(str, bytes) \
CAF_CHECK_EQUAL(hash::sha1::compute(string_view{str}), bytes);
CHECK_EQ(hash::sha1::compute(string_view{str}), bytes);
CAF_TEST(strings are hashed by their content only) {
CHECK_HASH_EQ("dGhlIHNhbXBsZSBub25jZQ==258EAFA5-E914-47DA-95CA-C5AB0DC85B11",
......
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
......@@ -111,7 +111,7 @@ fixture::fixture() {
} // namespace
CAF_TEST_FIXTURE_SCOPE(json_reader_tests, fixture)
BEGIN_FIXTURE_SCOPE(fixture)
CAF_TEST(json baselines) {
size_t baseline_index = 0;
......@@ -124,4 +124,4 @@ CAF_TEST(json baselines) {
}
}
CAF_TEST_FIXTURE_SCOPE_END()
END_FIXTURE_SCOPE()
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
Markdown is supported
0%
or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment