错误处理

Kernel/tests/renderive/frame_control/concept/Concepts_Test.cpp

@@ -18,5 +18,3 @@ static_assert(Flow_Frame_Refresh_Strategy<Frame_Control_Concept_Flow>);
 TEST(frame_control_concepts_test, concepts_compile) {
     SUCCEED();
 }
-static_assert(noexcept(std::declval<Low_Latency_Test_Strategy&>().on_real_time_data_update(std::declval<const Real_Time_Data_Observation&>())));
-static_assert(noexcept(std::declval<Low_Latency_Test_Strategy&>().discard_stale_latest_data_frame()));

Kernel/tests/renderive/frame_control/strategy/manual/Manual_Refresh_Strategy_Test.cpp

@@ -21,7 +21,7 @@ TEST(manual_refresh_strategy_test, publishes_only_after_manual_refresh) {
         auto frame = strategy.acquire_renderer();
         EXPECT_FALSE(frame);
     }
-    EXPECT_TRUE(strategy.refresh());
+    EXPECT_EQ(strategy.refresh(), Manual_Refresh_Error::none);
     {
         auto frame = strategy.acquire_renderer();
         ASSERT_TRUE(frame);
@@ -39,14 +39,14 @@ TEST(manual_refresh_strategy_test, keeps_latest_prepared_frame) {
         frame->value = 2;
     }
     EXPECT_EQ(strategy.state().replaced_prepared_frame_count, 1);
-    ASSERT_TRUE(strategy.refresh());
+    ASSERT_EQ(strategy.refresh(), Manual_Refresh_Error::none);
     auto frame = strategy.acquire_renderer();
     ASSERT_TRUE(frame);
     EXPECT_EQ(frame->value, 2);
 }
 TEST(manual_refresh_strategy_test, reports_failed_refresh_without_pending_frame) {
     Manual_Refresh_Test_Strategy strategy;
-    EXPECT_FALSE(strategy.refresh());
+    EXPECT_EQ(strategy.refresh(), Manual_Refresh_Error::no_pending_frame);
     EXPECT_EQ(strategy.state().failed_refresh_count, 1);
 }
 struct Manual_Refresh_Reentrant_Observer_Data {
@@ -82,7 +82,7 @@ TEST(manual_refresh_strategy_test, refresh_observer_can_acquire_renderer_without
             observed_value.store(frame->value, std::memory_order_release);
         }
     };
-    EXPECT_TRUE(strategy.refresh());
+    EXPECT_EQ(strategy.refresh(), Manual_Refresh_Error::none);
     EXPECT_EQ(observed_value.load(std::memory_order_acquire), 42);
 }
 

Kernel/tests/renderive/render_graph/Render_Graph_Runtime_Test.cpp

