Various services improved (#110)

Tests/TactilityCore/DispatcherTest.cpp

@@ -4,16 +4,26 @@
 
 using namespace tt;
 
-void increment_callback(void* context) {
-    auto* counter = (uint32_t*)context;
-    (*counter)++;
+static uint32_t counter = 0;
+static const uint32_t value_chacker_expected = 123;
+
+void increment_callback(TT_UNUSED std::shared_ptr<void> context) {
+    counter++;
+}
+
+void value_checker(std::shared_ptr<void> context) {
+    auto value = std::static_pointer_cast<uint32_t>(context);
+    if (*value != value_chacker_expected) {
+        tt_crash_implementation();
+    }
 }
 
 TEST_CASE("dispatcher should not call callback if consume isn't called") {
+    counter = 0;
     Dispatcher dispatcher;
 
-    uint32_t counter = 0;
-    dispatcher.dispatch(&increment_callback, &counter);
+    auto context = std::make_shared<uint32_t>();
+    dispatcher.dispatch(&increment_callback, std::move(context));
     delay_ticks(10);
 
     CHECK_EQ(counter, 0);
@@ -21,16 +31,25 @@ TEST_CASE("dispatcher should not call callback if consume isn't called") {
 
 TEST_CASE("dispatcher should be able to dealloc when message is not consumed") {
     auto* dispatcher = new Dispatcher();
-    uint32_t counter = 0;
-    dispatcher->dispatch(increment_callback, &counter);
+    auto context = std::make_shared<uint32_t>();
+    dispatcher->dispatch(increment_callback, std::move(context));
     delete dispatcher;
 }
 
 TEST_CASE("dispatcher should call callback when consume is called") {
+    counter = 0;
     Dispatcher dispatcher;
 
-    uint32_t counter = 0;
-    dispatcher.dispatch(increment_callback, &counter);
+    auto context = std::make_shared<uint32_t>();
+    dispatcher.dispatch(increment_callback, std::move(context));
     dispatcher.consume(100);
     CHECK_EQ(counter, 1);
 }
+
+TEST_CASE("message should be passed on correctly") {
+    Dispatcher dispatcher;
+
+    auto context = std::make_shared<uint32_t>(value_chacker_expected);
+    dispatcher.dispatch(value_checker, std::move(context));
+    dispatcher.consume(100);
+}

Tests/TactilityCore/TimerTest.cpp

@@ -2,32 +2,34 @@
 #include "TactilityCore.h"
 #include "Timer.h"
 
+#include <utility>
+
 using namespace tt;
 
-void* timer_callback_context = NULL;
-static void timer_callback_with_context(void* context) {
-    timer_callback_context = context;
+std::shared_ptr<void> timer_callback_context = NULL;
+static void timer_callback_with_context(std::shared_ptr<void> context) {
+    timer_callback_context = std::move(context);
 }
 
-static void timer_callback_with_counter(void* context) {
-    int* int_ptr = (int*)context;
+static void timer_callback_with_counter(std::shared_ptr<void> context) {
+    auto int_ptr = std::static_pointer_cast<int>(context);
     (*int_ptr)++;
 }
 
 TEST_CASE("a timer passes the context correctly") {
-    int foo = 1;
-    auto* timer = new Timer(Timer::TypeOnce, &timer_callback_with_context, &foo);
+    auto foo = std::make_shared<int>(1);
+    auto* timer = new Timer(Timer::TypeOnce, &timer_callback_with_context, foo);
     timer->start(1);
     delay_ticks(10);
     timer->stop();
     delete timer;
 
-    CHECK_EQ(timer_callback_context, &foo);
+    CHECK_EQ(*std::static_pointer_cast<int>(timer_callback_context), *foo);
 }
 
 TEST_CASE("TimerTypePeriodic timers can be stopped and restarted") {
-    int counter = 0;
-    auto* timer = new Timer(Timer::TypePeriodic, &timer_callback_with_counter, &counter);
+    auto counter = std::make_shared<int>(0);
+    auto* timer = new Timer(Timer::TypePeriodic, &timer_callback_with_counter, counter);
     timer->start(1);
     delay_ticks(10);
     timer->stop();
@@ -36,24 +38,24 @@ TEST_CASE("TimerTypePeriodic timers can be stopped and restarted") {
     timer->stop();
     delete timer;
 
-    CHECK_GE(counter, 2);
+    CHECK_GE(*counter, 2);
 }
 
 TEST_CASE("TimerTypePeriodic calls the callback periodically") {
-    int counter = 0;
+    auto counter = std::make_shared<int>(0);
     int ticks_to_run = 10;
-    auto* timer = new Timer(Timer::TypePeriodic, &timer_callback_with_counter, &counter);
+    auto* timer = new Timer(Timer::TypePeriodic, &timer_callback_with_counter, counter);
     timer->start(1);
     delay_ticks(ticks_to_run);
     timer->stop();
     delete timer;
 
-    CHECK_EQ(counter, ticks_to_run);
+    CHECK_EQ(*counter, ticks_to_run);
 }
 
 TEST_CASE("restarting TimerTypeOnce timers calls the callback again") {
-    int counter = 0;
-    auto* timer = new Timer(Timer::TypeOnce, &timer_callback_with_counter, &counter);
+    auto counter = std::make_shared<int>(0);
+    auto* timer = new Timer(Timer::TypeOnce, &timer_callback_with_counter, counter);
     timer->start(1);
     delay_ticks(10);
     timer->stop();
@@ -62,5 +64,5 @@ TEST_CASE("restarting TimerTypeOnce timers calls the callback again") {
     timer->stop();
     delete timer;
 
-    CHECK_EQ(counter, 2);
+    CHECK_EQ(*counter, 2);
 }