Unverified Commit 9d5165d6 authored by Noir's avatar Noir Committed by GitHub

Merge pull request #1300

Fix and improve some issues with the testing DSL
parents b10ee098 1936edfd
......@@ -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++
......@@ -5,10 +5,34 @@ is based on [Keep a Changelog](https://keepachangelog.com).
## [Unreleased]
### 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.
### 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
......
......@@ -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 ------------------------
......
......@@ -270,6 +270,7 @@ caf_add_component(
detail.unique_function
detail.unordered_flat_map
dictionary
dsl
dynamic_spawn
error
expected
......
......@@ -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.
......
......@@ -7,6 +7,7 @@
#include <cstdint>
#include "caf/detail/comparable.hpp"
#include "caf/fwd.hpp"
namespace caf {
......
......@@ -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.schedule.size(), 1u);
CHECK_EQ(t.schedule.size(), 1u);
// Advance time to trigger timeout.
t.advance_time(10s);
CAF_CHECK_EQUAL(t.schedule.size(), 0u);
CHECK_EQ(t.schedule.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.schedule.size(), 1u);
CHECK_EQ(t.schedule.size(), 1u);
// Advance time, but the clock drops the disposed callback.
t.advance_time(10s);
CAF_CHECK_EQUAL(t.schedule.size(), 0u);
CHECK_EQ(t.schedule.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.schedule.size(), 1u);
CHECK_EQ(t.schedule.size(), 1u);
// Advance time to send timeout message.
t.advance_time(10s);
CAF_CHECK_EQUAL(t.schedule.size(), 0u);
CHECK_EQ(t.schedule.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.schedule.size(), 1u);
CHECK_EQ(t.schedule.size(), 1u);
// Advance time to send the message.
t.advance_time(10s);
CAF_CHECK_EQUAL(t.schedule.size(), 0u);
CHECK_EQ(t.schedule.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.schedule.size(), 1u);
CHECK_EQ(t.schedule.size(), 1u);
// Advance time to send the message.
t.advance_time(10s);
CAF_CHECK_EQUAL(t.schedule.size(), 0u);
CHECK_EQ(t.schedule.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()
......@@ -60,10 +60,7 @@ public:
using behavior_type = behavior;
entity(actor_config& cfg, const char* cstr)
: super(cfg),
cstr_name(cstr),
mgr(this),
next_slot(1) {
: super(cfg), cstr_name(cstr), mgr(this), next_slot(1) {
// nop
}
......@@ -109,9 +106,7 @@ public:
}
size_t credit_for(entity& x) {
auto pred = [&](outbound_path* ptr) {
return ptr->hdl == &x;
};
auto pred = [&](outbound_path* ptr) { return ptr->hdl == &x; };
auto i = std::find_if(paths.begin(), paths.end(), pred);
CAF_REQUIRE(i != paths.end());
return static_cast<size_t>((*i)->open_credit);
......@@ -182,13 +177,13 @@ struct fixture {
}
fixture()
: sys(cfg),
alice_hdl(spawn(sys, 0, "alice")),
bob_hdl(spawn(sys, 1, "bob")),
carl_hdl(spawn(sys, 2, "carl")),
alice(fetch(alice_hdl)),
bob(fetch(bob_hdl)),
carl(fetch(carl_hdl)) {
: sys(cfg),
alice_hdl(spawn(sys, 0, "alice")),
bob_hdl(spawn(sys, 1, "bob")),
carl_hdl(spawn(sys, 2, "carl")),
alice(fetch(alice_hdl)),
bob(fetch(bob_hdl)),
carl(fetch(carl_hdl)) {
// nop
}
......@@ -227,10 +222,10 @@ struct receive_checker {
}
receive_checker(receive_checker&& x)
: f(x.f),
xs(std::move(x.xs)),
moved_from(false),
check_not_empty(x.check_not_empty) {
: f(x.f),
xs(std::move(x.xs)),
moved_from(false),
check_not_empty(x.check_not_empty) {
x.moved_from = true;
}
......@@ -279,16 +274,18 @@ receive_checker<F> operator<<(receive_checker<F> xs, not_empty_t) {
; \
make_receive_checker([&](fixture::batches_type& xs, bool check_not_empty) { \
if (!check_not_empty) \
CAF_CHECK_EQUAL(batches(CONCAT(who, __LINE__)), xs); \
CHECK_EQ(batches(CONCAT(who, __LINE__)), xs); \
else \
CAF_CHECK(!batches(CONCAT(who, __LINE__)).empty()); \
CHECK(!batches(CONCAT(who, __LINE__)).empty()); \
}) <<
#define ENTITY auto& CONCAT(who, __LINE__) =
#define AFTER
#define HAS ; size_t CONCAT(amount, __LINE__) =
#define HAS \
; \
size_t CONCAT(amount, __LINE__) =
#define CREDIT ;
......@@ -306,16 +303,15 @@ receive_checker<F> operator<<(receive_checker<F> xs, not_empty_t) {
; \
CONCAT(who, __LINE__) \
.new_round(CONCAT(amount, __LINE__), CONCAT(force, __LINE__)); \
CAF_MESSAGE(CONCAT(who, __LINE__).name() \
<< " tried sending " << CONCAT(amount, __LINE__) \
<< " elements");
MESSAGE(CONCAT(who, __LINE__).name() \
<< " tried sending " << CONCAT(amount, __LINE__) << " elements");
#define FOR \
struct CONCAT(for_helper_, __LINE__) { \
entity& who; \
size_t amount; \
void operator<<(entity& x) const { \
CAF_CHECK_EQUAL(who.credit_for(x), amount); \
CHECK_EQ(who.credit_for(x), amount); \
} \
}; \
CONCAT(for_helper_, __LINE__){CONCAT(who, __LINE__), \
......@@ -323,8 +319,8 @@ receive_checker<F> operator<<(receive_checker<F> xs, not_empty_t) {
<<
#define TOTAL \
CAF_CHECK_EQUAL(CONCAT(who, __LINE__).mgr.out().total_credit(), \
CONCAT(amount, __LINE__))
CHECK_EQ(CONCAT(who, __LINE__).mgr.out().total_credit(), \
CONCAT(amount, __LINE__))
#define BATCH(first, last) make_batch(first, last)
......@@ -332,7 +328,7 @@ receive_checker<F> operator<<(receive_checker<F> xs, not_empty_t) {
// -- unit tests ---------------------------------------------------------------
CAF_TEST_FIXTURE_SCOPE(broadcast_downstream_manager, fixture)
BEGIN_FIXTURE_SCOPE(fixture)
CAF_TEST(one_path_force) {
// Give alice 100 elements to send and a path to bob with desired batch size
......@@ -504,4 +500,4 @@ CAF_TEST(two_paths_different_sizes_without_force) {
}
}
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);
},
};
......
......@@ -37,8 +37,8 @@ TESTEE_STATE(file_reader) {
VARARGS_TESTEE(file_reader, size_t buf_size) {
return {
[=](string& fname) -> result<stream<int32_t>, string> {
CAF_CHECK_EQUAL(fname, "numbers.txt");
CAF_CHECK_EQUAL(self->mailbox().empty(), true);
CHECK_EQ(fname, "numbers.txt");
CHECK_EQ(self->mailbox().empty(), true);
return attach_stream_source(
self,
// forward file name in handshake to next stage
......@@ -52,7 +52,7 @@ VARARGS_TESTEE(file_reader, size_t buf_size) {
// get next element
[=](unit_t&, downstream<int32_t>& out, size_t num) {
auto& xs = self->state.buf;
CAF_MESSAGE("push " << num << " messages downstream");
MESSAGE("push " << num << " messages downstream");
auto n = std::min(num, xs.size());
for (size_t i = 0; i < n; ++i)
out.push(xs[i]);
......@@ -61,7 +61,7 @@ VARARGS_TESTEE(file_reader, size_t buf_size) {
// check whether we reached the end
[=](const unit_t&) {
if (self->state.buf.empty()) {
CAF_MESSAGE(self->name() << " is done");
MESSAGE(self->name() << " is done");
return true;
}
return false;
......@@ -77,7 +77,7 @@ TESTEE_STATE(sum_up) {
TESTEE(sum_up) {
return {
[=](stream<int32_t>& in, const string& fname) {
CAF_CHECK_EQUAL(fname, "numbers.txt");
CHECK_EQ(fname, "numbers.txt");
using int_ptr = int32_t*;
return attach_stream_sink(
self,
......@@ -88,12 +88,10 @@ TESTEE(sum_up) {
// processing step
[](int_ptr& x, int32_t y) { *x += y; },
// cleanup
[=](int_ptr&, const error&) {
CAF_MESSAGE(self->name() << " is done");
});
[=](int_ptr&, const error&) { MESSAGE(self->name() << " is done"); });
},
[=](join_atom atm, actor src) {
CAF_MESSAGE(self->name() << " joins a stream");
MESSAGE(self->name() << " joins a stream");
self->send(self * src, atm);
},
};
......@@ -113,15 +111,15 @@ TESTEE(stream_multiplexer) {
// processing step
[](unit_t&, downstream<int32_t>& out, int32_t x) { out.push(x); },
// cleanup
[=](unit_t&, const error&) { CAF_MESSAGE(self->name() << " is done"); });
[=](unit_t&, const error&) { MESSAGE(self->name() << " is done"); });
return {
[=](join_atom) {
CAF_MESSAGE("received 'join' request");
MESSAGE("received 'join' request");
return self->state.stage->add_outbound_path(
std::make_tuple("numbers.txt"));
},
[=](const stream<int32_t>& in, std::string& fname) {
CAF_CHECK_EQUAL(fname, "numbers.txt");
CHECK_EQ(fname, "numbers.txt");
return self->state.stage->add_inbound_path(in);
},
[=](close_atom, int32_t sink_index) {
......@@ -137,7 +135,7 @@ using fixture = test_coordinator_fixture<>;
// -- unit tests ---------------------------------------------------------------
CAF_TEST_FIXTURE_SCOPE(local_streaming_tests, fixture)
BEGIN_FIXTURE_SCOPE(fixture)
CAF_TEST(depth_3_pipeline_with_fork) {
auto src = sys.spawn(file_reader, 60u);
......@@ -145,21 +143,21 @@ CAF_TEST(depth_3_pipeline_with_fork) {
auto snk1 = sys.spawn(sum_up);
auto snk2 = sys.spawn(sum_up);
auto& st = deref<stream_multiplexer_actor>(stg).state;
CAF_MESSAGE("connect sinks to the stage (fork)");
MESSAGE("connect sinks to the stage (fork)");
self->send(snk1, join_atom_v, stg);
self->send(snk2, join_atom_v, stg);
consume_messages();
CAF_CHECK_EQUAL(st.stage->out().num_paths(), 2u);
CAF_MESSAGE("connect source to the stage (fork)");
CHECK_EQ(st.stage->out().num_paths(), 2u);
MESSAGE("connect source to the stage (fork)");
self->send(stg * src, "numbers.txt");
consume_messages();
CAF_CHECK_EQUAL(st.stage->out().num_paths(), 2u);
CAF_CHECK_EQUAL(st.stage->inbound_paths().size(), 1u);
CHECK_EQ(st.stage->out().num_paths(), 2u);
CHECK_EQ(st.stage->inbound_paths().size(), 1u);
run();
CAF_CHECK_EQUAL(st.stage->out().num_paths(), 2u);
CAF_CHECK_EQUAL(st.stage->inbound_paths().size(), 0u);
CAF_CHECK_EQUAL(deref<sum_up_actor>(snk1).state.x, sum(60));
CAF_CHECK_EQUAL(deref<sum_up_actor>(snk2).state.x, sum(60));
CHECK_EQ(st.stage->out().num_paths(), 2u);
CHECK_EQ(st.stage->inbound_paths().size(), 0u);
CHECK_EQ(deref<sum_up_actor>(snk1).state.x, sum(60));
CHECK_EQ(deref<sum_up_actor>(snk2).state.x, sum(60));
self->send_exit(stg, exit_reason::kill);
}
......@@ -169,21 +167,21 @@ CAF_TEST(depth_3_pipeline_with_join) {
auto stg = sys.spawn(stream_multiplexer);
auto snk = sys.spawn(sum_up);
auto& st = deref<stream_multiplexer_actor>(stg).state;
CAF_MESSAGE("connect sink to the stage");
MESSAGE("connect sink to the stage");
self->send(snk, join_atom_v, stg);
consume_messages();
CAF_CHECK_EQUAL(st.stage->out().num_paths(), 1u);
CAF_MESSAGE("connect sources to the stage (join)");
CHECK_EQ(st.stage->out().num_paths(), 1u);
MESSAGE("connect sources to the stage (join)");
self->send(stg * src1, "numbers.txt");
self->send(stg * src2, "numbers.txt");
consume_messages();
CAF_CHECK_EQUAL(st.stage->out().num_paths(), 1u);
CAF_CHECK_EQUAL(st.stage->inbound_paths().size(), 2u);
CHECK_EQ(st.stage->out().num_paths(), 1u);
CHECK_EQ(st.stage->inbound_paths().size(), 2u);
run();
CAF_CHECK_EQUAL(st.stage->out().num_paths(), 1u);
CAF_CHECK_EQUAL(st.stage->inbound_paths().size(), 0u);
CAF_CHECK_EQUAL(deref<sum_up_actor>(snk).state.x, sum(60) * 2);
CHECK_EQ(st.stage->out().num_paths(), 1u);
CHECK_EQ(st.stage->inbound_paths().size(), 0u);
CHECK_EQ(deref<sum_up_actor>(snk).state.x, sum(60) * 2);
self->send_exit(stg, exit_reason::kill);
}
CAF_TEST_FIXTURE_SCOPE_END()
END_FIXTURE_SCOPE()
......@@ -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") {
......@@ -263,4 +263,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()
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.
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