193 lines
8.8 KiB
C++
193 lines
8.8 KiB
C++
#define CAF_SUITE net.operation
|
|
|
|
#include "caf/net/operation.hpp"
|
|
|
|
#include "net-test.hpp"
|
|
|
|
using namespace caf;
|
|
using namespace caf::net;
|
|
|
|
SCENARIO("add_read_flag adds the read bit unless block_read prevents it") {
|
|
GIVEN("a valid operation enum value") {
|
|
WHEN("calling add_read_flag") {
|
|
THEN("the read bit is set unless the block_read flag is present") {
|
|
auto add_rd = [](auto x) { return add_read_flag(x); };
|
|
CHECK_EQ(add_rd(operation::none), operation::read);
|
|
CHECK_EQ(add_rd(operation::read), operation::read);
|
|
CHECK_EQ(add_rd(operation::write), operation::read_write);
|
|
CHECK_EQ(add_rd(operation::block_read), operation::block_read);
|
|
CHECK_EQ(add_rd(operation::block_write), operation::read_only);
|
|
CHECK_EQ(add_rd(operation::read_write), operation::read_write);
|
|
CHECK_EQ(add_rd(operation::read_only), operation::read_only);
|
|
CHECK_EQ(add_rd(operation::write_only), operation::write_only);
|
|
CHECK_EQ(add_rd(operation::shutdown), operation::shutdown);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
SCENARIO("add_write_flag adds the write bit unless block_write prevents it") {
|
|
GIVEN("a valid operation enum value") {
|
|
WHEN("calling add_write_flag") {
|
|
THEN("the write bit is set unless the block_write flag is present") {
|
|
auto add_wr = [](auto x) { return add_write_flag(x); };
|
|
CHECK_EQ(add_wr(operation::none), operation::write);
|
|
CHECK_EQ(add_wr(operation::read), operation::read_write);
|
|
CHECK_EQ(add_wr(operation::write), operation::write);
|
|
CHECK_EQ(add_wr(operation::block_read), operation::write_only);
|
|
CHECK_EQ(add_wr(operation::block_write), operation::block_write);
|
|
CHECK_EQ(add_wr(operation::read_write), operation::read_write);
|
|
CHECK_EQ(add_wr(operation::read_only), operation::read_only);
|
|
CHECK_EQ(add_wr(operation::write_only), operation::write_only);
|
|
CHECK_EQ(add_wr(operation::shutdown), operation::shutdown);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
SCENARIO("remove_read_flag erases the read flag") {
|
|
GIVEN("a valid operation enum value") {
|
|
WHEN("calling remove_read_flag") {
|
|
THEN("the read bit is removed if present") {
|
|
auto del_rd = [](auto x) { return remove_read_flag(x); };
|
|
CHECK_EQ(del_rd(operation::none), operation::none);
|
|
CHECK_EQ(del_rd(operation::read), operation::none);
|
|
CHECK_EQ(del_rd(operation::write), operation::write);
|
|
CHECK_EQ(del_rd(operation::block_read), operation::block_read);
|
|
CHECK_EQ(del_rd(operation::block_write), operation::block_write);
|
|
CHECK_EQ(del_rd(operation::read_write), operation::write);
|
|
CHECK_EQ(del_rd(operation::read_only), operation::block_write);
|
|
CHECK_EQ(del_rd(operation::write_only), operation::write_only);
|
|
CHECK_EQ(del_rd(operation::shutdown), operation::shutdown);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
SCENARIO("remove_write_flag erases the write flag") {
|
|
GIVEN("a valid operation enum value") {
|
|
WHEN("calling remove_write_flag") {
|
|
THEN("the write bit is removed if present") {
|
|
auto del_wr = [](auto x) { return remove_write_flag(x); };
|
|
CHECK_EQ(del_wr(operation::none), operation::none);
|
|
CHECK_EQ(del_wr(operation::read), operation::read);
|
|
CHECK_EQ(del_wr(operation::write), operation::none);
|
|
CHECK_EQ(del_wr(operation::block_read), operation::block_read);
|
|
CHECK_EQ(del_wr(operation::block_write), operation::block_write);
|
|
CHECK_EQ(del_wr(operation::read_write), operation::read);
|
|
CHECK_EQ(del_wr(operation::read_only), operation::read_only);
|
|
CHECK_EQ(del_wr(operation::write_only), operation::block_read);
|
|
CHECK_EQ(del_wr(operation::shutdown), operation::shutdown);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
SCENARIO("block_reads removes the read flag and sets the block read flag") {
|
|
GIVEN("a valid operation enum value") {
|
|
WHEN("calling block_reads") {
|
|
THEN("the read bit is removed if present and block_read is set") {
|
|
auto block_rd = [](auto x) { return block_reads(x); };
|
|
CHECK_EQ(block_rd(operation::none), operation::block_read);
|
|
CHECK_EQ(block_rd(operation::read), operation::block_read);
|
|
CHECK_EQ(block_rd(operation::write), operation::write_only);
|
|
CHECK_EQ(block_rd(operation::block_read), operation::block_read);
|
|
CHECK_EQ(block_rd(operation::block_write), operation::shutdown);
|
|
CHECK_EQ(block_rd(operation::read_write), operation::write_only);
|
|
CHECK_EQ(block_rd(operation::read_only), operation::shutdown);
|
|
CHECK_EQ(block_rd(operation::write_only), operation::write_only);
|
|
CHECK_EQ(block_rd(operation::shutdown), operation::shutdown);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
SCENARIO("block_writes removes the write flag and sets the block write flag") {
|
|
GIVEN("a valid operation enum value") {
|
|
WHEN("calling block_writes") {
|
|
THEN("the write bit is removed if present and block_write is set") {
|
|
auto block_wr = [](auto x) { return block_writes(x); };
|
|
CHECK_EQ(block_wr(operation::none), operation::block_write);
|
|
CHECK_EQ(block_wr(operation::read), operation::read_only);
|
|
CHECK_EQ(block_wr(operation::write), operation::block_write);
|
|
CHECK_EQ(block_wr(operation::block_read), operation::shutdown);
|
|
CHECK_EQ(block_wr(operation::block_write), operation::block_write);
|
|
CHECK_EQ(block_wr(operation::read_write), operation::read_only);
|
|
CHECK_EQ(block_wr(operation::read_only), operation::read_only);
|
|
CHECK_EQ(block_wr(operation::write_only), operation::shutdown);
|
|
CHECK_EQ(block_wr(operation::shutdown), operation::shutdown);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
SCENARIO("is-predicates check whether certain flags are present") {
|
|
GIVEN("a valid operation enum value") {
|
|
WHEN("calling is_reading") {
|
|
THEN("the predicate returns true if the read bit is present") {
|
|
CHECK_EQ(is_reading(operation::none), false);
|
|
CHECK_EQ(is_reading(operation::read), true);
|
|
CHECK_EQ(is_reading(operation::write), false);
|
|
CHECK_EQ(is_reading(operation::block_read), false);
|
|
CHECK_EQ(is_reading(operation::block_write), false);
|
|
CHECK_EQ(is_reading(operation::read_write), true);
|
|
CHECK_EQ(is_reading(operation::read_only), true);
|
|
CHECK_EQ(is_reading(operation::write_only), false);
|
|
CHECK_EQ(is_reading(operation::shutdown), false);
|
|
}
|
|
}
|
|
WHEN("calling is_writing") {
|
|
THEN("the predicate returns true if the write bit is present") {
|
|
CHECK_EQ(is_writing(operation::none), false);
|
|
CHECK_EQ(is_writing(operation::read), false);
|
|
CHECK_EQ(is_writing(operation::write), true);
|
|
CHECK_EQ(is_writing(operation::block_read), false);
|
|
CHECK_EQ(is_writing(operation::block_write), false);
|
|
CHECK_EQ(is_writing(operation::read_write), true);
|
|
CHECK_EQ(is_writing(operation::read_only), false);
|
|
CHECK_EQ(is_writing(operation::write_only), true);
|
|
CHECK_EQ(is_writing(operation::shutdown), false);
|
|
}
|
|
}
|
|
WHEN("calling is_idle") {
|
|
THEN("the predicate returns true when neither reading nor writing") {
|
|
CHECK_EQ(is_idle(operation::none), true);
|
|
CHECK_EQ(is_idle(operation::read), false);
|
|
CHECK_EQ(is_idle(operation::write), false);
|
|
CHECK_EQ(is_idle(operation::block_read), true);
|
|
CHECK_EQ(is_idle(operation::block_write), true);
|
|
CHECK_EQ(is_idle(operation::read_write), false);
|
|
CHECK_EQ(is_idle(operation::read_only), false);
|
|
CHECK_EQ(is_idle(operation::write_only), false);
|
|
CHECK_EQ(is_idle(operation::shutdown), true);
|
|
}
|
|
}
|
|
WHEN("calling is_read_blocked") {
|
|
THEN("the predicate returns when blocking reads") {
|
|
CHECK_EQ(is_read_blocked(operation::none), false);
|
|
CHECK_EQ(is_read_blocked(operation::read), false);
|
|
CHECK_EQ(is_read_blocked(operation::write), false);
|
|
CHECK_EQ(is_read_blocked(operation::block_read), true);
|
|
CHECK_EQ(is_read_blocked(operation::block_write), false);
|
|
CHECK_EQ(is_read_blocked(operation::read_write), false);
|
|
CHECK_EQ(is_read_blocked(operation::read_only), false);
|
|
CHECK_EQ(is_read_blocked(operation::write_only), true);
|
|
CHECK_EQ(is_read_blocked(operation::shutdown), true);
|
|
}
|
|
}
|
|
WHEN("calling is_write_blocked") {
|
|
THEN("the predicate returns when blocking writes") {
|
|
CHECK_EQ(is_write_blocked(operation::none), false);
|
|
CHECK_EQ(is_write_blocked(operation::read), false);
|
|
CHECK_EQ(is_write_blocked(operation::write), false);
|
|
CHECK_EQ(is_write_blocked(operation::block_read), false);
|
|
CHECK_EQ(is_write_blocked(operation::block_write), true);
|
|
CHECK_EQ(is_write_blocked(operation::read_write), false);
|
|
CHECK_EQ(is_write_blocked(operation::read_only), true);
|
|
CHECK_EQ(is_write_blocked(operation::write_only), false);
|
|
CHECK_EQ(is_write_blocked(operation::shutdown), true);
|
|
}
|
|
}
|
|
}
|
|
}
|