Improve Phlex test coverage

phlex/model/identifier.hpp

@@ -57,6 +57,14 @@ namespace phlex::experimental {
   inline std::string_view format_as(identifier const& id) { return std::string_view(id); }
 }
 
+template <>
+struct fmt::formatter<phlex::experimental::identifier> : formatter<std::string_view> {
+  auto format(phlex::experimental::identifier const& id, format_context& ctx) const
+  {
+    return formatter<std::string_view>::format(std::string_view(id), ctx);
+  }
+};
+
 template <>
 struct std::hash<phlex::experimental::identifier> {
   std::size_t operator()(phlex::experimental::identifier const& id) const noexcept

test/CMakeLists.txt

@@ -204,6 +204,10 @@ cet_test(
 cet_test(product_query USE_CATCH2_MAIN SOURCE product_query.cpp LIBRARIES
          phlex::core
 )
+cet_test(core_misc_test USE_CATCH2_MAIN SOURCE core_misc_test.cpp LIBRARIES
+         phlex::core
+         Boost::json
+)
 cet_test(
   provider_test
   USE_CATCH2_MAIN

test/core_misc_test.cpp

@@ -0,0 +1,107 @@
+#include "phlex/configuration.hpp"
+#include "phlex/core/consumer.hpp"
+#include "phlex/core/glue.hpp"
+#include "phlex/core/registrar.hpp"
+#include "phlex/model/algorithm_name.hpp"
+#include <catch2/catch_test_macros.hpp>
+
+#include <boost/json.hpp>
+#include <stdexcept>
+#include <string>
+#include <vector>
+
+TEST_CASE("algorithm_name tests", "[model]")
+{
+  using namespace phlex::experimental;
+
+  SECTION("Default constructor")
+  {
+    algorithm_name an;
+    CHECK(an.full() == "");
+  }
+  SECTION("Create from string with colon")
+  {
+    auto an = algorithm_name::create("plugin:algo");
+    CHECK(an.full() == "plugin:algo");
+  }
+  SECTION("Create from string without colon")
+  {
+    auto an = algorithm_name::create("algo");
+    // For 'either' cases, the first word is stored as plugin_
+    CHECK(an.full() == "algo:");
+  }
+  SECTION("Create from char pointer")
+  {
+    auto an = algorithm_name::create("ptr:algo");
+    CHECK(an.full() == "ptr:algo");
+  }
+  SECTION("Create error - trailing colon")
+  {
+    CHECK_THROWS_AS(algorithm_name::create("plugin:"), std::runtime_error);
+  }
+  SECTION("Match neither")
+  {
+    algorithm_name an = algorithm_name::create("p:a");
+    algorithm_name other; // neither
+    CHECK(an.match(other));
+  }
+  SECTION("Match either")
+  {
+    algorithm_name an = algorithm_name::create("p:a");
+    CHECK(an.match(algorithm_name::create("p")));
+    CHECK(an.match(algorithm_name::create("a")));
+  }
+  SECTION("Match both")
+  {
+    algorithm_name an = algorithm_name::create("p:a");
+    CHECK(an.match(algorithm_name::create("p:a")));
+    CHECK_FALSE(an.match(algorithm_name::create("p:b")));
+  }
+}
+
+TEST_CASE("consumer tests", "[core]")
+{
+  using namespace phlex::experimental;
+  algorithm_name an = algorithm_name::create("p:a");
+  consumer c(an, {"pred1"});
+
+  CHECK(c.full_name() == "p:a");
+  CHECK(c.plugin() == "p");
+  CHECK(c.algorithm() == "a");
+  CHECK(c.when().size() == 1);
+}
+
+TEST_CASE("verify_name tests", "[core]")
+{
+  using namespace phlex::experimental::detail;
+
+  SECTION("non-empty name does nothing") { CHECK_NOTHROW(verify_name("valid_name", nullptr)); }
+
+  SECTION("empty name throws") { CHECK_THROWS_AS(verify_name("", nullptr), std::runtime_error); }
+
+  SECTION("empty name with config includes module label")
+  {
+    boost::json::object obj;
+    obj["module_label"] = "my_module";
+    phlex::configuration config{obj};
+
+    try {
+      verify_name("", &config);
+      FAIL("Should have thrown");
+    } catch (std::runtime_error const& e) {
+      std::string msg = e.what();
+      CHECK(msg.find("my_module") != std::string::npos);
+    }
+  }
+}
+
+TEST_CASE("add_to_error_messages tests", "[core]")
+{
+  using namespace phlex::experimental::detail;
+
+  std::vector<std::string> errors;
+  add_to_error_messages(errors, "duplicate_node");
+
+  REQUIRE(errors.size() == 1);
+  CHECK(errors[0].find("duplicate_node") != std::string::npos);
+}

test/data_cell_index.cpp

@@ -23,3 +23,50 @@ TEST_CASE("Verify independent hashes", "[data model]")
   CHECK(event_760->hash() != event_4999->hash());
   CHECK(event_760->layer_hash() == event_4999->layer_hash());
 }
+
+TEST_CASE("data_cell_index methods", "[data model]")
+{
+  auto base = data_cell_index::base_ptr();
+  auto run0 = base->make_child(0, "run");
+  auto run1 = base->make_child(1, "run");
+
+  SECTION("Comparisons")
+  {
+    CHECK(*run0 < *run1);
+    CHECK_FALSE(*run1 < *run0);
+    CHECK_FALSE(*run0 < *run0);
+
+    auto subrun0 = run0->make_child(0, "subrun");
+    auto subrun1 = run0->make_child(1, "subrun");
+    CHECK(*subrun0 < *subrun1);
+    CHECK(*run0 < *subrun0);
+  }
+
+  SECTION("to_string")
+  {
+    auto subrun = run0->make_child(5, "subrun");
+    CHECK(subrun->to_string() == "[run:0, subrun:5]");
+    CHECK(base->to_string() == "[]");
+
+    auto nameless = base->make_child(10, "");
+    CHECK(nameless->to_string() == "[10]");
+  }
+
+  SECTION("Parent lookup")
+  {
+    auto subrun = run0->make_child(5, "subrun");
+    auto event = subrun->make_child(100, "event");
+
+    CHECK(event->parent("subrun") == subrun);
+    CHECK(event->parent("run") == run0);
+    CHECK(event->parent("nonexistent") == nullptr);
+  }
+
+  SECTION("Layer path")
+  {
+    auto subrun = run0->make_child(5, "subrun");
+    CHECK(subrun->layer_path() == "/job/run/subrun");
+  }
+
+  SECTION("Base access") { CHECK(&data_cell_index::base() == data_cell_index::base_ptr().get()); }
+}

test/identifier.cpp

@@ -65,5 +65,15 @@ int main()
     }
   }
   assert(ok);
+
+  // Additional coverage for identifier edge cases
+  identifier id1("abc");
+  identifier id2("def");
+  assert(id1 == id1);
+  assert(id1 != id2);
+  assert(id1 < id2 || id2 < id1);
+  assert(id1 <= id1);
+  assert(id1 >= id1);
+
   return 0;
 }