@@ -60,18 +60,20 @@ TEST(external_operation_test, completion_before_subscription_is_delivered_once)
 }
 
 TEST(external_operation_test,
-     callback_exceptions_are_contained_for_both_completion_orders) {
+     callback_exceptions_propagate_for_both_completion_orders) {
     External_Operation_Source completed_first;
     const auto completed_operation = completed_first.operation();
     ASSERT_TRUE(completed_first.complete());
-    EXPECT_NO_THROW(completed_operation.on_complete(
-        [](External_Operation_Completion) { throw std::runtime_error("late callback"); }));
+    EXPECT_THROW(completed_operation.on_complete(
+        [](External_Operation_Completion) {
+            throw std::runtime_error("late callback");
+        }), std::runtime_error);
 
     External_Operation_Source subscribed_first;
     const auto subscribed_operation = subscribed_first.operation();
     subscribed_operation.on_complete(
         [](External_Operation_Completion) { throw std::runtime_error("early callback"); });
-    EXPECT_TRUE(subscribed_first.complete());
+    EXPECT_THROW(static_cast<void>(subscribed_first.complete()), std::runtime_error);
 }
 
 TEST(render_graph_runtime_test, reusable_topology_executes_multiple_frames) {

Kernel/tests/renderive/scene/Dependency_Resolver_Test.cpp

@@ -47,10 +47,9 @@ TEST(dependency_resolver_test,
     resolver.add_parent(Preparation::upload_visual,
                         Preparation::transform_vertices);
 
-    EXPECT_THROW(
-        resolver.add_parent(Preparation::acquire_source,
-                            Preparation::upload_visual),
-        std::logic_error);
+    EXPECT_EQ(resolver.add_parent(Preparation::acquire_source,
+                                  Preparation::upload_visual).error,
+              renderive::scene::dependency::Mutation_Error::cycle);
 
     EXPECT_TRUE(resolver.parents(Preparation::acquire_source).empty());
     EXPECT_EQ(resolver.resolve().order,

Kernel/tests/renderive/scene/Render_Plan_Execution_Test.cpp

@@ -377,7 +377,7 @@ TEST(render_plan_execution_test, capture_requests_publish_exact_immutable_abstra
     ASSERT_TRUE(alternate_frame.completed_snapshot());
     EXPECT_EQ(alternate_frame.completed_snapshot(), session->frames.front().snapshot);
     ASSERT_GE(session->frames.size(), 2u);
-    EXPECT_NE(session->frames[0].snapshot->render_plan_version,
+    EXPECT_EQ(session->frames[0].snapshot->render_plan_version,
               session->frames[1].snapshot->render_plan_version);
     for (const auto& frame : session->frames) {
         ASSERT_TRUE(frame.snapshot);

Kernel/tests/renderive/scene/Scene3D_Context_Test.cpp

@@ -96,6 +96,7 @@ struct Scene3D_Playback_Snapshot_Test_Scene final
         auto frame = frame_control.acquire_renderer();
         ASSERT_TRUE(frame);
         render(*frame);
+        wait_for_render();
     }
 
     Node_Execution_Result render_scene(

Kernel/tests/renderive/scene/base/Scene_Base_Test.cpp

@@ -130,7 +130,7 @@ TEST(scene_base_test, attach_builder_can_build_complete_initial_topology) {
 TEST(scene_base_test, attach_builder_rejects_null_renderable) {
     Scene2D_Context<> scene;
     auto builder = scene.attach_builder();
-    EXPECT_THROW(builder.attach({}), std::invalid_argument);
+    EXPECT_EQ(builder.attach({}), Scene_Edit_Error::null_renderable);
 }
 TEST(scene_base_test, one_runtime_callback_attaches_multiple_renderables) {
     Scene2D_Context<> scene;
@@ -269,7 +269,7 @@ TEST(scene_base_test, detached_renderable_cannot_migrate_to_another_scene) {
     });
     EXPECT_EQ(first_scene.renderable_count(), 0u);
     auto builder = second_scene.attach_builder();
-    EXPECT_THROW(builder.attach(renderable), std::invalid_argument);
+    EXPECT_EQ(builder.attach(renderable), Scene_Edit_Error::foreign_renderable);
 }
 TEST(scene_base_test, dependency_edit_invalidates_cached_child_prepare) {
     Scene2D_Context<> scene;
@@ -476,9 +476,18 @@ TEST(scene_base_test, invalid_runtime_edit_rolls_back_complete_topology) {
     EXPECT_EQ(restored.renderables, topology.renderables);
     EXPECT_EQ(restored.display.size(), topology.display.size());
     ASSERT_EQ(restored.dependency.size(), topology.dependency.size());
-    ASSERT_EQ(restored.dependency.size(), 1u);
-    EXPECT_EQ(restored.dependency[0].child, topology.dependency[0].child);
-    EXPECT_EQ(restored.dependency[0].parent, topology.dependency[0].parent);
+    const auto restored_edge = std::ranges::find_if(
+        restored.dependency, [](const auto& relationship) {
+            return static_cast<bool>(relationship.parent);
+        });
+    const auto original_edge = std::ranges::find_if(
+        topology.dependency, [](const auto& relationship) {
+            return static_cast<bool>(relationship.parent);
+        });
+    ASSERT_NE(restored_edge, restored.dependency.end());
+    ASSERT_NE(original_edge, topology.dependency.end());
+    EXPECT_EQ(restored_edge->child, original_edge->child);
+    EXPECT_EQ(restored_edge->parent, original_edge->parent);
     scene.render();
     EXPECT_NO_THROW(scene.wait_for_render());
     EXPECT_EQ(parent->render_count, 1);

Kernel/tests/renderive/threading/Threading_Contract_Test.cpp

@@ -214,7 +214,7 @@ TEST(threading_contract_test, manual_strategy_keeps_frames_consistent_during_con
     std::thread refresher([&] {
         wait_start(start);
         for (;;) {
-            strategy.refresh();
+            static_cast<void>(strategy.refresh());
             const auto state = strategy.state();
             if (producers_done.load(std::memory_order_acquire) == producer_count && !state.pending_frame) {
                 break;