🎨 Separate flow tests

Problem:
- Flow tests are all in one file. They mix together the tests for regular flows,
  logging, and flows in separate translation units.
- GCC 12 has a constexpr bug that prevents flow steps from compiling. This is
  worked around in code, but ought to be called out in CMake.

Solution:
- Separate regular, separate TU, and logging tests for flows.
- Control GCC 12 compilation in CMake.

Author: elbeno

include/flow/step.hpp

@@ -51,7 +51,7 @@ struct ct_node : rt_node {
         }
     };
 
-    constexpr ct_node() : rt_node{run_func, log_func} {}
+    constexpr ct_node() : rt_node{+run_func, +log_func} {}
 
     constexpr auto operator*() const {
         if constexpr (Identity == subgraph_identity::REFERENCE) {

test/flow/CMakeLists.txt

@@ -1,12 +1,22 @@
-add_unit_test(
-    "flow_flow_test"
-    CATCH2
-    FILES
-    "flow.cpp"
-    "flow_cib_func.cpp"
-    LIBRARIES
-    warnings
-    cib)
+if(${CMAKE_CXX_COMPILER_ID} STREQUAL "GNU" AND ${CMAKE_CXX_COMPILER_VERSION}
+                                               VERSION_LESS 13)
+    message(
+        WARNING
+            "GCC has a constexpr bug before version 13 that prevents flow steps from compiling. Not adding flow tests."
+    )
+else()
+    add_unit_test(
+        "flow_separate_actions_test"
+        CATCH2
+        FILES
+        "flow_cib_func.cpp"
+        "separate_actions.cpp"
+        LIBRARIES
+        warnings
+        cib)
+
+    add_tests(flow logging)
+endif()
 
 add_tests(graph graph_builder)
 

test/flow/flow.cpp

@@ -6,16 +6,14 @@
 
 #include <catch2/catch_test_macros.hpp>
 
-#include <iterator>
 #include <string>
+#include <string_view>
 
 std::string actual = {};
 
 namespace {
 using namespace flow::literals;
 
-std::string log_buffer{};
-
 constexpr auto a = flow::action<"a">([] { actual += "a"; });
 constexpr auto b = flow::action<"b">([] { actual += "b"; });
 constexpr auto c = flow::action<"c">([] { actual += "c"; });
@@ -38,7 +36,6 @@ template <auto... Cs> struct wrapper {
 template <typename S, auto... Cs>
 constexpr auto check_flow = [](std::string_view expected) -> void {
     actual.clear();
-    log_buffer.clear();
     wrapper<Cs...>::template run<S>();
     CHECK(actual == expected);
 };
@@ -65,7 +62,7 @@ struct VizConfig {
 };
 } // namespace
 
-TEST_CASE("vizualize flow", "[flow]") {
+TEST_CASE("visualize flow", "[flow]") {
     cib::nexus<VizConfig> nexus{};
     auto viz = nexus.service<VizFlow>();
     auto expected = std::string{
@@ -76,9 +73,6 @@ a -> end
     CHECK(viz == expected);
 }
 
-#if defined(__GNUC__) && __GNUC__ == 12
-#else
-
 TEST_CASE("add single action through cib::nexus", "[flow]") {
     check_flow<TestFlowAlpha, cib::exports<TestFlowAlpha>,
                cib::extend<TestFlowAlpha>(*a)>("a");
@@ -198,52 +192,3 @@ TEST_CASE("add multi action through cib::nexus, run through cib::service",
     cib::service<TestFlowBeta>();
     CHECK(actual == "abcd");
 }
-
-TEST_CASE("add actions using func_decl through cib::nexus", "[flow]") {
-    check_flow<TestFlowAlpha, cib::exports<TestFlowAlpha>,
-               cib::extend<TestFlowAlpha>(*"e"_action >> *"f"_action)>("ef");
-}
-
-namespace {
-struct NamedTestFlow : public flow::service<"TestFlow"> {};
-} // namespace
-
-template <>
-inline auto logging::config<> =
-    logging::fmt::config{std::back_inserter(log_buffer)};
-
-TEST_CASE("unnamed flow does not log start/end", "[flow]") {
-    check_flow<TestFlowAlpha, cib::exports<TestFlowAlpha>>("");
-
-    CHECK(std::empty(log_buffer));
-}
-
-TEST_CASE("empty flow logs start/end", "[flow]") {
-    check_flow<NamedTestFlow, cib::exports<NamedTestFlow>>("");
-
-    CHECK(log_buffer.find("flow.start(TestFlow)") != std::string::npos);
-    CHECK(log_buffer.find("flow.end(TestFlow)") != std::string::npos);
-}
-
-TEST_CASE("unnamed flow does not log actions", "[flow]") {
-    check_flow<TestFlowAlpha, cib::exports<TestFlowAlpha>,
-               cib::extend<TestFlowAlpha>(*a)>("a");
-
-    CHECK(log_buffer.find("flow.action(a)") == std::string::npos);
-}
-
-TEST_CASE("named flow logs actions", "[flow]") {
-    check_flow<NamedTestFlow, cib::exports<NamedTestFlow>,
-               cib::extend<NamedTestFlow>(*a)>("a");
-
-    CHECK(log_buffer.find("flow.action(a)") != std::string::npos);
-}
-
-TEST_CASE("named flow logs milestones", "[flow]") {
-    check_flow<NamedTestFlow, cib::exports<NamedTestFlow>,
-               cib::extend<NamedTestFlow>(*"ms"_milestone)>("");
-
-    CHECK(log_buffer.find("flow.milestone(ms)") != std::string::npos);
-}
-
-#endif

test/flow/logging.cpp

@@ -0,0 +1,74 @@
+#include <cib/cib.hpp>
+#include <flow/flow.hpp>
+#include <log/fmt/logger.hpp>
+
+#include <catch2/catch_test_macros.hpp>
+
+#include <iterator>
+#include <string>
+
+namespace {
+using namespace flow::literals;
+
+std::string log_buffer{};
+
+template <auto... Cs> struct wrapper {
+    struct inner {
+        constexpr static auto config = cib::config(Cs...);
+    };
+    constexpr static auto n = cib::nexus<inner>{};
+
+    wrapper() { n.init(); }
+
+    template <typename S> static auto run() -> void { n.template service<S>(); }
+};
+
+template <typename S, auto... Cs>
+constexpr auto run_flow = [] {
+    log_buffer.clear();
+    wrapper<Cs...>::template run<S>();
+};
+
+struct TestFlowAlpha : public flow::service<> {};
+struct NamedTestFlow : public flow::service<"TestFlow"> {};
+
+constexpr auto a = flow::action<"a">([] {});
+} // namespace
+
+template <>
+inline auto logging::config<> =
+    logging::fmt::config{std::back_inserter(log_buffer)};
+
+TEST_CASE("unnamed flow does not log start/end", "[flow_logging]") {
+    run_flow<TestFlowAlpha, cib::exports<TestFlowAlpha>>();
+
+    CHECK(std::empty(log_buffer));
+}
+
+TEST_CASE("empty flow logs start/end", "[flow_logging]") {
+    run_flow<NamedTestFlow, cib::exports<NamedTestFlow>>();
+
+    CHECK(log_buffer.find("flow.start(TestFlow)") != std::string::npos);
+    CHECK(log_buffer.find("flow.end(TestFlow)") != std::string::npos);
+}
+
+TEST_CASE("unnamed flow does not log actions", "[flow_logging]") {
+    run_flow<TestFlowAlpha, cib::exports<TestFlowAlpha>,
+             cib::extend<TestFlowAlpha>(*a)>();
+
+    CHECK(log_buffer.find("flow.action(a)") == std::string::npos);
+}
+
+TEST_CASE("named flow logs actions", "[flow_logging]") {
+    run_flow<NamedTestFlow, cib::exports<NamedTestFlow>,
+             cib::extend<NamedTestFlow>(*a)>();
+
+    CHECK(log_buffer.find("flow.action(a)") != std::string::npos);
+}
+
+TEST_CASE("named flow logs milestones", "[flow_logging]") {
+    run_flow<NamedTestFlow, cib::exports<NamedTestFlow>,
+             cib::extend<NamedTestFlow>(*"ms"_milestone)>();
+
+    CHECK(log_buffer.find("flow.milestone(ms)") != std::string::npos);
+}

test/flow/separate_actions.cpp

@@ -0,0 +1,39 @@
+#include <cib/cib.hpp>
+#include <flow/flow.hpp>
+
+#include <catch2/catch_test_macros.hpp>
+
+#include <string>
+#include <string_view>
+
+std::string actual = {};
+
+namespace {
+using namespace flow::literals;
+
+struct TestFlowAlpha : public flow::service<> {};
+
+template <auto... Cs> struct wrapper {
+    struct inner {
+        constexpr static auto config = cib::config(Cs...);
+    };
+    constexpr static auto n = cib::nexus<inner>{};
+
+    wrapper() { n.init(); }
+
+    template <typename S> static auto run() -> void { n.template service<S>(); }
+};
+
+template <typename S, auto... Cs>
+constexpr auto check_flow = [](std::string_view expected) -> void {
+    actual.clear();
+    wrapper<Cs...>::template run<S>();
+    CHECK(actual == expected);
+};
+} // namespace
+
+TEST_CASE("add actions using func_decl through cib::nexus",
+          "[flow_separate_actions]") {
+    check_flow<TestFlowAlpha, cib::exports<TestFlowAlpha>,
+               cib::extend<TestFlowAlpha>(*"e"_action >> *"f"_action)>("ef");
+}