sigslots.cpp

Go to the documentation of this file.

/*****************************************************************************
** Includes
*****************************************************************************/


#include <iostream>
#include <gtest/gtest.h>
#include <ecl/exceptions/standard_exception.hpp>
#include "../../include/ecl/sigslots/signal.hpp"
#include "../../include/ecl/sigslots/slot.hpp"

/*****************************************************************************
** Using
*****************************************************************************/

using ecl::StandardException;
using ecl::Signal;
using ecl::Slot;

/*****************************************************************************
** Namespaces
*****************************************************************************/

namespace ecl {
namespace sigslots {
namespace tests {

/*****************************************************************************
** Classes
*****************************************************************************/

class A {
public:
        A() : f_count(0), g_count(0) {}

        void f(const int &i) {
//          std::cout << "  Member function with argument: " << i << std::endl;;
                f_count++;
        }
        void g() {
                g_count++;
//          std::cout << "  Member function" << std::endl;;
        }
        int f_count, g_count;
};

/*****************************************************************************
** Functions
*****************************************************************************/

static int f_count = 0;
static int g_count = 0;

void f(const int &i)
{
        f_count++;
//    std::cout << "  Global function with argument: " << i << std::endl;;
}

void g()
{
        g_count++;
//    std::cout << "  Global function" << std::endl;;
}

} // namespace tests
} // namespace signals
} // namespace ecl

/*****************************************************************************
** Using
*****************************************************************************/

using namespace ecl::sigslots::tests;

/*****************************************************************************
** Tests
*****************************************************************************/

TEST(SigSlotsTests, voidSigSlots) {

        A a;
    Signal<> sig_void;

    Slot<> slot_void0(g,"void_test");
    Slot<> slot_void1(&A::g,a);

    sig_void.connect("void_test");
//    slot_void0.connect("void_test");
    slot_void1.connect("void_test");

    sig_void.emit();

//    ecl::SigSlotsManager<>::printStatistics();

//    std::cout << "a.g_count: " << a.g_count << std::endl;
//    std::cout << "g_count: " << g_count << std::endl;
    EXPECT_EQ(1,a.g_count);
    EXPECT_EQ(1,g_count);
}

TEST(SigSlotsTests, relay) {

        A a;
    Signal<> sig_starter;
    Signal<> sig_relay;

    Slot<> slot_relayed_goal(g);

    sig_starter.connect("relay");
    sig_relay.connectAsSlot("relay");
    sig_relay.connect("final_goal");
    slot_relayed_goal.connect("final_goal");

    sig_starter.emit();

//    std::cout << "g_count: " << g_count << std::endl;
    EXPECT_EQ(2,g_count);
}

TEST(SigSlotsTests,dataSigSlots) {

        A a;
    Signal<const int&> sig_int;
    Slot<const int&> slot_int0(f);
    Slot<const int&> slot_int1(&A::f,a);

    sig_int.connect("int_test");
    slot_int0.connect("int_test");
    slot_int1.connect("int_test");

    sig_int.emit(4);
//      std::cout << "a.f_count: " << a.f_count << std::endl;
//      std::cout << "f_count: " << f_count << std::endl;
    EXPECT_EQ(1,a.f_count);
    EXPECT_EQ(1,f_count);
}

TEST(SigSlotsTests, disconnect) {

    Signal<> signal;
    Slot<> slot(g);
    signal.connect("disconnect");
    slot.connect("disconnect");
    signal.emit();
    slot.disconnect();
    Signal<const int&> data_signal;
    Slot<const int&> data_slot(f);
    data_signal.connect("disconnect"); // Each data type has its own 'namespace' per se, so this doesn't clash with the above.
    data_slot.connect("disconnect");
    data_signal.emit(1);
    data_slot.disconnect();
    data_signal.emit(1); // Shouldn't increment

    EXPECT_EQ(3,g_count);
    EXPECT_EQ(2,f_count);
}

/*****************************************************************************
** Main program
*****************************************************************************/

int main(int argc, char **argv) {

    testing::InitGoogleTest(&argc,argv);
    return RUN_ALL_TESTS();
}