adolforeyna/tactility
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

TactilityKernel improvements and more (#459)

Browse Source
This commit is contained in:
Ken Van Hoeylandt
2026-01-25 23:54:33 +01:00
committed by GitHub
parent 96eccbdc8d
commit dfe2c865d1
36 changed files with 759 additions and 331 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Tests/TactilityKernel/DeviceTest.cpp
+47 -48
View File
@@ -8,14 +8,13 @@
TEST_CASE("device_construct and device_destruct should set and unset the correct fields") {
Device device = { 0 };
int error = device_construct(&device);
CHECK_EQ(error, 0);
error_t error = device_construct(&device);
CHECK_EQ(error, ERROR_NONE);
CHECK_NE(device.internal.data, nullptr);
CHECK_NE(device.internal.mutex.handle, nullptr);
error = device_destruct(&device);
CHECK_EQ(error, 0);
CHECK_EQ(device_destruct(&device), ERROR_NONE);
CHECK_EQ(device.internal.data, nullptr);
CHECK_EQ(device.internal.mutex.handle, nullptr);
@@ -30,13 +29,13 @@ TEST_CASE("device_construct and device_destruct should set and unset the correct
TEST_CASE("device_add should add the device to the list of all devices") {
Device device = { 0 };
CHECK_EQ(device_construct(&device), 0);
CHECK_EQ(device_add(&device), 0);
CHECK_EQ(device_construct(&device), ERROR_NONE);
CHECK_EQ(device_add(&device), ERROR_NONE);
// Gather all devices
std::vector<Device*> devices;
for_each_device(&devices, [](auto* device, auto* context) {
auto* devices_ptr = (std::vector<Device*>*)context;
auto* devices_ptr = static_cast<std::vector<Device*>*>(context);
devices_ptr->push_back(device);
return true;
});
@@ -44,8 +43,8 @@ TEST_CASE("device_add should add the device to the list of all devices") {
CHECK_EQ(devices.size(), 1);
CHECK_EQ(devices[0], &device);
CHECK_EQ(device_remove(&device), 0);
CHECK_EQ(device_destruct(&device), 0);
CHECK_EQ(device_remove(&device), ERROR_NONE);
CHECK_EQ(device_destruct(&device), ERROR_NONE);
}
TEST_CASE("device_add should add the device to its parent") {
@@ -57,11 +56,11 @@ TEST_CASE("device_add should add the device to its parent") {
.parent = &parent
};
CHECK_EQ(device_construct(&parent), 0);
CHECK_EQ(device_add(&parent), 0);
CHECK_EQ(device_construct(&parent), ERROR_NONE);
CHECK_EQ(device_add(&parent), ERROR_NONE);
CHECK_EQ(device_construct(&child), 0);
CHECK_EQ(device_add(&child), 0);
CHECK_EQ(device_construct(&child), ERROR_NONE);
CHECK_EQ(device_add(&child), ERROR_NONE);
// Gather all child devices
std::vector<Device*> children;
@@ -74,30 +73,30 @@ TEST_CASE("device_add should add the device to its parent") {
CHECK_EQ(children.size(), 1);
CHECK_EQ(children[0], &child);
CHECK_EQ(device_remove(&child), 0);
CHECK_EQ(device_destruct(&child), 0);
CHECK_EQ(device_remove(&child), ERROR_NONE);
CHECK_EQ(device_destruct(&child), ERROR_NONE);
CHECK_EQ(device_remove(&parent), 0);
CHECK_EQ(device_destruct(&parent), 0);
CHECK_EQ(device_remove(&parent), ERROR_NONE);
CHECK_EQ(device_destruct(&parent), ERROR_NONE);
}
TEST_CASE("device_add should set the state to 'added'") {
Device device = { 0 };
CHECK_EQ(device_construct(&device), 0);
CHECK_EQ(device_construct(&device), ERROR_NONE);
CHECK_EQ(device.internal.state.added, false);
CHECK_EQ(device_add(&device), 0);
CHECK_EQ(device_add(&device), ERROR_NONE);
CHECK_EQ(device.internal.state.added, true);
CHECK_EQ(device_remove(&device), 0);
CHECK_EQ(device_destruct(&device), 0);
CHECK_EQ(device_remove(&device), ERROR_NONE);
CHECK_EQ(device_destruct(&device), ERROR_NONE);
}
TEST_CASE("device_remove should remove it from the list of all devices") {
Device device = { 0 };
CHECK_EQ(device_construct(&device), 0);
CHECK_EQ(device_add(&device), 0);
CHECK_EQ(device_remove(&device), 0);
CHECK_EQ(device_construct(&device), ERROR_NONE);
CHECK_EQ(device_add(&device), ERROR_NONE);
CHECK_EQ(device_remove(&device), ERROR_NONE);
// Gather all devices
std::vector<Device*> devices;
@@ -109,7 +108,7 @@ TEST_CASE("device_remove should remove it from the list of all devices") {
CHECK_EQ(devices.size(), 0);
CHECK_EQ(device_destruct(&device), 0);
CHECK_EQ(device_destruct(&device), ERROR_NONE);
}
TEST_CASE("device_remove should remove the device from its parent") {
@@ -121,12 +120,12 @@ TEST_CASE("device_remove should remove the device from its parent") {
.parent = &parent
};
CHECK_EQ(device_construct(&parent), 0);
CHECK_EQ(device_add(&parent), 0);
CHECK_EQ(device_construct(&parent), ERROR_NONE);
CHECK_EQ(device_add(&parent), ERROR_NONE);
CHECK_EQ(device_construct(&child), 0);
CHECK_EQ(device_add(&child), 0);
CHECK_EQ(device_remove(&child), 0);
CHECK_EQ(device_construct(&child), ERROR_NONE);
CHECK_EQ(device_add(&child), ERROR_NONE);
CHECK_EQ(device_remove(&child), ERROR_NONE);
// Gather all child devices
std::vector<Device*> children;
@@ -138,22 +137,22 @@ TEST_CASE("device_remove should remove the device from its parent") {
CHECK_EQ(children.size(), 0);
CHECK_EQ(device_destruct(&child), 0);
CHECK_EQ(device_destruct(&child), ERROR_NONE);
CHECK_EQ(device_remove(&parent), 0);
CHECK_EQ(device_destruct(&parent), 0);
CHECK_EQ(device_remove(&parent), ERROR_NONE);
CHECK_EQ(device_destruct(&parent), ERROR_NONE);
}
TEST_CASE("device_remove should clear the state 'added'") {
Device device = { 0 };
CHECK_EQ(device_construct(&device), 0);
CHECK_EQ(device_construct(&device), ERROR_NONE);
CHECK_EQ(device_add(&device), 0);
CHECK_EQ(device_add(&device), ERROR_NONE);
CHECK_EQ(device.internal.state.added, true);
CHECK_EQ(device_remove(&device), 0);
CHECK_EQ(device_remove(&device), ERROR_NONE);
CHECK_EQ(device.internal.state.added, false);
CHECK_EQ(device_destruct(&device), 0);
CHECK_EQ(device_destruct(&device), ERROR_NONE);
}
TEST_CASE("device_is_ready should return true only when it is started") {
@@ -161,30 +160,30 @@ TEST_CASE("device_is_ready should return true only when it is started") {
Driver driver = {
.name = "test_driver",
.compatible = compatible,
.start_device = nullptr,
.stop_device = nullptr,
.startDevice = nullptr,
.stopDevice = nullptr,
.api = nullptr,
.device_type = nullptr,
.deviceType = nullptr,
.internal = { 0 }
};
Device device = { 0 };
CHECK_EQ(driver_construct(&driver), 0);
CHECK_EQ(device_construct(&device), 0);
CHECK_EQ(driver_construct(&driver), ERROR_NONE);
CHECK_EQ(device_construct(&device), ERROR_NONE);
CHECK_EQ(device.internal.state.started, false);
device_set_driver(&device, &driver);
CHECK_EQ(device.internal.state.started, false);
CHECK_EQ(device_add(&device), 0);
CHECK_EQ(device_add(&device), ERROR_NONE);
CHECK_EQ(device.internal.state.started, false);
CHECK_EQ(device_start(&device), 0);
CHECK_EQ(device_start(&device), ERROR_NONE);
CHECK_EQ(device.internal.state.started, true);
CHECK_EQ(device_stop(&device), 0);
CHECK_EQ(device_stop(&device), ERROR_NONE);
CHECK_EQ(device.internal.state.started, false);
CHECK_EQ(device_remove(&device), 0);
CHECK_EQ(device_remove(&device), ERROR_NONE);
CHECK_EQ(device.internal.state.started, false);
CHECK_EQ(driver_destruct(&driver), 0);
CHECK_EQ(device_destruct(&device), 0);
CHECK_EQ(driver_destruct(&driver), ERROR_NONE);
CHECK_EQ(device_destruct(&device), ERROR_NONE);
}
Tests/TactilityKernel/DispatcherTest.cpp
+25
View File
@@ -0,0 +1,25 @@
#include "doctest.h"
#include <Tactility/FreeRTOS/task.h>
#include <Tactility/concurrent/Dispatcher.h>
TEST_CASE("dispatcher test") {
DispatcherHandle_t dispatcher = dispatcher_alloc();
CHECK_NE(dispatcher, nullptr);
int count = 0;
auto error = dispatcher_dispatch(dispatcher, &count, [](void* context) {
int* count_ptr = static_cast<int*>(context);
(*count_ptr)++;
});
CHECK_EQ(error, ERROR_NONE);
vTaskDelay(1);
CHECK_EQ(count, 0);
CHECK_EQ(dispatcher_consume(dispatcher), ERROR_NONE);
CHECK_EQ(count, 1);
dispatcher_free(dispatcher);
}
Tests/TactilityKernel/DriverIntegrationTest.cpp
+10 -10
View File
@@ -26,10 +26,10 @@ static int stop(Device* device) {
static Driver integration_driver = {
.name = "integration_test_driver",
.compatible = (const char*[]) { "integration", nullptr },
.start_device = start,
.stop_device = stop,
.startDevice = start,
.stopDevice = stop,
.api = nullptr,
.device_type = nullptr,
.deviceType = nullptr,
.internal = { 0 }
};
@@ -47,18 +47,18 @@ TEST_CASE("driver with with start success and stop success should start and stop
.parent = nullptr,
};
CHECK_EQ(driver_construct(&integration_driver), 0);
CHECK_EQ(driver_construct(&integration_driver), ERROR_NONE);
CHECK_EQ(device_construct(&integration_device), 0);
CHECK_EQ(device_construct(&integration_device), ERROR_NONE);
device_add(&integration_device);
CHECK_EQ(startCalled, 0);
CHECK_EQ(driver_bind(&integration_driver, &integration_device), 0);
CHECK_EQ(driver_bind(&integration_driver, &integration_device), ERROR_NONE);
CHECK_EQ(startCalled, 1);
CHECK_EQ(stopCalled, 0);
CHECK_EQ(driver_unbind(&integration_driver, &integration_device), 0);
CHECK_EQ(driver_unbind(&integration_driver, &integration_device), ERROR_NONE);
CHECK_EQ(stopCalled, 1);
CHECK_EQ(device_remove(&integration_device), 0);
CHECK_EQ(device_destruct(&integration_device), 0);
CHECK_EQ(device_remove(&integration_device), ERROR_NONE);
CHECK_EQ(device_destruct(&integration_device), ERROR_NONE);
CHECK_EQ(driver_destruct(&integration_driver), 0);
CHECK_EQ(driver_destruct(&integration_driver), ERROR_NONE);
}
Tests/TactilityKernel/DriverTest.cpp
+10 -15
View File
@@ -4,12 +4,9 @@
TEST_CASE("driver_construct and driver_destruct should set and unset the correct fields") {
Driver driver = { 0 };
int error = driver_construct(&driver);
CHECK_EQ(error, 0);
CHECK_EQ(driver_construct(&driver), ERROR_NONE);
CHECK_NE(driver.internal.data, nullptr);
error = driver_destruct(&driver);
CHECK_EQ(error, 0);
CHECK_EQ(driver_destruct(&driver), ERROR_NONE);
CHECK_EQ(driver.internal.data, nullptr);
}
@@ -18,10 +15,10 @@ TEST_CASE("driver_is_compatible should return true if a compatible value is foun
Driver driver = {
.name = "test_driver",
.compatible = compatible,
.start_device = nullptr,
.stop_device = nullptr,
.startDevice = nullptr,
.stopDevice = nullptr,
.api = nullptr,
.device_type = nullptr,
.deviceType = nullptr,
.internal = { 0 }
};
CHECK_EQ(driver_is_compatible(&driver, "test_compatible"), true);
@@ -34,24 +31,22 @@ TEST_CASE("driver_find should only find a compatible driver when the driver was
Driver driver = {
.name = "test_driver",
.compatible = compatible,
.start_device = nullptr,
.stop_device = nullptr,
.startDevice = nullptr,
.stopDevice = nullptr,
.api = nullptr,
.device_type = nullptr,
.deviceType = nullptr,
.internal = { 0 }
};
Driver* found_driver = driver_find_compatible("test_compatible");
CHECK_EQ(found_driver, nullptr);
int error = driver_construct(&driver);
CHECK_EQ(error, 0);
CHECK_EQ(driver_construct(&driver), ERROR_NONE);
found_driver = driver_find_compatible("test_compatible");
CHECK_EQ(found_driver, &driver);
error = driver_destruct(&driver);
CHECK_EQ(error, 0);
CHECK_EQ(driver_destruct(&driver), ERROR_NONE);
found_driver = driver_find_compatible("test_compatible");
CHECK_EQ(found_driver, nullptr);
Tests/TactilityKernel/MutexTest.cpp
+1 -1
View File
@@ -60,7 +60,7 @@ TEST_CASE("mutex_lock in another task should block when a lock is active") {
CHECK_EQ(task_lock_counter, 0);
mutex_unlock(&mutex);
vTaskDelay(1);
vTaskDelay(2); // 1 is sufficient most of the time, but not always
CHECK_EQ(task_lock_counter, 1);
mutex_destruct(&mutex);
}
Tests/TactilityKernel/RecursiveMutexTest.cpp
+1 -1
View File
@@ -80,7 +80,7 @@ TEST_CASE("recursive_mutex_lock in another task should block when a lock is acti
CHECK_EQ(task_lock_counter, 0);
recursive_mutex_unlock(&mutex);
vTaskDelay(1);
vTaskDelay(2); // 1 is sufficient most of the time, but not always
CHECK_EQ(task_lock_counter, 1);
recursive_mutex_destruct(&mutex);
}