| | #include "catch2/catch.hpp"
|
| | #include <fastsignals/signal.h>
|
| | #include <string>
|
| |
|
| | using namespace fastsignals;
|
| | using namespace std::literals;
|
| |
|
| | namespace
|
| | {
|
| | template <class T>
|
| | class any_of_combiner
|
| | {
|
| | public:
|
| | static_assert(std::is_same_v<T, bool>);
|
| |
|
| | using result_type = bool;
|
| |
|
| | template <class TRef>
|
| | void operator()(TRef&& value)
|
| | {
|
| | m_result = m_result || bool(value);
|
| | }
|
| |
|
| | result_type get_value() const
|
| | {
|
| | return m_result;
|
| | }
|
| |
|
| | private:
|
| | result_type m_result = {};
|
| | };
|
| | }
|
| |
|
| | TEST_CASE("Can connect a few slots and emit", "[signal]")
|
| | {
|
| | signal<void(int)> valueChanged;
|
| |
|
| | int value1 = 0;
|
| | int value2 = 0;
|
| | valueChanged.connect([&value1](int value) {
|
| | value1 = value;
|
| | });
|
| | valueChanged.connect([&value2](int value) {
|
| | value2 = value;
|
| | });
|
| | REQUIRE(value1 == 0);
|
| | REQUIRE(value2 == 0);
|
| |
|
| | valueChanged(10);
|
| | REQUIRE(value1 == 10);
|
| | REQUIRE(value2 == 10);
|
| | }
|
| |
|
| | TEST_CASE("Can safely pass rvalues", "[signal]")
|
| | {
|
| | const std::string expected = "If the type T is a reference type, provides the member typedef type which is the type referred to by T. Otherwise type is T.";
|
| | std::string passedValue = expected;
|
| | signal<void(std::string)> valueChanged;
|
| |
|
| | std::string value1;
|
| | std::string value2;
|
| | valueChanged.connect([&value1](std::string value) {
|
| | value1 = value;
|
| | });
|
| | valueChanged.connect([&value2](std::string value) {
|
| | value2 = value;
|
| | });
|
| |
|
| | valueChanged(std::move(passedValue));
|
| | REQUIRE(value1 == expected);
|
| | REQUIRE(value2 == expected);
|
| | }
|
| |
|
| | TEST_CASE("Can pass mutable ref", "[signal]")
|
| | {
|
| | const std::string expected = "If the type T is a reference type, provides the member typedef type which is the type referred to by T. Otherwise type is T.";
|
| | signal<void(std::string&)> valueChanged;
|
| |
|
| | std::string passedValue;
|
| | valueChanged.connect([expected](std::string& value) {
|
| | value = expected;
|
| | });
|
| | valueChanged(passedValue);
|
| |
|
| | REQUIRE(passedValue == expected);
|
| | }
|
| |
|
| | TEST_CASE("Can disconnect slot with explicit call", "[signal]")
|
| | {
|
| | signal<void(int)> valueChanged;
|
| |
|
| | int value1 = 0;
|
| | int value2 = 0;
|
| | int value3 = 0;
|
| | auto conn1 = valueChanged.connect([&value1](int value) {
|
| | value1 = value;
|
| | });
|
| | auto conn2 = valueChanged.connect([&value2](int value) {
|
| | value2 = value;
|
| | });
|
| | valueChanged.connect([&value3](int value) {
|
| | value3 = value;
|
| | });
|
| | REQUIRE(value1 == 0);
|
| | REQUIRE(value2 == 0);
|
| | REQUIRE(value3 == 0);
|
| |
|
| | valueChanged(10);
|
| | REQUIRE(value1 == 10);
|
| | REQUIRE(value2 == 10);
|
| | REQUIRE(value3 == 10);
|
| |
|
| | conn2.disconnect();
|
| | valueChanged(-99);
|
| | REQUIRE(value1 == -99);
|
| | REQUIRE(value2 == 10);
|
| | REQUIRE(value3 == -99);
|
| |
|
| | conn1.disconnect();
|
| | valueChanged(17);
|
| | REQUIRE(value1 == -99);
|
| | REQUIRE(value2 == 10);
|
| | REQUIRE(value3 == 17);
|
| | }
|
| |
|
| | TEST_CASE("Can disconnect slot with scoped_connection", "[signal]")
|
| | {
|
| | signal<void(int)> valueChanged;
|
| |
|
| | int value1 = 0;
|
| | int value2 = 0;
|
| | int value3 = 0;
|
| | {
|
| | scoped_connection conn1 = valueChanged.connect([&value1](int value) {
|
| | value1 = value;
|
| | });
|
| | {
|
| | scoped_connection conn2 = valueChanged.connect([&value2](int value) {
|
| | value2 = value;
|
| | });
|
| | valueChanged.connect([&value3](int value) {
|
| | value3 = value;
|
| | });
|
| | REQUIRE(value1 == 0);
|
| | REQUIRE(value2 == 0);
|
| | REQUIRE(value3 == 0);
|
| |
|
| | valueChanged(10);
|
| | REQUIRE(value1 == 10);
|
| | REQUIRE(value2 == 10);
|
| | REQUIRE(value3 == 10);
|
| | }
|
| |
|
| |
|
| | valueChanged(-99);
|
| | REQUIRE(value1 == -99);
|
| | REQUIRE(value2 == 10);
|
| | REQUIRE(value3 == -99);
|
| | }
|
| |
|
| |
|
| | valueChanged(17);
|
| | REQUIRE(value1 == -99);
|
| | REQUIRE(value2 == 10);
|
| | REQUIRE(value3 == 17);
|
| | }
|
| |
|
| | TEST_CASE("Can disconnect all", "[signal]")
|
| | {
|
| | signal<void(int)> valueChanged;
|
| |
|
| | int value1 = 0;
|
| | int value2 = 0;
|
| | int value3 = 0;
|
| | valueChanged.connect([&value1](int value) {
|
| | value1 = value;
|
| | });
|
| | valueChanged.connect([&value2](int value) {
|
| | value2 = value;
|
| | });
|
| | valueChanged.connect([&value3](int value) {
|
| | value3 = value;
|
| | });
|
| | REQUIRE(value1 == 0);
|
| | REQUIRE(value2 == 0);
|
| | REQUIRE(value3 == 0);
|
| |
|
| | valueChanged(63);
|
| | REQUIRE(value1 == 63);
|
| | REQUIRE(value2 == 63);
|
| | REQUIRE(value3 == 63);
|
| |
|
| | valueChanged.disconnect_all_slots();
|
| | valueChanged(101);
|
| | REQUIRE(value1 == 63);
|
| | REQUIRE(value2 == 63);
|
| | REQUIRE(value3 == 63);
|
| | }
|
| |
|
| | TEST_CASE("Can disconnect inside slot", "[signal]")
|
| | {
|
| | signal<void(int)> valueChanged;
|
| |
|
| | int value1 = 0;
|
| | int value2 = 0;
|
| | int value3 = 0;
|
| | connection conn2;
|
| | valueChanged.connect([&value1](int value) {
|
| | value1 = value;
|
| | });
|
| | conn2 = valueChanged.connect([&](int value) {
|
| | value2 = value;
|
| | conn2.disconnect();
|
| | });
|
| | valueChanged.connect([&value3](int value) {
|
| | value3 = value;
|
| | });
|
| | REQUIRE(value1 == 0);
|
| | REQUIRE(value2 == 0);
|
| | REQUIRE(value3 == 0);
|
| |
|
| | valueChanged(63);
|
| | REQUIRE(value1 == 63);
|
| | REQUIRE(value2 == 63);
|
| | REQUIRE(value3 == 63);
|
| |
|
| | valueChanged(101);
|
| | REQUIRE(value1 == 101);
|
| | REQUIRE(value2 == 63);
|
| | REQUIRE(value3 == 101);
|
| | }
|
| |
|
| | TEST_CASE("Disconnects OK if signal dead first", "[signal]")
|
| | {
|
| | connection conn2;
|
| | {
|
| | scoped_connection conn1;
|
| | {
|
| | signal<void(int)> valueChanged;
|
| | conn2 = valueChanged.connect([](int) {
|
| | });
|
| |
|
| | valueChanged.connect([](int) {
|
| | });
|
| | conn1 = valueChanged.connect([](int) {
|
| | });
|
| | }
|
| | REQUIRE(conn2.connected());
|
| | REQUIRE(conn1.connected());
|
| | conn2.disconnect();
|
| | REQUIRE(!conn2.connected());
|
| | REQUIRE(conn1.connected());
|
| | }
|
| | conn2.disconnect();
|
| | }
|
| |
|
| | TEST_CASE("Returns last called slot result with default combiner", "[signal]")
|
| | {
|
| | connection conn2;
|
| | {
|
| | scoped_connection conn1;
|
| | {
|
| | signal<int(int)> absSignal;
|
| | conn2 = absSignal.connect([](int value) {
|
| | return value * value;
|
| | });
|
| | conn1 = absSignal.connect([](int value) {
|
| | return abs(value);
|
| | });
|
| | absSignal(-1);
|
| |
|
| | REQUIRE(absSignal(45) == 45);
|
| | REQUIRE(absSignal(-1) == 1);
|
| | REQUIRE(absSignal(-177) == 177);
|
| | REQUIRE(absSignal(0) == 0);
|
| | }
|
| | REQUIRE(conn2.connected());
|
| | conn2.disconnect();
|
| | REQUIRE(!conn2.connected());
|
| | }
|
| | conn2.disconnect();
|
| | REQUIRE(!conn2.connected());
|
| | }
|
| |
|
| | TEST_CASE("Works with custom any_of combiner", "[signal]")
|
| | {
|
| | using cancellable_signal = signal<bool(std::string), any_of_combiner>;
|
| | cancellable_signal startRequested;
|
| | auto conn1 = startRequested.connect([](std::string op) {
|
| | return op == "1";
|
| | });
|
| | auto conn2 = startRequested.connect([](std::string op) {
|
| | return op == "1" || op == "2";
|
| | });
|
| | REQUIRE(startRequested("0") == false);
|
| | REQUIRE(startRequested("1") == true);
|
| | REQUIRE(startRequested("2") == true);
|
| | REQUIRE(startRequested("3") == false);
|
| | conn1.disconnect();
|
| | conn2.disconnect();
|
| | REQUIRE(startRequested("0") == false);
|
| | REQUIRE(startRequested("1") == false);
|
| | REQUIRE(startRequested("2") == false);
|
| | REQUIRE(startRequested("3") == false);
|
| | }
|
| |
|
| | TEST_CASE("Can release scoped connection", "[signal]")
|
| | {
|
| | int value2 = 0;
|
| | int value3 = 0;
|
| | signal<void(int)> valueChanged;
|
| | connection conn1;
|
| | {
|
| | scoped_connection conn2;
|
| | scoped_connection conn3;
|
| | conn2 = valueChanged.connect([&value2](int x) {
|
| | value2 = x;
|
| | });
|
| | conn3 = valueChanged.connect([&value3](int x) {
|
| | value3 = x;
|
| | });
|
| |
|
| | valueChanged(42);
|
| | REQUIRE(value2 == 42);
|
| | REQUIRE(value3 == 42);
|
| | REQUIRE(conn2.connected());
|
| | REQUIRE(conn3.connected());
|
| | REQUIRE(!conn1.connected());
|
| |
|
| | conn1 = conn3.release();
|
| | REQUIRE(conn2.connected());
|
| | REQUIRE(!conn3.connected());
|
| | REQUIRE(conn1.connected());
|
| | valueChanged(144);
|
| | REQUIRE(value2 == 144);
|
| | REQUIRE(value3 == 144);
|
| | }
|
| |
|
| |
|
| | valueChanged(17);
|
| | REQUIRE(value2 == 144);
|
| | REQUIRE(value3 == 17);
|
| | REQUIRE(conn1.connected());
|
| |
|
| | conn1.disconnect();
|
| | valueChanged(90);
|
| | REQUIRE(value2 == 144);
|
| | REQUIRE(value3 == 17);
|
| | }
|
| |
|
| | TEST_CASE("Can use signal with more than one argument", "[signal]")
|
| | {
|
| | signal<void(int, std::string, std::vector<std::string>)> event;
|
| |
|
| | int value1 = 0;
|
| | std::string value2;
|
| | std::vector<std::string> value3;
|
| | event.connect([&](int v1, const std::string& v2, const std::vector<std::string>& v3) {
|
| | value1 = v1;
|
| | value2 = v2;
|
| | value3 = v3;
|
| | });
|
| |
|
| | event(9815, "using namespace std::literals!"s, std::vector{ "std::vector"s, "using namespace std::literals"s });
|
| | REQUIRE(value1 == 9815);
|
| | REQUIRE(value2 == "using namespace std::literals!"s);
|
| | REQUIRE(value3 == std::vector{ "std::vector"s, "using namespace std::literals"s });
|
| | }
|
| |
|
| | TEST_CASE("Can blocks slots using shared_connection_block", "[signal]")
|
| | {
|
| | bool callbackShouldBeCalled = true;
|
| | bool callbackCalled = false;
|
| | const int value = 123;
|
| | signal<void(int)> event;
|
| | auto conn = event.connect([&](int gotValue) {
|
| | CHECK(gotValue == value);
|
| | callbackCalled = true;
|
| | if (!callbackShouldBeCalled)
|
| | {
|
| | FAIL("callback is blocked and should not be called");
|
| | }
|
| | },
|
| | advanced_tag{});
|
| | event(value);
|
| | REQUIRE(callbackCalled);
|
| | shared_connection_block block(conn);
|
| | callbackShouldBeCalled = false;
|
| | callbackCalled = false;
|
| | event(value);
|
| | REQUIRE(!callbackCalled);
|
| | block.unblock();
|
| | callbackShouldBeCalled = true;
|
| | event(value);
|
| | REQUIRE(callbackCalled);
|
| | }
|
| |
|
| | TEST_CASE("Other slots are unaffected by the block", "[signal]")
|
| | {
|
| | bool callback1Called = false;
|
| | bool callback2Called = false;
|
| | const int value = 123;
|
| | signal<void(int)> event;
|
| | auto conn1 = event.connect([&](int gotValue) {
|
| | CHECK(gotValue == value);
|
| | callback1Called = true;
|
| | },
|
| | advanced_tag{});
|
| | auto conn2 = event.connect([&](int) {
|
| | callback2Called = true;
|
| | FAIL("callback is blocked and should not be called");
|
| | },
|
| | advanced_tag{});
|
| | shared_connection_block block(conn2);
|
| | event(value);
|
| | REQUIRE(callback1Called);
|
| | REQUIRE(!callback2Called);
|
| | }
|
| |
|
| | TEST_CASE("Multiple blocks block until last one is unblocked", "[signal]")
|
| | {
|
| | bool callbackShouldBeCalled = false;
|
| | bool callbackCalled = false;
|
| | const int value = 123;
|
| | signal<void(int)> event;
|
| | auto conn = event.connect([&](int gotValue) {
|
| | CHECK(gotValue == value);
|
| | callbackCalled = true;
|
| | if (!callbackShouldBeCalled)
|
| | {
|
| | FAIL("callback is blocked and should not be called");
|
| | }
|
| | },
|
| | advanced_tag{});
|
| | shared_connection_block block1(conn);
|
| | shared_connection_block block2(conn);
|
| | event(value);
|
| | REQUIRE(!callbackCalled);
|
| | block1.unblock();
|
| | event(value);
|
| | REQUIRE(!callbackCalled);
|
| | block1.block();
|
| | block2.unblock();
|
| | event(value);
|
| | REQUIRE(!callbackCalled);
|
| | block1.unblock();
|
| | callbackShouldBeCalled = true;
|
| | event(value);
|
| | REQUIRE(callbackCalled);
|
| | }
|
| |
|
| | TEST_CASE("Can copy and move shared_connection_block objects", "[signal]")
|
| | {
|
| | bool callbackShouldBeCalled = false;
|
| | bool callbackCalled = false;
|
| | const int value = 123;
|
| | signal<void(int)> event;
|
| | auto conn = event.connect([&](int gotValue) {
|
| | CHECK(gotValue == value);
|
| | callbackCalled = true;
|
| | if (!callbackShouldBeCalled)
|
| | {
|
| | FAIL("callback is blocked and should not be called");
|
| | }
|
| | },
|
| | advanced_tag{});
|
| | shared_connection_block block1(conn);
|
| |
|
| | shared_connection_block block2(block1);
|
| | event(value);
|
| | REQUIRE(block1.blocking());
|
| | REQUIRE(block2.blocking());
|
| | REQUIRE(!callbackCalled);
|
| |
|
| | shared_connection_block block3(std::move(block2));
|
| | event(value);
|
| | REQUIRE(block1.blocking());
|
| | REQUIRE(!block2.blocking());
|
| | REQUIRE(block3.blocking());
|
| | REQUIRE(!callbackCalled);
|
| |
|
| | block2 = block3;
|
| | event(value);
|
| | REQUIRE(block1.blocking());
|
| | REQUIRE(block2.blocking());
|
| | REQUIRE(block3.blocking());
|
| | REQUIRE(!callbackCalled);
|
| |
|
| | block3 = std::move(block2);
|
| | event(value);
|
| | REQUIRE(block1.blocking());
|
| | REQUIRE(!block2.blocking());
|
| | REQUIRE(block3.blocking());
|
| | REQUIRE(!callbackCalled);
|
| |
|
| | block3 = shared_connection_block(conn, false);
|
| | event(value);
|
| | REQUIRE(block1.blocking());
|
| | REQUIRE(!block2.blocking());
|
| | REQUIRE(!block3.blocking());
|
| | REQUIRE(!callbackCalled);
|
| |
|
| | block1.unblock();
|
| | callbackShouldBeCalled = true;
|
| | event(value);
|
| | REQUIRE(!block1.blocking());
|
| | REQUIRE(!block2.blocking());
|
| | REQUIRE(!block3.blocking());
|
| | REQUIRE(callbackCalled);
|
| | }
|
| |
|
| | TEST_CASE("Unblocks when shared_connection_block goes out of scope")
|
| | {
|
| | bool callbackCalled = false;
|
| | const int value = 123;
|
| | signal<void(int)> event;
|
| | auto conn = event.connect([&](int gotValue) {
|
| | CHECK(gotValue == value);
|
| | callbackCalled = true;
|
| | },
|
| | advanced_tag{});
|
| |
|
| | callbackCalled = false;
|
| | event(value);
|
| | CHECK(callbackCalled);
|
| |
|
| | {
|
| | callbackCalled = false;
|
| | shared_connection_block block(conn);
|
| | event(value);
|
| | CHECK(!callbackCalled);
|
| |
|
| | {
|
| | callbackCalled = false;
|
| | shared_connection_block block2(conn);
|
| | event(value);
|
| | CHECK(!callbackCalled);
|
| | }
|
| | }
|
| |
|
| | callbackCalled = false;
|
| | event(value);
|
| | CHECK(callbackCalled);
|
| | }
|
| |
|
| | TEST_CASE("Can disconnect advanced slot using advanced_scoped_connection", "[signal]")
|
| | {
|
| | signal<void(int)> valueChanged;
|
| |
|
| | int value1 = 0;
|
| | int value2 = 0;
|
| | int value3 = 0;
|
| | {
|
| | advanced_scoped_connection conn1 = valueChanged.connect([&value1](int value) {
|
| | value1 = value;
|
| | },
|
| | advanced_tag{});
|
| | {
|
| | advanced_scoped_connection conn2 = valueChanged.connect([&value2](int value) {
|
| | value2 = value;
|
| | },
|
| | advanced_tag{});
|
| | valueChanged.connect([&value3](int value) {
|
| | value3 = value;
|
| | });
|
| | REQUIRE(value1 == 0);
|
| | REQUIRE(value2 == 0);
|
| | REQUIRE(value3 == 0);
|
| |
|
| | valueChanged(10);
|
| | REQUIRE(value1 == 10);
|
| | REQUIRE(value2 == 10);
|
| | REQUIRE(value3 == 10);
|
| | }
|
| |
|
| |
|
| | valueChanged(-99);
|
| | REQUIRE(value1 == -99);
|
| | REQUIRE(value2 == 10);
|
| | REQUIRE(value3 == -99);
|
| | }
|
| |
|
| |
|
| | valueChanged(17);
|
| | REQUIRE(value1 == -99);
|
| | REQUIRE(value2 == 10);
|
| | REQUIRE(value3 == 17);
|
| | }
|
| |
|
| | TEST_CASE("Can move signal", "[signal]")
|
| | {
|
| | signal<void()> src;
|
| |
|
| | int srcFireCount = 0;
|
| | auto srcConn = src.connect([&srcFireCount] {
|
| | ++srcFireCount;
|
| | });
|
| |
|
| | src();
|
| | REQUIRE(srcFireCount == 1);
|
| |
|
| | auto dst = std::move(src);
|
| |
|
| | int dstFireCount = 0;
|
| | auto dstConn = dst.connect([&dstFireCount] {
|
| | ++dstFireCount;
|
| | });
|
| |
|
| | dst();
|
| | REQUIRE(srcFireCount == 2);
|
| | REQUIRE(dstFireCount == 1);
|
| |
|
| | srcConn.disconnect();
|
| | dstConn.disconnect();
|
| | dst();
|
| | REQUIRE(srcFireCount == 2);
|
| | REQUIRE(dstFireCount == 1);
|
| | }
|
| |
|
| | TEST_CASE("Can swap signals", "[signal]")
|
| | {
|
| | signal<void()> s1;
|
| | signal<void()> s2;
|
| |
|
| | int s1FireCount = 0;
|
| | int s2FireCount = 0;
|
| |
|
| | s1.connect([&s1FireCount] {
|
| | ++s1FireCount;
|
| | });
|
| |
|
| | s2.connect([&s2FireCount] {
|
| | ++s2FireCount;
|
| | });
|
| |
|
| | std::swap(s1, s2);
|
| |
|
| | s1();
|
| | REQUIRE(s1FireCount == 0);
|
| | REQUIRE(s2FireCount == 1);
|
| |
|
| | s2();
|
| | REQUIRE(s1FireCount == 1);
|
| | REQUIRE(s2FireCount == 1);
|
| | }
|
| |
|
| | TEST_CASE("Signal can be destroyed inside its slot and will call the rest of its slots", "[signal]")
|
| | {
|
| | std::optional<signal<void()>> s;
|
| | s.emplace();
|
| | s->connect([&] {
|
| | s.reset();
|
| | });
|
| | bool called = false;
|
| | s->connect([&] {
|
| | called = true;
|
| | });
|
| | (*s)();
|
| | CHECK(called);
|
| | }
|
| |
|
| | TEST_CASE("Signal can be used as a slot for another signal", "[signal]")
|
| | {
|
| | signal<void()> s1;
|
| | bool called = false;
|
| | s1.connect([&] {
|
| | called = true;
|
| | });
|
| |
|
| | signal<void()> s2;
|
| | s2.connect(s1);
|
| |
|
| | s2();
|
| |
|
| | CHECK(called);
|
| | }
|
| |
|
| |
|
| | TEST_CASE("Releases lambda and its captured const data", "[signal]")
|
| | {
|
| | struct Captured
|
| | {
|
| | Captured(bool& released)
|
| | : m_released(released)
|
| | {
|
| | }
|
| |
|
| | ~Captured()
|
| | {
|
| | m_released = true;
|
| | }
|
| |
|
| | private:
|
| | bool& m_released;
|
| | };
|
| |
|
| | bool released = false;
|
| |
|
| | {
|
| | const auto captured = std::make_shared<Captured>(released);
|
| |
|
| | signal<void()> changeSignal;
|
| | changeSignal.connect([captured]{});
|
| | }
|
| |
|
| | CHECK(released);
|
| | } |
