tests/eventbus.cpp

   1 #include <msp/game/eventbus.h>
   2 #include <msp/game/eventobserver.h>
   3 #include <msp/game/eventsource.h>
   4 #include <msp/test/test.h>
   5
   6 using namespace std;
   7 using namespace Msp;
   8
   9 class EventBusTests: public Test::RegisteredTest<EventBusTests>
  10 {
  11 public:
  12         EventBusTests();
  13
  14         static const char *get_name() { return "Event bus"; }
  15
  16 private:
  17         void broadcast_events();
  18         void targeted_events();
  19         void observe_single();
  20         void observer_lifetime();
  21 };
  22
  23 struct E1 { int value; };
  24 struct E2 { int value; };
  25
  26 EventBusTests::EventBusTests()
  27 {
  28         add(&EventBusTests::broadcast_events, "Broadcast events");
  29         add(&EventBusTests::targeted_events, "Targeted events");
  30         add(&EventBusTests::observe_single, "Observe single source");
  31         add(&EventBusTests::observer_lifetime, "Observer lifetime");
  32 }
  33
  34 void EventBusTests::broadcast_events()
  35 {
  36         Game::EventBus bus;
  37         Game::EventSource<E1> src1(bus);
  38         Game::EventSource<E2> src2(bus);
  39         Game::EventObserver obs1(bus);
  40         Game::EventObserver obs2(bus);
  41         int value11 = 0;
  42         int value12 = 0;
  43         int value21 = 0;
  44         int value22 = 0;
  45         obs1.observe<E1>([&value11](const E1 &e){ value11 = e.value; });
  46         obs1.observe<E2>([&value12](const E2 &e){ value12 = e.value; });
  47         obs2.observe<E1>([&value21](const E1 &e){ value21 = e.value; });
  48         obs2.observe<E2>([&value22](const E2 &e){ value22 = e.value; });
  49         src1.emit<E1>(42);
  50         src2.emit<E2>(7777);
  51         EXPECT_EQUAL(value11, 42);
  52         EXPECT_EQUAL(value21, 42);
  53         EXPECT_EQUAL(value12, 7777);
  54         EXPECT_EQUAL(value22, 7777);
  55 }
  56
  57 void EventBusTests::targeted_events()
  58 {
  59         Game::EventBus bus;
  60         Game::EventSource<E1> src(bus);
  61         Game::EventObserver obs1(bus);
  62         Game::EventObserver obs2(bus);
  63         int value1 = 0;
  64         int value2 = 0;
  65         obs1.observe<E1>([&value1](const E1 &e){ value1 = e.value; });
  66         obs2.observe<E1>([&value2](const E1 &e){ value2 = e.value; });
  67         src.emit_to<E1>(obs1, 42);
  68         EXPECT_EQUAL(value1, 42);
  69         EXPECT_EQUAL(value2, 0);
  70 }
  71
  72 void EventBusTests::observe_single()
  73 {
  74         Game::EventBus bus;
  75         Game::EventSource<E1> src1(bus);
  76         Game::EventSource<E1> src2(bus);
  77         Game::EventObserver obs(bus);
  78         int value1 = 0;
  79         int value2 = 0;
  80         obs.observe<E1>(src1, [&value1](const E1 &e){ value1 = e.value; });
  81         src1.emit<E1>(42);
  82         src2.emit<E1>(7777);
  83         EXPECT_EQUAL(value1, 42);
  84         EXPECT_EQUAL(value2, 0);
  85 }
  86
  87 void EventBusTests::observer_lifetime()
  88 {
  89         Game::EventBus bus;
  90         Game::EventSource<E1> src(bus);
  91         int value = 0;
  92         {
  93                 Game::EventObserver obs(bus);
  94                 obs.observe<E1>([&value](const E1 &e){ value = e.value; });
  95                 src.emit<E1>(42);
  96                 EXPECT_EQUAL(value, 42);
  97         }
  98         src.emit<E1>(7777);
  99         EXPECT_EQUAL(value, 42);
 100 }