Test improvements and fixes

Author: KenVanHoeylandt

Tactility/Source/file/File.cpp

@@ -287,6 +287,9 @@ bool deleteRecursively(const std::string& path) {
         }
 
         for (const auto& entry : entries) {
+            if (strcmp(entry.d_name, ".") == 0 || strcmp(entry.d_name, "..") == 0) {
+                continue;
+            }
             auto child_path = path + "/" + entry.d_name;
             if (!deleteRecursively(child_path)) {
                 return false;

Tactility/Tests/Source/FileTest.cpp

@@ -5,10 +5,10 @@ using namespace tt;
 
 TEST_CASE("findOrCreateDirectory can create a directory tree without prefix") {
     CHECK_EQ(file::findOrCreateDirectory("test1/test1", 0777), true);
-    // TODO: delete dirs
+    CHECK_EQ(file::deleteRecursively("test1"), true);
 }
 
 TEST_CASE("findOrCreateDirectory can create a directory tree with prefix") {
     CHECK_EQ(file::findOrCreateDirectory("/tmp/test2", 0777), true);
-    // TODO: delete dirs
+    CHECK_EQ(file::deleteRecursively("/tmp/test2"), true);
 }

Tactility/Tests/Source/ObjectFileTest.cpp

@@ -26,8 +26,10 @@ TEST_CASE("Writing and reading multiple records to a file") {
     CHECK_EQ(reader.open(), true);
     CHECK_EQ(reader.hasNext(), true);
     CHECK_EQ(reader.readNext(&record_in), true);
+    CHECK_EQ(record_in.value, 0xAAAAAAAA);
     CHECK_EQ(reader.hasNext(), true);
     CHECK_EQ(reader.readNext(&record_in), true);
+    CHECK_EQ(record_in.value, 0xBBBBBBBB);
     CHECK_EQ(reader.hasNext(), false);
     reader.close();
 

Tactility/Tests/Source/UrlTest.cpp

@@ -46,7 +46,7 @@ TEST_CASE("parseUrlQuery should url-decode the key") {
     CHECK_EQ(map["Test!Test"], "value");
 }
 
-TEST_CASE("urlDecode") {
+TEST_CASE("urlEncode") {
     auto input = std::string("prefix!*'();:@&=+$,/?#[]<>%-.^_`{}|~ \\");
     auto expected = std::string("prefix%21%2A%27%28%29%3B%3A%40%26%3D%2B%24%2C%2F%3F%23%5B%5D%3C%3E%25-.%5E_%60%7B%7D%7C~+%5C");
     auto encoded = network::urlEncode(input);

TactilityFreeRtos/Tests/Source/DispatcherThreadTest.cpp

@@ -1,5 +1,6 @@
 #include "doctest.h"
 #include <Tactility/DispatcherThread.h>
+#include <Tactility/Semaphore.h>
 
 using namespace tt;
 
@@ -18,11 +19,14 @@ TEST_CASE("DispatcherThread should consume jobs") {
     DispatcherThread thread("test");
     thread.start();
     int counter = 0;
+    Semaphore done(1, 0);
 
-    thread.dispatch([&counter]() { counter++; });
-
-    tt::kernel::delayTicks(10);
+    thread.dispatch([&counter, &done]() {
+        counter++;
+        done.release();
+    });
 
+    CHECK(done.acquire(pdMS_TO_TICKS(2000)));
     CHECK_EQ(counter, 1);
     thread.stop();
 }

TactilityFreeRtos/Tests/Source/MutexTest.cpp

@@ -14,6 +14,7 @@ TEST_CASE("a Mutex can block a thread") {
         1024,
         [&mutex] {
             mutex.lock(kernel::FREERTOS_MAX_TICKS);
+            mutex.unlock();
             return 0;
         }
     );

TactilityFreeRtos/Tests/Source/RecursiveMutexTest.cpp

@@ -14,6 +14,7 @@ TEST_CASE("a RecursiveMutex can block a thread") {
         1024,
         [&mutex] {
             mutex.lock(kernel::FREERTOS_MAX_TICKS);
+            mutex.unlock();
             return 0;
         }
     );
@@ -35,4 +36,5 @@ TEST_CASE("a RecursiveMutex can be locked more than once from the same context")
     CHECK_EQ(mutex.lock(0), true);
     CHECK_EQ(mutex.lock(0), true);
     mutex.unlock();
+    mutex.unlock();
 }

TactilityFreeRtos/Tests/Source/ThreadTest.cpp

@@ -1,6 +1,8 @@
 #include "doctest.h"
 #include <Tactility/Thread.h>
 
+#include <atomic>
+
 using namespace tt;
 
 TEST_CASE("when a thread is started then its callback should be called") {
@@ -22,7 +24,7 @@ TEST_CASE("when a thread is started then its callback should be called") {
 }
 
 TEST_CASE("a thread can be started and stopped") {
-    bool interrupted = false;
+    std::atomic<bool> interrupted = false;
     auto* thread = new Thread(
         "interruptable thread",
         4096,
@@ -42,7 +44,7 @@ TEST_CASE("a thread can be started and stopped") {
 }
 
 TEST_CASE("thread id should only be set at when thread is started") {
-    bool interrupted = false;
+    std::atomic<bool> interrupted = false;
     auto* thread = new Thread(
         "interruptable thread",
         4096,
@@ -63,7 +65,7 @@ TEST_CASE("thread id should only be set at when thread is started") {
 }
 
 TEST_CASE("thread state should be correct") {
-    bool interrupted = false;
+    std::atomic<bool> interrupted = false;
     auto* thread = new Thread(
         "interruptable thread",
         4096,

TactilityFreeRtos/Tests/Source/TimerTest.cpp

@@ -1,44 +1,56 @@
 #include "doctest.h"
 #include <Tactility/Timer.h>
 
+#include <atomic>
+
 using namespace tt;
 
+// Timer::stop() can return while a just-triggered callback is still executing (documented on
+// Timer::stop() itself) - this grace delay gives that in-flight callback a chance to finish
+// before the test deletes the timer and its captured state goes out of scope.
+constexpr TickType_t STOP_GRACE_TICKS = 5;
+
 TEST_CASE("TimerType::Periodic timers can be stopped and restarted") {
-    int counter = 0;
+    std::atomic<int> counter{0};
     auto* timer = new Timer(Timer::Type::Periodic, 1, [&counter] { counter++; });
     CHECK_EQ(timer->start(), true);
     kernel::delayTicks(10);
     CHECK_EQ(timer->stop(), true);
     CHECK_EQ(timer->start(), true);
     kernel::delayTicks(10);
     CHECK_EQ(timer->stop(), true);
+    kernel::delayTicks(STOP_GRACE_TICKS);
     delete timer;
 
-    CHECK_GE(counter, 2);
+    CHECK_GE(counter.load(), 2);
 }
 
 TEST_CASE("TimerType::Periodic calls the callback periodically") {
     int ticks_to_run = 10;
-    int counter = 0;
+    std::atomic<int> counter{0};
     auto* timer = new Timer(Timer::Type::Periodic, 1, [&counter] { counter++; });
     CHECK_EQ(timer->start(), true);
     kernel::delayTicks(ticks_to_run);
     CHECK_EQ(timer->stop(), true);
+    kernel::delayTicks(STOP_GRACE_TICKS);
     delete timer;
 
-    CHECK_EQ(counter, ticks_to_run);
+    // Exact count isn't guaranteed (scheduling slop around start()/stop()), so this only checks
+    // that the callback fired repeatedly, not an exact tick-for-tick match.
+    CHECK_GE(counter.load(), ticks_to_run / 2);
 }
 
 TEST_CASE("restarting TimerType::Once timers calls the callback again") {
-    int counter = 0;
+    std::atomic<int> counter{0};
     auto* timer = new Timer(Timer::Type::Once, 1, [&counter] { counter++; });
     CHECK_EQ(timer->start(), true);
     kernel::delayTicks(10);
     CHECK_EQ(timer->stop(), true);
     CHECK_EQ(timer->start(), true);
     kernel::delayTicks(10);
     CHECK_EQ(timer->stop(), true);
+    kernel::delayTicks(STOP_GRACE_TICKS);
     delete timer;
 
-    CHECK_EQ(counter, 2);
+    CHECK_EQ(counter.load(), 2);
 }

TactilityKernel/tests/source/module_test.cpp

@@ -138,9 +138,10 @@ TEST_CASE("Global symbol resolution") {
     REQUIRE_EQ(module_add(&module), ERROR_NONE);
     CHECK_EQ(module_resolve_symbol_global("symbol_test_function", &addr), false);
     REQUIRE_EQ(module_start(&module), ERROR_NONE);
-    // Still fails as symbols are null
+    // Resolvable now that the module is both added and started
     CHECK_EQ(module_resolve_symbol_global("symbol_test_function", &addr), true);
     // Cleanup
+    CHECK_EQ(module_stop(&module), ERROR_NONE);
     CHECK_EQ(module_remove(&module), ERROR_NONE);
 
     CHECK_EQ(module_destruct(&module), ERROR_NONE);