feat: add lab-rv32i-freertos-static-task card

tests/host-shim/FreeRTOS.h

@@ -0,0 +1,14 @@
+#ifndef K08_HOST_FREERTOS_H
+#define K08_HOST_FREERTOS_H
+#include <stddef.h>
+#include <stdint.h>
+typedef int32_t BaseType_t;
+typedef uint32_t UBaseType_t;
+typedef uint32_t configSTACK_DEPTH_TYPE;
+typedef uint32_t StackType_t;
+typedef void * TaskHandle_t;
+typedef struct { uint32_t words[ 24 ]; } StaticTask_t;
+#define pdPASS ( ( BaseType_t ) 1 )
+#define pdFAIL ( ( BaseType_t ) 0 )
+#endif
+

tests/host-shim/task.h

@@ -0,0 +1,18 @@
+#ifndef K08_HOST_TASK_H
+#define K08_HOST_TASK_H
+#include "FreeRTOS.h"
+#ifdef __cplusplus
+extern "C" {
+#endif
+typedef void ( * TaskFunction_t )( void * );
+BaseType_t xTaskCreate( TaskFunction_t, const char *, configSTACK_DEPTH_TYPE,
+                        void *, UBaseType_t, TaskHandle_t * );
+TaskHandle_t xTaskCreateStatic( TaskFunction_t, const char *,
+                               configSTACK_DEPTH_TYPE, void *, UBaseType_t,
+                               StackType_t *, StaticTask_t * );
+void vTaskDelete( TaskHandle_t );
+#ifdef __cplusplus
+}
+#endif
+#endif
+

tests/storage_host.cpp

@@ -0,0 +1,78 @@
+#include <cassert>
+#include <type_traits>
+
+#include "freertos/task_storage.hpp"
+
+namespace
+{
+size_t dynamic_calls;
+size_t static_calls;
+void * dynamic_context;
+void * static_context;
+int dynamic_tcb;
+
+class DynamicProbe final : public freertos::DynamicTask< DynamicProbe >
+{
+    friend class freertos::DynamicTask< DynamicProbe >;
+public:
+    constexpr DynamicProbe() : DynamicTask { "dyn", 64U, 2U } {}
+private:
+    void run() {}
+};
+
+class StaticProbe final : public freertos::StaticTask< StaticProbe, 64U >
+{
+    friend class freertos::StaticTask< StaticProbe, 64U >;
+public:
+    explicit constexpr StaticProbe(
+        freertos::StaticTaskStorage< 64U > & storage )
+        : StaticTask { "stat", 2U, storage } {}
+private:
+    void run() {}
+};
+} // namespace
+
+extern "C" BaseType_t xTaskCreate( TaskFunction_t, const char *,
+                                    configSTACK_DEPTH_TYPE, void * context,
+                                    UBaseType_t, TaskHandle_t * handle )
+{
+    ++dynamic_calls;
+    dynamic_context = context;
+    *handle = &dynamic_tcb;
+    return pdPASS;
+}
+extern "C" TaskHandle_t xTaskCreateStatic(
+    TaskFunction_t, const char *, configSTACK_DEPTH_TYPE, void * context,
+    UBaseType_t, StackType_t *, StaticTask_t * tcb )
+{
+    ++static_calls;
+    static_context = context;
+    return tcb;
+}
+extern "C" void vTaskDelete( TaskHandle_t ) {}
+
+static_assert( !std::is_copy_constructible< DynamicProbe >::value );
+static_assert( !std::is_move_constructible< StaticProbe >::value );
+static_assert( !std::is_polymorphic< DynamicProbe >::value );
+static_assert( !std::is_polymorphic< StaticProbe >::value );
+
+int main()
+{
+    freertos::StaticTaskStorage< 64U > storage {};
+    DynamicProbe dynamic;
+    StaticProbe statik { storage };
+    assert( dynamic_calls == 0U && static_calls == 0U );
+    assert( dynamic.start() );
+    assert( dynamic_calls == 1U && dynamic_context == &dynamic );
+    assert( dynamic.native_handle() == &dynamic_tcb );
+    assert( statik.start() );
+    assert( static_calls == 1U && static_context == &statik );
+    assert( statik.native_handle() == &storage.tcb );
+    assert( statik.tcb_storage() == &storage.tcb );
+    assert( statik.stack_storage() == storage.stack );
+    assert( statik.stack_words() == 64U );
+    assert( statik.stack_bytes() == 64U * sizeof( StackType_t ) );
+    assert( !dynamic.start() && !statik.start() );
+    return 0;
+}
+