Add renderer and package readiness validation gates

2026-06-15 19:20:56 +02:00
parent 68617e8bc4
commit f78fc3076c
23 changed files with 2350 additions and 389 deletions
--- a/tests/foundation/task_queue_stress_tests.cpp
+++ b/tests/foundation/task_queue_stress_tests.cpp
@@ -0,0 +1,162 @@
+#include "foundation/task_queue.h"
+#include "test_harness.h"
+
+#include <vector>
+
+namespace {
+
+struct NestedPushPayload {
+    pp::foundation::TaskQueue* queue = nullptr;
+    std::vector<int>* order = nullptr;
+};
+
+struct MarkerPayload {
+    std::vector<int>* order = nullptr;
+    int marker = 0;
+};
+
+struct HandoffPayload {
+    pp::foundation::TaskQueue* ui_queue = nullptr;
+    std::vector<int>* order = nullptr;
+    int worker_marker = 0;
+    MarkerPayload* ui_marker = nullptr;
+};
+
+void nested_push_task(void* user_data) noexcept
+{
+    auto* payload = static_cast<NestedPushPayload*>(user_data);
+    payload->order->push_back(1);
+    payload->queue->push(pp::foundation::TaskItem { .callback = [](void* callback_data) noexcept {
+        auto* inner = static_cast<std::vector<int>*>(callback_data);
+        inner->push_back(2);
+    }, .user_data = payload->order, .id = 2 });
+}
+
+void record_marker_task(void* user_data) noexcept
+{
+    auto* payload = static_cast<MarkerPayload*>(user_data);
+    payload->order->push_back(payload->marker);
+}
+
+void handoff_to_ui_queue_task(void* user_data) noexcept
+{
+    const auto payload = static_cast<HandoffPayload*>(user_data);
+    payload->order->push_back(payload->worker_marker);
+    payload->ui_queue->push(pp::foundation::TaskItem {
+        .callback = record_marker_task,
+        .user_data = payload->ui_marker,
+        .id = static_cast<std::uint64_t>(payload->worker_marker),
+    });
+}
+
+void runs_nested_push_tasks_deterministically(pp::tests::Harness& harness)
+{
+    pp::foundation::TaskQueue queue;
+    std::vector<int> order;
+    NestedPushPayload payload { .queue = &queue, .order = &order };
+
+    PP_EXPECT(harness, queue.push(pp::foundation::TaskItem {
+        .callback = nested_push_task,
+        .user_data = &payload,
+        .id = 1
+    }).ok());
+
+    PP_EXPECT(harness, queue.run_all() == 2U);
+    PP_EXPECT(harness, order.size() == 2U);
+    PP_EXPECT(harness, order[0] == 1);
+    PP_EXPECT(harness, order[1] == 2);
+    PP_EXPECT(harness, queue.empty());
+}
+
+void worker_to_ui_queue_handoff_is_ordered(pp::tests::Harness& harness)
+{
+    pp::foundation::TaskQueue worker_queue;
+    pp::foundation::TaskQueue ui_queue;
+    std::vector<int> order;
+
+    MarkerPayload marker_payloads[] = {
+        { .order = &order, .marker = 2 },
+        { .order = &order, .marker = 3 },
+    };
+    HandoffPayload worker_payloads[] = {
+        {
+            .ui_queue = &ui_queue,
+            .order = &order,
+            .worker_marker = 1,
+            .ui_marker = &marker_payloads[0],
+        },
+        {
+            .ui_queue = &ui_queue,
+            .order = &order,
+            .worker_marker = 4,
+            .ui_marker = &marker_payloads[1],
+        },
+    };
+
+    PP_EXPECT(harness, worker_queue.push(pp::foundation::TaskItem {
+        .callback = handoff_to_ui_queue_task,
+        .user_data = &worker_payloads[0],
+        .id = 1,
+    }).ok());
+    PP_EXPECT(harness, worker_queue.push(pp::foundation::TaskItem {
+        .callback = handoff_to_ui_queue_task,
+        .user_data = &worker_payloads[1],
+        .id = 2,
+    }).ok());
+
+    PP_EXPECT(harness, worker_queue.run_all() == 2U);
+    PP_EXPECT(harness, order.size() == 2U);
+    PP_EXPECT(harness, order[0] == 1);
+    PP_EXPECT(harness, order[1] == 4);
+    PP_EXPECT(harness, worker_queue.empty());
+    PP_EXPECT(harness, !ui_queue.empty());
+
+    PP_EXPECT(harness, ui_queue.run_all() == 2U);
+    PP_EXPECT(harness, order.size() == 4U);
+    PP_EXPECT(harness, order[2] == 2);
+    PP_EXPECT(harness, order[3] == 3);
+    PP_EXPECT(harness, ui_queue.empty());
+}
+
+void stress_batch_push_and_overflow_reported(pp::tests::Harness& harness)
+{
+    constexpr std::size_t batch_size = 32U;
+    pp::foundation::TaskQueue queue(batch_size);
+
+    int counter = 0;
+    for (std::size_t i = 0U; i < batch_size; ++i)
+    {
+        PP_EXPECT(harness, queue.push(pp::foundation::TaskItem {
+            .callback = [](void* user_data) noexcept
+            {
+                ++*static_cast<int*>(user_data);
+            },
+            .user_data = &counter,
+            .id = static_cast<std::uint64_t>(i + 1),
+        }).ok());
+    }
+
+    const auto overflow = queue.push(pp::foundation::TaskItem {
+        .callback = [](void* user_data) noexcept
+        {
+            ++*static_cast<int*>(user_data);
+        },
+        .user_data = &counter,
+        .id = batch_size + 1U,
+    });
+    PP_EXPECT(harness, !overflow.ok());
+    PP_EXPECT(harness, queue.run_all() == batch_size);
+    PP_EXPECT(harness, counter == static_cast<int>(batch_size));
+    PP_EXPECT(harness, queue.empty());
+}
+
+}
+
+int main()
+{
+    pp::tests::Harness harness;
+    harness.run("nested pushes are executed deterministically", runs_nested_push_tasks_deterministically);
+    harness.run("worker to UI queue handoff preserves order", worker_to_ui_queue_handoff_is_ordered);
+    harness.run("stress batch push reports overflow and drains deterministically", stress_batch_push_and_overflow_reported);
+    return harness.finish();
+}