Move tests to relevant subprojects (#615)

- Moved test projects to the parent project they belong to
- Improved test stability/corectness
- Improved recursive directory deletion by safely ignoring current- and parent-directory entries.
- Update docs

Tactility/Tests/Source/FileTest.cpp

@@ -0,0 +1,14 @@
+#include "doctest.h"
+#include <Tactility/file/File.h>
+
+using namespace tt;
+
+TEST_CASE("findOrCreateDirectory can create a directory tree without prefix") {
+    CHECK_EQ(file::findOrCreateDirectory("test1/test1", 0777), true);
+    CHECK_EQ(file::deleteRecursively("test1"), true);
+}
+
+TEST_CASE("findOrCreateDirectory can create a directory tree with prefix") {
+    CHECK_EQ(file::findOrCreateDirectory("/tmp/test2", 0777), true);
+    CHECK_EQ(file::deleteRecursively("/tmp/test2"), true);
+}

Tactility/Tests/Source/Main.cpp

@@ -0,0 +1,64 @@
+#define DOCTEST_CONFIG_IMPLEMENT
+#include "doctest.h"
+
+#include "FreeRTOS.h"
+#include "task.h"
+
+#include <tactility/check.h>
+#include <tactility/dts.h>
+#include <tactility/kernel_init.h>
+
+typedef struct {
+    int argc;
+    char** argv;
+    int result;
+} TestTaskData;
+
+// From the relevant platform
+extern "C" struct Module platform_posix_module;
+
+void test_task(void* parameter) {
+    auto* data = (TestTaskData*)parameter;
+
+    doctest::Context context;
+
+    context.applyCommandLine(data->argc, data->argv);
+
+    // overrides
+    context.setOption("no-breaks", true); // don't break in the debugger when assertions fail
+
+    Module* dts_modules[] = { &platform_posix_module, nullptr };
+    DtsDevice dts_devices[] = { DTS_DEVICE_TERMINATOR };
+    check(kernel_init(dts_modules, dts_devices) == ERROR_NONE);
+
+    data->result = context.run();
+
+    vTaskEndScheduler();
+
+    vTaskDelete(nullptr);
+}
+
+int main(int argc, char** argv) {
+    TestTaskData data = {
+        .argc = argc,
+        .argv = argv,
+        .result = 0
+    };
+
+    BaseType_t task_result = xTaskCreate(
+        test_task,
+        "test_task",
+        8192,
+        &data,
+        1,
+        nullptr
+    );
+
+    if (task_result != pdPASS) {
+        return 1;
+    }
+
+    vTaskStartScheduler();
+
+    return data.result;
+}

Tactility/Tests/Source/ObjectFileTest.cpp

@@ -0,0 +1,69 @@
+#include "doctest.h"
+#include <Tactility/file/ObjectFile.h>
+
+using tt::file::ObjectFileWriter;
+using tt::file::ObjectFileReader;
+
+constexpr const char* TEMP_FILE = "test.tmp";
+
+struct TestStruct {
+    uint32_t value;
+};
+
+TEST_CASE("Writing and reading multiple records to a file") {
+    ObjectFileWriter writer = ObjectFileWriter(TEMP_FILE, sizeof(TestStruct), 1, false);
+
+    TestStruct record_out_1 = { .value = 0xAAAAAAAA };
+    TestStruct record_out_2 = { .value = 0xBBBBBBBB };
+
+    CHECK_EQ(writer.open(), true);
+    CHECK_EQ(writer.write(&record_out_1), true);
+    CHECK_EQ(writer.write(&record_out_2), true);
+    writer.close();
+
+    TestStruct record_in;
+    ObjectFileReader reader = ObjectFileReader(TEMP_FILE, sizeof(TestStruct));
+    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();
+
+    remove(TEMP_FILE);
+}
+
+TEST_CASE("Appending records to a file") {
+    remove(TEMP_FILE);
+
+    ObjectFileWriter writer = ObjectFileWriter(TEMP_FILE, sizeof(TestStruct), 1, false);
+
+    TestStruct record_out_1 = { .value = 0xAAAAAAAA };
+    TestStruct record_out_2 = { .value = 0xBBBBBBBB };
+
+    CHECK_EQ(writer.open(), true);
+    CHECK_EQ(writer.write(&record_out_1), true);
+    writer.close();
+
+    ObjectFileWriter appender = ObjectFileWriter(TEMP_FILE, sizeof(TestStruct), 1, true);
+    CHECK_EQ(appender.open(), true);
+    CHECK_EQ(appender.write(&record_out_2), true);
+    appender.close();
+
+    TestStruct record_in;
+    ObjectFileReader reader = ObjectFileReader(TEMP_FILE, sizeof(TestStruct));
+    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();
+
+    remove(TEMP_FILE);
+}

Tactility/Tests/Source/StringTest.cpp

@@ -0,0 +1,63 @@
+#include "doctest.h"
+#include <Tactility/StringUtils.h>
+
+// region split
+
+TEST_CASE("splitting an empty string results in an empty vector") {
+    auto result = tt::string::split("", ".");
+    CHECK_EQ(result.empty(), true);
+}
+
+TEST_CASE("splitting a string with a single token results in a vector with that token") {
+    auto result = tt::string::split("token", ".");
+    CHECK_EQ(result.size(), 1);
+    CHECK_EQ(result.front(), "token");
+}
+
+TEST_CASE("splitting a string with multiple tokens results in a vector with those tokens") {
+    auto result = tt::string::split("token1;token2;token3;", ";");
+    CHECK_EQ(result.size(), 3);
+    CHECK_EQ(result[0], "token1");
+    CHECK_EQ(result[1], "token2");
+    CHECK_EQ(result[2], "token3");
+}
+
+// endregion split
+
+// region join
+
+TEST_CASE("joining an empty vector results in an empty string") {
+    std::vector<std::string> tokens = {};
+    auto result = tt::string::join(tokens, ".");
+    CHECK_EQ(result, "");
+}
+
+TEST_CASE("joining a single token results in a string with that value") {
+    std::vector<std::string> tokens = {
+        "token"
+    };
+    auto result = tt::string::join(tokens, ".");
+    CHECK_EQ(result, "token");
+}
+
+TEST_CASE("joining multiple tokens results in a string with all the tokens and the delimiter") {
+    std::vector<std::string> tokens = {
+        "token1",
+        "token2",
+        "token3",
+    };
+    auto result = tt::string::join(tokens, ".");
+    CHECK_EQ(result, "token1.token2.token3");
+}
+
+TEST_CASE("joining with empty tokens leads to an extra delimiter") {
+    std::vector<std::string> tokens = {
+     "token1",
+     "",
+     "token2",
+    };
+    auto result = tt::string::join(tokens, ".");
+    CHECK_EQ(result, "token1..token2");
+}
+
+// endregion join

Tactility/Tests/Source/TestFile.h

@@ -0,0 +1,42 @@
+#pragma once
+
+#include "doctest.h"
+#include <unistd.h>
+
+#include <Tactility/file/File.h>
+
+/**
+ * A class for creating test files that can automatically clean themselves up.
+ */
+class TestFile {
+    const char* path;
+    bool autoClean;
+
+public:
+
+    TestFile(const char* path, bool autoClean = true) : path(path), autoClean(autoClean) {
+        if (autoClean && exists()) {
+            remove();
+        }
+    }
+
+    ~TestFile() {
+        if (autoClean && exists()) {
+            remove();
+        }
+    }
+
+    const char* getPath() const { return path; }
+
+    void writeData(const char* data) const {
+        CHECK_EQ(tt::file::writeString(path, data), true);
+    }
+
+    bool exists() const {
+        return access(path, F_OK) == 0;
+    }
+
+    void remove() const {
+        ::remove(path);
+    }
+};

Tactility/Tests/Source/UrlTest.cpp

@@ -0,0 +1,61 @@
+#include "doctest.h"
+#include <Tactility/network/Url.h>
+
+using namespace tt;
+
+TEST_CASE("parseUrlQuery can handle a single key-value pair") {
+    auto map = network::parseUrlQuery("?key=value");
+    CHECK_EQ(map.size(), 1);
+    CHECK_EQ(map["key"], "value");
+}
+
+TEST_CASE("parseUrlQuery can handle empty value in the middle") {
+    auto map = network::parseUrlQuery("?a=1&b=&c=3");
+    CHECK_EQ(map.size(), 3);
+    CHECK_EQ(map["a"], "1");
+    CHECK_EQ(map["b"], "");
+    CHECK_EQ(map["c"], "3");
+}
+
+TEST_CASE("parseUrlQuery can handle empty value at the end") {
+    auto map = network::parseUrlQuery("?a=1&b=");
+    CHECK_EQ(map.size(), 2);
+    CHECK_EQ(map["a"], "1");
+    CHECK_EQ(map["b"], "");
+}
+
+TEST_CASE("parseUrlQuery returns empty map when query s questionmark with a key without a value") {
+    auto map = network::parseUrlQuery("?a");
+    CHECK_EQ(map.size(), 0);
+}
+
+TEST_CASE("parseUrlQuery returns empty map when query is a questionmark") {
+    auto map = network::parseUrlQuery("?");
+    CHECK_EQ(map.size(), 0);
+}
+
+TEST_CASE("parseUrlQuery should url-decode the value") {
+    auto map = network::parseUrlQuery("?key=Test%21Test");
+    CHECK_EQ(map.size(), 1);
+    CHECK_EQ(map["key"], "Test!Test");
+}
+
+TEST_CASE("parseUrlQuery should url-decode the key") {
+    auto map = network::parseUrlQuery("?Test%21Test=value");
+    CHECK_EQ(map.size(), 1);
+    CHECK_EQ(map["Test!Test"], "value");
+}
+
+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);
+    CHECK_EQ(encoded, expected);
+}
+
+TEST_CASE("urlDecode") {
+    auto input = 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 expected = std::string("prefix!*'();:@&=+$,/?#[]<>%-.^_`{}|~ \\");
+    auto decoded = network::urlDecode(input);
+    CHECK_EQ(decoded, expected);
+}