WIP

src/class_diagram/generators/json/class_diagram_generator.cc

@@ -76,6 +76,8 @@ void to_json(nlohmann::json &j, const class_method &c)
     j["is_move_assignment"] = c.is_move_assignment();
     j["is_copy_assignment"] = c.is_copy_assignment();
     j["is_operator"] = c.is_operator();
+    j["template_parameters"] = c.template_params();
+    j["display_name"] = c.display_name();
 
     j["parameters"] = c.parameters();
 }
@@ -156,7 +158,10 @@ void generator::generate_top_level_elements(nlohmann::json &parent) const
 {
     for (const auto &p : model()) {
         if (auto *pkg = dynamic_cast<package *>(p.get()); pkg) {
-            if (!pkg->is_empty())
+            if (!pkg->is_empty() &&
+                !pkg->all_of([this](const common::model::element &e) {
+                    return !model().should_include(e);
+                }))
                 generate(*pkg, parent);
         }
         else if (auto *cls = dynamic_cast<class_ *>(p.get()); cls) {
@@ -198,7 +203,10 @@ void generator::generate(const package &p, nlohmann::json &parent) const
     for (const auto &subpackage : p) {
         if (dynamic_cast<package *>(subpackage.get()) != nullptr) {
             const auto &sp = dynamic_cast<package &>(*subpackage);
-            if (!sp.is_empty()) {
+            if (!sp.is_empty() &&
+                !sp.all_of([this](const common::model::element &e) {
+                    return !model().should_include(e);
+                })) {
                 if (config().generate_packages())
                     generate(sp, package_object);
                 else
@@ -282,6 +290,9 @@ void generator::generate_relationships(
     const class_ &c, nlohmann::json &parent) const
 {
     for (const auto &r : c.relationships()) {
+        if (!model().should_include(r))
+            continue;
+
         auto target_element = model().get(r.destination());
         if (!target_element.has_value()) {
             LOG_DBG("Skipping {} relation from {} to {} due "
@@ -310,6 +321,9 @@ void generator::generate_relationships(
     const enum_ &c, nlohmann::json &parent) const
 {
     for (const auto &r : c.relationships()) {
+        if (!model().should_include(r))
+            continue;
+
         auto target_element = model().get(r.destination());
         if (!target_element.has_value()) {
             LOG_DBG("Skipping {} relation from {} to {} due "
@@ -328,6 +342,9 @@ void generator::generate_relationships(
     const concept_ &c, nlohmann::json &parent) const
 {
     for (const auto &r : c.relationships()) {
+        if (!model().should_include(r))
+            continue;
+
         auto target_element = model().get(r.destination());
         if (!target_element.has_value()) {
             LOG_DBG("Skipping {} relation from {} to {} due "

src/class_diagram/generators/mermaid/class_diagram_generator.cc

@@ -281,8 +281,7 @@ void generator::generate_member(
 
 void generator::generate(const concept_ &c, std::ostream &ostr) const
 {
-    ostr << indent(1) << "class"
+    ostr << indent(1) << "class" << " " << c.alias();
-         << " " << c.alias();
 
     ostr << " {" << '\n';
     ostr << indent(2) << "<<concept>>\n";

src/class_diagram/model/class_method.cc

@@ -26,6 +26,26 @@ class_method::class_method(common::model::access_t access,
 {
 }
 
+void class_method::update(const common::model::namespace_ &un)
+{
+    if (template_params().empty()) {
+        set_display_name(name());
+    }
+    else {
+        std::stringstream template_params_str;
+        render_template_params(template_params_str, un, true);
+        set_display_name(
+            fmt::format("{}{}", name(), template_params_str.str()));
+    }
+}
+
+std::string class_method::display_name() const { return display_name_; }
+
+void class_method::set_display_name(const std::string &display_name)
+{
+    display_name_ = display_name;
+}
+
 bool class_method::is_pure_virtual() const { return is_pure_virtual_; }
 
 void class_method::is_pure_virtual(bool is_pure_virtual)

src/class_diagram/model/class_method.h

@@ -46,6 +46,17 @@ public:
 
     ~class_method() override = default;
 
+    void update(const common::model::namespace_& un);
+
+    /**
+     * @brief Method name including template parameters/arguments if any
+     *
+     * @return String representation of the methods display name
+     */
+    std::string display_name() const;
+
+    void set_display_name(const std::string &display_name);
+
     /**
      * @brief Whether the method is pure virtual.
      *
@@ -282,5 +293,7 @@ private:
     bool is_move_assignment_{false};
     bool is_copy_assignment_{false};
     bool is_operator_{false};
+
+    std::string display_name_;
 };
 } // namespace clanguml::class_diagram::model

src/class_diagram/visitor/translation_unit_visitor.cc

@@ -1187,7 +1187,8 @@ void translation_unit_visitor::process_method(
     }
 
     class_method method{common::access_specifier_to_access_t(mf.getAccess()),
-        util::trim(method_name), method_return_type};
+        util::trim(method_name),
+        config().simplify_template_type(method_return_type)};
 
     process_method_properties(mf, c, method_name, method);
 
@@ -1266,6 +1267,8 @@ void translation_unit_visitor::process_method(
         process_function_parameter_find_relationships_in_autotype(c, atsp);
     }
 
+    method.update(config().using_namespace());
+
     if (diagram().should_include(method)) {
         LOG_DBG("Adding method: {}", method.name());
 
@@ -1390,6 +1393,8 @@ void translation_unit_visitor::process_template_method(
             process_function_parameter(*param, method, c);
     }
 
+    method.update(config().using_namespace());
+
     if (diagram().should_include(method)) {
         LOG_DBG("Adding method: {}", method.name());
 
@@ -1678,7 +1683,9 @@ void translation_unit_visitor::process_static_field(
 
     class_member field{
         common::access_specifier_to_access_t(field_declaration.getAccess()),
-        field_declaration.getNameAsString(), type_name};
+        field_declaration.getNameAsString(),
+        config().simplify_template_type(type_name)};
+
     field.is_static(true);
 
     process_comment(field_declaration, field);
@@ -1769,7 +1776,7 @@ void translation_unit_visitor::process_field(
 
     class_member field{
         common::access_specifier_to_access_t(field_declaration.getAccess()),
-        field_name, field_type_str};
+        field_name, config().simplify_template_type(field_type_str)};
 
     // Parse the field comment
     process_comment(field_declaration, field);

src/common/model/diagram.cc

@@ -78,6 +78,11 @@ bool diagram::should_include(const namespace_ &ns) const
     return filter_->should_include(ns);
 }
 
+bool diagram::should_include(relationship r) const
+{
+    return should_include(r.type());
+}
+
 bool diagram::should_include(const relationship_t r) const
 {
     if (filter_.get() == nullptr)

tests/CMakeLists.txt

@@ -102,7 +102,7 @@ foreach(TEST_NAME ${TEST_NAMES})
             target_sources(${TEST_NAME} PUBLIC FILE_SET CXX_MODULES FILES
                            ${TEST_CASE_MODULE_SOURCES})
         endif(ENABLE_CXX_MODULES_TEST_CASES)
-        target_sources(${TEST_NAME} PUBLIC ${TEST_NAME}.cc test_cases_checks.h
+        target_sources(${TEST_NAME} PUBLIC ${TEST_NAME}.cc
                                            ${TEST_CASE_SOURCES} catch.h)
     else()
         target_sources(${TEST_NAME} PUBLIC ${TEST_NAME}.cc catch.h)

tests/t00028/test_case.h

@@ -30,31 +30,39 @@ TEST_CASE("t00028")
 
     REQUIRE(model->name() == "t00028_class");
 
-    CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
+    CHECK_CLASS_DIAGRAM(
-        REQUIRE(IsClass(src, "A"));
+        config, diagram, *model,
-        REQUIRE(IsClass(src, "B"));
+        [](const auto &src) {
-        REQUIRE(IsClass(src, "C"));
+            REQUIRE(IsClass(src, "A"));
-        REQUIRE(IsClass(src, "D"));
+            REQUIRE(IsClass(src, "B"));
-        REQUIRE(IsClassTemplate(src, "E<T>"));
+            REQUIRE(IsClass(src, "C"));
-        REQUIRE(IsEnum(src, "F"));
+            REQUIRE(IsClass(src, "D"));
-        REQUIRE(IsClass(src, "R"));
+            REQUIRE(IsClassTemplate(src, "E<T>"));
-        REQUIRE(HasNote(src, "A", "top", "A class note."));
+            REQUIRE(IsEnum(src, "F"));
-        REQUIRE(HasNote(src, "B", "left", "B class note."));
+            REQUIRE(IsClass(src, "R"));
-        REQUIRE(HasNote(src, "C", "bottom", "C class note."));
+            REQUIRE(HasNote(src, "A", "top", "A class note."));
-        const auto d_note = R"(
+            REQUIRE(HasNote(src, "B", "left", "B class note."));
+            REQUIRE(HasNote(src, "C", "bottom", "C class note."));
+            const auto d_note = R"(
 D
 class
 note.)";
-        REQUIRE(HasNote(src, "D", "left", d_note));
+            REQUIRE(HasNote(src, "D", "left", d_note));
-        REQUIRE(HasNote(src, "E<T>", "left", "E template class note."));
+            REQUIRE(HasNote(src, "E<T>", "left", "E template class note."));
-        REQUIRE(HasNote(src, "F", "bottom", "F enum note."));
+            REQUIRE(HasNote(src, "F", "bottom", "F enum note."));
-        REQUIRE(!HasNote(src, "G", "left", "G class note."));
+            REQUIRE(HasNote(src, "R", "right", "R class note."));
-        REQUIRE(HasNote(src, "R", "right", "R class note."));
+        },
-        REQUIRE(HasMemberNote(
+        [](const plantuml_t &src) {
-            src, "R", "aaa", "left", "R contains an instance of A."));
+            REQUIRE(HasMemberNote(src, "R", "ccc", "left", "Reference to C."));
-        REQUIRE(!HasMemberNote(src, "R", "bbb", "right", "R class note."));
+            REQUIRE(!HasMemberNote(src, "R", "bbb", "right", "R class note."));
-        REQUIRE(HasMemberNote(src, "R", "ccc", "left", "Reference to C."));
+            REQUIRE(HasMemberNote(
-    });
+                src, "R", "aaa", "left", "R contains an instance of A."));
+            REQUIRE(!HasNote(src, "G", "left", "G class note."));
+        },
+        [](const mermaid_t &src) {
+            REQUIRE(HasNote(src, "R", "left", "R contains an instance of A."));
+            REQUIRE(!HasNote(src, "G", "left", "G class note."));
+        });
     /*
         {
             auto src = generate_class_puml(diagram, *model);

tests/t00031/test_case.h

@@ -1,5 +1,5 @@
 /**
- * tests/t00031/test_case.cc
+ * tests/t00031/test_case.h
  *
  * Copyright (c) 2021-2024 Bartek Kryza <bkryza@gmail.com>
  *
@@ -16,8 +16,10 @@
  * limitations under the License.
  */
 
-TEST_CASE("t00031", "[test-case][class]")
+TEST_CASE("t00031")
 {
+    using namespace clanguml::test;
+
     auto [config, db] = load_config("t00031");
 
     auto diagram = config.diagrams["t00031_class"];
@@ -28,55 +30,20 @@ TEST_CASE("t00031", "[test-case][class]")
 
     REQUIRE(model->name() == "t00031_class");
 
-    {
+    CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
-        auto src = generate_class_puml(diagram, *model);
+        REQUIRE(IsClass(src, "A"));
-        AliasMatcher _A(src);
+        REQUIRE(IsEnum(src, "B"));
+        REQUIRE(IsClass(src, "D"));
+        REQUIRE(IsClassTemplate(src, "C<T>"));
 
-        REQUIRE_THAT(src, StartsWith("@startuml"));
+        REQUIRE(IsAssociation<Public>(
-        REQUIRE_THAT(src, EndsWith("@enduml\n"));
+            src, "R", "A", "aaa", "", "", "[#red,dashed,thickness=2]"));
-
+        REQUIRE(IsComposition<Public>(
-        REQUIRE_THAT(src, IsClass(_A("A")));
+            src, "R", "B", "bbb", "", "", "[#green,dashed,thickness=4]"));
-        REQUIRE_THAT(src, IsEnum(_A("B")));
+        REQUIRE(IsDependency(src, "R", "B"));
-        REQUIRE_THAT(src, IsClassTemplate("C", "T"));
+        REQUIRE(IsAggregation<Public>(
-        REQUIRE_THAT(src, IsClass(_A("D")));
+            src, "R", "C<int>", "ccc", "", "", "[#blue,dotted,thickness=8]"));
-
+        REQUIRE(IsAssociation<Public>(
-        REQUIRE_THAT(src,
+            src, "R", "D", "ddd", "", "", "[#blue,plain,thickness=16]"));
-            IsAssociation(
+    });
-                _A("R"), _A("A"), "+aaa", "", "", "[#red,dashed,thickness=2]"));
-        REQUIRE_THAT(src,
-            IsComposition(_A("R"), _A("B"), "+bbb", "", "",
-                "[#green,dashed,thickness=4]"));
-        REQUIRE_THAT(src, IsDependency(_A("R"), _A("B")));
-        REQUIRE_THAT(src,
-            IsAggregation(_A("R"), _A("C<int>"), "+ccc", "", "",
-                "[#blue,dotted,thickness=8]"));
-        REQUIRE_THAT(src,
-            IsAssociation(_A("R"), _A("D"), "+ddd", "", "",
-                "[#blue,plain,thickness=16]"));
-
-        save_puml(config.output_directory(), diagram->name + ".puml", src);
-    }
-    {
-        auto j = generate_class_json(diagram, *model);
-
-        using namespace json;
-
-        REQUIRE(IsClass(j, "A"));
-        REQUIRE(IsClassTemplate(j, "C<T>"));
-
-        save_json(config.output_directory(), diagram->name + ".json", j);
-    }
-    {
-        auto src = generate_class_mermaid(diagram, *model);
-
-        mermaid::AliasMatcher _A(src);
-        using mermaid::IsEnum;
-
-        REQUIRE_THAT(src, IsClass(_A("A")));
-        REQUIRE_THAT(src, IsEnum(_A("B")));
-        REQUIRE_THAT(src, IsClass(_A("C<T>")));
-        REQUIRE_THAT(src, IsClass(_A("D")));
-
-        save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
-    }
 }

tests/t00032/test_case.h

@@ -1,5 +1,5 @@
 /**
- * tests/t00032/test_case.cc
+ * tests/t00032/test_case.h
  *
  * Copyright (c) 2021-2024 Bartek Kryza <bkryza@gmail.com>
  *
@@ -16,8 +16,10 @@
  * limitations under the License.
  */
 
-TEST_CASE("t00032", "[test-case][class]")
+TEST_CASE("t00032")
 {
+    using namespace clanguml::test;
+
     auto [config, db] = load_config("t00032");
 
     auto diagram = config.diagrams["t00032_class"];
@@ -28,83 +30,24 @@ TEST_CASE("t00032", "[test-case][class]")
 
     REQUIRE(model->name() == "t00032_class");
 
-    {
+    CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
-        auto src = generate_class_puml(diagram, *model);
+        REQUIRE(IsClass(src, "Base"));
-        AliasMatcher _A(src);
+        REQUIRE(IsClass(src, "TBase"));
+        REQUIRE(IsClass(src, "A"));
+        REQUIRE(IsClass(src, "B"));
+        REQUIRE(IsClass(src, "C"));
+        REQUIRE(IsClass(src, "R"));
 
-        REQUIRE_THAT(src, StartsWith("@startuml"));
+        REQUIRE(IsClassTemplate(src, "Overload<T,L,Ts...>"));
-        REQUIRE_THAT(src, EndsWith("@enduml\n"));
 
-        REQUIRE_THAT(src, IsClass(_A("Base")));
+        REQUIRE(IsBaseClass(src, "Base", "Overload<T,L,Ts...>"));
-        REQUIRE_THAT(src, IsClass(_A("TBase")));
+        REQUIRE(IsBaseClass(src, "TBase", "Overload<TBase,int,A,B,C>"));
-        REQUIRE_THAT(src, IsClass(_A("A")));
+        REQUIRE(IsBaseClass(src, "A", "Overload<TBase,int,A,B,C>"));
-        REQUIRE_THAT(src, IsClass(_A("B")));
+        REQUIRE(IsBaseClass(src, "B", "Overload<TBase,int,A,B,C>"));
-        REQUIRE_THAT(src, IsClass(_A("C")));
+        REQUIRE(IsBaseClass(src, "C", "Overload<TBase,int,A,B,C>"));
-        REQUIRE_THAT(src, IsClass(_A("R")));
+        REQUIRE(!IsDependency(src, "Overload<TBase,int,A,B,C>", "TBase"));
-
+        REQUIRE(!IsDependency(src, "Overload<TBase,int,A,B,C>", "A"));
-        REQUIRE_THAT(src, IsClassTemplate("Overload", "T,L,Ts..."));
+        REQUIRE(!IsDependency(src, "Overload<TBase,int,A,B,C>", "B"));
-
+        REQUIRE(!IsDependency(src, "Overload<TBase,int,A,B,C>", "C"));
-        REQUIRE_THAT(src, IsBaseClass(_A("Base"), _A("Overload<T,L,Ts...>")));
+    });
-        REQUIRE_THAT(
-            src, IsBaseClass(_A("TBase"), _A("Overload<TBase,int,A,B,C>")));
-        REQUIRE_THAT(
-            src, IsBaseClass(_A("A"), _A("Overload<TBase,int,A,B,C>")));
-        REQUIRE_THAT(
-            src, IsBaseClass(_A("B"), _A("Overload<TBase,int,A,B,C>")));
-        REQUIRE_THAT(
-            src, IsBaseClass(_A("C"), _A("Overload<TBase,int,A,B,C>")));
-        REQUIRE_THAT(
-            src, !IsDependency(_A("Overload<TBase,int,A,B,C>"), _A("TBase")));
-        REQUIRE_THAT(
-            src, !IsDependency(_A("Overload<TBase,int,A,B,C>"), _A("A")));
-        REQUIRE_THAT(
-            src, !IsDependency(_A("Overload<TBase,int,A,B,C>"), _A("B")));
-        REQUIRE_THAT(
-            src, !IsDependency(_A("Overload<TBase,int,A,B,C>"), _A("C")));
-
-        save_puml(config.output_directory(), diagram->name + ".puml", src);
-    }
-    {
-        auto j = generate_class_json(diagram, *model);
-
-        using namespace json;
-
-        REQUIRE(IsBaseClass(j, "A", "Overload<TBase,int,A,B,C>"));
-
-        save_json(config.output_directory(), diagram->name + ".json", j);
-    }
-    {
-        auto src = generate_class_mermaid(diagram, *model);
-
-        mermaid::AliasMatcher _A(src);
-
-        REQUIRE_THAT(src, IsClass(_A("Base")));
-        REQUIRE_THAT(src, IsClass(_A("TBase")));
-        REQUIRE_THAT(src, IsClass(_A("A")));
-        REQUIRE_THAT(src, IsClass(_A("B")));
-        REQUIRE_THAT(src, IsClass(_A("C")));
-        REQUIRE_THAT(src, IsClass(_A("R")));
-
-        REQUIRE_THAT(src, IsClass(_A("Overload<T,L,Ts...>")));
-
-        REQUIRE_THAT(src, IsBaseClass(_A("Base"), _A("Overload<T,L,Ts...>")));
-        REQUIRE_THAT(
-            src, IsBaseClass(_A("TBase"), _A("Overload<TBase,int,A,B,C>")));
-        REQUIRE_THAT(
-            src, IsBaseClass(_A("A"), _A("Overload<TBase,int,A,B,C>")));
-        REQUIRE_THAT(
-            src, IsBaseClass(_A("B"), _A("Overload<TBase,int,A,B,C>")));
-        REQUIRE_THAT(
-            src, IsBaseClass(_A("C"), _A("Overload<TBase,int,A,B,C>")));
-        REQUIRE_THAT(
-            src, !IsDependency(_A("Overload<TBase,int,A,B,C>"), _A("TBase")));
-        REQUIRE_THAT(
-            src, !IsDependency(_A("Overload<TBase,int,A,B,C>"), _A("A")));
-        REQUIRE_THAT(
-            src, !IsDependency(_A("Overload<TBase,int,A,B,C>"), _A("B")));
-        REQUIRE_THAT(
-            src, !IsDependency(_A("Overload<TBase,int,A,B,C>"), _A("C")));
-
-        save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
-    }
 }

tests/t00033/test_case.h

@@ -1,5 +1,5 @@
 /**
- * tests/t00033/test_case.cc
+ * tests/t00033/test_case.h
  *
  * Copyright (c) 2021-2024 Bartek Kryza <bkryza@gmail.com>
  *
@@ -16,8 +16,10 @@
  * limitations under the License.
  */
 
-TEST_CASE("t00033", "[test-case][class]")
+TEST_CASE("t00033")
 {
+    using namespace clanguml::test;
+
     auto [config, db] = load_config("t00033");
 
     auto diagram = config.diagrams["t00033_class"];
@@ -28,70 +30,21 @@ TEST_CASE("t00033", "[test-case][class]")
 
     REQUIRE(model->name() == "t00033_class");
 
-    {
+    CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
-        auto src = generate_class_puml(diagram, *model);
+        REQUIRE(IsClassTemplate(src, "A<T>"));
-        AliasMatcher _A(src);
+        REQUIRE(IsClassTemplate(src, "B<T>"));
+        REQUIRE(IsClassTemplate(src, "C<T>"));
+        REQUIRE(IsClass(src, "D"));
+        REQUIRE(IsClass(src, "R"));
 
-        REQUIRE_THAT(src, StartsWith("@startuml"));
-        REQUIRE_THAT(src, EndsWith("@enduml\n"));
-
-        REQUIRE_THAT(src, IsClassTemplate("A", "T"));
-        REQUIRE_THAT(src, IsClassTemplate("B", "T"));
-        REQUIRE_THAT(src, IsClassTemplate("C", "T"));
-        REQUIRE_THAT(src, IsClass(_A("D")));
-        REQUIRE_THAT(src, IsClass(_A("R")));
-
-        REQUIRE_THAT(src,
-            IsDependency(_A("A<B<std::unique_ptr<C<D>>>>"),
-                _A("B<std::unique_ptr<C<D>>>")));
-        REQUIRE_THAT(
-            src, IsDependency(_A("B<std::unique_ptr<C<D>>>"), _A("C<D>")));
-        REQUIRE_THAT(src, IsDependency(_A("C<D>"), _A("D")));
-
-        REQUIRE_THAT(src, IsInstantiation(_A("C<T>"), _A("C<D>"), "up"));
-        REQUIRE_THAT(src,
-            IsInstantiation(_A("B<T>"), _A("B<std::unique_ptr<C<D>>>"), "up"));
-        REQUIRE_THAT(src,
-            IsInstantiation(
-                _A("A<T>"), _A("A<B<std::unique_ptr<C<D>>>>"), "up"));
-
-        save_puml(config.output_directory(), diagram->name + ".puml", src);
-    }
-    {
-        auto j = generate_class_json(diagram, *model);
-
-        using namespace json;
-
-        REQUIRE(IsClass(j, "A<B<std::unique_ptr<C<D>>>>"));
         REQUIRE(IsDependency(
-            j, "A<B<std::unique_ptr<C<D>>>>", "B<std::unique_ptr<C<D>>>"));
+            src, "A<B<std::unique_ptr<C<D>>>>", "B<std::unique_ptr<C<D>>>"));
+        REQUIRE(IsDependency(src, "B<std::unique_ptr<C<D>>>", "C<D>"));
+        REQUIRE(IsDependency(src, "C<D>", "D"));
 
-        save_json(config.output_directory(), diagram->name + ".json", j);
+        REQUIRE(IsInstantiation(src, "C<T>", "C<D>", "up"));
-    }
+        REQUIRE(IsInstantiation(src, "B<T>", "B<std::unique_ptr<C<D>>>", "up"));
-    {
+        REQUIRE(
-        auto src = generate_class_mermaid(diagram, *model);
+            IsInstantiation(src, "A<T>", "A<B<std::unique_ptr<C<D>>>>", "up"));
-
+    });
-        mermaid::AliasMatcher _A(src);
-
-        REQUIRE_THAT(src, IsClass(_A("A<T>")));
-        REQUIRE_THAT(src, IsClass(_A("B<T>")));
-        REQUIRE_THAT(src, IsClass(_A("C<T>")));
-        REQUIRE_THAT(src, IsClass(_A("D")));
-        REQUIRE_THAT(src, IsClass(_A("R")));
-
-        REQUIRE_THAT(src,
-            IsDependency(_A("A<B<std::unique_ptr<C<D>>>>"),
-                _A("B<std::unique_ptr<C<D>>>")));
-        REQUIRE_THAT(
-            src, IsDependency(_A("B<std::unique_ptr<C<D>>>"), _A("C<D>")));
-        REQUIRE_THAT(src, IsDependency(_A("C<D>"), _A("D")));
-
-        REQUIRE_THAT(src, IsInstantiation(_A("C<T>"), _A("C<D>")));
-        REQUIRE_THAT(
-            src, IsInstantiation(_A("B<T>"), _A("B<std::unique_ptr<C<D>>>")));
-        REQUIRE_THAT(src,
-            IsInstantiation(_A("A<T>"), _A("A<B<std::unique_ptr<C<D>>>>")));
-
-        save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
-    }
 }

tests/t00034/test_case.h

@@ -1,5 +1,5 @@
 /**
- * tests/t00034/test_case.cc
+ * tests/t00034/test_case.h
  *
  * Copyright (c) 2021-2024 Bartek Kryza <bkryza@gmail.com>
  *
@@ -16,8 +16,10 @@
  * limitations under the License.
  */
 
-TEST_CASE("t00034", "[test-case][class]")
+TEST_CASE("t00034")
 {
+    using namespace clanguml::test;
+
     auto [config, db] = load_config("t00034");
 
     auto diagram = config.diagrams["t00034_class"];
@@ -28,52 +30,14 @@ TEST_CASE("t00034", "[test-case][class]")
 
     REQUIRE(model->name() == "t00034_class");
 
-    {
+    CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
-        auto src = generate_class_puml(diagram, *model);
+        REQUIRE(IsClassTemplate(src, "lift_void<T>"));
-        AliasMatcher _A(src);
+        REQUIRE(IsClassTemplate(src, "drop_void<T>"));
+        REQUIRE(IsClass(src, "Void"));
+        REQUIRE(IsClass(src, "A"));
+        REQUIRE(IsClass(src, "R"));
 
-        REQUIRE_THAT(src, StartsWith("@startuml"));
+        REQUIRE(IsInstantiation(src, "lift_void<T>", "lift_void<void>"));
-        REQUIRE_THAT(src, EndsWith("@enduml\n"));
+        REQUIRE(IsInstantiation(src, "drop_void<T>", "drop_void<Void>"));
-
+    });
-        REQUIRE_THAT(src, IsClassTemplate("lift_void", "T"));
-        REQUIRE_THAT(src, IsClassTemplate("drop_void", "T"));
-        REQUIRE_THAT(src, IsClass(_A("Void")));
-        REQUIRE_THAT(src, IsClass(_A("A")));
-        REQUIRE_THAT(src, IsClass(_A("R")));
-
-        REQUIRE_THAT(
-            src, IsInstantiation(_A("lift_void<T>"), _A("lift_void<void>")));
-        REQUIRE_THAT(
-            src, IsInstantiation(_A("drop_void<T>"), _A("drop_void<Void>")));
-
-        save_puml(config.output_directory(), diagram->name + ".puml", src);
-    }
-    {
-        auto j = generate_class_json(diagram, *model);
-
-        using namespace json;
-
-        REQUIRE(IsClass(j, "A"));
-        REQUIRE(IsClassTemplate(j, "lift_void<T>"));
-
-        save_json(config.output_directory(), diagram->name + ".json", j);
-    }
-    {
-        auto src = generate_class_mermaid(diagram, *model);
-
-        mermaid::AliasMatcher _A(src);
-
-        REQUIRE_THAT(src, IsClass(_A("lift_void<T>")));
-        REQUIRE_THAT(src, IsClass(_A("drop_void<T>")));
-        REQUIRE_THAT(src, IsClass(_A("Void")));
-        REQUIRE_THAT(src, IsClass(_A("A")));
-        REQUIRE_THAT(src, IsClass(_A("R")));
-
-        REQUIRE_THAT(
-            src, IsInstantiation(_A("lift_void<T>"), _A("lift_void<void>")));
-        REQUIRE_THAT(
-            src, IsInstantiation(_A("drop_void<T>"), _A("drop_void<Void>")));
-
-        save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
-    }
 }

tests/t00035/test_case.h

@@ -1,5 +1,5 @@
 /**
- * tests/t00035/test_case.cc
+ * tests/t00035/test_case.h
  *
  * Copyright (c) 2021-2024 Bartek Kryza <bkryza@gmail.com>
  *
@@ -16,8 +16,10 @@
  * limitations under the License.
  */
 
-TEST_CASE("t00035", "[test-case][class]")
+TEST_CASE("t00035")
 {
+    using namespace clanguml::test;
+
     auto [config, db] = load_config("t00035");
 
     auto diagram = config.diagrams["t00035_class"];
@@ -28,50 +30,16 @@ TEST_CASE("t00035", "[test-case][class]")
 
     REQUIRE(model->name() == "t00035_class");
 
-    {
+    CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
-        auto src = generate_class_puml(diagram, *model);
+        REQUIRE(IsClass(src, "Top"));
-        AliasMatcher _A(src);
+        REQUIRE(IsClass(src, "Bottom"));
+        REQUIRE(IsClass(src, "Center"));
+        REQUIRE(IsClass(src, "Left"));
+        REQUIRE(IsClass(src, "Right"));
 
-        REQUIRE_THAT(src, StartsWith("@startuml"));
+        REQUIRE(IsLayoutHint(src, "Center", "up", "Top"));
-        REQUIRE_THAT(src, EndsWith("@enduml\n"));
+        REQUIRE(IsLayoutHint(src, "Center", "left", "Left"));
-
+        REQUIRE(IsLayoutHint(src, "Center", "right", "Right"));
-        REQUIRE_THAT(src, IsClass(_A("Top")));
+        REQUIRE(IsLayoutHint(src, "Center", "down", "Bottom"));
-        REQUIRE_THAT(src, IsClass(_A("Bottom")));
+    });
-        REQUIRE_THAT(src, IsClass(_A("Center")));
-        REQUIRE_THAT(src, IsClass(_A("Left")));
-        REQUIRE_THAT(src, IsClass(_A("Right")));
-
-        REQUIRE_THAT(src, IsLayoutHint(_A("Center"), "up", _A("Top")));
-        REQUIRE_THAT(src, IsLayoutHint(_A("Center"), "left", _A("Left")));
-        REQUIRE_THAT(src, IsLayoutHint(_A("Center"), "right", _A("Right")));
-        REQUIRE_THAT(src, IsLayoutHint(_A("Center"), "down", _A("Bottom")));
-
-        save_puml(config.output_directory(), diagram->name + ".puml", src);
-    }
-    {
-        auto j = generate_class_json(diagram, *model);
-
-        using namespace json;
-
-        REQUIRE(IsClass(j, "Top"));
-        REQUIRE(IsClass(j, "Bottom"));
-        REQUIRE(IsClass(j, "Center"));
-        REQUIRE(IsClass(j, "Left"));
-        REQUIRE(IsClass(j, "Right"));
-
-        save_json(config.output_directory(), diagram->name + ".json", j);
-    }
-    {
-        auto src = generate_class_mermaid(diagram, *model);
-
-        mermaid::AliasMatcher _A(src);
-
-        REQUIRE_THAT(src, IsClass(_A("Top")));
-        REQUIRE_THAT(src, IsClass(_A("Bottom")));
-        REQUIRE_THAT(src, IsClass(_A("Center")));
-        REQUIRE_THAT(src, IsClass(_A("Left")));
-        REQUIRE_THAT(src, IsClass(_A("Right")));
-
-        save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
-    }
 }

tests/t00036/test_case.h

@@ -16,8 +16,11 @@
  * limitations under the License.
  */
 
-TEST_CASE("t00036", "[test-case][class]")
+TEST_CASE("t00036")
 {
+    using namespace clanguml::test;
+    using namespace std::string_literals;
+
     auto [config, db] = load_config("t00036");
 
     auto diagram = config.diagrams["t00036_class"];
@@ -29,66 +32,23 @@ TEST_CASE("t00036", "[test-case][class]")
 
     REQUIRE(model->name() == "t00036_class");
 
-    {
+    CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
-        auto src = generate_class_puml(diagram, *model);
+        REQUIRE(IsClassTemplate(src, {"ns1::ns11", "A<T>"}));
-        AliasMatcher _A(src);
+        REQUIRE(IsClassTemplate(src, {"ns1::ns11", "A<int>"}));
+        REQUIRE(IsClass(src, {"ns1::ns11::ns111", "B"}));
+        REQUIRE(IsClass(src, {"ns2::ns22", "C"}));
+        REQUIRE(IsEnum(src, {"ns1", "E"}));
 
-        REQUIRE_THAT(src, StartsWith("@startuml"));
+        REQUIRE(!IsClass(src, "DImpl"));
-        REQUIRE_THAT(src, EndsWith("@enduml\n"));
 
-        REQUIRE_THAT(src, IsClassTemplate("A", "T"));
+        REQUIRE(IsNamespacePackage(src, "ns1"s));
-        REQUIRE_THAT(src, IsClassTemplate("A", "int"));
+        REQUIRE(IsNamespacePackage(src, "ns1"s, "ns11"s));
-        REQUIRE_THAT(src, IsEnum(_A("E")));
+        REQUIRE(IsNamespacePackage(src, "ns1"s, "ns11"s, "ns111"s));
-        REQUIRE_THAT(src, IsClass(_A("B")));
+        REQUIRE(IsNamespacePackage(src, "ns2"s));
-        REQUIRE_THAT(src, IsClass(_A("C")));
+        REQUIRE(IsNamespacePackage(src, "ns2"s, "ns22"s));
-        REQUIRE_THAT(src, !IsClass(_A("DImpl")));
-        REQUIRE_THAT(src, IsPackage("ns111"));
-        REQUIRE_THAT(src, IsPackage("ns22"));
-        REQUIRE_THAT(src, !IsPackage("ns3"));
-        REQUIRE_THAT(src, !IsPackage("ns33"));
 
-        REQUIRE_THAT(src, IsAggregation(_A("B"), _A("A<int>"), "+a_int"));
+        REQUIRE(!IsNamespacePackage(src, "ns3"s));
-
+        REQUIRE(!IsNamespacePackage(src, "ns33"s));
-        save_puml(config.output_directory(), diagram->name + ".puml", src);
+        REQUIRE(!IsNamespacePackage(src, "ns3"s, "ns33"s));
-    }
+    });
-    {
-        auto j = generate_class_json(diagram, *model);
-
-        using namespace json;
-        using namespace std::string_literals;
-
-        REQUIRE(IsClass(j, "ns1::ns11::A<T>"));
-        REQUIRE(IsClass(j, "ns1::ns11::A<int>"));
-        REQUIRE(IsClass(j, "ns1::ns11::ns111::B"));
-        REQUIRE(IsClass(j, "ns2::ns22::C"));
-        REQUIRE(IsEnum(j, "ns1::E"));
-        REQUIRE(IsNamespacePackage(j, "ns1"s));
-        REQUIRE(IsNamespacePackage(j, "ns1"s, "ns11"s));
-        REQUIRE(IsNamespacePackage(j, "ns1"s, "ns11"s, "ns111"s));
-        REQUIRE(IsNamespacePackage(j, "ns2"s));
-        REQUIRE(IsNamespacePackage(j, "ns2"s, "ns22"s));
-        REQUIRE(IsNamespacePackage(j, "ns3"s));
-        REQUIRE(IsNamespacePackage(j, "ns3"s, "ns33"s));
-
-        save_json(config.output_directory(), diagram->name + ".json", j);
-    }
-    {
-        auto src = generate_class_mermaid(diagram, *model);
-
-        mermaid::AliasMatcher _A(src);
-        using mermaid::IsEnum;
-
-        REQUIRE_THAT(src, IsClass(_A("ns1::ns11::A<T>")));
-        REQUIRE_THAT(src, IsClass(_A("ns1::ns11::A<int>")));
-        REQUIRE_THAT(src, IsEnum(_A("ns1::E")));
-        REQUIRE_THAT(src, IsClass(_A("ns1::ns11::ns111::B")));
-        REQUIRE_THAT(src, IsClass(_A("ns2::ns22::C")));
-        REQUIRE_THAT(src, !IsClass(_A("DImpl")));
-
-        REQUIRE_THAT(src,
-            IsAggregation(
-                _A("ns1::ns11::ns111::B"), _A("ns1::ns11::A<int>"), "+a_int"));
-
-        save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
-    }
 }

tests/t00037/test_case.h

@@ -1,5 +1,5 @@
 /**
- * tests/t00037/test_case.cc
+ * tests/t00037/test_case.h
  *
  * Copyright (c) 2021-2024 Bartek Kryza <bkryza@gmail.com>
  *
@@ -16,8 +16,10 @@
  * limitations under the License.
  */
 
-TEST_CASE("t00037", "[test-case][class]")
+TEST_CASE("t00037")
 {
+    using namespace clanguml::test;
+
     auto [config, db] = load_config("t00037");
 
     auto diagram = config.diagrams["t00037_class"];
@@ -29,49 +31,14 @@ TEST_CASE("t00037", "[test-case][class]")
 
     REQUIRE(model->name() == "t00037_class");
 
-    {
+    CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
-        auto src = generate_class_puml(diagram, *model);
+        REQUIRE(IsClass(src, "ST"));
-        AliasMatcher _A(src);
+        REQUIRE(IsClass(src, "A"));
+        REQUIRE(IsClass(src, "ST::(units)"));
+        REQUIRE(IsClass(src, "ST::(dimensions)"));
 
-        REQUIRE_THAT(src, StartsWith("@startuml"));
+        REQUIRE(
-        REQUIRE_THAT(src, EndsWith("@enduml\n"));
+            IsAggregation<Public>(src, "ST", "ST::(dimensions)", "dimensions"));
-
+        REQUIRE(IsAggregation<Private>(src, "ST", "ST::(units)", "units"));
-        REQUIRE_THAT(src, IsClass(_A("ST")));
+    });
-        REQUIRE_THAT(src, IsClass(_A("A")));
-        REQUIRE_THAT(src, IsClass(_A("ST::(units)")));
-        REQUIRE_THAT(src, IsClass(_A("ST::(dimensions)")));
-        REQUIRE_THAT(src,
-            IsAggregation(_A("ST"), _A("ST::(dimensions)"), "+dimensions"));
-        REQUIRE_THAT(src, IsAggregation(_A("ST"), _A("ST::(units)"), "-units"));
-
-        save_puml(config.output_directory(), diagram->name + ".puml", src);
-    }
-    {
-        auto j = generate_class_json(diagram, *model);
-
-        using namespace json;
-
-        REQUIRE(IsClass(j, "ST"));
-        REQUIRE(IsClass(j, "A"));
-        REQUIRE(IsClass(j, "ST::(units)"));
-        REQUIRE(IsClass(j, "ST::(dimensions)"));
-        REQUIRE(IsAggregation(j, "ST", "ST::(dimensions)", "dimensions"));
-
-        save_json(config.output_directory(), diagram->name + ".json", j);
-    }
-    {
-        auto src = generate_class_mermaid(diagram, *model);
-
-        mermaid::AliasMatcher _A(src);
-
-        REQUIRE_THAT(src, IsClass(_A("ST")));
-        REQUIRE_THAT(src, IsClass(_A("A")));
-        REQUIRE_THAT(src, IsClass(_A("ST::(units)")));
-        REQUIRE_THAT(src, IsClass(_A("ST::(dimensions)")));
-        REQUIRE_THAT(src,
-            IsAggregation(_A("ST"), _A("ST::(dimensions)"), "+dimensions"));
-        REQUIRE_THAT(src, IsAggregation(_A("ST"), _A("ST::(units)"), "-units"));
-
-        save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
-    }
 }

tests/t00038/test_case.h

@@ -1,5 +1,5 @@
 /**
- * tests/t00038/test_case.cc
+ * tests/t00038/test_case.h
  *
  * Copyright (c) 2021-2024 Bartek Kryza <bkryza@gmail.com>
  *
@@ -16,8 +16,10 @@
  * limitations under the License.
  */
 
-TEST_CASE("t00038", "[test-case][class]")
+TEST_CASE("t00038")
 {
+        using namespace clanguml::test;
+
     auto [config, db] = load_config("t00038");
 
     auto diagram = config.diagrams["t00038_class"];
@@ -29,152 +31,56 @@ TEST_CASE("t00038", "[test-case][class]")
 
     REQUIRE(model->name() == "t00038_class");
 
-    {
+    CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
-        auto src = generate_class_puml(diagram, *model);
+        REQUIRE(IsClass(src, "A"));
-        AliasMatcher _A(src);
+        REQUIRE(IsClass(src, "B"));
+        REQUIRE(IsClass(src, "C"));
+        REQUIRE(IsClass(src, "thirdparty::ns1::E"));
+        REQUIRE(IsClass(src, "key_t"));
+        REQUIRE(IsClassTemplate(src, "map<T>"));
+        REQUIRE(IsClassTemplate(src,
+            "map<std::integral_constant<property_t,property_t::property_a>>"));
 
-        REQUIRE_THAT(src, StartsWith("@startuml"));
+        REQUIRE(IsClassTemplate(src,
-        REQUIRE_THAT(src, EndsWith("@enduml\n"));
+            "map<std::vector<std::integral_constant<property_t,property_t::"
+            "property_b>>>"));
+        REQUIRE(IsClassTemplate(src,
+            "map<std::map<key_t,std::vector<std::integral_constant<property_t,"
+            "property_t::property_c>>>>"));
 
-        REQUIRE_THAT(src, IsClass(_A("A")));
+        REQUIRE(IsEnum(src, "property_t"));
-        REQUIRE_THAT(src, IsClass(_A("B")));
-        REQUIRE_THAT(src, IsClass(_A("C")));
-        REQUIRE_THAT(src, IsClass(_A("thirdparty::ns1::E")));
-        REQUIRE_THAT(src, IsClass(_A("key_t")));
-        REQUIRE_THAT(src, IsClassTemplate("map", "T"));
-        REQUIRE_THAT(src,
-            IsClassTemplate("map",
-                "std::integral_constant<property_t,property_t::property_a>"));
-        REQUIRE_THAT(src,
-            IsClassTemplate("map",
-                "std::vector<std::integral_constant<property_t,property_t::"
-                "property_b>>"));
-        REQUIRE_THAT(src,
-            IsClassTemplate("map",
-                "std::map<key_t,std::vector<std::integral_constant<property_t,"
-                "property_t::property_c>>>"));
 
-        REQUIRE_THAT(src, IsEnum(_A("property_t")));
+        REQUIRE(IsInstantiation(src, "map<T>",
+            "map<std::map<key_t,std::vector<std::integral_constant<"
+            "property_t,property_t::property_c>>>>"));
 
-        REQUIRE_THAT(src,
+        REQUIRE(IsDependency(src,
-            IsInstantiation(_A("map<T>"),
+            "map<std::integral_constant<property_t,property_t::property_a>>",
-                _A("map<std::map<key_t,std::vector<std::integral_constant<"
+            "property_t"));
-                   "property_"
-                   "t,property_t::property_c>>>>")));
 
-        REQUIRE_THAT(src,
+        REQUIRE(IsDependency(src,
-            IsDependency(_A("map<std::integral_constant<property_t,property_t::"
+            "map<"
-                            "property_a>>"),
+            "std::vector<std::integral_constant<property_t,"
-                _A("property_t")));
+            "property_t::property_b>>>",
+            "property_t"));
 
-        REQUIRE_THAT(src,
+        REQUIRE(IsDependency(src,
-            IsDependency(_A("map<"
+            "map<std::map<key_t,std::vector<std::integral_constant<"
-                            "std::vector<std::integral_constant<property_t,"
+            "property_t,property_t::property_c>>>>",
-                            "property_t::property_b>>>"),
+            "property_t"));
-                _A("property_t")));
 
-        REQUIRE_THAT(src,
+        REQUIRE(IsDependency(src,
-            IsDependency(
+            "map<std::map<key_t,std::vector<std::integral_constant<"
-                _A("map<std::map<key_t,std::vector<std::integral_constant<"
+            "property_t,property_t::property_c>>>>",
-                   "property_t,property_t::property_c>>>>"),
+            "key_t"));
-                _A("property_t")));
 
-        REQUIRE_THAT(src,
+        REQUIRE(IsDependency(src,
-            IsDependency(
+            "map<std::integral_constant<thirdparty::ns1::color_t,"
-                _A("map<std::map<key_t,std::vector<std::integral_constant<"
+            "thirdparty::ns1::color_t::red>>",
-                   "property_t,property_t::property_c>>>>"),
+            "thirdparty::ns1::color_t"));
-                _A("key_t")));
 
-        REQUIRE_THAT(src,
+        REQUIRE(IsBaseClass(src, "thirdparty::ns1::E",
-            IsDependency(
+            "map<std::integral_constant<thirdparty::ns1::color_t,"
-                _A("map<std::integral_constant<thirdparty::ns1::color_t,"
+            "thirdparty::ns1::color_t::red>>"));
-                   "thirdparty::ns1::color_t::red>>"),
+    });
-                _A("thirdparty::ns1::color_t")));
-
-        REQUIRE_THAT(src,
-            IsBaseClass(_A("thirdparty::ns1::E"),
-                _A("map<std::integral_constant<thirdparty::ns1::color_t,"
-                   "thirdparty::ns1::color_t::red>>")));
-
-        save_puml(config.output_directory(), diagram->name + ".puml", src);
-    }
-    {
-        auto j = generate_class_json(diagram, *model);
-
-        using namespace json;
-
-        REQUIRE(IsClass(j, "A"));
-        REQUIRE(IsClass(j, "B"));
-        REQUIRE(IsClass(j, "C"));
-
-        save_json(config.output_directory(), diagram->name + ".json", j);
-    }
-    {
-        auto src = generate_class_mermaid(diagram, *model);
-
-        mermaid::AliasMatcher _A(src);
-        using mermaid::IsEnum;
-
-        REQUIRE_THAT(src, IsClass(_A("A")));
-        REQUIRE_THAT(src, IsClass(_A("B")));
-        REQUIRE_THAT(src, IsClass(_A("C")));
-        REQUIRE_THAT(src, IsClass(_A("thirdparty::ns1::E")));
-        REQUIRE_THAT(src, IsClass(_A("key_t")));
-        REQUIRE_THAT(src, IsClass(_A("map<T>")));
-        REQUIRE_THAT(src,
-            IsClass(_A("map<std::integral_constant<property_t,property_t::"
-                       "property_a>>")));
-        REQUIRE_THAT(src,
-            IsClass(_A(
-                "map<std::vector<std::integral_constant<property_t,property_t::"
-                "property_b>>>")));
-        REQUIRE_THAT(src,
-            IsClass(_A("map<std::map<key_t,std::vector<std::integral_constant<"
-                       "property_t,"
-                       "property_t::property_c>>>>")));
-
-        REQUIRE_THAT(src, IsEnum(_A("property_t")));
-
-        REQUIRE_THAT(src,
-            IsInstantiation(_A("map<T>"),
-                _A("map<std::map<key_t,std::vector<std::integral_constant<"
-                   "property_"
-                   "t,property_t::property_c>>>>")));
-
-        REQUIRE_THAT(src,
-            IsDependency(_A("map<std::integral_constant<property_t,property_t::"
-                            "property_a>>"),
-                _A("property_t")));
-
-        REQUIRE_THAT(src,
-            IsDependency(_A("map<"
-                            "std::vector<std::integral_constant<property_t,"
-                            "property_t::property_b>>>"),
-                _A("property_t")));
-
-        REQUIRE_THAT(src,
-            IsDependency(
-                _A("map<std::map<key_t,std::vector<std::integral_constant<"
-                   "property_t,property_t::property_c>>>>"),
-                _A("property_t")));
-
-        REQUIRE_THAT(src,
-            IsDependency(
-                _A("map<std::map<key_t,std::vector<std::integral_constant<"
-                   "property_t,property_t::property_c>>>>"),
-                _A("key_t")));
-
-        REQUIRE_THAT(src,
-            IsDependency(
-                _A("map<std::integral_constant<thirdparty::ns1::color_t,"
-                   "thirdparty::ns1::color_t::red>>"),
-                _A("thirdparty::ns1::color_t")));
-
-        REQUIRE_THAT(src,
-            IsBaseClass(_A("thirdparty::ns1::E"),
-                _A("map<std::integral_constant<thirdparty::ns1::color_t,"
-                   "thirdparty::ns1::color_t::red>>")));
-
-        save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
-    }
 }

tests/t00039/test_case.h

@@ -1,5 +1,5 @@
 /**
- * tests/t00039/test_case.cc
+ * tests/t00039/test_case.h
  *
  * Copyright (c) 2021-2024 Bartek Kryza <bkryza@gmail.com>
  *
@@ -16,8 +16,10 @@
  * limitations under the License.
  */
 
-TEST_CASE("t00039", "[test-case][class]")
+TEST_CASE("t00039")
 {
+        using namespace clanguml::test;
+
     auto [config, db] = load_config("t00039");
 
     auto diagram = config.diagrams["t00039_class"];
@@ -28,96 +30,33 @@ TEST_CASE("t00039", "[test-case][class]")
 
     REQUIRE(model->name() == "t00039_class");
 
-    {
+    CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
-        auto src = generate_class_puml(diagram, *model);
+        REQUIRE(IsClass(src, "A"));
-        AliasMatcher _A(src);
+        REQUIRE(IsClass(src, "AA"));
+        REQUIRE(IsClass(src, "AAA"));
+        REQUIRE(IsClass(src, "ns2::AAAA"));
+        REQUIRE(IsBaseClass(src, "A", "AA"));
+        REQUIRE(IsBaseClass(src, "AA", "AAA"));
+        REQUIRE(IsBaseClass(src, "AAA", "ns2::AAAA"));
+        REQUIRE(!IsClass(src, "detail::AA"));
 
-        REQUIRE_THAT(src, StartsWith("@startuml"));
+        REQUIRE(!IsClass(src, "B"));
-        REQUIRE_THAT(src, EndsWith("@enduml\n"));
+        REQUIRE(!IsClass(src, "ns1::BB"));
 
-        REQUIRE_THAT(src, IsClass(_A("A")));
+        REQUIRE(IsClass(src, "C"));
-        REQUIRE_THAT(src, IsClass(_A("AA")));
+        REQUIRE(IsClass(src, "D"));
-        REQUIRE_THAT(src, IsClass(_A("AAA")));
+        REQUIRE(IsClass(src, "E"));
-        REQUIRE_THAT(src, IsClass(_A("ns2::AAAA")));
+        REQUIRE(IsBaseClass(src, "C", "CD"));
-        REQUIRE_THAT(src, IsBaseClass(_A("A"), _A("AA")));
+        REQUIRE(IsBaseClass(src, "D", "CD"));
-        REQUIRE_THAT(src, IsBaseClass(_A("AA"), _A("AAA")));
+        REQUIRE(IsBaseClass(src, "D", "DE"));
-        REQUIRE_THAT(src, IsBaseClass(_A("AAA"), _A("ns2::AAAA")));
+        REQUIRE(IsBaseClass(src, "E", "DE"));
-        REQUIRE_THAT(src, !IsClass(_A("detail::AA")));
+        REQUIRE(IsBaseClass(src, "C", "CDE"));
+        REQUIRE(IsBaseClass(src, "D", "CDE"));
+        REQUIRE(IsBaseClass(src, "E", "CDE"));
 
-        REQUIRE_THAT(src, !IsClass(_A("B")));
+        REQUIRE(IsClassTemplate(src, "ns3::F<T>"));
-        REQUIRE_THAT(src, !IsClass(_A("ns1::BB")));
+        REQUIRE(IsClassTemplate(src, "ns3::FF<T,M>"));
-
+        REQUIRE(IsClassTemplate(src, "ns3::FE<T,M>"));
-        REQUIRE_THAT(src, IsClass(_A("C")));
+        REQUIRE(IsClassTemplate(src, "ns3::FFF<T,M,N>"));
-        REQUIRE_THAT(src, IsClass(_A("D")));
+    });
-        REQUIRE_THAT(src, IsClass(_A("E")));
-        REQUIRE_THAT(src, IsBaseClass(_A("C"), _A("CD")));
-        REQUIRE_THAT(src, IsBaseClass(_A("D"), _A("CD")));
-        REQUIRE_THAT(src, IsBaseClass(_A("D"), _A("DE")));
-        REQUIRE_THAT(src, IsBaseClass(_A("E"), _A("DE")));
-        REQUIRE_THAT(src, IsBaseClass(_A("C"), _A("CDE")));
-        REQUIRE_THAT(src, IsBaseClass(_A("D"), _A("CDE")));
-        REQUIRE_THAT(src, IsBaseClass(_A("E"), _A("CDE")));
-
-        REQUIRE_THAT(src, IsClassTemplate("ns3::F", "T"));
-        REQUIRE_THAT(src, IsClassTemplate("ns3::FF", "T,M"));
-        REQUIRE_THAT(src, IsClassTemplate("ns3::FE", "T,M"));
-        REQUIRE_THAT(src, IsClassTemplate("ns3::FFF", "T,M,N"));
-
-        save_puml(config.output_directory(), diagram->name + ".puml", src);
-    }
-    {
-        auto j = generate_class_json(diagram, *model);
-
-        using namespace json;
-
-        REQUIRE(IsClass(j, "A"));
-        REQUIRE(IsClass(j, "AA"));
-        REQUIRE(IsClass(j, "AAA"));
-        REQUIRE(IsBaseClass(j, "C", "CD"));
-        REQUIRE(IsBaseClass(j, "D", "CD"));
-        REQUIRE(IsBaseClass(j, "E", "DE"));
-        REQUIRE(IsBaseClass(j, "D", "DE"));
-        REQUIRE(IsBaseClass(j, "C", "CDE"));
-        REQUIRE(IsBaseClass(j, "D", "CDE"));
-        REQUIRE(IsBaseClass(j, "E", "CDE"));
-
-        REQUIRE(IsClassTemplate(j, "ns3::F<T>"));
-
-        save_json(config.output_directory(), diagram->name + ".json", j);
-    }
-    {
-        auto src = generate_class_mermaid(diagram, *model);
-
-        mermaid::AliasMatcher _A(src);
-
-        REQUIRE_THAT(src, IsClass(_A("A")));
-        REQUIRE_THAT(src, IsClass(_A("AA")));
-        REQUIRE_THAT(src, IsClass(_A("AAA")));
-        REQUIRE_THAT(src, IsClass(_A("ns2::AAAA")));
-        REQUIRE_THAT(src, IsBaseClass(_A("A"), _A("AA")));
-        REQUIRE_THAT(src, IsBaseClass(_A("AA"), _A("AAA")));
-        REQUIRE_THAT(src, IsBaseClass(_A("AAA"), _A("ns2::AAAA")));
-        REQUIRE_THAT(src, !IsClass(_A("detail::AA")));
-
-        REQUIRE_THAT(src, !IsClass(_A("B")));
-        REQUIRE_THAT(src, !IsClass(_A("ns1::BB")));
-
-        REQUIRE_THAT(src, IsClass(_A("C")));
-        REQUIRE_THAT(src, IsClass(_A("D")));
-        REQUIRE_THAT(src, IsClass(_A("E")));
-        REQUIRE_THAT(src, IsBaseClass(_A("C"), _A("CD")));
-        REQUIRE_THAT(src, IsBaseClass(_A("D"), _A("CD")));
-        REQUIRE_THAT(src, IsBaseClass(_A("D"), _A("DE")));
-        REQUIRE_THAT(src, IsBaseClass(_A("E"), _A("DE")));
-        REQUIRE_THAT(src, IsBaseClass(_A("C"), _A("CDE")));
-        REQUIRE_THAT(src, IsBaseClass(_A("D"), _A("CDE")));
-        REQUIRE_THAT(src, IsBaseClass(_A("E"), _A("CDE")));
-
-        REQUIRE_THAT(src, IsClass(_A("ns3::F<T>")));
-        REQUIRE_THAT(src, IsClass(_A("ns3::FF<T,M>")));
-        REQUIRE_THAT(src, IsClass(_A("ns3::FE<T,M>")));
-        REQUIRE_THAT(src, IsClass(_A("ns3::FFF<T,M,N>")));
-
-        save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
-    }
 }

tests/t00040/test_case.h

@@ -1,5 +1,5 @@
 /**
- * tests/t00040/test_case.cc
+ * tests/t00040/test_case.h
  *
  * Copyright (c) 2021-2024 Bartek Kryza <bkryza@gmail.com>
  *
@@ -16,8 +16,10 @@
  * limitations under the License.
  */
 
-TEST_CASE("t00040", "[test-case][class]")
+TEST_CASE("t00040")
 {
+    using namespace clanguml::test;
+
     auto [config, db] = load_config("t00040");
 
     auto diagram = config.diagrams["t00040_class"];
@@ -28,51 +30,14 @@ TEST_CASE("t00040", "[test-case][class]")
     auto model = generate_class_diagram(*db, diagram);
 
     REQUIRE(model->name() == "t00040_class");
-    {
-        auto src = generate_class_puml(diagram, *model);
-        AliasMatcher _A(src);
 
-        REQUIRE_THAT(src, StartsWith("@startuml"));
+    CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
-        REQUIRE_THAT(src, EndsWith("@enduml\n"));
+        REQUIRE(IsClass(src, "A"));
-
+        REQUIRE(IsClass(src, "AA"));
-        REQUIRE_THAT(src, IsClass(_A("A")));
+        REQUIRE(IsClass(src, "AAA"));
-        REQUIRE_THAT(src, IsClass(_A("AA")));
+        REQUIRE(IsBaseClass(src, "A", "AA"));
-        REQUIRE_THAT(src, IsClass(_A("AAA")));
+        REQUIRE(IsBaseClass(src, "AA", "AAA"));
-        REQUIRE_THAT(src, IsBaseClass(_A("A"), _A("AA")));
+        REQUIRE(!IsClass(src, "B"));
-        REQUIRE_THAT(src, IsBaseClass(_A("AA"), _A("AAA")));
+        REQUIRE(!IsDependency(src, "R", "A"));
-
+    });
-        REQUIRE_THAT(src, !IsClass(_A("B")));
-
-        REQUIRE_THAT(src, !IsDependency(_A("R"), _A("A")));
-
-        save_puml(config.output_directory(), diagram->name + ".puml", src);
-    }
-    {
-        auto j = generate_class_json(diagram, *model);
-
-        using namespace json;
-
-        REQUIRE(IsClass(j, "A"));
-        REQUIRE(IsClass(j, "AA"));
-        REQUIRE(IsClass(j, "AAA"));
-
-        save_json(config.output_directory(), diagram->name + ".json", j);
-    }
-    {
-        auto src = generate_class_mermaid(diagram, *model);
-
-        mermaid::AliasMatcher _A(src);
-
-        REQUIRE_THAT(src, IsClass(_A("A")));
-        REQUIRE_THAT(src, IsClass(_A("AA")));
-        REQUIRE_THAT(src, IsClass(_A("AAA")));
-        REQUIRE_THAT(src, IsBaseClass(_A("A"), _A("AA")));
-        REQUIRE_THAT(src, IsBaseClass(_A("AA"), _A("AAA")));
-
-        REQUIRE_THAT(src, !IsClass(_A("B")));
-
-        REQUIRE_THAT(src, !IsDependency(_A("R"), _A("A")));
-
-        save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
-    }
 }

tests/t00041/test_case.h

@@ -1,5 +1,5 @@
 /**
- * tests/t00041/test_case.cc
+ * tests/t00041/test_case.h
  *
  * Copyright (c) 2021-2024 Bartek Kryza <bkryza@gmail.com>
  *
@@ -16,8 +16,10 @@
  * limitations under the License.
  */
 
-TEST_CASE("t00041", "[test-case][class]")
+TEST_CASE("t00041")
 {
+    using namespace clanguml::test;
+
     auto [config, db] = load_config("t00041");
 
     auto diagram = config.diagrams["t00041_class"];
@@ -29,95 +31,34 @@ TEST_CASE("t00041", "[test-case][class]")
 
     REQUIRE(model->name() == "t00041_class");
 
-    {
+    CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
-        auto src = generate_class_puml(diagram, *model);
+        REQUIRE(!IsClass(src, "A"));
-        AliasMatcher _A(src);
+        REQUIRE(!IsClass(src, "AA"));
+        REQUIRE(!IsClass(src, "AAA"));
 
-        REQUIRE_THAT(src, StartsWith("@startuml"));
+        REQUIRE(!IsClass(src, "B"));
-        REQUIRE_THAT(src, EndsWith("@enduml\n"));
 
-        REQUIRE_THAT(src, !IsClass(_A("A")));
+        REQUIRE(IsClass(src, "D"));
-        REQUIRE_THAT(src, !IsClass(_A("AA")));
+        REQUIRE(IsClass(src, "E"));
-        REQUIRE_THAT(src, !IsClass(_A("AAA")));
+        REQUIRE(IsClass(src, "F"));
+        REQUIRE(IsClass(src, "R"));
+        REQUIRE(IsClass(src, "RR"));
+        REQUIRE(IsClass(src, "RRR"));
+        REQUIRE(!IsClass(src, "detail::G"));
+        REQUIRE(!IsClass(src, "H"));
 
-        REQUIRE_THAT(src, !IsClass(_A("B")));
+        REQUIRE(IsBaseClass(src, "R", "RR"));
+        REQUIRE(IsBaseClass(src, "RR", "RRR"));
 
-        REQUIRE_THAT(src, IsClass(_A("D")));
+        REQUIRE(IsAssociation<Public>(src, "D", "RR", "rr"));
-        REQUIRE_THAT(src, IsClass(_A("E")));
+        REQUIRE(IsAssociation<Public>(src, "RR", "E", "e"));
-        REQUIRE_THAT(src, IsClass(_A("F")));
+        REQUIRE(IsAssociation<Public>(src, "RR", "F", "f"));
-        REQUIRE_THAT(src, IsClass(_A("R")));
+        REQUIRE(!IsDependency(src, "RR", "H"));
-        REQUIRE_THAT(src, IsClass(_A("RR")));
-        REQUIRE_THAT(src, IsClass(_A("RRR")));
-        REQUIRE_THAT(src, !IsClass(_A("detail::G")));
-        REQUIRE_THAT(src, !IsClass(_A("H")));
 
-        REQUIRE_THAT(src, IsBaseClass(_A("R"), _A("RR")));
+        REQUIRE(IsClass(src, {"ns1", "N"}));
-        REQUIRE_THAT(src, IsBaseClass(_A("RR"), _A("RRR")));
+        REQUIRE(IsClass(src, {"ns1", "NN"}));
-
+        REQUIRE(IsClass(src, {"ns1", "NM"}));
-        REQUIRE_THAT(src, IsAssociation(_A("D"), _A("RR"), "+rr"));
+        REQUIRE(IsBaseClass(src, "ns1::N", "ns1::NN"));
-        REQUIRE_THAT(src, IsAssociation(_A("RR"), _A("E"), "+e"));
+        REQUIRE(IsBaseClass(src, "ns1::N", "ns1::NM"));
-        REQUIRE_THAT(src, IsAssociation(_A("RR"), _A("F"), "+f"));
+    });
-        REQUIRE_THAT(src, !IsDependency(_A("RR"), _A("H")));
-
-        REQUIRE_THAT(src, IsClass(_A("ns1::N")));
-        REQUIRE_THAT(src, IsClass(_A("ns1::NN")));
-        REQUIRE_THAT(src, IsClass(_A("ns1::NM")));
-        REQUIRE_THAT(src, IsBaseClass(_A("ns1::N"), _A("ns1::NN")));
-        REQUIRE_THAT(src, IsBaseClass(_A("ns1::N"), _A("ns1::NM")));
-
-        save_puml(config.output_directory(), diagram->name + ".puml", src);
-    }
-    {
-        auto j = generate_class_json(diagram, *model);
-
-        using namespace json;
-
-        REQUIRE(!IsClass(j, "A"));
-        REQUIRE(!IsClass(j, "AA"));
-        REQUIRE(!IsClass(j, "AAA"));
-        REQUIRE(IsClass(j, "D"));
-        REQUIRE(IsClass(j, "E"));
-        REQUIRE(IsClass(j, "F"));
-        REQUIRE(IsClass(j, "R"));
-
-        REQUIRE(IsAssociation(j, "D", "RR", "rr"));
-
-        save_json(config.output_directory(), diagram->name + ".json", j);
-    }
-    {
-        auto src = generate_class_mermaid(diagram, *model);
-
-        mermaid::AliasMatcher _A(src);
-
-        REQUIRE_THAT(src, !IsClass(_A("A")));
-        REQUIRE_THAT(src, !IsClass(_A("AA")));
-        REQUIRE_THAT(src, !IsClass(_A("AAA")));
-
-        REQUIRE_THAT(src, !IsClass(_A("B")));
-
-        REQUIRE_THAT(src, IsClass(_A("D")));
-        REQUIRE_THAT(src, IsClass(_A("E")));
-        REQUIRE_THAT(src, IsClass(_A("F")));
-        REQUIRE_THAT(src, IsClass(_A("R")));
-        REQUIRE_THAT(src, IsClass(_A("RR")));
-        REQUIRE_THAT(src, IsClass(_A("RRR")));
-        REQUIRE_THAT(src, !IsClass(_A("detail::G")));
-        REQUIRE_THAT(src, !IsClass(_A("H")));
-
-        REQUIRE_THAT(src, IsBaseClass(_A("R"), _A("RR")));
-        REQUIRE_THAT(src, IsBaseClass(_A("RR"), _A("RRR")));
-
-        REQUIRE_THAT(src, IsAssociation(_A("D"), _A("RR"), "+rr"));
-        REQUIRE_THAT(src, IsAssociation(_A("RR"), _A("E"), "+e"));
-        REQUIRE_THAT(src, IsAssociation(_A("RR"), _A("F"), "+f"));
-        REQUIRE_THAT(src, !IsDependency(_A("RR"), _A("H")));
-
-        REQUIRE_THAT(src, IsClass(_A("ns1::N")));
-        REQUIRE_THAT(src, IsClass(_A("ns1::NN")));
-        REQUIRE_THAT(src, IsClass(_A("ns1::NM")));
-        REQUIRE_THAT(src, IsBaseClass(_A("ns1::N"), _A("ns1::NN")));
-        REQUIRE_THAT(src, IsBaseClass(_A("ns1::N"), _A("ns1::NM")));
-
-        save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
-    }
 }

tests/t00042/test_case.h

@@ -1,5 +1,5 @@
 /**
- * tests/t00042/test_case.cc
+ * tests/t00042/test_case.h
  *
  * Copyright (c) 2021-2024 Bartek Kryza <bkryza@gmail.com>
  *
@@ -16,8 +16,10 @@
  * limitations under the License.
  */
 
-TEST_CASE("t00042", "[test-case][class]")
+TEST_CASE("t00042")
 {
+    using namespace clanguml::test;
+
     auto [config, db] = load_config("t00042");
 
     auto diagram = config.diagrams["t00042_class"];
@@ -29,38 +31,9 @@ TEST_CASE("t00042", "[test-case][class]")
 
     REQUIRE(model->name() == "t00042_class");
 
-    {
+    CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
-        auto src = generate_class_puml(diagram, *model);
+        REQUIRE(IsClassTemplate(src, "A<T>"));
-        AliasMatcher _A(src);
+        REQUIRE(IsClassTemplate(src, "B<T,K>"));
-
+        REQUIRE(!IsClassTemplate(src, "C<T>"));
-        REQUIRE_THAT(src, StartsWith("@startuml"));
+    });
-        REQUIRE_THAT(src, EndsWith("@enduml\n"));
-
-        REQUIRE_THAT(src, IsClassTemplate("A", "T"));
-        REQUIRE_THAT(src, IsClassTemplate("B", "T,K"));
-        REQUIRE_THAT(src, !IsClassTemplate("C", "T"));
-
-        save_puml(config.output_directory(), diagram->name + ".puml", src);
-    }
-    {
-        auto j = generate_class_json(diagram, *model);
-
-        using namespace json;
-
-        REQUIRE(IsClassTemplate(j, "A<T>"));
-        REQUIRE(IsClassTemplate(j, "B<T,K>"));
-
-        save_json(config.output_directory(), diagram->name + ".json", j);
-    }
-    {
-        auto src = generate_class_mermaid(diagram, *model);
-
-        mermaid::AliasMatcher _A(src);
-
-        REQUIRE_THAT(src, IsClass(_A("A<T>")));
-        REQUIRE_THAT(src, IsClass(_A("B<T,K>")));
-        REQUIRE_THAT(src, !IsClass(_A("C<T>")));
-
-        save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
-    }
 }

tests/t00043/test_case.h

@@ -1,5 +1,5 @@
 /**
- * tests/t00043/test_case.cc
+ * tests/t00043/test_case.h
  *
  * Copyright (c) 2021-2024 Bartek Kryza <bkryza@gmail.com>
  *
@@ -16,8 +16,10 @@
  * limitations under the License.
  */
 
-TEST_CASE("t00043", "[test-case][class]")
+TEST_CASE("t00043")
 {
+    using namespace clanguml::test;
+
     auto [config, db] = load_config("t00043");
 
     auto diagram = config.diagrams["t00043_class"];
@@ -29,104 +31,31 @@ TEST_CASE("t00043", "[test-case][class]")
 
     REQUIRE(model->name() == "t00043_class");
 
-    {
+    CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
-        auto src = generate_class_puml(diagram, *model);
+        REQUIRE(IsClass(src, {"dependants", "A"}));
-        AliasMatcher _A(src);
+        REQUIRE(IsClass(src, {"dependants", "B"}));
+        REQUIRE(IsClass(src, {"dependants", "C"}));
+        REQUIRE(IsClass(src, {"dependants", "D"}));
+        REQUIRE(IsClass(src, {"dependants", "BB"}));
+        REQUIRE(IsClass(src, {"dependants", "E"}));
+        REQUIRE(IsDependency(src, {"dependants", "B"}, {"dependants", "A"}));
+        REQUIRE(IsDependency(src, {"dependants", "BB"}, {"dependants", "A"}));
+        REQUIRE(IsDependency(src, {"dependants", "C"}, {"dependants", "B"}));
+        REQUIRE(IsDependency(src, {"dependants", "D"}, {"dependants", "C"}));
+        REQUIRE(IsDependency(src, {"dependants", "E"}, {"dependants", "D"}));
 
-        REQUIRE_THAT(src, StartsWith("@startuml"));
+        REQUIRE(IsClass(src, {"dependencies", "G"}));
-        REQUIRE_THAT(src, EndsWith("@enduml\n"));
+        REQUIRE(IsClass(src, {"dependencies", "GG"}));
+        REQUIRE(IsClass(src, {"dependencies", "H"}));
+        REQUIRE(!IsClass(src, {"dependencies", "HH"}));
 
-        // Check dependants filter
+        REQUIRE(
-        REQUIRE_THAT(src, IsClass(_A("A")));
+            IsDependency(src, {"dependencies", "J"}, {"dependencies", "I"}));
-        REQUIRE_THAT(src, IsClass(_A("B")));
+        REQUIRE(
-        REQUIRE_THAT(src, IsClass(_A("BB")));
+            IsDependency(src, {"dependencies", "H"}, {"dependencies", "G"}));
-        REQUIRE_THAT(src, IsClass(_A("D")));
+        REQUIRE(
-        REQUIRE_THAT(src, IsClass(_A("E")));
+            IsDependency(src, {"dependencies", "I"}, {"dependencies", "H"}));
-        REQUIRE_THAT(src, !IsClass(_A("F")));
+        REQUIRE(
-
+            IsDependency(src, {"dependencies", "H"}, {"dependencies", "GG"}));
-        REQUIRE_THAT(src, IsDependency(_A("B"), _A("A")));
+    });
-        REQUIRE_THAT(src, IsDependency(_A("BB"), _A("A")));
-        REQUIRE_THAT(src, IsDependency(_A("C"), _A("B")));
-        REQUIRE_THAT(src, IsDependency(_A("D"), _A("C")));
-        REQUIRE_THAT(src, IsDependency(_A("E"), _A("D")));
-
-        // Check dependencies filter
-        REQUIRE_THAT(src, IsClass(_A("G")));
-        REQUIRE_THAT(src, IsClass(_A("GG")));
-        REQUIRE_THAT(src, IsClass(_A("H")));
-        REQUIRE_THAT(src, !IsClass(_A("HH")));
-        REQUIRE_THAT(src, IsClass(_A("I")));
-        REQUIRE_THAT(src, IsClass(_A("J")));
-
-        REQUIRE_THAT(src, IsDependency(_A("H"), _A("G")));
-        REQUIRE_THAT(src, IsDependency(_A("H"), _A("GG")));
-        REQUIRE_THAT(src, IsDependency(_A("I"), _A("H")));
-        REQUIRE_THAT(src, IsDependency(_A("J"), _A("I")));
-
-        save_puml(config.output_directory(), diagram->name + ".puml", src);
-    }
-    {
-        auto j = generate_class_json(diagram, *model);
-
-        using namespace json;
-
-        REQUIRE(IsClass(j, "dependants::A"));
-        REQUIRE(IsClass(j, "dependants::B"));
-        REQUIRE(IsClass(j, "dependants::C"));
-        REQUIRE(IsClass(j, "dependants::D"));
-        REQUIRE(IsClass(j, "dependants::BB"));
-        REQUIRE(IsClass(j, "dependants::E"));
-        REQUIRE(IsDependency(j, "dependants::B", "dependants::A"));
-
-        REQUIRE(IsClass(j, "dependencies::G"));
-        REQUIRE(IsClass(j, "dependencies::GG"));
-        REQUIRE(IsClass(j, "dependencies::H"));
-        REQUIRE(IsDependency(j, "dependencies::J", "dependencies::I"));
-        REQUIRE(IsDependency(j, "dependencies::H", "dependencies::G"));
-
-        save_json(config.output_directory(), diagram->name + ".json", j);
-    }
-    {
-        auto src = generate_class_mermaid(diagram, *model);
-
-        mermaid::AliasMatcher _A(src);
-
-        // Check dependants filter
-        REQUIRE_THAT(src, IsClass(_A("dependants::A")));
-        REQUIRE_THAT(src, IsClass(_A("dependants::B")));
-        REQUIRE_THAT(src, IsClass(_A("dependants::BB")));
-        REQUIRE_THAT(src, IsClass(_A("dependants::D")));
-        REQUIRE_THAT(src, IsClass(_A("dependants::E")));
-        REQUIRE_THAT(src, !IsClass(_A("dependants::F")));
-
-        REQUIRE_THAT(
-            src, IsDependency(_A("dependants::B"), _A("dependants::A")));
-        REQUIRE_THAT(
-            src, IsDependency(_A("dependants::BB"), _A("dependants::A")));
-        REQUIRE_THAT(
-            src, IsDependency(_A("dependants::C"), _A("dependants::B")));
-        REQUIRE_THAT(
-            src, IsDependency(_A("dependants::D"), _A("dependants::C")));
-        REQUIRE_THAT(
-            src, IsDependency(_A("dependants::E"), _A("dependants::D")));
-
-        // Check dependencies filter
-        REQUIRE_THAT(src, IsClass(_A("dependencies::G")));
-        REQUIRE_THAT(src, IsClass(_A("dependencies::GG")));
-        REQUIRE_THAT(src, IsClass(_A("dependencies::H")));
-        REQUIRE_THAT(src, !IsClass(_A("dependencies::HH")));
-        REQUIRE_THAT(src, IsClass(_A("dependencies::I")));
-        REQUIRE_THAT(src, IsClass(_A("dependencies::J")));
-
-        REQUIRE_THAT(
-            src, IsDependency(_A("dependencies::H"), _A("dependencies::G")));
-        REQUIRE_THAT(
-            src, IsDependency(_A("dependencies::H"), _A("dependencies::GG")));
-        REQUIRE_THAT(
-            src, IsDependency(_A("dependencies::I"), _A("dependencies::H")));
-        REQUIRE_THAT(
-            src, IsDependency(_A("dependencies::J"), _A("dependencies::I")));
-
-        save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
-    }
 }

tests/t00044/test_case.h

@@ -1,5 +1,5 @@
 /**
- * tests/t00044/test_case.cc
+ * tests/t00044/test_case.h
  *
  * Copyright (c) 2021-2024 Bartek Kryza <bkryza@gmail.com>
  *
@@ -16,8 +16,10 @@
  * limitations under the License.
  */
 
-TEST_CASE("t00044", "[test-case][class]")
+TEST_CASE("t00044")
 {
+    using namespace clanguml::test;
+
     auto [config, db] = load_config("t00044");
 
     auto diagram = config.diagrams["t00044_class"];
@@ -29,90 +31,28 @@ TEST_CASE("t00044", "[test-case][class]")
 
     REQUIRE(model->name() == "t00044_class");
 
-    {
+    CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
-        auto src = generate_class_puml(diagram, *model);
+        REQUIRE(!src.contains("type-parameter-"));
-        AliasMatcher _A(src);
 
-        REQUIRE_THAT(src, StartsWith("@startuml"));
+        REQUIRE(IsClassTemplate(src, "sink<T>"));
-        REQUIRE_THAT(src, EndsWith("@enduml\n"));
+        REQUIRE(IsClassTemplate(src, "signal_handler<T,A>"));
 
-        REQUIRE_THAT(src, !Contains("type-parameter-"));
+        REQUIRE(IsClassTemplate(src, "signal_handler<Ret(Args...),A>"));
+        REQUIRE(IsClassTemplate(src, "signal_handler<void(int),bool>"));
 
-        REQUIRE_THAT(src, IsClassTemplate("sink", "T"));
+        REQUIRE(IsClassTemplate(src, "sink<signal_handler<Ret(Args...),A>>"));
-        REQUIRE_THAT(src, IsClassTemplate("signal_handler", "T,A"));
 
-        REQUIRE_THAT(src, IsClassTemplate("signal_handler", "Ret(Args...),A"));
+        REQUIRE(IsInstantiation(
-        REQUIRE_THAT(src, IsClassTemplate("signal_handler", "void(int),bool"));
+            src, "sink<T>", "sink<signal_handler<Ret(Args...),A>>"));
 
-        REQUIRE_THAT(
+        REQUIRE(IsInstantiation(src, "sink<signal_handler<Ret(Args...),A>>",
-            src, IsClassTemplate("sink", "signal_handler<Ret(Args...),A>"));
+            "sink<signal_handler<void(int),bool>>"));
 
-        REQUIRE_THAT(src,
+        REQUIRE(IsClassTemplate(src, "signal_handler<T,A>"));
-            IsInstantiation(
+        REQUIRE(IsInstantiation(
-                _A("sink<T>"), _A("sink<signal_handler<Ret(Args...),A>>")));
+            src, "signal_handler<T,A>", "signal_handler<Ret(Args...),A>"));
 
-        REQUIRE_THAT(src,
+        REQUIRE(IsInstantiation(src, "signal_handler<Ret(Args...),A>",
-            IsInstantiation(_A("sink<signal_handler<Ret(Args...),A>>"),
+            "signal_handler<void(int),bool>"));
-                _A("sink<signal_handler<void(int),bool>>")));
+    });
-
-        REQUIRE_THAT(src, IsClassTemplate("signal_handler", "T,A"));
-        REQUIRE_THAT(src,
-            IsInstantiation(_A("signal_handler<T,A>"),
-                _A("signal_handler<Ret(Args...),A>")));
-
-        REQUIRE_THAT(src,
-            IsInstantiation(_A("signal_handler<Ret(Args...),A>"),
-                _A("signal_handler<void(int),bool>")));
-
-        save_puml(config.output_directory(), diagram->name + ".puml", src);
-    }
-    {
-        auto j = generate_class_json(diagram, *model);
-
-        using namespace json;
-
-        REQUIRE(IsClassTemplate(j, "sink<T>"));
-        REQUIRE(IsClassTemplate(j, "signal_handler<T,A>"));
-        REQUIRE(IsClassTemplate(j, "signal_handler<Ret(Args...),A>"));
-        REQUIRE(IsStruct(j, "signal_handler<Ret(Args...),A>"));
-        REQUIRE(IsClassTemplate(j, "signal_handler<void(int),bool>"));
-        REQUIRE(IsClassTemplate(j, "sink<signal_handler<Ret(Args...),A>>"));
-        REQUIRE(IsStruct(j, "R"));
-
-        save_json(config.output_directory(), diagram->name + ".json", j);
-    }
-    {
-        auto src = generate_class_mermaid(diagram, *model);
-
-        mermaid::AliasMatcher _A(src);
-
-        REQUIRE_THAT(src, !Contains("type-parameter-"));
-
-        REQUIRE_THAT(src, IsClass(_A("sink<T>")));
-        REQUIRE_THAT(src, IsClass(_A("signal_handler<T,A>")));
-
-        REQUIRE_THAT(src, IsClass(_A("signal_handler<Ret(Args...),A>")));
-        REQUIRE_THAT(src, IsClass(_A("signal_handler<void(int),bool>")));
-
-        REQUIRE_THAT(src, IsClass(_A("sink<signal_handler<Ret(Args...),A>>")));
-
-        REQUIRE_THAT(src,
-            IsInstantiation(
-                _A("sink<T>"), _A("sink<signal_handler<Ret(Args...),A>>")));
-
-        REQUIRE_THAT(src,
-            IsInstantiation(_A("sink<signal_handler<Ret(Args...),A>>"),
-                _A("sink<signal_handler<void(int),bool>>")));
-
-        REQUIRE_THAT(src, IsClass(_A("signal_handler<T,A>")));
-        REQUIRE_THAT(src,
-            IsInstantiation(_A("signal_handler<T,A>"),
-                _A("signal_handler<Ret(Args...),A>")));
-
-        REQUIRE_THAT(src,
-            IsInstantiation(_A("signal_handler<Ret(Args...),A>"),
-                _A("signal_handler<void(int),bool>")));
-
-        save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
-    }
 }

tests/t00045/test_case.h

@@ -16,8 +16,10 @@
  * limitations under the License.
  */
 
-TEST_CASE("t00045", "[test-case][class]")
+TEST_CASE("t00045")
 {
+    using namespace clanguml::test;
+
     auto [config, db] = load_config("t00045");
 
     auto diagram = config.diagrams["t00045_class"];
@@ -28,97 +30,33 @@ TEST_CASE("t00045", "[test-case][class]")
 
     REQUIRE(model->name() == "t00045_class");
 
-    {
+    CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
-        auto src = generate_class_puml(diagram, *model);
+        REQUIRE(IsClass(src, "A"));
-        AliasMatcher _A(src);
+        REQUIRE(IsClass(src, {"ns1", "A"}));
+        REQUIRE(IsClass(src, {"ns1::ns2", "A"}));
+        REQUIRE(IsClass(src, {"ns1::ns2", "B"}));
+        REQUIRE(IsClass(src, {"ns1::ns2", "C"}));
+        REQUIRE(IsClass(src, {"ns1::ns2", "D"}));
+        REQUIRE(IsClass(src, {"ns1::ns2", "E"}));
+        REQUIRE(IsClass(src, {"ns1::ns2", "R"}));
 
-        REQUIRE_THAT(src, StartsWith("@startuml"));
+        REQUIRE(IsBaseClass(src, {"ns1::ns2", "A"}, {"ns1::ns2", "B"}));
-        REQUIRE_THAT(src, EndsWith("@enduml\n"));
+        REQUIRE(IsBaseClass(src, {"ns1", "A"}, {"ns1::ns2", "C"}));
-        REQUIRE_THAT(src, IsClass(_A("A")));
+        REQUIRE(IsBaseClass(src, {"ns1::ns2", "A"}, {"ns1::ns2", "D"}));
-        REQUIRE_THAT(src, IsClass(_A("ns1::A")));
+        REQUIRE(IsBaseClass(src, "A", {"ns1::ns2", "E"}));
-        REQUIRE_THAT(src, IsClass(_A("ns1::ns2::A")));
-        REQUIRE_THAT(src, IsClass(_A("ns1::ns2::B")));
-        REQUIRE_THAT(src, IsClass(_A("ns1::ns2::C")));
-        REQUIRE_THAT(src, IsClass(_A("ns1::ns2::D")));
-        REQUIRE_THAT(src, IsClass(_A("ns1::ns2::E")));
-        REQUIRE_THAT(src, IsClass(_A("ns1::ns2::R")));
 
-        REQUIRE_THAT(src, IsBaseClass(_A("ns1::ns2::A"), _A("ns1::ns2::B")));
+        REQUIRE(IsAssociation<Public>(src, "ns1::ns2::R", "ns1::ns2::A", "a"));
-        REQUIRE_THAT(src, IsBaseClass(_A("ns1::A"), _A("ns1::ns2::C")));
+        REQUIRE(IsAssociation<Public>(src, "ns1::ns2::R", "ns1::A", "ns1_a"));
-        REQUIRE_THAT(src, IsBaseClass(_A("ns1::ns2::A"), _A("ns1::ns2::D")));
+        REQUIRE(IsAssociation<Public>(
-        REQUIRE_THAT(src, IsBaseClass(_A("A"), _A("ns1::ns2::E")));
+            src, "ns1::ns2::R", "ns1::ns2::A", "ns1_ns2_a"));
+        REQUIRE(IsAssociation<Public>(src, "ns1::ns2::R", "A", "root_a"));
 
-        REQUIRE_THAT(
+        REQUIRE(IsDependency(src, "ns1::ns2::R", "AA"));
-            src, IsAssociation(_A("ns1::ns2::R"), _A("ns1::ns2::A"), "+a"));
-        REQUIRE_THAT(
-            src, IsAssociation(_A("ns1::ns2::R"), _A("ns1::A"), "+ns1_a"));
-        REQUIRE_THAT(src,
-            IsAssociation(_A("ns1::ns2::R"), _A("ns1::ns2::A"), "+ns1_ns2_a"));
-        REQUIRE_THAT(src, IsAssociation(_A("ns1::ns2::R"), _A("A"), "+root_a"));
 
-        REQUIRE_THAT(src, IsDependency(_A("ns1::ns2::R"), _A("AA")));
+        REQUIRE(IsFriend<Public>(src, "ns1::ns2::R", "AAA"));
-
+        REQUIRE(!IsFriend<Public>(src, "ns1::ns2::R", "ns1::ns2::AAA"));
-        REQUIRE_THAT(src, IsFriend<Public>(_A("ns1::ns2::R"), _A("AAA")));
-        REQUIRE_THAT(
-            src, !IsFriend<Public>(_A("ns1::ns2::R"), _A("ns1::ns2::AAA")));
         // TODO:
-        // REQUIRE_THAT(puml, IsFriend<Public>(_A("ns1::ns2::R"),
+        // REQUIRE(puml, IsFriend<Public>(src, "ns1::ns2::R"),
         // _A("AAAA<T>")));
-
+    });
-        save_puml(config.output_directory(), diagram->name + ".puml", src);
-    }
-    {
-        auto j = generate_class_json(diagram, *model);
-
-        using namespace json;
-
-        REQUIRE(IsClass(j, "A"));
-        REQUIRE(IsClass(j, "ns1::A"));
-        REQUIRE(IsClass(j, "ns1::ns2::A"));
-        REQUIRE(IsClass(j, "ns1::ns2::B"));
-        REQUIRE(IsClass(j, "ns1::ns2::C"));
-        REQUIRE(IsClass(j, "ns1::ns2::D"));
-        REQUIRE(IsClass(j, "ns1::ns2::E"));
-        REQUIRE(IsClass(j, "ns1::ns2::R"));
-
-        REQUIRE(IsBaseClass(j, "ns1::ns2::A", "ns1::ns2::B"));
-
-        save_json(config.output_directory(), diagram->name + ".json", j);
-    }
-    {
-        auto src = generate_class_mermaid(diagram, *model);
-
-        mermaid::AliasMatcher _A(src);
-        using mermaid::IsFriend;
-
-        REQUIRE_THAT(src, IsClass(_A("A")));
-        REQUIRE_THAT(src, IsClass(_A("ns1::A")));
-        REQUIRE_THAT(src, IsClass(_A("ns1::ns2::A")));
-        REQUIRE_THAT(src, IsClass(_A("ns1::ns2::B")));
-        REQUIRE_THAT(src, IsClass(_A("ns1::ns2::C")));
-        REQUIRE_THAT(src, IsClass(_A("ns1::ns2::D")));
-        REQUIRE_THAT(src, IsClass(_A("ns1::ns2::E")));
-        REQUIRE_THAT(src, IsClass(_A("ns1::ns2::R")));
-
-        REQUIRE_THAT(src, IsBaseClass(_A("ns1::ns2::A"), _A("ns1::ns2::B")));
-        REQUIRE_THAT(src, IsBaseClass(_A("ns1::A"), _A("ns1::ns2::C")));
-        REQUIRE_THAT(src, IsBaseClass(_A("ns1::ns2::A"), _A("ns1::ns2::D")));
-        REQUIRE_THAT(src, IsBaseClass(_A("A"), _A("ns1::ns2::E")));
-
-        REQUIRE_THAT(
-            src, IsAssociation(_A("ns1::ns2::R"), _A("ns1::ns2::A"), "+a"));
-        REQUIRE_THAT(
-            src, IsAssociation(_A("ns1::ns2::R"), _A("ns1::A"), "+ns1_a"));
-        REQUIRE_THAT(src,
-            IsAssociation(_A("ns1::ns2::R"), _A("ns1::ns2::A"), "+ns1_ns2_a"));
-        REQUIRE_THAT(src, IsAssociation(_A("ns1::ns2::R"), _A("A"), "+root_a"));
-
-        REQUIRE_THAT(src, IsDependency(_A("ns1::ns2::R"), _A("AA")));
-
-        REQUIRE_THAT(src, IsFriend<Public>(_A("ns1::ns2::R"), _A("AAA")));
-        REQUIRE_THAT(
-            src, !IsFriend<Public>(_A("ns1::ns2::R"), _A("ns1::ns2::AAA")));
-
-        save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
-    }
 }

tests/t00046/test_case.h

@@ -1,5 +1,5 @@
 /**
- * tests/t00046/test_case.cc
+ * tests/t00046/test_case.h
  *
  * Copyright (c) 2021-2024 Bartek Kryza <bkryza@gmail.com>
  *
@@ -16,8 +16,10 @@
  * limitations under the License.
  */
 
-TEST_CASE("t00046", "[test-case][class]")
+TEST_CASE("t00046")
 {
+    using namespace clanguml::test;
+
     auto [config, db] = load_config("t00046");
 
     auto diagram = config.diagrams["t00046_class"];
@@ -28,51 +30,16 @@ TEST_CASE("t00046", "[test-case][class]")
 
     REQUIRE(model->name() == "t00046_class");
 
-    {
+    CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
-        auto src = generate_class_puml(diagram, *model);
+        REQUIRE(IsClass(src, "A"));
-        AliasMatcher _A(src);
+        REQUIRE(IsClass(src, "AA"));
+        REQUIRE(IsClass(src, {"ns1::ns2", "B"}));
+        REQUIRE(IsClass(src, {"ns1::ns2", "C"}));
+        REQUIRE(IsClass(src, {"ns1::ns2", "D"}));
+        REQUIRE(IsClass(src, {"ns1::ns2", "E"}));
+        REQUIRE(IsClass(src, {"ns1::ns2", "R"}));
 
-        REQUIRE_THAT(src, StartsWith("@startuml"));
+        REQUIRE(IsField<Public>(
-        REQUIRE_THAT(src, EndsWith("@enduml\n"));
+            src, "ns1::ns2::R", "i", "std::vector<std::uint8_t>"));
-        REQUIRE_THAT(src, IsClass(_A("A")));
+    });
-        REQUIRE_THAT(src, IsClass(_A("B")));
-        REQUIRE_THAT(src, IsClass(_A("C")));
-        REQUIRE_THAT(src, IsClass(_A("D")));
-        REQUIRE_THAT(src, IsClass(_A("E")));
-        REQUIRE_THAT(src, IsClass(_A("R")));
-
-        REQUIRE_THAT(src, IsField<Public>("i", "std::vector<std::uint8_t>"));
-
-        save_puml(config.output_directory(), diagram->name + ".puml", src);
-    }
-    {
-        auto j = generate_class_json(diagram, *model);
-
-        using namespace json;
-
-        REQUIRE(get_element(j, "A").value()["type"] == "class");
-        REQUIRE(get_element(j, "AA").value()["type"] == "class");
-        REQUIRE(get_element(j, "ns1::A").value()["type"] == "class");
-        REQUIRE(get_element(j, "ns1::ns2::D").value()["type"] == "class");
-
-        save_json(config.output_directory(), diagram->name + ".json", j);
-    }
-    {
-        auto src = generate_class_mermaid(diagram, *model);
-
-        mermaid::AliasMatcher _A(src);
-        using mermaid::IsField;
-
-        REQUIRE_THAT(src, IsClass(_A("A")));
-        REQUIRE_THAT(src, IsClass(_A("AA")));
-        REQUIRE_THAT(src, IsClass(_A("ns1::ns2::B")));
-        REQUIRE_THAT(src, IsClass(_A("ns1::ns2::C")));
-        REQUIRE_THAT(src, IsClass(_A("ns1::ns2::D")));
-        REQUIRE_THAT(src, IsClass(_A("ns1::ns2::E")));
-        REQUIRE_THAT(src, IsClass(_A("ns1::ns2::R")));
-
-        REQUIRE_THAT(src, IsField<Public>("i", "std::vector<std::uint8_t>"));
-
-        save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
-    }
 }

tests/t00047/test_case.h

@@ -16,8 +16,10 @@
  * limitations under the License.
  */
 
-TEST_CASE("t00047", "[test-case][class]")
+TEST_CASE("t00047")
 {
+    using namespace clanguml::test;
+
     auto [config, db] = load_config("t00047");
 
     auto diagram = config.diagrams["t00047_class"];
@@ -28,48 +30,10 @@ TEST_CASE("t00047", "[test-case][class]")
 
     REQUIRE(model->name() == "t00047_class");
 
-    {
+    CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
-        auto src = generate_class_puml(diagram, *model);
+        REQUIRE(IsClassTemplate(src, "conditional_t<Ts...>"));
-        AliasMatcher _A(src);
+        REQUIRE(IsClass(src, "conditional_t<Else>"));
-
+        REQUIRE(IsClass(src, "conditional_t<std::true_type,Result,Tail...>"));
-        REQUIRE_THAT(src, StartsWith("@startuml"));
+        REQUIRE(IsClass(src, "conditional_t<std::false_type,Result,Tail...>"));
-        REQUIRE_THAT(src, EndsWith("@enduml\n"));
+    });
-
-        // Check if class templates exist
-        REQUIRE_THAT(src, IsClassTemplate("conditional_t", "Ts..."));
-        REQUIRE_THAT(src, IsClassTemplate("conditional_t", "Else"));
-        REQUIRE_THAT(src,
-            IsClassTemplate("conditional_t", "std::true_type,Result,Tail..."));
-        REQUIRE_THAT(src,
-            IsClassTemplate("conditional_t", "std::false_type,Result,Tail..."));
-
-        save_puml(config.output_directory(), diagram->name + ".puml", src);
-    }
-    {
-        auto j = generate_class_json(diagram, *model);
-
-        using namespace json;
-
-        REQUIRE(IsClassTemplate(j, "conditional_t<Ts...>"));
-        REQUIRE(IsClass(j, "conditional_t<Else>"));
-        REQUIRE(IsClass(j, "conditional_t<std::true_type,Result,Tail...>"));
-        REQUIRE(IsClass(j, "conditional_t<std::false_type,Result,Tail...>"));
-
-        save_json(config.output_directory(), diagram->name + ".json", j);
-    }
-    {
-        auto src = generate_class_mermaid(diagram, *model);
-
-        mermaid::AliasMatcher _A(src);
-
-        // Check if class templates exist
-        REQUIRE_THAT(src, IsClass(_A("conditional_t<Ts...>")));
-        REQUIRE_THAT(src, IsClass(_A("conditional_t<Else>")));
-        REQUIRE_THAT(
-            src, IsClass(_A("conditional_t<std::true_type,Result,Tail...>")));
-        REQUIRE_THAT(
-            src, IsClass(_A("conditional_t<std::false_type,Result,Tail...>")));
-
-        save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
-    }
 }

tests/t00048/test_case.h

@@ -16,8 +16,10 @@
  * limitations under the License.
  */
 
-TEST_CASE("t00048", "[test-case][class]")
+TEST_CASE("t00048")
 {
+    using namespace clanguml::test;
+
     auto [config, db] = load_config("t00048");
 
     auto diagram = config.diagrams["t00048_class"];
@@ -28,63 +30,19 @@ TEST_CASE("t00048", "[test-case][class]")
 
     REQUIRE(model->name() == "t00048_class");
 
-    {
+    CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
-        auto src = generate_class_puml(diagram, *model);
-        AliasMatcher _A(src);
-
-        REQUIRE_THAT(src, StartsWith("@startuml"));
-        REQUIRE_THAT(src, EndsWith("@enduml\n"));
-
         // Check if all classes exist
-        REQUIRE_THAT(src, IsAbstractClass(_A("Base")));
+        REQUIRE(IsAbstractClass(src, "Base"));
-        REQUIRE_THAT(src, IsClass(_A("A")));
+        REQUIRE(IsClass(src, "A"));
-        REQUIRE_THAT(src, IsClass(_A("B")));
+        REQUIRE(IsClass(src, "B"));
 
         // Check if class templates exist
-        REQUIRE_THAT(src, IsAbstractClassTemplate("BaseTemplate", "T"));
+        REQUIRE(IsAbstractClassTemplate(src, "BaseTemplate<T>"));
-        REQUIRE_THAT(src, IsClassTemplate("ATemplate", "T"));
+        REQUIRE(IsClassTemplate(src, "ATemplate<T>"));
-        REQUIRE_THAT(src, IsClassTemplate("BTemplate", "T"));
+        REQUIRE(IsClassTemplate(src, "BTemplate<T>"));
 
         // Check if all inheritance relationships exist
-        REQUIRE_THAT(src, IsBaseClass(_A("Base"), _A("A")));
+        REQUIRE(IsBaseClass(src, "Base", "A"));
-        REQUIRE_THAT(src, IsBaseClass(_A("Base"), _A("B")));
+        REQUIRE(IsBaseClass(src, "Base", "B"));
-
+    });
-        save_puml(config.output_directory(), diagram->name + ".puml", src);
-    }
-    {
-        auto j = generate_class_json(diagram, *model);
-
-        using namespace json;
-
-        REQUIRE(IsClass(j, "A"));
-        REQUIRE(IsClass(j, "B"));
-        REQUIRE(IsClass(j, "ATemplate<T>"));
-        REQUIRE(IsClass(j, "BTemplate<T>"));
-        REQUIRE(IsBaseClass(j, "Base", "A"));
-        REQUIRE(IsBaseClass(j, "Base", "B"));
-
-        save_json(config.output_directory(), diagram->name + ".json", j);
-    }
-    {
-        auto src = generate_class_mermaid(diagram, *model);
-
-        mermaid::AliasMatcher _A(src);
-        using mermaid::IsAbstractClass;
-
-        // Check if all classes exist
-        REQUIRE_THAT(src, IsAbstractClass(_A("Base")));
-        REQUIRE_THAT(src, IsClass(_A("A")));
-        REQUIRE_THAT(src, IsClass(_A("B")));
-
-        // Check if class templates exist
-        REQUIRE_THAT(src, IsAbstractClass(_A("BaseTemplate<T>")));
-        REQUIRE_THAT(src, IsClass(_A("ATemplate<T>")));
-        REQUIRE_THAT(src, IsClass(_A("BTemplate<T>")));
-
-        // Check if all inheritance relationships exist
-        REQUIRE_THAT(src, IsBaseClass(_A("Base"), _A("A")));
-        REQUIRE_THAT(src, IsBaseClass(_A("Base"), _A("B")));
-
-        save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
-    }
 }

tests/t00049/test_case.h

@@ -16,8 +16,10 @@
  * limitations under the License.
  */
 
-TEST_CASE("t00049", "[test-case][class]")
+TEST_CASE("t00049")
 {
+    using namespace clanguml::test;
+
     auto [config, db] = load_config("t00049");
 
     auto diagram = config.diagrams["t00049_class"];
@@ -27,78 +29,22 @@ TEST_CASE("t00049", "[test-case][class]")
     auto model = generate_class_diagram(*db, diagram);
 
     REQUIRE(model->name() == "t00049_class");
+    CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
+        REQUIRE(IsClass(src, "R"));
 
-    {
+        REQUIRE(IsClassTemplate(src, "A<T>"));
-        auto src = generate_class_puml(diagram, *model);
-        AliasMatcher _A(src);
 
-        REQUIRE_THAT(src, StartsWith("@startuml"));
+        REQUIRE(IsMethod<Public>(src, "R", "get_int_map", "A<intmap>"));
-        REQUIRE_THAT(src, EndsWith("@enduml\n"));
+        REQUIRE(IsMethod<Public>(
+            src, "R", "set_int_map", "void", "A<intmap> && int_map"));
 
-        // Check if all classes exist
+        REQUIRE(IsField<Public>(src, "R", "a_string", "A<thestring>"));
-        REQUIRE_THAT(src, IsClass(_A("R")));
+        REQUIRE(
+            IsField<Public>(src, "R", "a_vector_string", "A<string_vector>"));
+        REQUIRE(IsField<Public>(src, "R", "a_int_map", "A<intmap>"));
 
-        // Check if class templates exist
+        REQUIRE(IsInstantiation(src, "A<T>", "A<string_vector>"));
-        REQUIRE_THAT(src, IsClassTemplate("A", "T"));
+        REQUIRE(IsInstantiation(src, "A<T>", "A<thestring>"));
-
+        REQUIRE(IsInstantiation(src, "A<T>", "A<intmap>"));
-        // Check if all methods exist
+    });
-        REQUIRE_THAT(src, (IsMethod<Public>("get_int_map", "A<intmap>")));
-        REQUIRE_THAT(src,
-            (IsMethod<Public>("set_int_map", "void", "A<intmap> && int_map")));
-
-        // Check if all fields exist
-        REQUIRE_THAT(src, (IsField<Public>("a_string", "A<thestring>")));
-        REQUIRE_THAT(
-            src, (IsField<Public>("a_vector_string", "A<string_vector>")));
-        REQUIRE_THAT(src, (IsField<Public>("a_int_map", "A<intmap>")));
-
-        // Check if all relationships exist
-        REQUIRE_THAT(src, IsInstantiation(_A("A<T>"), _A("A<string_vector>")));
-        REQUIRE_THAT(src, IsInstantiation(_A("A<T>"), _A("A<thestring>")));
-        REQUIRE_THAT(src, IsInstantiation(_A("A<T>"), _A("A<intmap>")));
-
-        save_puml(config.output_directory(), diagram->name + ".puml", src);
-    }
-    {
-        auto j = generate_class_json(diagram, *model);
-
-        using namespace json;
-
-        REQUIRE(IsClass(j, "R"));
-        REQUIRE(IsClassTemplate(j, "A<T>"));
-        REQUIRE(IsInstantiation(j, "A<T>", "A<string_vector>"));
-
-        save_json(config.output_directory(), diagram->name + ".json", j);
-    }
-    {
-        auto src = generate_class_mermaid(diagram, *model);
-
-        mermaid::AliasMatcher _A(src);
-        using mermaid::IsField;
-        using mermaid::IsMethod;
-
-        // Check if all classes exist
-        REQUIRE_THAT(src, IsClass(_A("R")));
-
-        // Check if class templates exist
-        REQUIRE_THAT(src, IsClass(_A("A<T>")));
-
-        // Check if all methods exist
-        REQUIRE_THAT(src, (IsMethod<Public>("get_int_map", "A<intmap>")));
-        REQUIRE_THAT(src,
-            (IsMethod<Public>("set_int_map", "void", "A<intmap> && int_map")));
-
-        // Check if all fields exist
-        REQUIRE_THAT(src, (IsField<Public>("a_string", "A<thestring>")));
-        REQUIRE_THAT(
-            src, (IsField<Public>("a_vector_string", "A<string_vector>")));
-        REQUIRE_THAT(src, (IsField<Public>("a_int_map", "A<intmap>")));
-
-        // Check if all relationships exist
-        REQUIRE_THAT(src, IsInstantiation(_A("A<T>"), _A("A<string_vector>")));
-        REQUIRE_THAT(src, IsInstantiation(_A("A<T>"), _A("A<thestring>")));
-        REQUIRE_THAT(src, IsInstantiation(_A("A<T>"), _A("A<intmap>")));
-
-        save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
-    }
 }

tests/t00050/test_case.h

@@ -16,8 +16,10 @@
  * limitations under the License.
  */
 
-TEST_CASE("t00050", "[test-case][class]")
+TEST_CASE("t00050")
 {
+    using namespace clanguml::test;
+
     auto [config, db] = load_config("t00050");
 
     auto diagram = config.diagrams["t00050_class"];
@@ -28,73 +30,31 @@ TEST_CASE("t00050", "[test-case][class]")
 
     REQUIRE(model->name() == "t00050_class");
 
-    {
+    CHECK_CLASS_DIAGRAM(
-        auto src = generate_class_puml(diagram, *model);
+        config, diagram, *model,
-        AliasMatcher _A(src);
+        [](const auto &src) {
+            REQUIRE(IsClass(src, "A"));
+            REQUIRE(IsClass(src, "B"));
+            REQUIRE(IsClass(src, "C"));
+            REQUIRE(IsClass(src, {"utils", "D"}));
+            REQUIRE(IsEnum(src, "E"));
 
-        REQUIRE_THAT(src, StartsWith("@startuml"));
+            REQUIRE(HasNote(src, "A", "left"));
-        REQUIRE_THAT(src, EndsWith("@enduml\n"));
+            REQUIRE(HasNote(src, "A", "right"));
-
+            REQUIRE(HasNote(src, "B", "top"));
-        // Check if all classes exist
+            REQUIRE(HasNote(src, "C", "top"));
-        REQUIRE_THAT(src, IsClass(_A("A")));
+            REQUIRE(HasNote(src, "utils::D", "top"));
-        REQUIRE_THAT(src, IsClass(_A("B")));
+            REQUIRE(HasNote(src, "F<T,V,int N>", "top"));
-        REQUIRE_THAT(src, IsClass(_A("C")));
+            REQUIRE(HasNote(src, "G", "top"));
-        REQUIRE_THAT(src, IsClass(_A("utils::D")));
+            REQUIRE(HasNote(src, "G", "bottom"));
-        REQUIRE_THAT(src, IsEnum(_A("E")));
+            REQUIRE(HasNote(src, "G", "right"));
-
+        },
-        REQUIRE_THAT(src, HasNote(_A("A"), "left"));
+        [](const plantuml_t &src) {
-        REQUIRE_THAT(src, HasNote(_A("A"), "right"));
+            REQUIRE(!HasNote(src, "E", "bottom"));
-        REQUIRE_THAT(src, HasNote(_A("B"), "top"));
+            REQUIRE(!HasNote(src, "NoComment", "top"));
-        REQUIRE_THAT(src, HasNote(_A("C"), "top"));
+        },
-        REQUIRE_THAT(src, HasNote(_A("utils::D"), "top"));
+        [](const mermaid_t &src) {
-        REQUIRE_THAT(src, !HasNote(_A("E"), "bottom"));
+            REQUIRE(!HasNote(src, "E", "bottom"));
-        REQUIRE_THAT(src, !HasNote(_A("NoComment"), "top"));
+            REQUIRE(!HasNote(src, "NoComment", "top"));
-        REQUIRE_THAT(src, HasNote(_A("F<T,V,int N>"), "top"));
+        });
-        REQUIRE_THAT(src, HasNote(_A("G"), "top"));
-        REQUIRE_THAT(src, HasNote(_A("G"), "bottom"));
-        REQUIRE_THAT(src, HasNote(_A("G"), "right"));
-
-        save_puml(config.output_directory(), diagram->name + ".puml", src);
-    }
-    {
-        auto j = generate_class_json(diagram, *model);
-
-        using namespace json;
-
-        REQUIRE(IsClass(j, "A"));
-        REQUIRE(IsClass(j, "B"));
-        REQUIRE(IsClass(j, "C"));
-        REQUIRE(IsClass(j, "utils::D"));
-        REQUIRE(IsEnum(j, "E"));
-
-        save_json(config.output_directory(), diagram->name + ".json", j);
-    }
-    {
-        auto src = generate_class_mermaid(diagram, *model);
-
-        mermaid::AliasMatcher _A(src);
-        using mermaid::HasNote;
-        using mermaid::IsEnum;
-
-        // Check if all classes exist
-        REQUIRE_THAT(src, IsClass(_A("A")));
-        REQUIRE_THAT(src, IsClass(_A("B")));
-        REQUIRE_THAT(src, IsClass(_A("C")));
-        REQUIRE_THAT(src, IsClass(_A("utils::D")));
-        REQUIRE_THAT(src, IsEnum(_A("E")));
-
-        REQUIRE_THAT(src, HasNote(_A("A"), "left"));
-        REQUIRE_THAT(src, HasNote(_A("A"), "right"));
-        REQUIRE_THAT(src, HasNote(_A("B"), "top"));
-        REQUIRE_THAT(src, HasNote(_A("C"), "top"));
-        REQUIRE_THAT(src, HasNote(_A("utils::D"), "top"));
-        REQUIRE_THAT(src, !HasNote(_A("E"), "bottom"));
-        REQUIRE_THAT(src, !HasNote(_A("NoComment"), "top"));
-        REQUIRE_THAT(src, HasNote(_A("F<T,V,int N>"), "top"));
-        REQUIRE_THAT(src, HasNote(_A("G"), "top"));
-        REQUIRE_THAT(src, HasNote(_A("G"), "bottom"));
-        REQUIRE_THAT(src, HasNote(_A("G"), "right"));
-
-        save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
-    }
 }

tests/t00051/test_case.h

@@ -16,8 +16,10 @@
  * limitations under the License.
  */
 
-TEST_CASE("t00051", "[test-case][class]")
+TEST_CASE("t00051")
 {
+    using namespace clanguml::test;
+
     auto [config, db] = load_config("t00051");
 
     auto diagram = config.diagrams["t00051_class"];
@@ -28,6 +30,36 @@ TEST_CASE("t00051", "[test-case][class]")
 
     REQUIRE(model->name() == "t00051_class");
 
+    CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
+        REQUIRE(IsClass(src, "A"));
+        REQUIRE(IsInnerClass(src, "A", "A::custom_thread1"));
+        REQUIRE(IsInnerClass(src, "A", "A::custom_thread2"));
+
+        REQUIRE(IsMethod<Public>(src, "A::custom_thread1",
+            "custom_thread1<Function,Args...>", "void",
+            "Function && f, Args &&... args"));
+        REQUIRE(IsMethod<Public>(src, "A::custom_thread2", "thread", "void",
+            "(lambda at t00051.cc:59:27) &&"));
+        REQUIRE(IsMethod<Private>(src, "A", "start_thread3",
+            "B<(lambda at t00051.cc:43:18),(lambda at "
+            "t00051.cc:43:27)>"));
+        REQUIRE(IsMethod<Private>(
+            src, "A", "get_function", "(lambda at t00051.cc:48:16)"));
+
+        REQUIRE(IsClassTemplate(src, "B<F,FF=F>"));
+        REQUIRE(IsMethod<Public>(src, "B<F,FF=F>", "f", "void"));
+        REQUIRE(IsMethod<Public>(src, "B<F,FF=F>", "ff", "void"));
+
+        REQUIRE(IsClassTemplate(
+            src, "B<(lambda at t00051.cc:43:18),(lambda at t00051.cc:43:27)>"));
+
+        REQUIRE(IsInstantiation(src, "B<F,FF=F>",
+            "B<(lambda at t00051.cc:43:18),(lambda at t00051.cc:43:27)>"));
+
+        REQUIRE(IsDependency(src, "A",
+            "B<(lambda at t00051.cc:43:18),(lambda at t00051.cc:43:27)>"));
+    });
+    /*
     {
         auto src = generate_class_puml(diagram, *model);
         AliasMatcher _A(src);
@@ -128,4 +160,5 @@ TEST_CASE("t00051", "[test-case][class]")
 
         save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
     }
+     */
 }

tests/t00052/test_case.h

@@ -16,8 +16,10 @@
  * limitations under the License.
  */
 
-TEST_CASE("t00052", "[test-case][class]")
+TEST_CASE("t00052")
 {
+    using namespace clanguml::test;
+
     auto [config, db] = load_config("t00052");
 
     auto diagram = config.diagrams["t00052_class"];
@@ -28,6 +30,17 @@ TEST_CASE("t00052", "[test-case][class]")
 
     REQUIRE(model->name() == "t00052_class");
 
+    CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
+        REQUIRE(IsClass(src, "A"));
+
+        REQUIRE(IsClassTemplate(src, "B<T>"));
+
+        REQUIRE(IsMethod<Public>(src, "A", "a<T>", "T", "T p"));
+        REQUIRE(IsMethod<Public>(src, "A", "aa<F,Q>", "void", "F && f, Q q"));
+        REQUIRE(IsMethod<Public>(src, "B<T>", "b", "T", "T t"));
+        REQUIRE(IsMethod<Public>(src, "B<T>", "bb<F>", "T", "F && f, T t"));
+    });
+    /*
     {
         auto src = generate_class_puml(diagram, *model);
         AliasMatcher _A(src);
@@ -79,4 +92,5 @@ TEST_CASE("t00052", "[test-case][class]")
 
         save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
     }
+     */
 }

tests/t00053/test_case.h

@@ -16,8 +16,10 @@
  * limitations under the License.
  */
 
-TEST_CASE("t00053", "[test-case][class]")
+TEST_CASE("t00053")
 {
+    using namespace clanguml::test;
+
     auto [config, db] = load_config("t00053");
 
     auto diagram = config.diagrams["t00053_class"];
@@ -28,78 +30,98 @@ TEST_CASE("t00053", "[test-case][class]")
 
     REQUIRE(model->name() == "t00053_class");
 
-    {
+    CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
-        auto src = generate_class_puml(diagram, *model);
+        REQUIRE(IsClass(src, "a"));
-        AliasMatcher _A(src);
+        REQUIRE(IsClass(src, "b"));
+        REQUIRE(IsClass(src, "c"));
+        REQUIRE(IsClass(src, "d"));
+        REQUIRE(IsClass(src, "e"));
+        REQUIRE(IsClass(src, "f"));
+        REQUIRE(IsClass(src, "g"));
 
-        REQUIRE_THAT(src, StartsWith("@startuml"));
+        REQUIRE(IsClass(src, "A"));
-        REQUIRE_THAT(src, EndsWith("@enduml\n"));
+        REQUIRE(IsClass(src, "B"));
+        REQUIRE(IsClass(src, "C"));
+        REQUIRE(IsClass(src, "D"));
+        REQUIRE(IsClass(src, "E"));
+        REQUIRE(IsClass(src, "F"));
+        REQUIRE(IsClass(src, "G"));
+    });
+    /*
+            {
+            auto src = generate_class_puml(diagram, *model);
+            AliasMatcher _A(src);
 
-        // Check if all classes exist
+            REQUIRE_THAT(src, StartsWith("@startuml"));
-        REQUIRE_THAT(src, IsClass(_A("a")));
+            REQUIRE_THAT(src, EndsWith("@enduml\n"));
-        REQUIRE_THAT(src, IsClass(_A("b")));
-        REQUIRE_THAT(src, IsClass(_A("c")));
-        REQUIRE_THAT(src, IsClass(_A("d")));
-        REQUIRE_THAT(src, IsClass(_A("e")));
-        REQUIRE_THAT(src, IsClass(_A("f")));
-        REQUIRE_THAT(src, IsClass(_A("g")));
 
-        REQUIRE_THAT(src, IsClass(_A("A")));
+            // Check if all classes exist
-        REQUIRE_THAT(src, IsClass(_A("B")));
+            REQUIRE_THAT(src, IsClass(_A("a")));
-        REQUIRE_THAT(src, IsClass(_A("C")));
+            REQUIRE_THAT(src, IsClass(_A("b")));
-        REQUIRE_THAT(src, IsClass(_A("D")));
+            REQUIRE_THAT(src, IsClass(_A("c")));
-        REQUIRE_THAT(src, IsClass(_A("E")));
+            REQUIRE_THAT(src, IsClass(_A("d")));
-        REQUIRE_THAT(src, IsClass(_A("F")));
+            REQUIRE_THAT(src, IsClass(_A("e")));
-        REQUIRE_THAT(src, IsClass(_A("G")));
+            REQUIRE_THAT(src, IsClass(_A("f")));
+            REQUIRE_THAT(src, IsClass(_A("g")));
 
-        save_puml(config.output_directory(), diagram->name + ".puml", src);
+            REQUIRE_THAT(src, IsClass(_A("A")));
-    }
+            REQUIRE_THAT(src, IsClass(_A("B")));
+            REQUIRE_THAT(src, IsClass(_A("C")));
+            REQUIRE_THAT(src, IsClass(_A("D")));
+            REQUIRE_THAT(src, IsClass(_A("E")));
+            REQUIRE_THAT(src, IsClass(_A("F")));
+            REQUIRE_THAT(src, IsClass(_A("G")));
 
-    {
+            save_puml(config.output_directory(), diagram->name + ".puml", src);
-        auto j = generate_class_json(diagram, *model);
+        }
 
-        using namespace json;
+        {
+            auto j = generate_class_json(diagram, *model);
 
-        REQUIRE(IsClass(j, "a"));
+            using namespace json;
-        REQUIRE(IsClass(j, "b"));
-        REQUIRE(IsClass(j, "c"));
-        REQUIRE(IsClass(j, "d"));
-        REQUIRE(IsClass(j, "e"));
-        REQUIRE(IsClass(j, "f"));
-        REQUIRE(IsClass(j, "g"));
 
-        REQUIRE(IsClass(j, "A"));
+            REQUIRE(IsClass(j, "a"));
-        REQUIRE(IsClass(j, "B"));
+            REQUIRE(IsClass(j, "b"));
-        REQUIRE(IsClass(j, "C"));
+            REQUIRE(IsClass(j, "c"));
-        REQUIRE(IsClass(j, "D"));
+            REQUIRE(IsClass(j, "d"));
-        REQUIRE(IsClass(j, "E"));
+            REQUIRE(IsClass(j, "e"));
-        REQUIRE(IsClass(j, "F"));
+            REQUIRE(IsClass(j, "f"));
-        REQUIRE(IsClass(j, "G"));
+            REQUIRE(IsClass(j, "g"));
 
-        save_json(config.output_directory(), diagram->name + ".json", j);
+            REQUIRE(IsClass(j, "A"));
-    }
+            REQUIRE(IsClass(j, "B"));
-    {
+            REQUIRE(IsClass(j, "C"));
-        auto src = generate_class_mermaid(diagram, *model);
+            REQUIRE(IsClass(j, "D"));
+            REQUIRE(IsClass(j, "E"));
+            REQUIRE(IsClass(j, "F"));
+            REQUIRE(IsClass(j, "G"));
 
-        mermaid::AliasMatcher _A(src);
+            save_json(config.output_directory(), diagram->name + ".json", j);
+        }
+        {
+            auto src = generate_class_mermaid(diagram, *model);
 
-        // Check if all classes exist
+            mermaid::AliasMatcher _A(src);
-        REQUIRE_THAT(src, IsClass(_A("a")));
-        REQUIRE_THAT(src, IsClass(_A("b")));
-        REQUIRE_THAT(src, IsClass(_A("c")));
-        REQUIRE_THAT(src, IsClass(_A("d")));
-        REQUIRE_THAT(src, IsClass(_A("e")));
-        REQUIRE_THAT(src, IsClass(_A("f")));
-        REQUIRE_THAT(src, IsClass(_A("g")));
 
-        REQUIRE_THAT(src, IsClass(_A("A")));
+            // Check if all classes exist
-        REQUIRE_THAT(src, IsClass(_A("B")));
+            REQUIRE_THAT(src, IsClass(_A("a")));
-        REQUIRE_THAT(src, IsClass(_A("C")));
+            REQUIRE_THAT(src, IsClass(_A("b")));
-        REQUIRE_THAT(src, IsClass(_A("D")));
+            REQUIRE_THAT(src, IsClass(_A("c")));
-        REQUIRE_THAT(src, IsClass(_A("E")));
+            REQUIRE_THAT(src, IsClass(_A("d")));
-        REQUIRE_THAT(src, IsClass(_A("F")));
+            REQUIRE_THAT(src, IsClass(_A("e")));
-        REQUIRE_THAT(src, IsClass(_A("G")));
+            REQUIRE_THAT(src, IsClass(_A("f")));
+            REQUIRE_THAT(src, IsClass(_A("g")));
 
-        save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
+            REQUIRE_THAT(src, IsClass(_A("A")));
-    }
+            REQUIRE_THAT(src, IsClass(_A("B")));
+            REQUIRE_THAT(src, IsClass(_A("C")));
+            REQUIRE_THAT(src, IsClass(_A("D")));
+            REQUIRE_THAT(src, IsClass(_A("E")));
+            REQUIRE_THAT(src, IsClass(_A("F")));
+            REQUIRE_THAT(src, IsClass(_A("G")));
+
+            save_mermaid(config.output_directory(), diagram->name + ".mmd",
+       src);
+        }
+        */
 }

tests/t00054/test_case.h

@@ -16,8 +16,10 @@
  * limitations under the License.
  */
 
-TEST_CASE("t00054", "[test-case][class]")
+TEST_CASE("t00054")
 {
+    using namespace clanguml::test;
+
     auto [config, db] = load_config("t00054");
 
     auto diagram = config.diagrams["t00054_class"];
@@ -28,6 +30,28 @@ TEST_CASE("t00054", "[test-case][class]")
 
     REQUIRE(model->name() == "t00054_class");
 
+    CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
+        REQUIRE(IsClass(src, "a"));
+        REQUIRE(IsClass(src, "b"));
+        REQUIRE(IsClass(src, {"detail", "c"}));
+        REQUIRE(IsClass(src, {"detail", "d"}));
+        REQUIRE(IsClass(src, {"detail", "e"}));
+        REQUIRE(IsClass(src, "f"));
+        REQUIRE(IsClass(src, "g"));
+
+        REQUIRE(IsClass(src, "A"));
+        REQUIRE(IsClass(src, "B"));
+        REQUIRE(IsClass(src, {"detail2", "C"}));
+        REQUIRE(IsClass(src, {"detail2::detail3", "D"}));
+        REQUIRE(IsClass(src, {"detail2::detail3", "E"}));
+        REQUIRE(IsClass(src, {"detail2", "F"}));
+        REQUIRE(IsClass(src, "G"));
+
+        REQUIRE(IsEnum(src, {"detail4", "i"}));
+        REQUIRE(IsEnum(src, {"detail4", "h"}));
+        REQUIRE(IsEnum(src, {"detail4", "j"}));
+    });
+    /*
     {
         auto src = generate_class_puml(diagram, *model);
         AliasMatcher _A(src);
@@ -114,5 +138,5 @@ TEST_CASE("t00054", "[test-case][class]")
         REQUIRE_THAT(src, IsEnum(_A("detail4::j")));
 
         save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
-    }
+    }*/
 }

tests/t00055/test_case.h

@@ -16,8 +16,10 @@
  * limitations under the License.
  */
 
-TEST_CASE("t00055", "[test-case][class]")
+TEST_CASE("t00055")
 {
+    using namespace clanguml::test;
+
     auto [config, db] = load_config("t00055");
 
     auto diagram = config.diagrams["t00055_class"];
@@ -28,6 +30,29 @@ TEST_CASE("t00055", "[test-case][class]")
 
     REQUIRE(model->name() == "t00055_class");
 
+    CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
+        REQUIRE(IsClass(src, "A"));
+        REQUIRE(IsClass(src, "B"));
+        REQUIRE(IsClass(src, "C"));
+        REQUIRE(IsClass(src, "D"));
+        REQUIRE(IsClass(src, "E"));
+        REQUIRE(IsClass(src, "F"));
+        REQUIRE(IsClass(src, "G"));
+        REQUIRE(IsClass(src, "H"));
+        REQUIRE(IsClass(src, "I"));
+        REQUIRE(IsClass(src, "J"));
+
+        REQUIRE(IsLayoutHint(src, "A", "right", "C"));
+        REQUIRE(IsLayoutHint(src, "C", "right", "E"));
+        REQUIRE(IsLayoutHint(src, "E", "right", "G"));
+        REQUIRE(IsLayoutHint(src, "G", "right", "I"));
+
+        REQUIRE(IsLayoutHint(src, "B", "down", "D"));
+        REQUIRE(IsLayoutHint(src, "D", "down", "F"));
+        REQUIRE(IsLayoutHint(src, "F", "down", "H"));
+        REQUIRE(IsLayoutHint(src, "H", "down", "J"));
+    });
+    /*
     {
         auto src = generate_class_puml(diagram, *model);
         AliasMatcher _A(src);
@@ -96,5 +121,5 @@ TEST_CASE("t00055", "[test-case][class]")
         REQUIRE_THAT(src, IsClass(_A("J")));
 
         save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
-    }
+    }*/
 }

tests/t00056/test_case.h

@@ -16,8 +16,10 @@
  * limitations under the License.
  */
 
-TEST_CASE("t00056", "[test-case][class]")
+TEST_CASE("t00056")
 {
+    using namespace clanguml::test;
+
     auto [config, db] = load_config("t00056");
 
     auto diagram = config.diagrams["t00056_class"];
@@ -28,200 +30,267 @@ TEST_CASE("t00056", "[test-case][class]")
 
     REQUIRE(model->name() == "t00056_class");
 
-    {
+    CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
-        auto src = generate_class_puml(diagram, *model);
+        REQUIRE(IsConcept(src, "greater_than_simple<T,L>"));
-        AliasMatcher _A(src);
+        REQUIRE(IsConcept(src, "greater_than_with_requires<T,P>"));
+        REQUIRE(IsConcept(src, "max_four_bytes<T>"));
+        REQUIRE(IsConcept(src, "iterable<T>"));
+        REQUIRE(IsConcept(src, "has_value_type<T>"));
+        REQUIRE(IsConcept(src, "convertible_to_string<T>"));
+        REQUIRE(IsConcept(src, "iterable_with_value_type<T>"));
+        REQUIRE(IsConcept(src, "iterable_or_small_value_type<T>"));
 
-        REQUIRE_THAT(src, StartsWith("@startuml"));
+        REQUIRE(IsConceptRequirement(
-        REQUIRE_THAT(src, EndsWith("@enduml\n"));
+            src, "greater_than_with_requires<T,P>", "sizeof (l) > sizeof (r)"));
 
-        // Check if all classes exist
+        REQUIRE(IsConceptRequirement(src, "iterable<T>", "container.begin()"));
-        REQUIRE_THAT(src, IsConcept(_A("greater_than_simple<T,L>")));
+        REQUIRE(IsConceptRequirement(src, "iterable<T>", "container.end()"));
-        REQUIRE_THAT(src, IsConcept(_A("greater_than_with_requires<T,P>")));
-        REQUIRE_THAT(src, IsConcept(_A("max_four_bytes<T>")));
-        REQUIRE_THAT(src, IsConcept(_A("iterable<T>")));
-        REQUIRE_THAT(src, IsConcept(_A("has_value_type<T>")));
-        REQUIRE_THAT(src, IsConcept(_A("convertible_to_string<T>")));
-        REQUIRE_THAT(src, IsConcept(_A("iterable_with_value_type<T>")));
-        REQUIRE_THAT(src, IsConcept(_A("iterable_or_small_value_type<T>")));
-
-        REQUIRE_THAT(src,
-            IsConceptRequirement(_A("greater_than_with_requires<T,P>"),
-                "sizeof (l) > sizeof (r)"));
-
-        REQUIRE_THAT(
-            src, IsConceptRequirement(_A("iterable<T>"), "container.begin()"));
-        REQUIRE_THAT(
-            src, IsConceptRequirement(_A("iterable<T>"), "container.end()"));
 
 #if (LLVM_VERSION_MAJOR == 13) || (LLVM_VERSION_MAJOR == 14)
-        REQUIRE_THAT(src,
+        REQUIRE(IsConceptRequirement(
-            IsConceptRequirement(
+            src, "convertible_to_string<T>", "std::string({s})"));
-                _A("convertible_to_string<T>"), "std::string({s})"));
 #else
-        REQUIRE_THAT(src,
+        REQUIRE(
             IsConceptRequirement(
-                _A("convertible_to_string<T>"), "std::string{s}"));
+                src,"convertible_to_string<T>", "std::string{s}"));
 #endif
-        REQUIRE_THAT(src,
+        REQUIRE(IsConceptRequirement(
-            IsConceptRequirement(_A("convertible_to_string<T>"),
+            src, "convertible_to_string<T>", "{std::to_string(s)} noexcept"));
-                "{std::to_string(s)} noexcept"));
+        REQUIRE(IsConceptRequirement(src, "convertible_to_string<T>",
-        REQUIRE_THAT(src,
+            "{std::to_string(s)} -> std::same_as<std::string>"));
-            IsConceptRequirement(_A("convertible_to_string<T>"),
-                "{std::to_string(s)} -> std::same_as<std::string>"));
 
-        // Check if class templates exist
+        REQUIRE(IsClassTemplate(src, "A<max_four_bytes T>"));
-        REQUIRE_THAT(src, IsClassTemplate("A", "max_four_bytes T"));
-        REQUIRE_THAT(src, IsClassTemplate("B", "T"));
-        REQUIRE_THAT(src, IsClassTemplate("C", "convertible_to_string T"));
-        REQUIRE_THAT(
-            src, IsClassTemplate("D", "iterable T1,T2,iterable T3,T4,T5"));
-        REQUIRE_THAT(src, IsClassTemplate("E", "T1,T2,T3"));
-        REQUIRE_THAT(src, IsClassTemplate("F", "T1,T2,T3"));
 
-        // Check if all relationships exist
+        REQUIRE(IsClassTemplate(src, "B<T>"));
-        REQUIRE_THAT(src,
+        REQUIRE(IsClassTemplate(src, "C<convertible_to_string T>"));
-            IsConstraint(
+        REQUIRE(IsClassTemplate(src, "D<iterable T1,T2,iterable T3,T4,T5>"));
-                _A("A<max_four_bytes T>"), _A("max_four_bytes<T>"), "T"));
+        REQUIRE(IsClassTemplate(src, "E<T1,T2,T3>"));
+        REQUIRE(IsClassTemplate(src, "F<T1,T2,T3>"));
 
-        REQUIRE_THAT(src,
+        REQUIRE(
-            IsConstraint(_A("D<iterable T1,T2,iterable T3,T4,T5>"),
+            IsConstraint(src, "A<max_four_bytes T>", "max_four_bytes<T>", "T"));
-                _A("max_four_bytes<T>"), "T2"));
-        REQUIRE_THAT(src,
-            IsConstraint(_A("D<iterable T1,T2,iterable T3,T4,T5>"),
-                _A("max_four_bytes<T>"), "T5"));
-        REQUIRE_THAT(src,
-            IsConstraint(_A("D<iterable T1,T2,iterable T3,T4,T5>"),
-                _A("iterable<T>"), "T1"));
-        REQUIRE_THAT(src,
-            IsConstraint(_A("D<iterable T1,T2,iterable T3,T4,T5>"),
-                _A("iterable<T>"), "T3"));
 
-        REQUIRE_THAT(src,
+        REQUIRE(IsConstraint(src, "D<iterable T1,T2,iterable T3,T4,T5>",
-            IsConstraint(_A("iterable_with_value_type<T>"),
+            "max_four_bytes<T>", "T2"));
-                _A("has_value_type<T>"), "T"));
+        REQUIRE(IsConstraint(src, "D<iterable T1,T2,iterable T3,T4,T5>",
+            "max_four_bytes<T>", "T5"));
+        REQUIRE(IsConstraint(
+            src, "D<iterable T1,T2,iterable T3,T4,T5>", "iterable<T>", "T1"));
+        REQUIRE(IsConstraint(
+            src, "D<iterable T1,T2,iterable T3,T4,T5>", "iterable<T>", "T3"));
 
-        REQUIRE_THAT(src,
+        REQUIRE(IsConstraint(
-            IsConstraint(_A("iterable_or_small_value_type<T>"),
+            src, "iterable_with_value_type<T>", "has_value_type<T>", "T"));
-                _A("max_four_bytes<T>"), "T"));
-        REQUIRE_THAT(src,
-            IsConstraint(_A("iterable_or_small_value_type<T>"),
-                _A("iterable_with_value_type<T>"), "T"));
 
-        REQUIRE_THAT(src,
+        REQUIRE(IsConstraint(
-            IsConstraint(_A("E<T1,T2,T3>"),
+            src, "iterable_or_small_value_type<T>", "max_four_bytes<T>", "T"));
-                _A("greater_than_with_requires<T,P>"), "T1,T3"));
+        REQUIRE(IsConstraint(src, "iterable_or_small_value_type<T>",
+            "iterable_with_value_type<T>", "T"));
 
-        REQUIRE_THAT(src,
+        REQUIRE(IsConstraint(
-            IsConstraint(
+            src, "E<T1,T2,T3>", "greater_than_with_requires<T,P>", "T1,T3"));
-                _A("F<T1,T2,T3>"), _A("greater_than_simple<T,L>"), "T1,T3"));
 
-        save_puml(config.output_directory(), diagram->name + ".puml", src);
+        REQUIRE(IsConstraint(
-    }
+            src, "F<T1,T2,T3>", "greater_than_simple<T,L>", "T1,T3"));
-    {
+    });
-        auto j = generate_class_json(diagram, *model);
+    /*
+        {
+            auto src = generate_class_puml(diagram, *model);
+            AliasMatcher _A(src);
 
-        using namespace json;
+            REQUIRE_THAT(src, StartsWith("@startuml"));
+            REQUIRE_THAT(src, EndsWith("@enduml\n"));
 
-        REQUIRE(IsConcept(j, "greater_than_simple<T,L>"));
+            // Check if all classes exist
-        REQUIRE(IsConcept(j, "greater_than_with_requires<T,P>"));
+            REQUIRE_THAT(src, IsConcept(_A("greater_than_simple<T,L>")));
-        REQUIRE(IsConcept(j, "max_four_bytes<T>"));
+            REQUIRE_THAT(src, IsConcept(_A("greater_than_with_requires<T,P>")));
-        REQUIRE(IsConcept(j, "iterable<T>"));
+            REQUIRE_THAT(src, IsConcept(_A("max_four_bytes<T>")));
-        REQUIRE(IsConcept(j, "has_value_type<T>"));
+            REQUIRE_THAT(src, IsConcept(_A("iterable<T>")));
-        REQUIRE(IsConcept(j, "convertible_to_string<T>"));
+            REQUIRE_THAT(src, IsConcept(_A("has_value_type<T>")));
-        REQUIRE(IsConcept(j, "iterable_with_value_type<T>"));
+            REQUIRE_THAT(src, IsConcept(_A("convertible_to_string<T>")));
-        REQUIRE(IsConcept(j, "iterable_or_small_value_type<T>"));
+            REQUIRE_THAT(src, IsConcept(_A("iterable_with_value_type<T>")));
+            REQUIRE_THAT(src, IsConcept(_A("iterable_or_small_value_type<T>")));
 
-        save_json(config.output_directory(), diagram->name + ".json", j);
+            REQUIRE_THAT(src,
-    }
+                IsConceptRequirement(_A("greater_than_with_requires<T,P>"),
-    {
+                    "sizeof (l) > sizeof (r)"));
-        auto src = generate_class_mermaid(diagram, *model);
 
-        mermaid::AliasMatcher _A(src);
+            REQUIRE_THAT(
-        using mermaid::IsConcept;
+                src, IsConceptRequirement(_A("iterable<T>"),
-        using mermaid::IsConceptRequirement;
+    "container.begin()")); REQUIRE_THAT( src,
-        using mermaid::IsConstraint;
+    IsConceptRequirement(_A("iterable<T>"), "container.end()"));
 
-        // Check if all classes exist
+    #if (LLVM_VERSION_MAJOR == 13) || (LLVM_VERSION_MAJOR == 14)
-        REQUIRE_THAT(src, IsConcept(_A("greater_than_simple<T,L>")));
+            REQUIRE_THAT(src,
-        REQUIRE_THAT(src, IsConcept(_A("greater_than_with_requires<T,P>")));
+                IsConceptRequirement(
-        REQUIRE_THAT(src, IsConcept(_A("max_four_bytes<T>")));
+                    _A("convertible_to_string<T>"), "std::string({s})"));
-        REQUIRE_THAT(src, IsConcept(_A("iterable<T>")));
+    #else
-        REQUIRE_THAT(src, IsConcept(_A("has_value_type<T>")));
+            REQUIRE_THAT(src,
-        REQUIRE_THAT(src, IsConcept(_A("convertible_to_string<T>")));
+                IsConceptRequirement(
-        REQUIRE_THAT(src, IsConcept(_A("iterable_with_value_type<T>")));
+                    _A("convertible_to_string<T>"), "std::string{s}"));
-        REQUIRE_THAT(src, IsConcept(_A("iterable_or_small_value_type<T>")));
+    #endif
+            REQUIRE_THAT(src,
+                IsConceptRequirement(_A("convertible_to_string<T>"),
+                    "{std::to_string(s)} noexcept"));
+            REQUIRE_THAT(src,
+                IsConceptRequirement(_A("convertible_to_string<T>"),
+                    "{std::to_string(s)} -> std::same_as<std::string>"));
 
-        REQUIRE_THAT(src,
+            // Check if class templates exist
-            IsConceptRequirement(_A("greater_than_with_requires<T,P>"),
+            REQUIRE_THAT(src, IsClassTemplate("A", "max_four_bytes T"));
-                "sizeof (l) > sizeof (r)"));
+            REQUIRE_THAT(src, IsClassTemplate("B", "T"));
+            REQUIRE_THAT(src, IsClassTemplate("C", "convertible_to_string T"));
+            REQUIRE_THAT(
+                src, IsClassTemplate("D", "iterable T1,T2,iterable T3,T4,T5"));
+            REQUIRE_THAT(src, IsClassTemplate("E", "T1,T2,T3"));
+            REQUIRE_THAT(src, IsClassTemplate("F", "T1,T2,T3"));
 
-        REQUIRE_THAT(
+            // Check if all relationships exist
-            src, IsConceptRequirement(_A("iterable<T>"), "container.begin()"));
+            REQUIRE_THAT(src,
-        REQUIRE_THAT(
+                IsConstraint(
-            src, IsConceptRequirement(_A("iterable<T>"), "container.end()"));
+                    _A("A<max_four_bytes T>"), _A("max_four_bytes<T>"), "T"));
 
-#if (LLVM_VERSION_MAJOR == 13) || (LLVM_VERSION_MAJOR == 14)
+            REQUIRE_THAT(src,
-        REQUIRE_THAT(src,
+                IsConstraint(_A("D<iterable T1,T2,iterable T3,T4,T5>"),
-            IsConceptRequirement(
+                    _A("max_four_bytes<T>"), "T2"));
-                _A("convertible_to_string<T>"), "std::string({s})"));
+            REQUIRE_THAT(src,
-#else
+                IsConstraint(_A("D<iterable T1,T2,iterable T3,T4,T5>"),
-        REQUIRE_THAT(src,
+                    _A("max_four_bytes<T>"), "T5"));
-            IsConceptRequirement(
+            REQUIRE_THAT(src,
-                _A("convertible_to_string<T>"), "std::string{s}"));
+                IsConstraint(_A("D<iterable T1,T2,iterable T3,T4,T5>"),
-#endif
+                    _A("iterable<T>"), "T1"));
-        REQUIRE_THAT(src,
+            REQUIRE_THAT(src,
-            IsConceptRequirement(_A("convertible_to_string<T>"),
+                IsConstraint(_A("D<iterable T1,T2,iterable T3,T4,T5>"),
-                "{std::to_string(s)} noexcept"));
+                    _A("iterable<T>"), "T3"));
-        REQUIRE_THAT(src,
-            IsConceptRequirement(_A("convertible_to_string<T>"),
-                "{std::to_string(s)} -> std::same_as<std::string>"));
 
-        // Check if class templates exist
+            REQUIRE_THAT(src,
-        REQUIRE_THAT(src, IsClass(_A("A<max_four_bytes T>")));
+                IsConstraint(_A("iterable_with_value_type<T>"),
-        REQUIRE_THAT(src, IsClass(_A("B<T>")));
+                    _A("has_value_type<T>"), "T"));
-        REQUIRE_THAT(src, IsClass(_A("C<convertible_to_string T>")));
-        REQUIRE_THAT(src, IsClass(_A("D<iterable T1,T2,iterable T3,T4,T5>")));
-        REQUIRE_THAT(src, IsClass(_A("E<T1,T2,T3>")));
-        REQUIRE_THAT(src, IsClass(_A("F<T1,T2,T3>")));
 
-        // Check if all relationships exist
+            REQUIRE_THAT(src,
-        REQUIRE_THAT(src,
+                IsConstraint(_A("iterable_or_small_value_type<T>"),
-            IsConstraint(
+                    _A("max_four_bytes<T>"), "T"));
-                _A("A<max_four_bytes T>"), _A("max_four_bytes<T>"), "T"));
+            REQUIRE_THAT(src,
+                IsConstraint(_A("iterable_or_small_value_type<T>"),
+                    _A("iterable_with_value_type<T>"), "T"));
 
-        REQUIRE_THAT(src,
+            REQUIRE_THAT(src,
-            IsConstraint(_A("D<iterable T1,T2,iterable T3,T4,T5>"),
+                IsConstraint(_A("E<T1,T2,T3>"),
-                _A("max_four_bytes<T>"), "T2"));
+                    _A("greater_than_with_requires<T,P>"), "T1,T3"));
-        REQUIRE_THAT(src,
-            IsConstraint(_A("D<iterable T1,T2,iterable T3,T4,T5>"),
-                _A("max_four_bytes<T>"), "T5"));
-        REQUIRE_THAT(src,
-            IsConstraint(_A("D<iterable T1,T2,iterable T3,T4,T5>"),
-                _A("iterable<T>"), "T1"));
-        REQUIRE_THAT(src,
-            IsConstraint(_A("D<iterable T1,T2,iterable T3,T4,T5>"),
-                _A("iterable<T>"), "T3"));
 
-        REQUIRE_THAT(src,
+            REQUIRE_THAT(src,
-            IsConstraint(_A("iterable_with_value_type<T>"),
+                IsConstraint(
-                _A("has_value_type<T>"), "T"));
+                    _A("F<T1,T2,T3>"), _A("greater_than_simple<T,L>"),
+    "T1,T3"));
 
-        REQUIRE_THAT(src,
+            save_puml(config.output_directory(), diagram->name + ".puml", src);
-            IsConstraint(_A("iterable_or_small_value_type<T>"),
+        }
-                _A("max_four_bytes<T>"), "T"));
+        {
-        REQUIRE_THAT(src,
+            auto j = generate_class_json(diagram, *model);
-            IsConstraint(_A("iterable_or_small_value_type<T>"),
-                _A("iterable_with_value_type<T>"), "T"));
 
-        REQUIRE_THAT(src,
+            using namespace json;
-            IsConstraint(_A("E<T1,T2,T3>"),
-                _A("greater_than_with_requires<T,P>"), "T1,T3"));
 
-        REQUIRE_THAT(src,
+            REQUIRE(IsConcept(j, "greater_than_simple<T,L>"));
-            IsConstraint(
+            REQUIRE(IsConcept(j, "greater_than_with_requires<T,P>"));
-                _A("F<T1,T2,T3>"), _A("greater_than_simple<T,L>"), "T1,T3"));
+            REQUIRE(IsConcept(j, "max_four_bytes<T>"));
+            REQUIRE(IsConcept(j, "iterable<T>"));
+            REQUIRE(IsConcept(j, "has_value_type<T>"));
+            REQUIRE(IsConcept(j, "convertible_to_string<T>"));
+            REQUIRE(IsConcept(j, "iterable_with_value_type<T>"));
+            REQUIRE(IsConcept(j, "iterable_or_small_value_type<T>"));
 
-        save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
+            save_json(config.output_directory(), diagram->name + ".json", j);
-    }
+        }
+        {
+            auto src = generate_class_mermaid(diagram, *model);
+
+            mermaid::AliasMatcher _A(src);
+            using mermaid::IsConcept;
+            using mermaid::IsConceptRequirement;
+            using mermaid::IsConstraint;
+
+            // Check if all classes exist
+            REQUIRE_THAT(src, IsConcept(_A("greater_than_simple<T,L>")));
+            REQUIRE_THAT(src, IsConcept(_A("greater_than_with_requires<T,P>")));
+            REQUIRE_THAT(src, IsConcept(_A("max_four_bytes<T>")));
+            REQUIRE_THAT(src, IsConcept(_A("iterable<T>")));
+            REQUIRE_THAT(src, IsConcept(_A("has_value_type<T>")));
+            REQUIRE_THAT(src, IsConcept(_A("convertible_to_string<T>")));
+            REQUIRE_THAT(src, IsConcept(_A("iterable_with_value_type<T>")));
+            REQUIRE_THAT(src, IsConcept(_A("iterable_or_small_value_type<T>")));
+
+            REQUIRE_THAT(src,
+                IsConceptRequirement(_A("greater_than_with_requires<T,P>"),
+                    "sizeof (l) > sizeof (r)"));
+
+            REQUIRE_THAT(
+                src, IsConceptRequirement(_A("iterable<T>"),
+    "container.begin()")); REQUIRE_THAT( src,
+    IsConceptRequirement(_A("iterable<T>"), "container.end()"));
+
+    #if (LLVM_VERSION_MAJOR == 13) || (LLVM_VERSION_MAJOR == 14)
+            REQUIRE_THAT(src,
+                IsConceptRequirement(
+                    _A("convertible_to_string<T>"), "std::string({s})"));
+    #else
+            REQUIRE_THAT(src,
+                IsConceptRequirement(
+                    _A("convertible_to_string<T>"), "std::string{s}"));
+    #endif
+            REQUIRE_THAT(src,
+                IsConceptRequirement(_A("convertible_to_string<T>"),
+                    "{std::to_string(s)} noexcept"));
+            REQUIRE_THAT(src,
+                IsConceptRequirement(_A("convertible_to_string<T>"),
+                    "{std::to_string(s)} -> std::same_as<std::string>"));
+
+            // Check if class templates exist
+            REQUIRE_THAT(src, IsClass(_A("A<max_four_bytes T>")));
+            REQUIRE_THAT(src, IsClass(_A("B<T>")));
+            REQUIRE_THAT(src, IsClass(_A("C<convertible_to_string T>")));
+            REQUIRE_THAT(src, IsClass(_A("D<iterable T1,T2,iterable
+    T3,T4,T5>"))); REQUIRE_THAT(src, IsClass(_A("E<T1,T2,T3>")));
+            REQUIRE_THAT(src, IsClass(_A("F<T1,T2,T3>")));
+
+            // Check if all relationships exist
+            REQUIRE_THAT(src,
+                IsConstraint(
+                    _A("A<max_four_bytes T>"), _A("max_four_bytes<T>"), "T"));
+
+            REQUIRE_THAT(src,
+                IsConstraint(_A("D<iterable T1,T2,iterable T3,T4,T5>"),
+                    _A("max_four_bytes<T>"), "T2"));
+            REQUIRE_THAT(src,
+                IsConstraint(_A("D<iterable T1,T2,iterable T3,T4,T5>"),
+                    _A("max_four_bytes<T>"), "T5"));
+            REQUIRE_THAT(src,
+                IsConstraint(_A("D<iterable T1,T2,iterable T3,T4,T5>"),
+                    _A("iterable<T>"), "T1"));
+            REQUIRE_THAT(src,
+                IsConstraint(_A("D<iterable T1,T2,iterable T3,T4,T5>"),
+                    _A("iterable<T>"), "T3"));
+
+            REQUIRE_THAT(src,
+                IsConstraint(_A("iterable_with_value_type<T>"),
+                    _A("has_value_type<T>"), "T"));
+
+            REQUIRE_THAT(src,
+                IsConstraint(_A("iterable_or_small_value_type<T>"),
+                    _A("max_four_bytes<T>"), "T"));
+            REQUIRE_THAT(src,
+                IsConstraint(_A("iterable_or_small_value_type<T>"),
+                    _A("iterable_with_value_type<T>"), "T"));
+
+            REQUIRE_THAT(src,
+                IsConstraint(_A("E<T1,T2,T3>"),
+                    _A("greater_than_with_requires<T,P>"), "T1,T3"));
+
+            REQUIRE_THAT(src,
+                IsConstraint(
+                    _A("F<T1,T2,T3>"), _A("greater_than_simple<T,L>"),
+    "T1,T3"));
+
+            save_mermaid(config.output_directory(), diagram->name + ".mmd",
+    src);
+        }*/
 }

tests/t00057/test_case.h

@@ -16,8 +16,10 @@
  * limitations under the License.
  */
 
-TEST_CASE("t00057", "[test-case][class]")
+TEST_CASE("t00057")
 {
+    using namespace clanguml::test;
+
     auto [config, db] = load_config("t00057");
 
     auto diagram = config.diagrams["t00057_class"];
@@ -28,86 +30,110 @@ TEST_CASE("t00057", "[test-case][class]")
 
     REQUIRE(model->name() == "t00057_class");
 
-    {
+    CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
-        auto src = generate_class_puml(diagram, *model);
+        REQUIRE(IsClass(src, "t00057_A"));
-        AliasMatcher _A(src);
+        REQUIRE(IsClass(src, "t00057_B"));
+        REQUIRE(IsClass(src, "t00057_C"));
+        REQUIRE(IsUnion(src, "t00057_D"));
+        REQUIRE(IsClass(src, "t00057_E"));
+        REQUIRE(IsClass(src, "t00057_F"));
+        REQUIRE(IsClass(src, "t00057_G"));
+        REQUIRE(!IsClass(src, "(anonymous)"));
+        REQUIRE(IsClass(src, "t00057_R"));
 
-        REQUIRE_THAT(src, StartsWith("@startuml"));
+        REQUIRE(IsAggregation<Public>(src, "t00057_R", "t00057_A", "a"));
-        REQUIRE_THAT(src, EndsWith("@enduml\n"));
+        REQUIRE(IsAggregation<Public>(src, "t00057_R", "t00057_B", "b"));
+        REQUIRE(IsAssociation<Public>(src, "t00057_R", "t00057_C", "c"));
+        REQUIRE(IsAggregation<Public>(src, "t00057_R", "t00057_D", "d"));
+        REQUIRE(IsAssociation<Public>(src, "t00057_R", "t00057_E", "e"));
+        REQUIRE(IsAssociation<Public>(src, "t00057_R", "t00057_F", "f"));
+        REQUIRE(IsAggregation<Public>(
+            src, "t00057_E", "t00057_E::(coordinates)", "coordinates"));
+        REQUIRE(IsAggregation<Public>(
+            src, "t00057_E", "t00057_E::(height)", "height"));
+    });
 
-        // Check if all classes exist
+    /*
-        REQUIRE_THAT(src, IsClass(_A("t00057_A")));
+            {
-        REQUIRE_THAT(src, IsClass(_A("t00057_B")));
+            auto src = generate_class_puml(diagram, *model);
-        REQUIRE_THAT(src, IsClass(_A("t00057_C")));
+            AliasMatcher _A(src);
-        REQUIRE_THAT(src, IsUnion(_A("t00057_D")));
-        REQUIRE_THAT(src, IsClass(_A("t00057_E")));
-        REQUIRE_THAT(src, IsClass(_A("t00057_F")));
-        REQUIRE_THAT(src, IsClass(_A("t00057_G")));
-        REQUIRE_THAT(src, !IsClass(_A("(anonymous)")));
-        REQUIRE_THAT(src, IsClass(_A("t00057_R")));
 
-        // Check if all relationships exist
+            REQUIRE_THAT(src, StartsWith("@startuml"));
-        REQUIRE_THAT(src, IsAggregation(_A("t00057_R"), _A("t00057_A"), "+a"));
+            REQUIRE_THAT(src, EndsWith("@enduml\n"));
-        REQUIRE_THAT(src, IsAggregation(_A("t00057_R"), _A("t00057_B"), "+b"));
-        REQUIRE_THAT(src, IsAssociation(_A("t00057_R"), _A("t00057_C"), "+c"));
-        REQUIRE_THAT(src, IsAggregation(_A("t00057_R"), _A("t00057_D"), "+d"));
-        REQUIRE_THAT(src, IsAssociation(_A("t00057_R"), _A("t00057_E"), "+e"));
-        REQUIRE_THAT(src, IsAssociation(_A("t00057_R"), _A("t00057_F"), "+f"));
-        REQUIRE_THAT(src,
-            IsAggregation(
-                _A("t00057_E"), _A("t00057_E::(coordinates)"), "+coordinates"));
-        REQUIRE_THAT(src,
-            IsAggregation(_A("t00057_E"), _A("t00057_E::(height)"), "+height"));
 
-        save_puml(config.output_directory(), diagram->name + ".puml", src);
+            // Check if all classes exist
-    }
+            REQUIRE_THAT(src, IsClass(_A("t00057_A")));
+            REQUIRE_THAT(src, IsClass(_A("t00057_B")));
+            REQUIRE_THAT(src, IsClass(_A("t00057_C")));
+            REQUIRE_THAT(src, IsUnion(_A("t00057_D")));
+            REQUIRE_THAT(src, IsClass(_A("t00057_E")));
+            REQUIRE_THAT(src, IsClass(_A("t00057_F")));
+            REQUIRE_THAT(src, IsClass(_A("t00057_G")));
+            REQUIRE_THAT(src, !IsClass(_A("(anonymous)")));
+            REQUIRE_THAT(src, IsClass(_A("t00057_R")));
 
-    {
+            // Check if all relationships exist
-        auto j = generate_class_json(diagram, *model);
+            REQUIRE_THAT(src, IsAggregation(_A("t00057_R"), _A("t00057_A"),
+       "+a")); REQUIRE_THAT(src, IsAggregation(_A("t00057_R"), _A("t00057_B"),
+       "+b")); REQUIRE_THAT(src, IsAssociation(_A("t00057_R"), _A("t00057_C"),
+       "+c")); REQUIRE_THAT(src, IsAggregation(_A("t00057_R"), _A("t00057_D"),
+       "+d")); REQUIRE_THAT(src, IsAssociation(_A("t00057_R"), _A("t00057_E"),
+       "+e")); REQUIRE_THAT(src, IsAssociation(_A("t00057_R"), _A("t00057_F"),
+       "+f")); REQUIRE_THAT(src, IsAggregation( _A("t00057_E"),
+       _A("t00057_E::(coordinates)"), "+coordinates")); REQUIRE_THAT(src,
+                IsAggregation(_A("t00057_E"), _A("t00057_E::(height)"),
+       "+height"));
 
-        using namespace json;
+            save_puml(config.output_directory(), diagram->name + ".puml", src);
+        }
 
-        REQUIRE(get_element(j, "t00057_A").value()["type"] == "class");
+        {
-        REQUIRE(get_element(j, "t00057_B").value()["type"] == "class");
+            auto j = generate_class_json(diagram, *model);
-        REQUIRE(get_element(j, "t00057_C").value()["type"] == "class");
-        REQUIRE(get_element(j, "t00057_D").value()["type"] == "class");
-        REQUIRE(get_element(j, "t00057_E").value()["type"] == "class");
-        REQUIRE(get_element(j, "t00057_F").value()["type"] == "class");
-        REQUIRE(get_element(j, "t00057_G").value()["type"] == "class");
-        REQUIRE(get_element(j, "t00057_R").value()["type"] == "class");
 
-        save_json(config.output_directory(), diagram->name + ".json", j);
+            using namespace json;
-    }
-    {
-        auto src = generate_class_mermaid(diagram, *model);
 
-        mermaid::AliasMatcher _A(src);
+            REQUIRE(get_element(j, "t00057_A").value()["type"] == "class");
-        using mermaid::IsUnion;
+            REQUIRE(get_element(j, "t00057_B").value()["type"] == "class");
+            REQUIRE(get_element(j, "t00057_C").value()["type"] == "class");
+            REQUIRE(get_element(j, "t00057_D").value()["type"] == "class");
+            REQUIRE(get_element(j, "t00057_E").value()["type"] == "class");
+            REQUIRE(get_element(j, "t00057_F").value()["type"] == "class");
+            REQUIRE(get_element(j, "t00057_G").value()["type"] == "class");
+            REQUIRE(get_element(j, "t00057_R").value()["type"] == "class");
 
-        // Check if all classes exist
+            save_json(config.output_directory(), diagram->name + ".json", j);
-        REQUIRE_THAT(src, IsClass(_A("t00057_A")));
+        }
-        REQUIRE_THAT(src, IsClass(_A("t00057_B")));
+        {
-        REQUIRE_THAT(src, IsClass(_A("t00057_C")));
+            auto src = generate_class_mermaid(diagram, *model);
-        REQUIRE_THAT(src, IsUnion(_A("t00057_D")));
-        REQUIRE_THAT(src, IsClass(_A("t00057_E")));
-        REQUIRE_THAT(src, IsClass(_A("t00057_F")));
-        REQUIRE_THAT(src, IsClass(_A("t00057_G")));
-        REQUIRE_THAT(src, !IsClass(_A("(anonymous)")));
-        REQUIRE_THAT(src, IsClass(_A("t00057_R")));
 
-        // Check if all relationships exist
+            mermaid::AliasMatcher _A(src);
-        REQUIRE_THAT(src, IsAggregation(_A("t00057_R"), _A("t00057_A"), "+a"));
+            using mermaid::IsUnion;
-        REQUIRE_THAT(src, IsAggregation(_A("t00057_R"), _A("t00057_B"), "+b"));
-        REQUIRE_THAT(src, IsAssociation(_A("t00057_R"), _A("t00057_C"), "+c"));
-        REQUIRE_THAT(src, IsAggregation(_A("t00057_R"), _A("t00057_D"), "+d"));
-        REQUIRE_THAT(src, IsAssociation(_A("t00057_R"), _A("t00057_E"), "+e"));
-        REQUIRE_THAT(src, IsAssociation(_A("t00057_R"), _A("t00057_F"), "+f"));
-        REQUIRE_THAT(src,
-            IsAggregation(
-                _A("t00057_E"), _A("t00057_E::(coordinates)"), "+coordinates"));
-        REQUIRE_THAT(src,
-            IsAggregation(_A("t00057_E"), _A("t00057_E::(height)"), "+height"));
 
-        save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
+            // Check if all classes exist
-    }
+            REQUIRE_THAT(src, IsClass(_A("t00057_A")));
+            REQUIRE_THAT(src, IsClass(_A("t00057_B")));
+            REQUIRE_THAT(src, IsClass(_A("t00057_C")));
+            REQUIRE_THAT(src, IsUnion(_A("t00057_D")));
+            REQUIRE_THAT(src, IsClass(_A("t00057_E")));
+            REQUIRE_THAT(src, IsClass(_A("t00057_F")));
+            REQUIRE_THAT(src, IsClass(_A("t00057_G")));
+            REQUIRE_THAT(src, !IsClass(_A("(anonymous)")));
+            REQUIRE_THAT(src, IsClass(_A("t00057_R")));
+
+            // Check if all relationships exist
+            REQUIRE_THAT(src, IsAggregation(_A("t00057_R"), _A("t00057_A"),
+       "+a")); REQUIRE_THAT(src, IsAggregation(_A("t00057_R"), _A("t00057_B"),
+       "+b")); REQUIRE_THAT(src, IsAssociation(_A("t00057_R"), _A("t00057_C"),
+       "+c")); REQUIRE_THAT(src, IsAggregation(_A("t00057_R"), _A("t00057_D"),
+       "+d")); REQUIRE_THAT(src, IsAssociation(_A("t00057_R"), _A("t00057_E"),
+       "+e")); REQUIRE_THAT(src, IsAssociation(_A("t00057_R"), _A("t00057_F"),
+       "+f")); REQUIRE_THAT(src, IsAggregation( _A("t00057_E"),
+       _A("t00057_E::(coordinates)"), "+coordinates")); REQUIRE_THAT(src,
+                IsAggregation(_A("t00057_E"), _A("t00057_E::(height)"),
+       "+height"));
+
+            save_mermaid(config.output_directory(), diagram->name + ".mmd",
+       src);
+        }
+        */
 }

tests/t00058/.clang-uml

@@ -8,5 +8,8 @@ diagrams:
         - clanguml::t00058
     using_namespace: clanguml::t00058
     plantuml:
+      after:
+        - '{{ alias("same_as_first_type<T,Args...>") }} ..> {{ alias("first_type<T,Args...>") }}'
+    mermaid:
       after:
         - '{{ alias("same_as_first_type<T,Args...>") }} ..> {{ alias("first_type<T,Args...>") }}'

tests/t00058/test_case.h

@@ -16,8 +16,10 @@
  * limitations under the License.
  */
 
-TEST_CASE("t00058", "[test-case][class]")
+TEST_CASE("t00058")
 {
+    using namespace clanguml::test;
+
     auto [config, db] = load_config("t00058");
 
     auto diagram = config.diagrams["t00058_class"];
@@ -28,96 +30,134 @@ TEST_CASE("t00058", "[test-case][class]")
 
     REQUIRE(model->name() == "t00058_class");
 
-    {
+    CHECK_CLASS_DIAGRAM(
-        auto src = generate_class_puml(diagram, *model);
+        config, diagram, *model,
-        AliasMatcher _A(src);
+        [](const auto &src) {
+            REQUIRE(IsClassTemplate(src, "A<int,int,double,std::string>"));
+            REQUIRE(IsClassTemplate(
+                src, "B<int,std::string,int,double,A<int,int>>"));
 
-        REQUIRE_THAT(src, StartsWith("@startuml"));
+            REQUIRE(IsConcept(src, "same_as_first_type<T,Args...>"));
-        REQUIRE_THAT(src, EndsWith("@enduml\n"));
 
-        REQUIRE_THAT(src, IsClassTemplate("A", "int,int,double,std::string"));
+            REQUIRE(IsConstraint(src, "A<T,Args...>",
-        REQUIRE_THAT(
+                "same_as_first_type<T,Args...>", "T,Args..."));
-            src, IsClassTemplate("B", "int,std::string,int,double,A<int,int>"));
 
-        REQUIRE_THAT(src, IsConcept(_A("same_as_first_type<T,Args...>")));
+            REQUIRE(IsConstraint(src, "B<T,P,Args...>",
+                "same_as_first_type<T,Args...>", "T,Args..."));
 
-        REQUIRE_THAT(src,
+            REQUIRE(IsAggregation<Public>(
-            IsConstraint(_A("A<T,Args...>"),
+                src, "R", "A<int,int,double,std::string>", "aa"));
-                _A("same_as_first_type<T,Args...>"), "T,Args..."));
+            REQUIRE(IsAggregation<Public>(
+                src, "R", "B<int,std::string,int,double,A<int,int>>", "bb"));
 
-        REQUIRE_THAT(src,
+            REQUIRE(IsInstantiation(
-            IsConstraint(_A("B<T,P,Args...>"),
+                src, "A<T,Args...>", "A<int,int,double,std::string>"));
-                _A("same_as_first_type<T,Args...>"), "T,Args..."));
+            REQUIRE(IsInstantiation(src, "B<T,P,Args...>",
+                "B<int,std::string,int,double,A<int,int>>"));
+        },
+        [](const plantuml_t &src) {
+            // TODO: This dependency has to be added manually in config file
+            //       so it doesn't work in JSON
+            REQUIRE(IsDependency(
+                src, "same_as_first_type<T,Args...>", "first_type<T,Args...>"));
+        },
+        [](const mermaid_t &src) {
+            // TODO: This dependency has to be added manually in config file
+            //       so it doesn't work in JSON
+            REQUIRE(IsDependency(
+                src, "same_as_first_type<T,Args...>", "first_type<T,Args...>"));
+        });
 
-        REQUIRE_THAT(src,
+    /*
-            IsAggregation(_A("R"), _A("A<int,int,double,std::string>"), "+aa"));
+        {
-        REQUIRE_THAT(src,
+            auto src = generate_class_puml(diagram, *model);
-            IsAggregation(_A("R"),
+            AliasMatcher _A(src);
-                _A("B<int,std::string,int,double,A<int,int>>"), "+bb"));
 
-        REQUIRE_THAT(src,
+            REQUIRE_THAT(src, StartsWith("@startuml"));
-            IsInstantiation(
+            REQUIRE_THAT(src, EndsWith("@enduml\n"));
-                _A("A<T,Args...>"), _A("A<int,int,double,std::string>")));
-        REQUIRE_THAT(src,
-            IsInstantiation(_A("B<T,P,Args...>"),
-                _A("B<int,std::string,int,double,A<int,int>>")));
 
-        REQUIRE_THAT(src,
+            REQUIRE_THAT(src, IsClassTemplate("A",
-            IsDependency(_A("same_as_first_type<T,Args...>"),
+       "int,int,double,std::string")); REQUIRE_THAT( src, IsClassTemplate("B",
-                _A("first_type<T,Args...>")));
+       "int,std::string,int,double,A<int,int>"));
 
-        save_puml(config.output_directory(), diagram->name + ".puml", src);
+            REQUIRE_THAT(src, IsConcept(_A("same_as_first_type<T,Args...>")));
-    }
 
-    {
+            REQUIRE_THAT(src,
-        auto j = generate_class_json(diagram, *model);
+                IsConstraint(_A("A<T,Args...>"),
+                    _A("same_as_first_type<T,Args...>"), "T,Args..."));
 
-        using namespace json;
+            REQUIRE_THAT(src,
+                IsConstraint(_A("B<T,P,Args...>"),
+                    _A("same_as_first_type<T,Args...>"), "T,Args..."));
 
-        REQUIRE(IsClass(j, "A<int,int,double,std::string>"));
+            REQUIRE_THAT(src,
-        REQUIRE(IsClass(j, "B<int,std::string,int,double,A<int,int>>"));
+                IsAggregation(_A("R"), _A("A<int,int,double,std::string>"),
+       "+aa")); REQUIRE_THAT(src, IsAggregation(_A("R"),
+                    _A("B<int,std::string,int,double,A<int,int>>"), "+bb"));
 
-        save_json(config.output_directory(), diagram->name + ".json", j);
+            REQUIRE_THAT(src,
-    }
+                IsInstantiation(
-    {
+                    _A("A<T,Args...>"), _A("A<int,int,double,std::string>")));
-        auto src = generate_class_mermaid(diagram, *model);
+            REQUIRE_THAT(src,
+                IsInstantiation(_A("B<T,P,Args...>"),
+                    _A("B<int,std::string,int,double,A<int,int>>")));
 
-        mermaid::AliasMatcher _A(src);
+            REQUIRE_THAT(src,
-        using mermaid::IsConcept;
+                IsDependency(_A("same_as_first_type<T,Args...>"),
-        using mermaid::IsConstraint;
+                    _A("first_type<T,Args...>")));
 
-        REQUIRE_THAT(src, IsClass(_A("A<int,int,double,std::string>")));
+            save_puml(config.output_directory(), diagram->name + ".puml", src);
-        REQUIRE_THAT(
+        }
-            src, IsClass(_A("B<int,std::string,int,double,A<int,int>>")));
 
-        REQUIRE_THAT(src, IsConcept(_A("same_as_first_type<T,Args...>")));
+        {
+            auto j = generate_class_json(diagram, *model);
 
-        REQUIRE_THAT(src,
+            using namespace json;
-            IsConstraint(_A("A<T,Args...>"),
-                _A("same_as_first_type<T,Args...>"), "T,Args..."));
 
-        REQUIRE_THAT(src,
+            REQUIRE(IsClass(j, "A<int,int,double,std::string>"));
-            IsConstraint(_A("B<T,P,Args...>"),
+            REQUIRE(IsClass(j, "B<int,std::string,int,double,A<int,int>>"));
-                _A("same_as_first_type<T,Args...>"), "T,Args..."));
 
-        REQUIRE_THAT(src,
+            save_json(config.output_directory(), diagram->name + ".json", j);
-            IsAggregation(_A("R"), _A("A<int,int,double,std::string>"), "+aa"));
+        }
-        REQUIRE_THAT(src,
+        {
-            IsAggregation(_A("R"),
+            auto src = generate_class_mermaid(diagram, *model);
-                _A("B<int,std::string,int,double,A<int,int>>"), "+bb"));
 
-        REQUIRE_THAT(src,
+            mermaid::AliasMatcher _A(src);
-            IsInstantiation(
+            using mermaid::IsConcept;
-                _A("A<T,Args...>"), _A("A<int,int,double,std::string>")));
+            using mermaid::IsConstraint;
-        REQUIRE_THAT(src,
-            IsInstantiation(_A("B<T,P,Args...>"),
-                _A("B<int,std::string,int,double,A<int,int>>")));
 
-        // TODO
+            REQUIRE_THAT(src, IsClass(_A("A<int,int,double,std::string>")));
-        //        REQUIRE_THAT(src,
+            REQUIRE_THAT(
-        //            IsDependency(_A("same_as_first_type<T,Args...>"),
+                src, IsClass(_A("B<int,std::string,int,double,A<int,int>>")));
-        //                _A("first_type<T,Args...>")));
 
-        save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
+            REQUIRE_THAT(src, IsConcept(_A("same_as_first_type<T,Args...>")));
-    }
+
+            REQUIRE_THAT(src,
+                IsConstraint(_A("A<T,Args...>"),
+                    _A("same_as_first_type<T,Args...>"), "T,Args..."));
+
+            REQUIRE_THAT(src,
+                IsConstraint(_A("B<T,P,Args...>"),
+                    _A("same_as_first_type<T,Args...>"), "T,Args..."));
+
+            REQUIRE_THAT(src,
+                IsAggregation(_A("R"), _A("A<int,int,double,std::string>"),
+       "+aa")); REQUIRE_THAT(src, IsAggregation(_A("R"),
+                    _A("B<int,std::string,int,double,A<int,int>>"), "+bb"));
+
+            REQUIRE_THAT(src,
+                IsInstantiation(
+                    _A("A<T,Args...>"), _A("A<int,int,double,std::string>")));
+            REQUIRE_THAT(src,
+                IsInstantiation(_A("B<T,P,Args...>"),
+                    _A("B<int,std::string,int,double,A<int,int>>")));
+
+            // TODO
+            //        REQUIRE_THAT(src,
+            //            IsDependency(_A("same_as_first_type<T,Args...>"),
+            //                _A("first_type<T,Args...>")));
+
+            save_mermaid(config.output_directory(), diagram->name + ".mmd",
+       src);
+        }*/
 }

tests/t00059/test_case.h

@@ -16,8 +16,10 @@
  * limitations under the License.
  */
 
-TEST_CASE("t00059", "[test-case][class]")
+TEST_CASE("t00059")
 {
+    using namespace clanguml::test;
+
     auto [config, db] = load_config("t00059");
 
     auto diagram = config.diagrams["t00059_class"];
@@ -28,138 +30,186 @@ TEST_CASE("t00059", "[test-case][class]")
 
     REQUIRE(model->name() == "t00059_class");
 
-    {
+    CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
-        auto src = generate_class_puml(diagram, *model);
+        REQUIRE(IsConcept(src, "fruit_c<T>"));
-        AliasMatcher _A(src);
+        REQUIRE(IsConcept(src, "apple_c<T>"));
+        REQUIRE(IsConcept(src, "orange_c<T>"));
 
-        REQUIRE_THAT(src, StartsWith("@startuml"));
+        REQUIRE(IsConstraint(src, "apple_c<T>", "fruit_c<T>", "T", "up"));
-        REQUIRE_THAT(src, EndsWith("@enduml\n"));
+        REQUIRE(IsConstraint(src, "orange_c<T>", "fruit_c<T>", "T", "up"));
 
-        REQUIRE_THAT(src, IsConcept(_A("fruit_c<T>")));
+        REQUIRE(IsConceptRequirement(src, "apple_c<T>", "t.get_sweetness()"));
-        REQUIRE_THAT(src, IsConcept(_A("apple_c<T>")));
+        REQUIRE(IsConceptRequirement(src, "apple_c<T>", "t.get_bitterness()"));
-        REQUIRE_THAT(src, IsConcept(_A("orange_c<T>")));
 
-        REQUIRE_THAT(
+        REQUIRE(IsClass(src, "gala_apple"));
-            src, IsConstraint(_A("apple_c<T>"), _A("fruit_c<T>"), "T", "up"));
+        REQUIRE(IsClass(src, "empire_apple"));
-        REQUIRE_THAT(
+        REQUIRE(IsClass(src, "valencia_orange"));
-            src, IsConstraint(_A("orange_c<T>"), _A("fruit_c<T>"), "T", "up"));
+        REQUIRE(IsClass(src, "lima_orange"));
+        REQUIRE(IsClass(src, "R"));
 
-        REQUIRE_THAT(
+        REQUIRE(IsClassTemplate(src, "fruit_factory<apple_c TA,orange_c TO>"));
-            src, IsConceptRequirement(_A("apple_c<T>"), "t.get_sweetness()"));
-        REQUIRE_THAT(
-            src, IsConceptRequirement(_A("apple_c<T>"), "t.get_bitterness()"));
 
-        REQUIRE_THAT(src, IsClass(_A("gala_apple")));
+        REQUIRE(IsDependency(src, "fruit_factory<gala_apple,valencia_orange>",
-        REQUIRE_THAT(src, IsClass(_A("empire_apple")));
+            "gala_apple", "up"));
-        REQUIRE_THAT(src, IsClass(_A("valencia_orange")));
+        REQUIRE(IsDependency(src, "fruit_factory<gala_apple,valencia_orange>",
-        REQUIRE_THAT(src, IsClass(_A("lima_orange")));
+            "valencia_orange", "up"));
-        REQUIRE_THAT(src, IsClass(_A("R")));
 
-        REQUIRE_THAT(
+        REQUIRE(IsDependency(src, "fruit_factory<empire_apple,lima_orange>",
-            src, IsClassTemplate("fruit_factory", "apple_c TA,orange_c TO"));
+            "empire_apple", "up"));
+        REQUIRE(IsDependency(src, "fruit_factory<empire_apple,lima_orange>",
+            "lima_orange", "up"));
 
-        REQUIRE_THAT(src,
+        REQUIRE(IsAggregation<Public>(src, "R",
-            IsDependency(_A("fruit_factory<gala_apple,valencia_orange>"),
+            "fruit_factory<gala_apple,valencia_orange>", "factory_1", "", "",
-                _A("gala_apple"), "up"));
+            "up"));
-        REQUIRE_THAT(src,
+        REQUIRE(IsAggregation<Public>(src, "R",
-            IsDependency(_A("fruit_factory<gala_apple,valencia_orange>"),
+            "fruit_factory<empire_apple,lima_orange>", "factory_2", "", "",
-                _A("valencia_orange"), "up"));
+            "up"));
 
-        REQUIRE_THAT(src,
+        REQUIRE(IsInstantiation(src, "fruit_factory<apple_c TA,orange_c TO>",
-            IsDependency(_A("fruit_factory<empire_apple,lima_orange>"),
+            "fruit_factory<gala_apple,valencia_orange>", "up"));
-                _A("empire_apple"), "up"));
+        REQUIRE(IsInstantiation(src, "fruit_factory<apple_c TA,orange_c TO>",
-        REQUIRE_THAT(src,
+            "fruit_factory<empire_apple,lima_orange>", "up"));
-            IsDependency(_A("fruit_factory<empire_apple,lima_orange>"),
+    });
-                _A("lima_orange"), "up"));
+    /*
 
-        REQUIRE_THAT(src,
+        {
-            IsAggregation(_A("R"),
+            auto src = generate_class_puml(diagram, *model);
-                _A("fruit_factory<gala_apple,valencia_orange>"), "+factory_1",
+            AliasMatcher _A(src);
-                "", "", "up"));
-        REQUIRE_THAT(src,
-            IsAggregation(_A("R"),
-                _A("fruit_factory<empire_apple,lima_orange>"), "+factory_2", "",
-                "", "up"));
 
-        REQUIRE_THAT(src,
+            REQUIRE_THAT(src, StartsWith("@startuml"));
-            IsInstantiation(_A("fruit_factory<apple_c TA,orange_c TO>"),
+            REQUIRE_THAT(src, EndsWith("@enduml\n"));
-                _A("fruit_factory<gala_apple,valencia_orange>"), "up"));
-        REQUIRE_THAT(src,
-            IsInstantiation(_A("fruit_factory<apple_c TA,orange_c TO>"),
-                _A("fruit_factory<empire_apple,lima_orange>"), "up"));
 
-        save_puml(config.output_directory(), diagram->name + ".puml", src);
+            REQUIRE_THAT(src, IsConcept(_A("fruit_c<T>")));
-    }
+            REQUIRE_THAT(src, IsConcept(_A("apple_c<T>")));
+            REQUIRE_THAT(src, IsConcept(_A("orange_c<T>")));
 
-    {
+            REQUIRE_THAT(
-        auto j = generate_class_json(diagram, *model);
+                src, IsConstraint(_A("apple_c<T>"), _A("fruit_c<T>"), "T",
+       "up")); REQUIRE_THAT( src, IsConstraint(_A("orange_c<T>"),
+       _A("fruit_c<T>"), "T", "up"));
 
-        using namespace json;
+            REQUIRE_THAT(
+                src, IsConceptRequirement(_A("apple_c<T>"),
+       "t.get_sweetness()")); REQUIRE_THAT( src,
+       IsConceptRequirement(_A("apple_c<T>"), "t.get_bitterness()"));
 
-        REQUIRE(IsConcept(j, "fruit_c<T>"));
+            REQUIRE_THAT(src, IsClass(_A("gala_apple")));
-        REQUIRE(IsConcept(j, "apple_c<T>"));
+            REQUIRE_THAT(src, IsClass(_A("empire_apple")));
-        REQUIRE(IsConcept(j, "orange_c<T>"));
+            REQUIRE_THAT(src, IsClass(_A("valencia_orange")));
+            REQUIRE_THAT(src, IsClass(_A("lima_orange")));
+            REQUIRE_THAT(src, IsClass(_A("R")));
 
-        save_json(config.output_directory(), diagram->name + ".json", j);
+            REQUIRE_THAT(
-    }
+                src, IsClassTemplate("fruit_factory", "apple_c TA,orange_c
-    {
+       TO"));
-        auto src = generate_class_mermaid(diagram, *model);
 
-        mermaid::AliasMatcher _A(src);
+            REQUIRE_THAT(src,
-        using mermaid::IsConcept;
+                IsDependency(_A("fruit_factory<gala_apple,valencia_orange>"),
-        using mermaid::IsConceptRequirement;
+                    _A("gala_apple"), "up"));
-        using mermaid::IsConstraint;
+            REQUIRE_THAT(src,
+                IsDependency(_A("fruit_factory<gala_apple,valencia_orange>"),
+                    _A("valencia_orange"), "up"));
 
-        REQUIRE_THAT(src, IsConcept(_A("fruit_c<T>")));
+            REQUIRE_THAT(src,
-        REQUIRE_THAT(src, IsConcept(_A("apple_c<T>")));
+                IsDependency(_A("fruit_factory<empire_apple,lima_orange>"),
-        REQUIRE_THAT(src, IsConcept(_A("orange_c<T>")));
+                    _A("empire_apple"), "up"));
+            REQUIRE_THAT(src,
+                IsDependency(_A("fruit_factory<empire_apple,lima_orange>"),
+                    _A("lima_orange"), "up"));
 
-        REQUIRE_THAT(
+            REQUIRE_THAT(src,
-            src, IsConstraint(_A("apple_c<T>"), _A("fruit_c<T>"), "T"));
+                IsAggregation(_A("R"),
-        REQUIRE_THAT(
+                    _A("fruit_factory<gala_apple,valencia_orange>"),
-            src, IsConstraint(_A("orange_c<T>"), _A("fruit_c<T>"), "T"));
+       "+factory_1",
+                    "", "", "up"));
+            REQUIRE_THAT(src,
+                IsAggregation(_A("R"),
+                    _A("fruit_factory<empire_apple,lima_orange>"), "+factory_2",
+       "",
+                    "", "up"));
 
-        REQUIRE_THAT(
+            REQUIRE_THAT(src,
-            src, IsConceptRequirement(_A("apple_c<T>"), "t.get_sweetness()"));
+                IsInstantiation(_A("fruit_factory<apple_c TA,orange_c TO>"),
-        REQUIRE_THAT(
+                    _A("fruit_factory<gala_apple,valencia_orange>"), "up"));
-            src, IsConceptRequirement(_A("apple_c<T>"), "t.get_bitterness()"));
+            REQUIRE_THAT(src,
+                IsInstantiation(_A("fruit_factory<apple_c TA,orange_c TO>"),
+                    _A("fruit_factory<empire_apple,lima_orange>"), "up"));
 
-        REQUIRE_THAT(src, IsClass(_A("gala_apple")));
+            save_puml(config.output_directory(), diagram->name + ".puml", src);
-        REQUIRE_THAT(src, IsClass(_A("empire_apple")));
+        }
-        REQUIRE_THAT(src, IsClass(_A("valencia_orange")));
-        REQUIRE_THAT(src, IsClass(_A("lima_orange")));
-        REQUIRE_THAT(src, IsClass(_A("R")));
 
-        REQUIRE_THAT(src, IsClass(_A("fruit_factory<apple_c TA,orange_c TO>")));
+        {
+            auto j = generate_class_json(diagram, *model);
 
-        REQUIRE_THAT(src,
+            using namespace json;
-            IsDependency(_A("fruit_factory<gala_apple,valencia_orange>"),
-                _A("gala_apple")));
-        REQUIRE_THAT(src,
-            IsDependency(_A("fruit_factory<gala_apple,valencia_orange>"),
-                _A("valencia_orange")));
 
-        REQUIRE_THAT(src,
+            REQUIRE(IsConcept(j, "fruit_c<T>"));
-            IsDependency(_A("fruit_factory<empire_apple,lima_orange>"),
+            REQUIRE(IsConcept(j, "apple_c<T>"));
-                _A("empire_apple")));
+            REQUIRE(IsConcept(j, "orange_c<T>"));
-        REQUIRE_THAT(src,
-            IsDependency(_A("fruit_factory<empire_apple,lima_orange>"),
-                _A("lima_orange")));
 
-        REQUIRE_THAT(src,
+            save_json(config.output_directory(), diagram->name + ".json", j);
-            IsAggregation(_A("R"),
+        }
-                _A("fruit_factory<gala_apple,valencia_orange>"), "+factory_1"));
+        {
-        REQUIRE_THAT(src,
+            auto src = generate_class_mermaid(diagram, *model);
-            IsAggregation(_A("R"),
-                _A("fruit_factory<empire_apple,lima_orange>"), "+factory_2"));
 
-        REQUIRE_THAT(src,
+            mermaid::AliasMatcher _A(src);
-            IsInstantiation(_A("fruit_factory<apple_c TA,orange_c TO>"),
+            using mermaid::IsConcept;
-                _A("fruit_factory<gala_apple,valencia_orange>")));
+            using mermaid::IsConceptRequirement;
-        REQUIRE_THAT(src,
+            using mermaid::IsConstraint;
-            IsInstantiation(_A("fruit_factory<apple_c TA,orange_c TO>"),
-                _A("fruit_factory<empire_apple,lima_orange>")));
 
-        save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
+            REQUIRE_THAT(src, IsConcept(_A("fruit_c<T>")));
-    }
+            REQUIRE_THAT(src, IsConcept(_A("apple_c<T>")));
+            REQUIRE_THAT(src, IsConcept(_A("orange_c<T>")));
+
+            REQUIRE_THAT(
+                src, IsConstraint(_A("apple_c<T>"), _A("fruit_c<T>"), "T"));
+            REQUIRE_THAT(
+                src, IsConstraint(_A("orange_c<T>"), _A("fruit_c<T>"), "T"));
+
+            REQUIRE_THAT(
+                src, IsConceptRequirement(_A("apple_c<T>"),
+       "t.get_sweetness()")); REQUIRE_THAT( src,
+       IsConceptRequirement(_A("apple_c<T>"), "t.get_bitterness()"));
+
+            REQUIRE_THAT(src, IsClass(_A("gala_apple")));
+            REQUIRE_THAT(src, IsClass(_A("empire_apple")));
+            REQUIRE_THAT(src, IsClass(_A("valencia_orange")));
+            REQUIRE_THAT(src, IsClass(_A("lima_orange")));
+            REQUIRE_THAT(src, IsClass(_A("R")));
+
+            REQUIRE_THAT(src, IsClass(_A("fruit_factory<apple_c TA,orange_c
+       TO>")));
+
+            REQUIRE_THAT(src,
+                IsDependency(_A("fruit_factory<gala_apple,valencia_orange>"),
+                    _A("gala_apple")));
+            REQUIRE_THAT(src,
+                IsDependency(_A("fruit_factory<gala_apple,valencia_orange>"),
+                    _A("valencia_orange")));
+
+            REQUIRE_THAT(src,
+                IsDependency(_A("fruit_factory<empire_apple,lima_orange>"),
+                    _A("empire_apple")));
+            REQUIRE_THAT(src,
+                IsDependency(_A("fruit_factory<empire_apple,lima_orange>"),
+                    _A("lima_orange")));
+
+            REQUIRE_THAT(src,
+                IsAggregation(_A("R"),
+                    _A("fruit_factory<gala_apple,valencia_orange>"),
+       "+factory_1")); REQUIRE_THAT(src, IsAggregation(_A("R"),
+                    _A("fruit_factory<empire_apple,lima_orange>"),
+       "+factory_2"));
+
+            REQUIRE_THAT(src,
+                IsInstantiation(_A("fruit_factory<apple_c TA,orange_c TO>"),
+                    _A("fruit_factory<gala_apple,valencia_orange>")));
+            REQUIRE_THAT(src,
+                IsInstantiation(_A("fruit_factory<apple_c TA,orange_c TO>"),
+                    _A("fruit_factory<empire_apple,lima_orange>")));
+
+            save_mermaid(config.output_directory(), diagram->name + ".mmd",
+       src);
+        }*/
 }

tests/t00060/test_case.h

@@ -16,8 +16,10 @@
  * limitations under the License.
  */
 
-TEST_CASE("t00060", "[test-case][class]")
+TEST_CASE("t00060")
 {
+    using namespace clanguml::test;
+
     auto [config, db] = load_config("t00060");
 
     auto diagram = config.diagrams["t00060_class"];
@@ -28,59 +30,72 @@ TEST_CASE("t00060", "[test-case][class]")
 
     REQUIRE(model->name() == "t00060_class");
 
-    {
+    CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
-        auto src = generate_class_puml(diagram, *model);
+        REQUIRE(IsClass(src, "A"));
-        AliasMatcher _A(src);
+        REQUIRE(IsClass(src, "B"));
+        REQUIRE(IsClass(src, "C"));
+        REQUIRE(IsClass(src, "D"));
+        REQUIRE(!IsClass(src, "E"));
+        REQUIRE(!IsClass(src, "F"));
 
-        REQUIRE_THAT(src, StartsWith("@startuml"));
+        REQUIRE(IsClassTemplate(src, "G<T>"));
-        REQUIRE_THAT(src, EndsWith("@enduml\n"));
+        REQUIRE(IsClassTemplate(src, "H<T,P>"));
+    });
+    /*
+{
+    auto src = generate_class_puml(diagram, *model);
+    AliasMatcher _A(src);
 
-        // Check if all classes exist
+    REQUIRE_THAT(src, StartsWith("@startuml"));
-        REQUIRE_THAT(src, IsClass(_A("A")));
+    REQUIRE_THAT(src, EndsWith("@enduml\n"));
-        REQUIRE_THAT(src, IsClass(_A("B")));
-        REQUIRE_THAT(src, IsClass(_A("C")));
-        REQUIRE_THAT(src, IsClass(_A("D")));
-        REQUIRE_THAT(src, !IsClass(_A("E")));
-        REQUIRE_THAT(src, !IsClass(_A("F")));
 
-        // Check if class templates exist
+    // Check if all classes exist
-        REQUIRE_THAT(src, IsClassTemplate("G", "T"));
+    REQUIRE_THAT(src, IsClass(_A("A")));
-        REQUIRE_THAT(src, IsClassTemplate("H", "T,P"));
+    REQUIRE_THAT(src, IsClass(_A("B")));
+    REQUIRE_THAT(src, IsClass(_A("C")));
+    REQUIRE_THAT(src, IsClass(_A("D")));
+    REQUIRE_THAT(src, !IsClass(_A("E")));
+    REQUIRE_THAT(src, !IsClass(_A("F")));
 
-        save_puml(config.output_directory(), diagram->name + ".puml", src);
+    // Check if class templates exist
-    }
+    REQUIRE_THAT(src, IsClassTemplate("G", "T"));
+    REQUIRE_THAT(src, IsClassTemplate("H", "T,P"));
 
-    {
+    save_puml(config.output_directory(), diagram->name + ".puml", src);
-        auto j = generate_class_json(diagram, *model);
+}
 
-        using namespace json;
+{
+    auto j = generate_class_json(diagram, *model);
 
-        REQUIRE(IsClass(j, "A"));
+    using namespace json;
-        REQUIRE(IsClass(j, "B"));
-        REQUIRE(IsClass(j, "C"));
-        REQUIRE(IsClass(j, "D"));
-        REQUIRE(!IsClass(j, "E"));
-        REQUIRE(!IsClass(j, "F"));
 
-        save_json(config.output_directory(), diagram->name + ".json", j);
+    REQUIRE(IsClass(j, "A"));
-    }
+    REQUIRE(IsClass(j, "B"));
-    {
+    REQUIRE(IsClass(j, "C"));
-        auto src = generate_class_mermaid(diagram, *model);
+    REQUIRE(IsClass(j, "D"));
+    REQUIRE(!IsClass(j, "E"));
+    REQUIRE(!IsClass(j, "F"));
 
-        mermaid::AliasMatcher _A(src);
+    save_json(config.output_directory(), diagram->name + ".json", j);
+}
+{
+    auto src = generate_class_mermaid(diagram, *model);
 
-        // Check if all classes exist
+    mermaid::AliasMatcher _A(src);
-        REQUIRE_THAT(src, IsClass(_A("A")));
-        REQUIRE_THAT(src, IsClass(_A("B")));
-        REQUIRE_THAT(src, IsClass(_A("C")));
-        REQUIRE_THAT(src, IsClass(_A("D")));
-        REQUIRE_THAT(src, !IsClass(_A("E")));
-        REQUIRE_THAT(src, !IsClass(_A("F")));
 
-        // Check if class templates exist
+    // Check if all classes exist
-        REQUIRE_THAT(src, IsClass(_A("G<T>")));
+    REQUIRE_THAT(src, IsClass(_A("A")));
-        REQUIRE_THAT(src, IsClass(_A("H<T,P>")));
+    REQUIRE_THAT(src, IsClass(_A("B")));
+    REQUIRE_THAT(src, IsClass(_A("C")));
+    REQUIRE_THAT(src, IsClass(_A("D")));
+    REQUIRE_THAT(src, !IsClass(_A("E")));
+    REQUIRE_THAT(src, !IsClass(_A("F")));
 
-        save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
+    // Check if class templates exist
-    }
+    REQUIRE_THAT(src, IsClass(_A("G<T>")));
+    REQUIRE_THAT(src, IsClass(_A("H<T,P>")));
+
+    save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
+}
+     */
 }

tests/t00061/test_case.h

@@ -16,8 +16,10 @@
  * limitations under the License.
  */
 
-TEST_CASE("t00061", "[test-case][class]")
+TEST_CASE("t00061")
 {
+    using namespace clanguml::test;
+
     auto [config, db] = load_config("t00061");
 
     auto diagram = config.diagrams["t00061_class"];
@@ -28,42 +30,49 @@ TEST_CASE("t00061", "[test-case][class]")
 
     REQUIRE(model->name() == "t00061_class");
 
-    {
+    CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
-        auto src = generate_class_puml(diagram, *model);
+        REQUIRE(IsClass(src, "A"));
-        AliasMatcher _A(src);
+        REQUIRE(!IsClass(src, "B"));
+        REQUIRE(!IsClass(src, "C"));
+    });
+    /*
+{
+    auto src = generate_class_puml(diagram, *model);
+    AliasMatcher _A(src);
 
-        REQUIRE_THAT(src, StartsWith("@startuml"));
+    REQUIRE_THAT(src, StartsWith("@startuml"));
-        REQUIRE_THAT(src, EndsWith("@enduml\n"));
+    REQUIRE_THAT(src, EndsWith("@enduml\n"));
 
-        // Check if all classes exist
+    // Check if all classes exist
-        REQUIRE_THAT(src, IsClass(_A("A")));
+    REQUIRE_THAT(src, IsClass(_A("A")));
-        REQUIRE_THAT(src, !IsClass(_A("B")));
+    REQUIRE_THAT(src, !IsClass(_A("B")));
-        REQUIRE_THAT(src, !IsClass(_A("C")));
+    REQUIRE_THAT(src, !IsClass(_A("C")));
 
-        save_puml(config.output_directory(), diagram->name + ".puml", src);
+    save_puml(config.output_directory(), diagram->name + ".puml", src);
-    }
+}
 
-    {
+{
-        auto j = generate_class_json(diagram, *model);
+    auto j = generate_class_json(diagram, *model);
 
-        using namespace json;
+    using namespace json;
 
-        REQUIRE(IsClass(j, "A"));
+    REQUIRE(IsClass(j, "A"));
-        REQUIRE(!IsClass(j, "B"));
+    REQUIRE(!IsClass(j, "B"));
-        REQUIRE(!IsClass(j, "C"));
+    REQUIRE(!IsClass(j, "C"));
 
-        save_json(config.output_directory(), diagram->name + ".json", j);
+    save_json(config.output_directory(), diagram->name + ".json", j);
-    }
+}
-    {
+{
-        auto src = generate_class_mermaid(diagram, *model);
+    auto src = generate_class_mermaid(diagram, *model);
 
-        mermaid::AliasMatcher _A(src);
+    mermaid::AliasMatcher _A(src);
 
-        // Check if all classes exist
+    // Check if all classes exist
-        REQUIRE_THAT(src, IsClass(_A("A")));
+    REQUIRE_THAT(src, IsClass(_A("A")));
-        REQUIRE_THAT(src, !IsClass(_A("B")));
+    REQUIRE_THAT(src, !IsClass(_A("B")));
-        REQUIRE_THAT(src, !IsClass(_A("C")));
+    REQUIRE_THAT(src, !IsClass(_A("C")));
 
-        save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
+    save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
-    }
+}
+     */
 }

tests/t00062/test_case.h

@@ -16,8 +16,10 @@
  * limitations under the License.
  */
 
-TEST_CASE("t00062", "[test-case][class]")
+TEST_CASE("t00062")
 {
+    using namespace clanguml::test;
+
     auto [config, db] = load_config("t00062");
 
     auto diagram = config.diagrams["t00062_class"];
@@ -28,6 +30,55 @@ TEST_CASE("t00062", "[test-case][class]")
 
     REQUIRE(model->name() == "t00062_class");
 
+    CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
+        REQUIRE(!src.contains("type-parameter-"));
+
+        REQUIRE(IsClassTemplate(src, "A<T>"));
+        REQUIRE(IsClassTemplate(src, "A<U &>"));
+        REQUIRE(IsClassTemplate(src, "A<U &&>"));
+        REQUIRE(IsClassTemplate(src, "A<U const&>"));
+        REQUIRE(IsClassTemplate(src, "A<M C::*>"));
+        REQUIRE(IsClassTemplate(src, "A<M C::* &&>"));
+        REQUIRE(IsClassTemplate(src, "A<M (C::*)(Arg)>"));
+        REQUIRE(IsClassTemplate(src, "A<int (C::*)(bool)>"));
+        REQUIRE(IsClassTemplate(src, "A<M (C::*)(Arg) &&>"));
+        REQUIRE(IsClassTemplate(src, "A<M (C::*)(Arg1,Arg2,Arg3)>"));
+        REQUIRE(IsClassTemplate(src, "A<float (C::*)(int) &&>"));
+
+        REQUIRE(IsClassTemplate(src, "A<char[N]>"));
+        REQUIRE(IsClassTemplate(src, "A<char[1000]>"));
+
+        REQUIRE(IsClassTemplate(src, "A<U(...)>"));
+        REQUIRE(IsClassTemplate(src, "A<C<T>>"));
+        REQUIRE(IsClassTemplate(src, "A<C<T,Args...>>"));
+
+        REQUIRE(IsField<Public>(src, "A<U &>", "u", "U &"));
+        REQUIRE(IsField<Public>(src, "A<U **>", "u", "U **"));
+        REQUIRE(IsField<Public>(src, "A<U ***>", "u", "U ***"));
+        REQUIRE(IsField<Public>(src, "A<U &&>", "u", "U &&"));
+        REQUIRE(IsField<Public>(src, "A<const U &>", "u", "const U &"));
+        REQUIRE(IsField<Public>(src, "A<C &>", "c", "C &"));
+        REQUIRE(IsField<Public>(src, "A<M C::*>", "m", "M C::*"));
+
+        REQUIRE(IsInstantiation(src, "A<T>", "A<U &>"));
+        REQUIRE(IsInstantiation(src, "A<T>", "A<U &&>"));
+        REQUIRE(IsInstantiation(src, "A<T>", "A<M C::*>"));
+        REQUIRE(IsInstantiation(src, "A<U &&>", "A<M C::* &&>"));
+
+        REQUIRE(IsInstantiation(src, "A<T>", "A<M (C::*)(Arg)>"));
+        REQUIRE(
+            IsInstantiation(src, "A<M (C::*)(Arg)>", "A<int (C::*)(bool)>"));
+
+        REQUIRE(IsInstantiation(src, "A<T>", "A<char[N]>"));
+        REQUIRE(IsInstantiation(src, "A<char[N]>", "A<char[1000]>"));
+
+        REQUIRE(IsInstantiation(src, "A<T>", "A<U(...)>"));
+        REQUIRE(IsInstantiation(src, "A<T>", "A<U(...)>"));
+        REQUIRE(IsInstantiation(src, "A<T>", "A<C<T>>"));
+        REQUIRE(IsInstantiation(src, "A<T>", "A<C<T,Args...>>"));
+    });
+
+    /*
     {
         auto src = generate_class_puml(diagram, *model);
         AliasMatcher _A(src);
@@ -148,5 +199,5 @@ TEST_CASE("t00062", "[test-case][class]")
         REQUIRE_THAT(src, IsInstantiation(_A("A<T>"), _A("A<C<T,Args...>>")));
 
         save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
-    }
+    }*/
 }

tests/t00063/test_case.h

@@ -16,8 +16,10 @@
  * limitations under the License.
  */
 
-TEST_CASE("t00063", "[test-case][class]")
+TEST_CASE("t00063")
 {
+    using namespace clanguml::test;
+
     auto [config, db] = load_config("t00063");
 
     auto diagram = config.diagrams["t00063_class"];
@@ -28,41 +30,49 @@ TEST_CASE("t00063", "[test-case][class]")
 
     REQUIRE(model->name() == "t00063_class");
 
-    {
+    CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
-        auto src = generate_class_puml(diagram, *model);
+        REQUIRE(IsClass(src, "A"));
-        AliasMatcher _A(src);
+        REQUIRE(!IsEnum(src, "B"));
+        REQUIRE(!IsEnum(src, "C"));
+    });
+    /*
+        {
+            auto src = generate_class_puml(diagram, *model);
+            AliasMatcher _A(src);
 
-        REQUIRE_THAT(src, StartsWith("@startuml"));
+            REQUIRE_THAT(src, StartsWith("@startuml"));
-        REQUIRE_THAT(src, EndsWith("@enduml\n"));
+            REQUIRE_THAT(src, EndsWith("@enduml\n"));
 
-        REQUIRE_THAT(src, IsClass(_A("A")));
+            REQUIRE_THAT(src, IsClass(_A("A")));
-        REQUIRE_THAT(src, !IsEnum(_A("B")));
+            REQUIRE_THAT(src, !IsEnum(_A("B")));
-        REQUIRE_THAT(src, !IsEnum(_A("C")));
+            REQUIRE_THAT(src, !IsEnum(_A("C")));
 
-        save_puml(config.output_directory(), diagram->name + ".puml", src);
+            save_puml(config.output_directory(), diagram->name + ".puml", src);
-    }
+        }
 
-    {
+        {
-        auto j = generate_class_json(diagram, *model);
+            auto j = generate_class_json(diagram, *model);
 
-        using namespace json;
+            using namespace json;
 
-        REQUIRE(IsClass(j, "A"));
+            REQUIRE(IsClass(j, "A"));
-        REQUIRE(!IsEnum(j, "B"));
+            REQUIRE(!IsEnum(j, "B"));
-        REQUIRE(!IsEnum(j, "C"));
+            REQUIRE(!IsEnum(j, "C"));
 
-        save_json(config.output_directory(), diagram->name + ".json", j);
+            save_json(config.output_directory(), diagram->name + ".json", j);
-    }
+        }
-    {
+        {
-        auto src = generate_class_mermaid(diagram, *model);
+            auto src = generate_class_mermaid(diagram, *model);
 
-        mermaid::AliasMatcher _A(src);
+            mermaid::AliasMatcher _A(src);
-        using mermaid::IsEnum;
+            using mermaid::IsEnum;
 
-        REQUIRE_THAT(src, IsClass(_A("A")));
+            REQUIRE_THAT(src, IsClass(_A("A")));
-        REQUIRE_THAT(src, !IsEnum(_A("B")));
+            REQUIRE_THAT(src, !IsEnum(_A("B")));
-        REQUIRE_THAT(src, !IsEnum(_A("C")));
+            REQUIRE_THAT(src, !IsEnum(_A("C")));
 
-        save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
+            save_mermaid(config.output_directory(), diagram->name + ".mmd",
-    }
+       src);
+        }
+        */
 }

tests/t00064/test_case.h

@@ -16,8 +16,10 @@
  * limitations under the License.
  */
 
-TEST_CASE("t00064", "[test-case][class]")
+TEST_CASE("t00064")
 {
+    using namespace clanguml::test;
+
     auto [config, db] = load_config("t00064");
 
     auto diagram = config.diagrams["t00064_class"];
@@ -28,6 +30,45 @@ TEST_CASE("t00064", "[test-case][class]")
 
     REQUIRE(model->name() == "t00064_class");
 
+    CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
+        REQUIRE(!src.contains("type-parameter-"));
+
+        REQUIRE(IsClass(src, "A"));
+        REQUIRE(IsClass(src, "B"));
+        REQUIRE(IsClass(src, "C"));
+        REQUIRE(IsClass(src, "R"));
+
+        REQUIRE(IsClassTemplate(src, "type_list<Ts...>"));
+        REQUIRE(IsClassTemplate(src, "type_list<Ret(Arg &&),Ts...>"));
+        REQUIRE(IsClassTemplate(src, "type_list<T const,Ts...>"));
+
+        REQUIRE(IsClassTemplate(src, "head<typename>"));
+        REQUIRE(IsClassTemplate(src, "head<type_list<Head,Tail...>>"));
+        REQUIRE(IsClassTemplate(src, "type_group_pair<typename,typename>"));
+        REQUIRE(IsClassTemplate(
+            src, "type_group_pair<type_list<First...>,type_list<Second...>>"));
+        REQUIRE(IsClassTemplate(
+            src, "type_group_pair<type_list<float,double>,type_list<A,B,C>>"));
+
+        REQUIRE(IsClassTemplate(src, "optional_ref<T>"));
+
+        REQUIRE(IsClassTemplate(src,
+            "type_group_pair_it<It,type_list<First...>,type_list<Second...>>"));
+        REQUIRE(IsMethod<Public>(src, "get", "ref_t", "unsigned int i"));
+#if LLVM_VERSION_MAJOR < 16
+        REQUIRE(IsMethod<Public>(
+            src, "getp", "value_type const*", "unsigned int i"));
+        REQUIRE(IsMethod<Public, Constexpr>(
+            src, "find", "unsigned int", "value_type const& v"));
+#else
+        REQUIRE(
+            IsMethod<Public>(src,   "getp", "const value_type *", "unsigned int i"));
+        REQUIRE(
+            IsMethod<Public, Constexpr>(src,
+                "find", "unsigned int", "const value_type & v"));
+#endif
+    });
+    /*
     {
         auto src = generate_class_puml(diagram, *model);
         AliasMatcher _A(src);
@@ -137,4 +178,5 @@ TEST_CASE("t00064", "[test-case][class]")
 
         save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
     }
+     */
 }

tests/t00065/test_case.h

@@ -16,8 +16,10 @@
  * limitations under the License.
  */
 
-TEST_CASE("t00065", "[test-case][class]")
+TEST_CASE("t00065")
 {
+    using namespace clanguml::test;
+
     auto [config, db] = load_config("t00065");
 
     auto diagram = config.diagrams["t00065_class"];
@@ -28,48 +30,62 @@ TEST_CASE("t00065", "[test-case][class]")
 
     REQUIRE(model->name() == "t00065_class");
 
-    {
+    CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
-        auto src = generate_class_puml(diagram, *model);
+        REQUIRE(IsClass(src, "R"));
-        AliasMatcher _A(src);
+        REQUIRE(IsClass(src, "A"));
+        REQUIRE(IsClass(src, {"detail", "AImpl"}));
+        REQUIRE(IsEnum(src, "XYZ"));
+        REQUIRE(IsEnum(src, "ABC"));
 
-        REQUIRE_THAT(src, StartsWith("@startuml"));
+        REQUIRE(IsPackage("module1"));
-        REQUIRE_THAT(src, EndsWith("@enduml\n"));
+        REQUIRE(IsPackage("module2"));
+        REQUIRE(IsPackage("submodule1a"));
+        REQUIRE(IsPackage("concepts"));
+    });
+    /*
+        {
+            auto src = generate_class_puml(diagram, *model);
+            AliasMatcher _A(src);
 
-        // Check if all classes exist
+            REQUIRE_THAT(src, StartsWith("@startuml"));
-        REQUIRE_THAT(src, IsClass(_A("R")));
+            REQUIRE_THAT(src, EndsWith("@enduml\n"));
-        REQUIRE_THAT(src, IsClass(_A("A")));
-        REQUIRE_THAT(src, IsClass(_A("detail::AImpl")));
-        REQUIRE_THAT(src, IsEnum(_A("XYZ")));
-        REQUIRE_THAT(src, IsEnum(_A("ABC")));
 
-        REQUIRE_THAT(src, IsPackage("module1"));
+            // Check if all classes exist
-        REQUIRE_THAT(src, IsPackage("module2"));
+            REQUIRE_THAT(src, IsClass(_A("R")));
-        REQUIRE_THAT(src, IsPackage("submodule1a"));
+            REQUIRE_THAT(src, IsClass(_A("A")));
-        REQUIRE_THAT(src, IsPackage("concepts"));
+            REQUIRE_THAT(src, IsClass(_A("detail::AImpl")));
+            REQUIRE_THAT(src, IsEnum(_A("XYZ")));
+            REQUIRE_THAT(src, IsEnum(_A("ABC")));
 
-        save_puml(config.output_directory(), diagram->name + ".puml", src);
+            REQUIRE_THAT(src, IsPackage("module1"));
-    }
+            REQUIRE_THAT(src, IsPackage("module2"));
+            REQUIRE_THAT(src, IsPackage("submodule1a"));
+            REQUIRE_THAT(src, IsPackage("concepts"));
 
-    {
+            save_puml(config.output_directory(), diagram->name + ".puml", src);
-        auto j = generate_class_json(diagram, *model);
+        }
 
-        using namespace json;
+        {
+            auto j = generate_class_json(diagram, *model);
 
-        save_json(config.output_directory(), diagram->name + ".json", j);
+            using namespace json;
-    }
-    {
-        auto src = generate_class_mermaid(diagram, *model);
 
-        mermaid::AliasMatcher _A(src);
+            save_json(config.output_directory(), diagram->name + ".json", j);
-        using mermaid::IsEnum;
+        }
+        {
+            auto src = generate_class_mermaid(diagram, *model);
 
-        // Check if all classes exist
+            mermaid::AliasMatcher _A(src);
-        REQUIRE_THAT(src, IsClass(_A("R")));
+            using mermaid::IsEnum;
-        REQUIRE_THAT(src, IsClass(_A("A")));
-        REQUIRE_THAT(src, IsClass(_A("detail::AImpl")));
-        REQUIRE_THAT(src, IsEnum(_A("XYZ")));
-        REQUIRE_THAT(src, IsEnum(_A("ABC")));
 
-        save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
+            // Check if all classes exist
-    }
+            REQUIRE_THAT(src, IsClass(_A("R")));
+            REQUIRE_THAT(src, IsClass(_A("A")));
+            REQUIRE_THAT(src, IsClass(_A("detail::AImpl")));
+            REQUIRE_THAT(src, IsEnum(_A("XYZ")));
+            REQUIRE_THAT(src, IsEnum(_A("ABC")));
+
+            save_mermaid(config.output_directory(), diagram->name + ".mmd",
+       src);
+        }*/
 }

tests/t00066/test_case.h

@@ -16,8 +16,10 @@
  * limitations under the License.
  */
 
-TEST_CASE("t00066", "[test-case][class]")
+TEST_CASE("t00066")
 {
+    using namespace clanguml::test;
+
     auto [config, db] = load_config("t00066");
 
     auto diagram = config.diagrams["t00066_class"];
@@ -28,98 +30,132 @@ TEST_CASE("t00066", "[test-case][class]")
 
     REQUIRE(model->name() == "t00066_class");
 
-    {
+    CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
-        auto src = generate_class_puml(diagram, *model);
+        REQUIRE(IsClass(src, "A"));
-        AliasMatcher _A(src);
 
-        REQUIRE_THAT(src, StartsWith("@startuml"));
+        REQUIRE(!IsDependency(src, "A", "A"));
-        REQUIRE_THAT(src, EndsWith("@enduml\n"));
 
-        REQUIRE_THAT(src, IsClass(_A("A")));
+        REQUIRE(IsMethod<Public, Default>(src,"A")));
+        REQUIRE(IsMethod<Public, Default>(src, "A", "void", "A &&"));
+        REQUIRE(IsMethod<Public, Deleted>(src, "A", "void", "const A &"));
 
-        REQUIRE_THAT(src, !IsDependency(_A("A"), _A("A")));
+        REQUIRE(IsMethod<Public, Default>(src, "~A"));
 
-        REQUIRE_THAT(src, (IsMethod<Public, Default>("A")));
+        REQUIRE(IsMethod<Public>(src,"basic_method")));
-        REQUIRE_THAT(src, (IsMethod<Public, Default>("A", "void", "A &&")));
+        REQUIRE(IsMethod<Public, Static>(src,"static_method", "int")));
-        REQUIRE_THAT(
+        REQUIRE(IsMethod<Public, Const>(src,"const_method")));
-            src, (IsMethod<Public, Deleted>("A", "void", "const A &")));
+        REQUIRE(IsMethod<Public>(src,"default_int", "int", "int i = 12")));
+        REQUIRE(IsMethod<Public>(src, "default_string", "std::string",
+            "int i, std::string s = \"abc\""));
 
-        REQUIRE_THAT(src, (IsMethod<Public, Default>("~A")));
+        REQUIRE(IsMethod<Public, Const>(src, "size", "std::size_t"));
 
-        REQUIRE_THAT(src, (IsMethod<Public>("basic_method")));
+        REQUIRE(IsMethod<Protected>(src, "protected_method"));
-        REQUIRE_THAT(src, (IsMethod<Public, Static>("static_method", "int")));
+        REQUIRE(IsMethod<Private>(src, "private_method"));
-        REQUIRE_THAT(src, (IsMethod<Public, Const>("const_method")));
+        REQUIRE(IsField<Public>(src, "public_member", "int"));
-        REQUIRE_THAT(
+        REQUIRE(IsField<Protected>(src, "protected_member", "int"));
-            src, (IsMethod<Public>("default_int", "int", "int i = 12")));
+        REQUIRE(IsField<Private>(src, "private_member", "int"));
-        REQUIRE_THAT(src,
+        REQUIRE(
-            (IsMethod<Public>("default_string", "std::string",
+            (IsField<Public, Static>(src,"auto_member", "const unsigned long"));
-                "int i, std::string s = \"abc\"")));
 
-        REQUIRE_THAT(src, (IsMethod<Public, Const>("size", "std::size_t")));
+        REQUIRE(IsField<Private>(src,"a_", "int"));
+        REQUIRE(IsField<Private>(src,"b_", "int"));
+        REQUIRE(IsField<Private>(src,"c_", "int"));
+    });
 
-        REQUIRE_THAT(src, (IsMethod<Protected>("protected_method")));
+    /*
-        REQUIRE_THAT(src, (IsMethod<Private>("private_method")));
+{
-        REQUIRE_THAT(src, (IsField<Public>("public_member", "int")));
+    auto src = generate_class_puml(diagram, *model);
-        REQUIRE_THAT(src, (IsField<Protected>("protected_member", "int")));
+    AliasMatcher _A(src);
-        REQUIRE_THAT(src, (IsField<Private>("private_member", "int")));
-        REQUIRE_THAT(src,
-            (IsField<Public, Static>("auto_member", "const unsigned long")));
 
-        REQUIRE_THAT(src, (IsField<Private>("a_", "int")));
+    REQUIRE_THAT(src, StartsWith("@startuml"));
-        REQUIRE_THAT(src, (IsField<Private>("b_", "int")));
+    REQUIRE_THAT(src, EndsWith("@enduml\n"));
-        REQUIRE_THAT(src, (IsField<Private>("c_", "int")));
 
-        save_puml(config.output_directory(), diagram->name + ".puml", src);
+    REQUIRE_THAT(src, IsClass(_A("A")));
-    }
 
-    {
+    REQUIRE_THAT(src, !IsDependency(_A("A"), _A("A")));
-        auto j = generate_class_json(diagram, *model);
 
-        using namespace json;
+    REQUIRE_THAT(src, (IsMethod<Public, Default>("A")));
+    REQUIRE_THAT(src, (IsMethod<Public, Default>("A", "void", "A &&")));
+    REQUIRE_THAT(
+        src, (IsMethod<Public, Deleted>("A", "void", "const A &")));
 
-        save_json(config.output_directory(), diagram->name + ".json", j);
+    REQUIRE_THAT(src, (IsMethod<Public, Default>("~A")));
-    }
-    {
-        auto src = generate_class_mermaid(diagram, *model);
 
-        mermaid::AliasMatcher _A(src);
+    REQUIRE_THAT(src, (IsMethod<Public>("basic_method")));
-        using mermaid::IsField;
+    REQUIRE_THAT(src, (IsMethod<Public, Static>("static_method", "int")));
-        using mermaid::IsMethod;
+    REQUIRE_THAT(src, (IsMethod<Public, Const>("const_method")));
+    REQUIRE_THAT(
+        src, (IsMethod<Public>("default_int", "int", "int i = 12")));
+    REQUIRE_THAT(src,
+        (IsMethod<Public>("default_string", "std::string",
+            "int i, std::string s = \"abc\"")));
 
-        REQUIRE_THAT(src, IsClass(_A("A")));
+    REQUIRE_THAT(src, (IsMethod<Public, Const>("size", "std::size_t")));
 
-        REQUIRE_THAT(src, !IsDependency(_A("A"), _A("A")));
+    REQUIRE_THAT(src, (IsMethod<Protected>("protected_method")));
+    REQUIRE_THAT(src, (IsMethod<Private>("private_method")));
+    REQUIRE_THAT(src, (IsField<Public>("public_member", "int")));
+    REQUIRE_THAT(src, (IsField<Protected>("protected_member", "int")));
+    REQUIRE_THAT(src, (IsField<Private>("private_member", "int")));
+    REQUIRE_THAT(src,
+        (IsField<Public, Static>("auto_member", "const unsigned long")));
 
-        REQUIRE_THAT(src, (IsMethod<Public, Default>("A")));
+    REQUIRE_THAT(src, (IsField<Private>("a_", "int")));
-        REQUIRE_THAT(src, (IsMethod<Public, Default>("A", "void", "A &&")));
+    REQUIRE_THAT(src, (IsField<Private>("b_", "int")));
-        REQUIRE_THAT(
+    REQUIRE_THAT(src, (IsField<Private>("c_", "int")));
-            src, (IsMethod<Public, Deleted>("A", "void", "const A &")));
 
-        REQUIRE_THAT(src, (IsMethod<Public, Default>("~A")));
+    save_puml(config.output_directory(), diagram->name + ".puml", src);
+}
 
-        REQUIRE_THAT(src, (IsMethod<Public>("basic_method")));
+{
-        REQUIRE_THAT(src, (IsMethod<Public, Static>("static_method", "int")));
+    auto j = generate_class_json(diagram, *model);
-        REQUIRE_THAT(src, (IsMethod<Public, Const>("const_method")));
-        REQUIRE_THAT(
-            src, (IsMethod<Public>("default_int", "int", "int i = 12")));
-        REQUIRE_THAT(src,
-            (IsMethod<Public>("default_string", "std::string",
-                "int i, std::string s = \"abc\"")));
 
-        REQUIRE_THAT(src, (IsMethod<Public, Const>("size", "std::size_t")));
+    using namespace json;
 
-        REQUIRE_THAT(src, (IsMethod<Protected>("protected_method")));
+    save_json(config.output_directory(), diagram->name + ".json", j);
-        REQUIRE_THAT(src, (IsMethod<Private>("private_method")));
+}
-        REQUIRE_THAT(src, (IsField<Public>("public_member", "int")));
+{
-        REQUIRE_THAT(src, (IsField<Protected>("protected_member", "int")));
+    auto src = generate_class_mermaid(diagram, *model);
-        REQUIRE_THAT(src, (IsField<Private>("private_member", "int")));
-        REQUIRE_THAT(src,
-            (IsField<Public, Static>("auto_member", "const unsigned long")));
 
-        REQUIRE_THAT(src, (IsField<Private>("a_", "int")));
+    mermaid::AliasMatcher _A(src);
-        REQUIRE_THAT(src, (IsField<Private>("b_", "int")));
+    using mermaid::IsField;
-        REQUIRE_THAT(src, (IsField<Private>("c_", "int")));
+    using mermaid::IsMethod;
 
-        save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
+    REQUIRE_THAT(src, IsClass(_A("A")));
-    }
+
+    REQUIRE_THAT(src, !IsDependency(_A("A"), _A("A")));
+
+    REQUIRE_THAT(src, (IsMethod<Public, Default>("A")));
+    REQUIRE_THAT(src, (IsMethod<Public, Default>("A", "void", "A &&")));
+    REQUIRE_THAT(
+        src, (IsMethod<Public, Deleted>("A", "void", "const A &")));
+
+    REQUIRE_THAT(src, (IsMethod<Public, Default>("~A")));
+
+    REQUIRE_THAT(src, (IsMethod<Public>("basic_method")));
+    REQUIRE_THAT(src, (IsMethod<Public, Static>("static_method", "int")));
+    REQUIRE_THAT(src, (IsMethod<Public, Const>("const_method")));
+    REQUIRE_THAT(
+        src, (IsMethod<Public>("default_int", "int", "int i = 12")));
+    REQUIRE_THAT(src,
+        (IsMethod<Public>("default_string", "std::string",
+            "int i, std::string s = \"abc\"")));
+
+    REQUIRE_THAT(src, (IsMethod<Public, Const>("size", "std::size_t")));
+
+    REQUIRE_THAT(src, (IsMethod<Protected>("protected_method")));
+    REQUIRE_THAT(src, (IsMethod<Private>("private_method")));
+    REQUIRE_THAT(src, (IsField<Public>("public_member", "int")));
+    REQUIRE_THAT(src, (IsField<Protected>("protected_member", "int")));
+    REQUIRE_THAT(src, (IsField<Private>("private_member", "int")));
+    REQUIRE_THAT(src,
+        (IsField<Public, Static>("auto_member", "const unsigned long")));
+
+    REQUIRE_THAT(src, (IsField<Private>("a_", "int")));
+    REQUIRE_THAT(src, (IsField<Private>("b_", "int")));
+    REQUIRE_THAT(src, (IsField<Private>("c_", "int")));
+
+    save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
+}*/
 }

tests/t00067/test_case.h

@@ -16,8 +16,10 @@
  * limitations under the License.
  */
 
-TEST_CASE("t00067", "[test-case][class]")
+TEST_CASE("t00067")
 {
+    using namespace clanguml::test;
+
     auto [config, db] = load_config("t00067");
 
     auto diagram = config.diagrams["t00067_class"];
@@ -28,6 +30,16 @@ TEST_CASE("t00067", "[test-case][class]")
 
     REQUIRE(model->name() == "t00067_class");
 
+    CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
+        REQUIRE(!(IsMethod<Public, Default>(src, "A")));
+        REQUIRE(!(IsMethod<Public, Default>(src, "A", "void", "A &&")));
+        REQUIRE(!(IsMethod<Public, Deleted>(src, "A", "void", "const A &")));
+
+        REQUIRE(!(IsMethod<Public, Default>(src, "~A")));
+
+        REQUIRE(!(IsMethod<Public, Default>(src, "~A")));
+    });
+    /*
     {
         auto src = generate_class_puml(diagram, *model);
         AliasMatcher _A(src);
@@ -71,5 +83,5 @@ TEST_CASE("t00067", "[test-case][class]")
         REQUIRE_THAT(src, !(IsMethod<Public, Default>("~A")));
 
         save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
-    }
+    }*/
 }

tests/t00068/test_case.h

@@ -16,8 +16,10 @@
  * limitations under the License.
  */
 
-TEST_CASE("t00068_r0", "[test-case][class][t00068]")
+TEST_CASE("t00068_r0")
 {
+    using namespace clanguml::test;
+
     auto [config, db] = load_config("t00068");
 
     auto diagram = config.diagrams["t00068_r0_class"];
@@ -26,61 +28,25 @@ TEST_CASE("t00068_r0", "[test-case][class][t00068]")
 
     REQUIRE(model->name() == "t00068_r0_class");
 
-    {
+    CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
-        auto src = generate_class_puml(diagram, *model);
+        REQUIRE(!IsClass(src, "A"));
-        AliasMatcher _A(src);
+        REQUIRE(!IsClass(src, "AA"));
+        REQUIRE(IsClass(src, "AAA"));
 
-        REQUIRE_THAT(src, StartsWith("@startuml"));
+        REQUIRE(!IsClass(src, "B"));
-        REQUIRE_THAT(src, EndsWith("@enduml\n"));
+        REQUIRE(!IsClass(src, "BB"));
 
-        REQUIRE_THAT(src, !IsClass(_A("A")));
+        REQUIRE(!IsClass(src, "R"));
-        REQUIRE_THAT(src, !IsClass(_A("AA")));
+        REQUIRE(!IsClass(src, "RR"));
-        REQUIRE_THAT(src, IsClass(_A("AAA")));
 
-        REQUIRE_THAT(src, !IsClass(_A("B")));
+        REQUIRE(!IsEnum(src, "AKind"));
-        REQUIRE_THAT(src, !IsClass(_A("BB")));
+    });
-
-        REQUIRE_THAT(src, !IsClass(_A("R")));
-        REQUIRE_THAT(src, !IsClass(_A("RR")));
-
-        REQUIRE_THAT(src, !IsEnum(_A("AKind")));
-
-        save_puml(config.output_directory(), diagram->name + ".puml", src);
-    }
-
-    {
-        auto j = generate_class_json(diagram, *model);
-
-        using namespace json;
-
-        save_json(config.output_directory(), diagram->name + ".json", j);
-    }
-
-    {
-        auto src = generate_class_mermaid(diagram, *model);
-
-        mermaid::AliasMatcher _A(src);
-        using mermaid::IsClass;
-        using mermaid::IsEnum;
-
-        REQUIRE_THAT(src, !IsClass(_A("A")));
-        REQUIRE_THAT(src, !IsClass(_A("AA")));
-        REQUIRE_THAT(src, IsClass(_A("AAA")));
-
-        REQUIRE_THAT(src, !IsClass(_A("B")));
-        REQUIRE_THAT(src, !IsClass(_A("BB")));
-
-        REQUIRE_THAT(src, !IsClass(_A("R")));
-        REQUIRE_THAT(src, !IsClass(_A("RR")));
-
-        REQUIRE_THAT(src, !IsEnum(_A("AKind")));
-
-        save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
-    }
 }
 
-TEST_CASE("t00068_r1", "[test-case][class][t00068]")
+TEST_CASE("t00068_r1")
 {
+    using namespace clanguml::test;
+
     auto [config, db] = load_config("t00068");
 
     auto diagram = config.diagrams["t00068_r1_class"];
@@ -88,53 +54,25 @@ TEST_CASE("t00068_r1", "[test-case][class][t00068]")
     auto model = generate_class_diagram(*db, diagram);
 
     REQUIRE(model->name() == "t00068_r1_class");
+    CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
+        REQUIRE(!IsClass(src, "A"));
+        REQUIRE(IsClass(src, "AA"));
+        REQUIRE(IsClass(src, "AAA"));
 
-    {
+        REQUIRE(!IsClass(src, "B"));
-        auto src = generate_class_puml(diagram, *model);
+        REQUIRE(IsClass(src, "BB"));
-        AliasMatcher _A(src);
 
-        REQUIRE_THAT(src, StartsWith("@startuml"));
+        REQUIRE(IsClass(src, "R"));
-        REQUIRE_THAT(src, EndsWith("@enduml\n"));
+        REQUIRE(!IsClass(src, "RR"));
 
-        REQUIRE_THAT(src, !IsClass(_A("A")));
+        REQUIRE(IsEnum(src, "AKind"));
-        REQUIRE_THAT(src, IsClass(_A("AA")));
+    });
-        REQUIRE_THAT(src, IsClass(_A("AAA")));
-
-        REQUIRE_THAT(src, !IsClass(_A("B")));
-        REQUIRE_THAT(src, IsClass(_A("BB")));
-
-        REQUIRE_THAT(src, IsClass(_A("R")));
-        REQUIRE_THAT(src, !IsClass(_A("RR")));
-
-        REQUIRE_THAT(src, IsEnum(_A("AKind")));
-
-        save_puml(config.output_directory(), diagram->name + ".puml", src);
-    }
-
-    {
-        auto j = generate_class_json(diagram, *model);
-
-        using namespace json;
-
-        save_json(config.output_directory(), diagram->name + ".json", j);
-    }
-
-    {
-        auto src = generate_class_mermaid(diagram, *model);
-
-        mermaid::AliasMatcher _A(src);
-        using mermaid::IsClass;
-
-        REQUIRE_THAT(src, !IsClass(_A("A")));
-        REQUIRE_THAT(src, IsClass(_A("AA")));
-        REQUIRE_THAT(src, IsClass(_A("AAA")));
-
-        save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
-    }
 }
 
-TEST_CASE("t00068_r2", "[test-case][class][t00068]")
+TEST_CASE("t00068_r2")
 {
+    using namespace clanguml::test;
+
     auto [config, db] = load_config("t00068");
 
     auto diagram = config.diagrams["t00068_r2_class"];
@@ -143,53 +81,17 @@ TEST_CASE("t00068_r2", "[test-case][class][t00068]")
 
     REQUIRE(model->name() == "t00068_r2_class");
 
-    {
+    CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
-        auto src = generate_class_puml(diagram, *model);
+        REQUIRE(IsClass(src, "A"));
-        AliasMatcher _A(src);
+        REQUIRE(IsClass(src, "AA"));
+        REQUIRE(IsClass(src, "AAA"));
 
-        REQUIRE_THAT(src, StartsWith("@startuml"));
+        REQUIRE(IsClass(src, "B"));
-        REQUIRE_THAT(src, EndsWith("@enduml\n"));
+        REQUIRE(IsClass(src, "BB"));
 
-        REQUIRE_THAT(src, IsClass(_A("A")));
+        REQUIRE(IsClass(src, "R"));
-        REQUIRE_THAT(src, IsClass(_A("AA")));
+        REQUIRE(IsClass(src, "RR"));
-        REQUIRE_THAT(src, IsClass(_A("AAA")));
 
-        REQUIRE_THAT(src, IsClass(_A("B")));
+        REQUIRE(IsEnum(src, "AKind"));
-        REQUIRE_THAT(src, IsClass(_A("BB")));
+    });
-
-        REQUIRE_THAT(src, IsClass(_A("R")));
-        REQUIRE_THAT(src, IsClass(_A("RR")));
-
-        REQUIRE_THAT(src, IsEnum(_A("AKind")));
-
-        save_puml(config.output_directory(), diagram->name + ".puml", src);
-    }
-
-    {
-        auto j = generate_class_json(diagram, *model);
-
-        using namespace json;
-
-        save_json(config.output_directory(), diagram->name + ".json", j);
-    }
-
-    {
-        auto src = generate_class_mermaid(diagram, *model);
-
-        mermaid::AliasMatcher _A(src);
-        using mermaid::IsClass;
-        using mermaid::IsEnum;
-
-        REQUIRE_THAT(src, IsClass(_A("A")));
-        REQUIRE_THAT(src, IsClass(_A("AA")));
-        REQUIRE_THAT(src, IsClass(_A("AAA")));
-
-        REQUIRE_THAT(src, IsClass(_A("B")));
-        REQUIRE_THAT(src, IsClass(_A("BB")));
-
-        REQUIRE_THAT(src, IsClass(_A("R")));
-        REQUIRE_THAT(src, IsClass(_A("RR")));
-
-        save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
-    }
 }

tests/t00069/test_case.h

@@ -16,8 +16,10 @@
  * limitations under the License.
  */
 
-TEST_CASE("t00069", "[test-case][class]")
+TEST_CASE("t00069")
 {
+    using namespace clanguml::test;
+
     auto [config, db] = load_config("t00069");
 
     auto diagram = config.diagrams["t00069_class"];
@@ -28,60 +30,82 @@ TEST_CASE("t00069", "[test-case][class]")
 
     REQUIRE(model->name() == "t00069_class");
 
-    {
+    CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
-        auto src = generate_class_puml(diagram, *model);
+        REQUIRE(IsClass(src, "A"));
-        AliasMatcher _A(src);
 
-        REQUIRE_THAT(src, StartsWith("@startuml"));
+        REQUIRE(IsClassTemplate(src, "generator", "T"));
-        REQUIRE_THAT(src, EndsWith("@enduml\n"));
 
-        // Check if all classes exist
+        REQUIRE(
-        REQUIRE_THAT(src, IsClass(_A("A")));
+            IsInnerClass(src,("generator<T>", "generator::promise_type"));
 
-        // Check if class templates exist
+        REQUIRE(
-        REQUIRE_THAT(src, IsClassTemplate("generator", "T"));
+            IsMethod<Public, Coroutine>(src,"iota", "generator<unsigned long>"));
+        REQUIRE(
+            IsMethod<Public, Coroutine>(src,"seed", "generator<unsigned long>"));
 
-        // Check if all inner classes exist
+        REQUIRE(
-        REQUIRE_THAT(src,
+            IsDependency(src,"A", "generator<unsigned long>"));
-            IsInnerClass(_A("generator<T>"), _A("generator::promise_type")));
+        REQUIRE(
-
-        // Check if all methods exist
-        REQUIRE_THAT(src,
-            (IsMethod<Public, Coroutine>("iota", "generator<unsigned long>")));
-        REQUIRE_THAT(src,
-            (IsMethod<Public, Coroutine>("seed", "generator<unsigned long>")));
-
-        // Check if all relationships exist
-        REQUIRE_THAT(
-            src, IsDependency(_A("A"), _A("generator<unsigned long>")));
-        REQUIRE_THAT(src,
             IsInstantiation(
-                _A("generator<T>"), _A("generator<unsigned long>")));
+                src,"generator<T>", "generator<unsigned long>"));
+    });
+    /*
+        {
+            auto src = generate_class_puml(diagram, *model);
+            AliasMatcher _A(src);
 
-        save_puml(config.output_directory(), diagram->name + ".puml", src);
+            REQUIRE_THAT(src, StartsWith("@startuml"));
-    }
+            REQUIRE_THAT(src, EndsWith("@enduml\n"));
 
-    {
+            // Check if all classes exist
-        auto j = generate_class_json(diagram, *model);
+            REQUIRE_THAT(src, IsClass(_A("A")));
 
-        using namespace json;
+            // Check if class templates exist
+            REQUIRE_THAT(src, IsClassTemplate("generator", "T"));
 
-        save_json(config.output_directory(), diagram->name + ".json", j);
+            // Check if all inner classes exist
-    }
+            REQUIRE_THAT(src,
+                IsInnerClass(_A("generator<T>"),
+       _A("generator::promise_type")));
 
-    {
+            // Check if all methods exist
-        auto src = generate_class_mermaid(diagram, *model);
+            REQUIRE_THAT(src,
+                (IsMethod<Public, Coroutine>("iota", "generator<unsigned
+       long>"))); REQUIRE_THAT(src, (IsMethod<Public, Coroutine>("seed",
+       "generator<unsigned long>")));
 
-        mermaid::AliasMatcher _A(src);
+            // Check if all relationships exist
-        using mermaid::IsClass;
+            REQUIRE_THAT(
-        using mermaid::IsMethod;
+                src, IsDependency(_A("A"), _A("generator<unsigned long>")));
+            REQUIRE_THAT(src,
+                IsInstantiation(
+                    _A("generator<T>"), _A("generator<unsigned long>")));
 
-        REQUIRE_THAT(src, IsClass(_A("A")));
+            save_puml(config.output_directory(), diagram->name + ".puml", src);
-        REQUIRE_THAT(src,
+        }
-            (IsMethod<Public, Coroutine>("iota", "generator<unsigned long>")));
-        REQUIRE_THAT(src,
-            (IsMethod<Public, Coroutine>("seed", "generator<unsigned long>")));
 
-        save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
+        {
-    }
+            auto j = generate_class_json(diagram, *model);
+
+            using namespace json;
+
+            save_json(config.output_directory(), diagram->name + ".json", j);
+        }
+
+        {
+            auto src = generate_class_mermaid(diagram, *model);
+
+            mermaid::AliasMatcher _A(src);
+            using mermaid::IsClass;
+            using mermaid::IsMethod;
+
+            REQUIRE_THAT(src, IsClass(_A("A")));
+            REQUIRE_THAT(src,
+                (IsMethod<Public, Coroutine>("iota", "generator<unsigned
+       long>"))); REQUIRE_THAT(src, (IsMethod<Public, Coroutine>("seed",
+       "generator<unsigned long>")));
+
+            save_mermaid(config.output_directory(), diagram->name + ".mmd",
+       src);
+        }*/
 }

tests/t00070/test_case.h

@@ -16,8 +16,10 @@
  * limitations under the License.
  */
 
-TEST_CASE("t00070", "[test-case][class]")
+TEST_CASE("t00070")
 {
+    using namespace clanguml::test;
+
     auto [config, db] = load_config("t00070");
 
     auto diagram = config.diagrams["t00070_class"];
@@ -28,62 +30,67 @@ TEST_CASE("t00070", "[test-case][class]")
 
     REQUIRE(model->name() == "t00070_class");
 
-    {
+    CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
-        auto src = generate_class_puml(diagram, *model);
+        REQUIRE(IsClass(src, "A"));
-        AliasMatcher _A(src);
+        REQUIRE(IsClass(src, "B"));
+        REQUIRE(!IsClass(src, "C"));
 
-        REQUIRE_THAT(src, StartsWith("@startuml"));
+        REQUIRE(IsClassTemplate(src, "BB<T>"));
-        REQUIRE_THAT(src, EndsWith("@enduml\n"));
+        REQUIRE(!IsClassTemplate(src, "CC<T>"));
 
-        REQUIRE_THAT(src, IsClass(_A("A")));
+        REQUIRE(IsEnum(src, "BBB"));
-        REQUIRE_THAT(src, IsClass(_A("B")));
+        REQUIRE(!IsClass(src, "BBBB"));
-        REQUIRE_THAT(src, !IsClass(_A("C")));
+        REQUIRE(!IsEnum(src, "CCC"));
+    });
 
-        REQUIRE_THAT(src, IsClassTemplate("BB", "T"));
+    /*
-        REQUIRE_THAT(src, !IsClassTemplate("CC", "T"));
+        {
+            auto src = generate_class_puml(diagram, *model);
+            AliasMatcher _A(src);
 
-        REQUIRE_THAT(src, IsEnum(_A("BBB")));
+            REQUIRE_THAT(src, StartsWith("@startuml"));
-        REQUIRE_THAT(src, !IsClass(_A("BBBB")));
+            REQUIRE_THAT(src, EndsWith("@enduml\n"));
-        REQUIRE_THAT(src, !IsEnum(_A("CCC")));
 
-        save_puml(config.output_directory(), diagram->name + ".puml", src);
-    }
 
-    {
+            save_puml(config.output_directory(), diagram->name + ".puml", src);
-        auto j = generate_class_json(diagram, *model);
+        }
 
-        using namespace json;
+        {
+            auto j = generate_class_json(diagram, *model);
 
-        REQUIRE(IsClass(j, "A"));
+            using namespace json;
-        REQUIRE(IsClass(j, "B"));
-        REQUIRE(!IsClass(j, "C"));
 
-        REQUIRE(InPublicModule(j, "A", "t00070"));
+            REQUIRE(IsClass(j, "A"));
-        REQUIRE(InPublicModule(j, "B", "t00070.lib1"));
+            REQUIRE(IsClass(j, "B"));
+            REQUIRE(!IsClass(j, "C"));
 
-        REQUIRE(!IsClass(j, "BBBB"));
+            REQUIRE(InPublicModule(j, "A", "t00070"));
+            REQUIRE(InPublicModule(j, "B", "t00070.lib1"));
 
-        save_json(config.output_directory(), diagram->name + ".json", j);
+            REQUIRE(!IsClass(j, "BBBB"));
-    }
 
-    {
+            save_json(config.output_directory(), diagram->name + ".json", j);
-        auto src = generate_class_mermaid(diagram, *model);
+        }
 
-        mermaid::AliasMatcher _A(src);
+        {
-        using mermaid::IsClass;
+            auto src = generate_class_mermaid(diagram, *model);
-        using mermaid::IsEnum;
 
-        REQUIRE_THAT(src, IsClass(_A("A")));
+            mermaid::AliasMatcher _A(src);
-        REQUIRE_THAT(src, IsClass(_A("B")));
+            using mermaid::IsClass;
-        REQUIRE_THAT(src, !IsClass(_A("C")));
+            using mermaid::IsEnum;
 
-        REQUIRE_THAT(src, IsClass(_A("BB<T>")));
+            REQUIRE_THAT(src, IsClass(_A("A")));
-        REQUIRE_THAT(src, !IsClass(_A("CC<T>")));
+            REQUIRE_THAT(src, IsClass(_A("B")));
+            REQUIRE_THAT(src, !IsClass(_A("C")));
 
-        REQUIRE_THAT(src, IsEnum(_A("BBB")));
+            REQUIRE_THAT(src, IsClass(_A("BB<T>")));
-        REQUIRE_THAT(src, !IsClass(_A("BBBB")));
+            REQUIRE_THAT(src, !IsClass(_A("CC<T>")));
-        REQUIRE_THAT(src, !IsEnum(_A("CCC")));
 
-        save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
+            REQUIRE_THAT(src, IsEnum(_A("BBB")));
-    }
+            REQUIRE_THAT(src, !IsClass(_A("BBBB")));
+            REQUIRE_THAT(src, !IsEnum(_A("CCC")));
+
+            save_mermaid(config.output_directory(), diagram->name + ".mmd",
+       src);
+        }*/
 }

tests/t00071/test_case.h

@@ -16,8 +16,10 @@
  * limitations under the License.
  */
 
-TEST_CASE("t00071", "[test-case][class]")
+TEST_CASE("t00071")
 {
+    using namespace clanguml::test;
+
     auto [config, db] = load_config("t00071");
 
     auto diagram = config.diagrams["t00071_class"];
@@ -28,49 +30,63 @@ TEST_CASE("t00071", "[test-case][class]")
 
     REQUIRE(model->name() == "t00071_class");
 
-    {
+    CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
-        auto src = generate_class_puml(diagram, *model);
+        REQUIRE(IsClass(src, "A"));
-        AliasMatcher _A(src);
+        REQUIRE(IsClass(src, "R"));
 
-        REQUIRE_THAT(src, StartsWith("@startuml"));
+        REQUIRE(IsEnum(src, {"detail", "BBB"}));
-        REQUIRE_THAT(src, EndsWith("@enduml\n"));
+        REQUIRE(IsEnum(src, {"detail", "CCC"}));
 
-        REQUIRE_THAT(src, IsClass(_A("A")));
+        REQUIRE(IsModulePackage(src, "app"s));
-        REQUIRE_THAT(src, IsClass(_A("R")));
+        REQUIRE(IsModulePackage(src, "app"s, "lib1"s));
+        REQUIRE(IsModulePackage(src, "app"s, "lib1"s, "mod1"s));
+        REQUIRE(IsModulePackage(src, "app"s, "lib1"s, "mod2"s));
+    });
+    /*
+        {
+            auto src = generate_class_puml(diagram, *model);
+            AliasMatcher _A(src);
 
-        REQUIRE_THAT(src, IsEnum(_A("detail::BBB")));
+            REQUIRE_THAT(src, StartsWith("@startuml"));
-        REQUIRE_THAT(src, IsEnum(_A("detail::CCC")));
+            REQUIRE_THAT(src, EndsWith("@enduml\n"));
 
-        save_puml(config.output_directory(), diagram->name + ".puml", src);
+            REQUIRE_THAT(src, IsClass(_A("A")));
-    }
+            REQUIRE_THAT(src, IsClass(_A("R")));
 
-    {
+            REQUIRE_THAT(src, IsEnum(_A("detail::BBB")));
-        auto j = generate_class_json(diagram, *model);
+            REQUIRE_THAT(src, IsEnum(_A("detail::CCC")));
 
-        using namespace json;
+            save_puml(config.output_directory(), diagram->name + ".puml", src);
-        using namespace std::string_literals;
+        }
 
-        REQUIRE(IsModulePackage(j, "app"s));
+        {
-        REQUIRE(IsModulePackage(j, "app"s, "lib1"s));
+            auto j = generate_class_json(diagram, *model);
-        REQUIRE(IsModulePackage(j, "app"s, "lib1"s, "mod1"s));
-        REQUIRE(IsModulePackage(j, "app"s, "lib1"s, "mod2"s));
 
-        save_json(config.output_directory(), diagram->name + ".json", j);
+            using namespace json;
-    }
+            using namespace std::string_literals;
 
-    {
+            REQUIRE(IsModulePackage(j, "app"s));
-        auto src = generate_class_mermaid(diagram, *model);
+            REQUIRE(IsModulePackage(j, "app"s, "lib1"s));
+            REQUIRE(IsModulePackage(j, "app"s, "lib1"s, "mod1"s));
+            REQUIRE(IsModulePackage(j, "app"s, "lib1"s, "mod2"s));
 
-        mermaid::AliasMatcher _A(src);
+            save_json(config.output_directory(), diagram->name + ".json", j);
-        using mermaid::IsClass;
+        }
-        using mermaid::IsEnum;
 
-        REQUIRE_THAT(src, IsClass(_A("A")));
+        {
-        REQUIRE_THAT(src, IsClass(_A("R")));
+            auto src = generate_class_mermaid(diagram, *model);
 
-        REQUIRE_THAT(src, IsEnum(_A("detail::BBB")));
+            mermaid::AliasMatcher _A(src);
-        REQUIRE_THAT(src, IsEnum(_A("detail::CCC")));
+            using mermaid::IsClass;
+            using mermaid::IsEnum;
 
-        save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
+            REQUIRE_THAT(src, IsClass(_A("A")));
-    }
+            REQUIRE_THAT(src, IsClass(_A("R")));
+
+            REQUIRE_THAT(src, IsEnum(_A("detail::BBB")));
+            REQUIRE_THAT(src, IsEnum(_A("detail::CCC")));
+
+            save_mermaid(config.output_directory(), diagram->name + ".mmd",
+       src);
+        }*/
 }

tests/t00072/test_case.h

@@ -16,8 +16,10 @@
  * limitations under the License.
  */
 
-TEST_CASE("t00072", "[test-case][class]")
+TEST_CASE("t00072")
 {
+    using namespace clanguml::test;
+
     auto [config, db] = load_config("t00072");
 
     auto diagram = config.diagrams["t00072_class"];
@@ -28,6 +30,27 @@ TEST_CASE("t00072", "[test-case][class]")
 
     REQUIRE(model->name() == "t00072_class");
 
+    CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
+        REQUIRE(IsPackage(src, "app"));
+        REQUIRE(IsPackage(src, ":lib1"));
+        REQUIRE(IsPackage(src, ":lib2"));
+        REQUIRE(IsPackage(src, "mod1"));
+        REQUIRE(IsPackage(src, "mod2"));
+
+        REQUIRE(IsClass(src, "A"));
+        REQUIRE(IsClass(src, "C"));
+        REQUIRE(IsClassTemplate(src, "CC<T>"));
+        REQUIRE(IsEnum(src, {"detail", "CCC"}));
+
+        REQUIRE(IsClass(src, "B"));
+        REQUIRE(IsClassTemplate(src, "BB<T>"));
+        REQUIRE(IsEnum(src, {"detail", "BBB"}));
+
+        REQUIRE(IsClass(src, "D"));
+        REQUIRE(IsClass(src, "E"));
+    });
+    /*
+
     {
         auto src = generate_class_puml(diagram, *model);
         AliasMatcher _A(src);
@@ -100,4 +123,5 @@ TEST_CASE("t00072", "[test-case][class]")
 
         save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
     }
+    */
 }

tests/t00073/test_case.h

@@ -16,8 +16,10 @@
  * limitations under the License.
  */
 
-TEST_CASE("t00073", "[test-case][class]")
+TEST_CASE("t00073")
 {
+    using namespace clanguml::test;
+
     auto [config, db] = load_config("t00073");
 
     auto diagram = config.diagrams["t00073_class"];
@@ -28,69 +30,84 @@ TEST_CASE("t00073", "[test-case][class]")
 
     REQUIRE(model->name() == "t00073_class");
 
-    {
+    CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
-        auto src = generate_class_puml(diagram, *model);
+        REQUIRE(IsClass(src, "A"));
-        AliasMatcher _A(src);
+        REQUIRE(IsClass(src, "B"));
+        REQUIRE(IsClass(src, "AHandler"));
+        REQUIRE(IsClass(src, "BHandler"));
+        REQUIRE(IsClassTemplate(src, "Overload<Bases...>"));
+        REQUIRE(IsClassTemplate(src, "Overload<AHandler,BHandler>"));
 
-        REQUIRE_THAT(src, StartsWith("@startuml"));
+        REQUIRE(IsDependency(src, "AHandler", "A"));
-        REQUIRE_THAT(src, EndsWith("@enduml\n"));
+        REQUIRE(IsDependency(src, "BHandler", "B"));
+        REQUIRE(IsInstantiation(
+            src, "Overload<Bases...>", "Overload<AHandler,BHandler>"));
+        REQUIRE(IsAggregation<Public>(
+            src, "R", "Overload<AHandler,BHandler>", "dispatch"));
+    });
+    /*
+        {
+            auto src = generate_class_puml(diagram, *model);
+            AliasMatcher _A(src);
 
-        REQUIRE_THAT(src, IsClass(_A("A")));
+            REQUIRE_THAT(src, StartsWith("@startuml"));
-        REQUIRE_THAT(src, IsClass(_A("B")));
+            REQUIRE_THAT(src, EndsWith("@enduml\n"));
-        REQUIRE_THAT(src, IsClass(_A("AHandler")));
-        REQUIRE_THAT(src, IsClass(_A("BHandler")));
-        REQUIRE_THAT(src, IsClassTemplate("Overload", "Bases..."));
-        REQUIRE_THAT(src, IsClassTemplate("Overload", "AHandler,BHandler"));
 
-        REQUIRE_THAT(src, IsDependency(_A("AHandler"), _A("A")));
+            REQUIRE_THAT(src, IsClass(_A("A")));
-        REQUIRE_THAT(src, IsDependency(_A("BHandler"), _A("B")));
+            REQUIRE_THAT(src, IsClass(_A("B")));
-        REQUIRE_THAT(src,
+            REQUIRE_THAT(src, IsClass(_A("AHandler")));
-            IsInstantiation(
+            REQUIRE_THAT(src, IsClass(_A("BHandler")));
-                _A("Overload<Bases...>"), _A("Overload<AHandler,BHandler>")));
+            REQUIRE_THAT(src, IsClassTemplate("Overload", "Bases..."));
-        REQUIRE_THAT(src,
+            REQUIRE_THAT(src, IsClassTemplate("Overload", "AHandler,BHandler"));
-            IsAggregation(
-                _A("R"), _A("Overload<AHandler,BHandler>"), "+dispatch"));
 
-        save_puml(config.output_directory(), diagram->name + ".puml", src);
+            REQUIRE_THAT(src, IsDependency(_A("AHandler"), _A("A")));
-    }
+            REQUIRE_THAT(src, IsDependency(_A("BHandler"), _A("B")));
+            REQUIRE_THAT(src,
+                IsInstantiation(
+                    _A("Overload<Bases...>"),
+       _A("Overload<AHandler,BHandler>"))); REQUIRE_THAT(src, IsAggregation(
+                    _A("R"), _A("Overload<AHandler,BHandler>"), "+dispatch"));
 
-    {
+            save_puml(config.output_directory(), diagram->name + ".puml", src);
-        auto j = generate_class_json(diagram, *model);
+        }
 
-        using namespace json;
+        {
+            auto j = generate_class_json(diagram, *model);
 
-        REQUIRE(IsClassTemplate(j, "Overload<Bases...>"));
+            using namespace json;
-        REQUIRE(IsClass(j, "A"));
-        REQUIRE(IsClass(j, "B"));
-        REQUIRE(IsClass(j, "AHandler"));
-        REQUIRE(IsClass(j, "BHandler"));
-        REQUIRE(IsClass(j, "Overload<AHandler,BHandler>"));
 
-        save_json(config.output_directory(), diagram->name + ".json", j);
+            REQUIRE(IsClassTemplate(j, "Overload<Bases...>"));
-    }
+            REQUIRE(IsClass(j, "A"));
+            REQUIRE(IsClass(j, "B"));
+            REQUIRE(IsClass(j, "AHandler"));
+            REQUIRE(IsClass(j, "BHandler"));
+            REQUIRE(IsClass(j, "Overload<AHandler,BHandler>"));
 
-    {
+            save_json(config.output_directory(), diagram->name + ".json", j);
-        auto src = generate_class_mermaid(diagram, *model);
+        }
 
-        mermaid::AliasMatcher _A(src);
+        {
-        using mermaid::IsClass;
+            auto src = generate_class_mermaid(diagram, *model);
 
-        REQUIRE_THAT(src, IsClass(_A("A")));
+            mermaid::AliasMatcher _A(src);
-        REQUIRE_THAT(src, IsClass(_A("B")));
+            using mermaid::IsClass;
-        REQUIRE_THAT(src, IsClass(_A("AHandler")));
-        REQUIRE_THAT(src, IsClass(_A("BHandler")));
-        REQUIRE_THAT(src, IsClass(_A("Overload<Bases...>")));
-        REQUIRE_THAT(src, IsClass(_A("Overload<AHandler,BHandler>")));
 
-        REQUIRE_THAT(src, IsDependency(_A("AHandler"), _A("A")));
+            REQUIRE_THAT(src, IsClass(_A("A")));
-        REQUIRE_THAT(src, IsDependency(_A("BHandler"), _A("B")));
+            REQUIRE_THAT(src, IsClass(_A("B")));
-        REQUIRE_THAT(src,
+            REQUIRE_THAT(src, IsClass(_A("AHandler")));
-            IsInstantiation(
+            REQUIRE_THAT(src, IsClass(_A("BHandler")));
-                _A("Overload<Bases...>"), _A("Overload<AHandler,BHandler>")));
+            REQUIRE_THAT(src, IsClass(_A("Overload<Bases...>")));
-        REQUIRE_THAT(src,
+            REQUIRE_THAT(src, IsClass(_A("Overload<AHandler,BHandler>")));
-            IsAggregation(
-                _A("R"), _A("Overload<AHandler,BHandler>"), "+dispatch"));
 
-        save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
+            REQUIRE_THAT(src, IsDependency(_A("AHandler"), _A("A")));
-    }
+            REQUIRE_THAT(src, IsDependency(_A("BHandler"), _A("B")));
+            REQUIRE_THAT(src,
+                IsInstantiation(
+                    _A("Overload<Bases...>"),
+       _A("Overload<AHandler,BHandler>"))); REQUIRE_THAT(src, IsAggregation(
+                    _A("R"), _A("Overload<AHandler,BHandler>"), "+dispatch"));
+
+            save_mermaid(config.output_directory(), diagram->name + ".mmd",
+       src);
+        }*/
 }

tests/t00074/test_case.h

@@ -16,8 +16,10 @@
  * limitations under the License.
  */
 
-TEST_CASE("t00074", "[test-case][class]")
+TEST_CASE("t00074")
 {
+    using namespace clanguml::test;
+
     auto [config, db] = load_config("t00074");
 
     auto diagram = config.diagrams["t00074_class"];
@@ -28,6 +30,19 @@ TEST_CASE("t00074", "[test-case][class]")
 
     REQUIRE(model->name() == "t00074_class");
 
+    CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
+        REQUIRE(IsConcept(src, "fruit_c<T>"));
+        REQUIRE(IsConcept(src, "apple_c<T>"));
+        REQUIRE(IsConcept(src, "orange_c<T>"));
+
+        REQUIRE(IsConstraint(src, "apple_c<T>", "fruit_c<T>", "T"));
+        REQUIRE(IsConstraint(src, "orange_c<T>", "fruit_c<T>", "T"));
+
+        REQUIRE(!IsConceptRequirement(src, "apple_c<T>", "t.get_sweetness()"));
+        REQUIRE(
+            !IsConceptRequirement(src, "orange_c<T>", "t.get_bitterness()"));
+    });
+/*
     {
         auto src = generate_class_puml(diagram, *model);
         AliasMatcher _A(src);
@@ -87,5 +102,5 @@ TEST_CASE("t00074", "[test-case][class]")
             src, !IsConceptRequirement(_A("apple_c<T>"), "t.get_bitterness()"));
 
         save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
-    }
+    }*/
 }

tests/t00075/test_case.h

@@ -16,8 +16,10 @@
  * limitations under the License.
  */
 
-TEST_CASE("t00075", "[test-case][class]")
+TEST_CASE("t00075")
 {
+    using namespace clanguml::test;
+
     auto [config, db] = load_config("t00075");
 
     auto diagram = config.diagrams["t00075_class"];
@@ -28,6 +30,25 @@ TEST_CASE("t00075", "[test-case][class]")
 
     REQUIRE(model->name() == "t00075_class");
 
+    CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
+        REQUIRE(IsClass(src, "A"));
+        REQUIRE(IsClass(src, "B"));
+        REQUIRE(IsClassTemplate(src, "ABE<ns1::ns2::C T>"));
+        REQUIRE(IsClass(src, "R"));
+
+        REQUIRE(IsEnum(src, "E"));
+
+        REQUIRE(IsConcept(src, "C<T>"));
+
+        REQUIRE(IsConceptRequirement(src, "C<T>", "T{}"));
+        REQUIRE(IsConceptRequirement(src, "C<T>", "t.e()"));
+        REQUIRE(IsConceptRequirement(src, "C<T>", "(T t)"));
+        REQUIRE(!IsConceptRequirement(src, "C<T>", "(T ns1::ns2::t)"));
+
+        REQUIRE(IsConstraint(src, "ABE<ns1::ns2::C T>", "C<T>", "T",
+            "up[#green,dashed,thickness=2]"));
+    });
+
     {
         auto src = generate_class_puml(diagram, *model);
         AliasMatcher _A(src);

tests/t30011/test_case.h

@@ -38,10 +38,10 @@ TEST_CASE("t30011")
         REQUIRE(IsDirectoryPackage(src, "libraries"s, "lib3"s));
         REQUIRE(IsDirectoryPackage(src, "libraries"s, "lib4"s));
 
-        REQUIRE(IsDependency(src, "app"s, "lib1"s));
+        REQUIRE(IsDependency(src, "app", "lib1"));
-        REQUIRE(IsDependency(src, "app"s, "lib2"s));
+        REQUIRE(IsDependency(src, "app", "lib2"));
-        REQUIRE(IsDependency(src, "app"s, "lib3"s));
+        REQUIRE(IsDependency(src, "app", "lib3"));
-        REQUIRE(IsDependency(src, "app"s, "lib4"s));
+        REQUIRE(IsDependency(src, "app", "lib4"));
     });
     /*
         {

tests/test_cases.cc

@@ -387,7 +387,7 @@ void try_run_test_case(const diagram_source_storage &diagrams, TC &&tc)
             std::cout << "-----------------------------------------------------"
                          "--------------------------\n";
             std::cout << "Test case failed for diagram type "
-                      << T::diagram_type_name << ": " << "\n";
+                      << T::diagram_type_name << ": " << "\n\n";
             std::cout << diagrams.get<T>().to_string() << "\n";
 
             throw e;
@@ -1044,9 +1044,6 @@ template <> bool IsClass(json_t d, std::string name)
 #include "t00028/test_case.h"
 #include "t00029/test_case.h"
 #include "t00030/test_case.h"
-
-/*
-
 #include "t00031/test_case.h"
 #include "t00032/test_case.h"
 #include "t00033/test_case.h"
@@ -1085,6 +1082,10 @@ template <> bool IsClass(json_t d, std::string name)
 #include "t00062/test_case.h"
 #include "t00063/test_case.h"
 #include "t00064/test_case.h"
+/*
+
+
+
 #if defined(ENABLE_CXX_STD_20_TEST_CASES)
 #include "t00065/test_case.h"
 #endif
@@ -1215,43 +1216,24 @@ int main(int argc, char *argv[])
 {
     doctest::Context context;
 
-    // defaults
-    //    context.addFilter("test-case-exclude",
-    //        "*math*"); // exclude test cases with "math" in their name
-    context.setOption(
-        "abort-after", 5); // stop test execution after 5 failed assertions
-    context.setOption("order-by", "name"); // sort the test cases by their name
-
     context.applyCommandLine(argc, argv);
 
-    // overrides
-    context.setOption(
-        "no-breaks", false); // don't break in the debugger when assertions fail
-
     clanguml::cli::cli_handler clih;
 
     std::vector<const char *> argvv = {
         "clang-uml", "--config", "./test_config_data/simple.yml"};
 
-    //    if (debug_log)
+    argvv.push_back("-vvv");
-    //        argvv.push_back("-vvv");
-    //    else
-    argvv.push_back("-q");
 
     clih.handle_options(argvv.size(), argvv.data());
 
-    int res = context.run(); // run
+    int res = context.run();
 
-    if (context.shouldExit()) // important - query flags (and --exit) rely on
+    if (context.shouldExit())
-                              // the user doing this
+        return res;
-        return res;           // propagate the result of the tests
 
-    int client_stuff_return_code = 0;
+    return res;
-    // your program - if the testing framework is integrated in your production
-    // code
 
-    return res + client_stuff_return_code; // the result from doctest is
-                                           // propagated here as well
     /*
     Catch::Session session;
     using namespace Catch::clara;

tests/test_cases.h

@@ -124,6 +124,11 @@ template <typename T> struct diagram_source_t {
         return "__INVALID_ALIAS__";
     }
 
+    virtual std::string get_alias(std::string ns, std::string name) const
+    {
+        return get_alias(fmt::format("{}::{}", ns, name));
+    }
+
     bool search(const std::string &pattern) const;
 
     std::string to_string() const;
@@ -364,6 +369,43 @@ template <> std::string diagram_source_t<nlohmann::json>::to_string() const
     return src.dump(2);
 }
 
+struct QualifiedName {
+    QualifiedName(const char *n)
+        : name{n}
+    {
+    }
+
+    QualifiedName(std::string_view n)
+        : name{n}
+    {
+    }
+
+    QualifiedName(std::string_view ns_, std::string_view n)
+        : ns{ns_}
+        , name{n}
+    {
+    }
+
+    QualifiedName(const char *ns_, const char *n)
+        : ns{ns_}
+        , name{n}
+    {
+    }
+
+    operator std::string() const { return str(); }
+
+    std::string str() const
+    {
+        if (ns)
+            return fmt::format("{}::{}", ns.value(), name);
+
+        return name;
+    }
+
+    std::optional<std::string> ns;
+    std::string name;
+};
+
 ///
 /// The following functions declarations define various checks on generated
 /// diagrams.
@@ -386,23 +428,31 @@ bool HasTitle(const DiagramType &d, std::string const &str);
 
 // Check if generated diagram contains a specified enum
 template <typename DiagramType>
-bool IsEnum(const DiagramType &d, std::string name);
+bool IsEnum(const DiagramType &d, QualifiedName name);
+
+// Check if generated diagram contains a specified union
+template <typename DiagramType>
+bool IsUnion(const DiagramType &d, QualifiedName name);
 
 // Check if generated diagram contains a specified class
 template <typename DiagramType>
-bool IsClass(const DiagramType &d, std::string name);
+bool IsClass(const DiagramType &d, QualifiedName name);
 
 // Check if generated diagram contains a specified class template
 template <typename DiagramType>
-bool IsClassTemplate(const DiagramType &d, std::string name);
+bool IsClassTemplate(const DiagramType &d, QualifiedName name);
+
+template <typename DiagramType>
+bool IsAbstractClassTemplate(const DiagramType &d, QualifiedName name);
 
 // Check if generated diagram contains a specified abstract class
 template <typename DiagramType>
-bool IsAbstractClass(const DiagramType &d, std::string name);
+bool IsAbstractClass(const DiagramType &d, QualifiedName name);
 
 // Check if generated diagram contains a specified class
 template <typename DiagramType>
-bool IsBaseClass(const DiagramType &d, std::string base, std::string subclass);
+bool IsBaseClass(
+    const DiagramType &d, QualifiedName base, QualifiedName subclass);
 
 template <typename DiagramType>
 bool IsInnerClass(
@@ -440,8 +490,8 @@ bool IsInstantiation(const DiagramType &d, std::string const &from,
     std::string const &to, std::string style = "");
 
 template <typename DiagramType>
-bool IsDependency(const DiagramType &d, std::string const &from,
+bool IsDependency(const DiagramType &d, QualifiedName from, QualifiedName to,
-    std::string const &to, std::string style = "");
+    std::string style = "");
 
 template <typename DiagramType, typename... Ts>
 bool IsFriend(
@@ -459,6 +509,9 @@ template <typename DiagramType>
 bool IsConstraint(const DiagramType &d, std::string const &from,
     std::string const &to, std::string label = {}, std::string style = "");
 
+template <typename DiagramType>
+bool IsConcept(const DiagramType &d, std::string const &cpt);
+
 template <typename DiagramType>
 bool IsConceptRequirement(
     const DiagramType &d, std::string const &cpt, std::string requirement);
@@ -543,28 +596,40 @@ template <> bool HasTitle(const plantuml_t &d, std::string const &str)
     return d.contains("title " + str);
 }
 
-template <> bool IsEnum(const plantuml_t &d, std::string name)
+template <> bool IsEnum(const plantuml_t &d, QualifiedName enm)
 {
-    return d.contains(fmt::format("enum {}", d.get_alias(name)));
+    return d.contains(fmt::format("enum {}", d.get_alias(enm.name)));
 }
 
-template <> bool IsClass(const plantuml_t &d, std::string name)
+template <> bool IsUnion(const plantuml_t &d, QualifiedName cls)
 {
-    return d.contains(fmt::format("class {}", d.get_alias(name)));
+    return d.contains(fmt::format("class {} <<union>>", d.get_alias(cls)));
 }
 
-template <> bool IsClassTemplate(const plantuml_t &d, std::string name)
+template <> bool IsClass(const plantuml_t &d, QualifiedName cls)
 {
-    return d.contains(fmt::format("class \"{}\"", name));
+    return d.contains(fmt::format("class {}", d.get_alias(cls.name))) ||
+        d.contains(fmt::format("class {}", d.get_alias(cls.str())));
 }
 
-template <> bool IsAbstractClass(const plantuml_t &d, std::string name)
+template <> bool IsClassTemplate(const plantuml_t &d, QualifiedName cls)
 {
-    return d.contains(fmt::format("abstract {}", d.get_alias(name)));
+    return d.contains(fmt::format("class \"{}\"", cls.name));
+}
+
+template <> bool IsAbstractClassTemplate(const plantuml_t &d, QualifiedName cls)
+{
+    return d.contains(fmt::format("abstract \"{}\"", cls.name));
+}
+
+template <> bool IsAbstractClass(const plantuml_t &d, QualifiedName cls)
+{
+    return d.contains(fmt::format("abstract {}", d.get_alias(cls.name)));
 }
 
 template <>
-bool IsBaseClass(const plantuml_t &d, std::string base, std::string subclass)
+bool IsBaseClass(
+    const plantuml_t &d, QualifiedName base, QualifiedName subclass)
 {
     return d.contains(
         fmt::format("{} <|-- {}", d.get_alias(base), d.get_alias(subclass)));
@@ -750,11 +815,13 @@ bool IsInstantiation(const plantuml_t &d, std::string const &from,
 }
 
 template <>
-bool IsDependency(const plantuml_t &d, std::string const &from,
+bool IsDependency(const plantuml_t &d, QualifiedName from, QualifiedName to,
-    std::string const &to, std::string style)
+    std::string style)
 {
-    return d.contains(
+    return d.contains(fmt::format(
-        fmt::format("{} .{}.> {}", d.get_alias(from), style, d.get_alias(to)));
+               "{} .{}.> {}", d.get_alias(from), style, d.get_alias(to))) ||
+        d.contains(fmt::format("{} .{}.> {}", d.get_alias(from.name), style,
+            d.get_alias(to.name)));
 }
 
 template <typename... Ts>
@@ -802,6 +869,11 @@ bool IsConstraint(const plantuml_t &d, std::string const &from,
         "{} .{}.> {} : {}", d.get_alias(from), style, d.get_alias(to), label));
 }
 
+template <> bool IsConcept(const plantuml_t &d, std::string const &cpt)
+{
+    return d.contains("class " + d.get_alias(cpt) + " <<concept>>");
+}
+
 template <>
 bool IsConceptRequirement(
     const plantuml_t &d, std::string const &cpt, std::string requirement)
@@ -945,30 +1017,43 @@ template <> bool HasTitle(const mermaid_t &d, std::string const &str)
     return d.contains("title: " + str);
 }
 
-template <> bool IsEnum(const mermaid_t &d, std::string name)
+template <> bool IsEnum(const mermaid_t &d, QualifiedName enm)
 {
-    return d.search(std::string("class ") + d.get_alias(name) +
+    return d.search(std::string("class ") + d.get_alias(enm) +
         " \\{\\n\\s+<<enumeration>>");
 }
 
-template <> bool IsClass(const mermaid_t &d, std::string name)
+template <> bool IsUnion(const mermaid_t &d, QualifiedName cls)
 {
-    return d.contains(fmt::format("class {}[\"{}\"]", d.get_alias(name), name));
+    return d.search(
+        std::string("class ") + d.get_alias(cls) + " \\{\\n\\s+<<union>>");
 }
 
-template <> bool IsClassTemplate(const mermaid_t &d, std::string name)
+template <> bool IsClass(const mermaid_t &d, QualifiedName cls)
 {
-    return d.contains(fmt::format("class {}", d.get_alias(name)));
+    return d.contains(fmt::format("class {}", d.get_alias(cls)));
 }
 
-template <> bool IsAbstractClass(const mermaid_t &d, std::string name)
+template <> bool IsClassTemplate(const mermaid_t &d, QualifiedName cls)
+{
+    return d.contains(fmt::format("class {}", d.get_alias(cls)));
+}
+
+template <> bool IsAbstractClassTemplate(const mermaid_t &d, QualifiedName cls)
+{
+    //    return d.contains(fmt::format("class {}", d.get_alias(cls)));
+    return d.search(
+        std::string("class ") + d.get_alias(cls) + " \\{\\n\\s+<<abstract>>");
+}
+
+template <> bool IsAbstractClass(const mermaid_t &d, QualifiedName name)
 {
     return d.search(
         std::string("class ") + d.get_alias(name) + " \\{\\n\\s+<<abstract>>");
 }
 
 template <>
-bool IsBaseClass(const mermaid_t &d, std::string base, std::string subclass)
+bool IsBaseClass(const mermaid_t &d, QualifiedName base, QualifiedName subclass)
 {
     return d.contains(
         fmt::format("{} <|-- {}", d.get_alias(base), d.get_alias(subclass)));
@@ -1119,7 +1204,7 @@ bool IsComposition(const mermaid_t &d, std::string const &from,
     if (!multiplicity_source.empty())
         format_string += " \"" + multiplicity_source + "\"";
 
-    format_string += fmt::format(" *-{}-", style);
+    format_string += fmt::format(" *--", style);
 
     if (!multiplicity_dest.empty())
         format_string += " \"" + multiplicity_dest + "\"";
@@ -1168,8 +1253,8 @@ bool IsInstantiation(const mermaid_t &d, std::string const &from,
 }
 
 template <>
-bool IsDependency(const mermaid_t &d, std::string const &from,
+bool IsDependency(
-    std::string const &to, std::string style)
+    const mermaid_t &d, QualifiedName from, QualifiedName to, std::string style)
 {
     if (d.diagram_type == common::model::diagram_t::kClass) {
         return d.contains(
@@ -1259,6 +1344,12 @@ bool IsConstraint(const mermaid_t &d, std::string const &from,
     return d.contains(fmt::format("{} ..> {} : {}", from_id, to_id, label));
 }
 
+template <> bool IsConcept(const mermaid_t &d, std::string const &cpt)
+{
+    return d.search(
+        std::string("class ") + d.get_alias(cpt) + " \\{\\n\\s+<<concept>>");
+}
+
 template <>
 bool IsConceptRequirement(
     const mermaid_t &d, std::string const &cpt, std::string requirement)
@@ -1354,8 +1445,13 @@ template <> bool IsSystemHeader(const mermaid_t &d, std::string const &path)
 template <typename... Args>
 bool IsNamespacePackage(const mermaid_t &d, Args... args)
 {
+    if (d.diagram_type == class_diagram::model::diagram_t::kClass) {
+        std::vector<std::string> toks{{args...}};
+        return d.contains(fmt::format("[\"{}", fmt::join(toks, "::")));
+    }
+
     const auto &name = get_last(args...);
-    return d.contains("subgraph " + d.get_alias(name));
+    return d.contains(fmt::format("subgraph {}", d.get_alias(name)));
 }
 
 template <typename... Args>
@@ -1394,32 +1490,44 @@ template <> bool HasTitle(const json_t &d, std::string const &str)
     return d.src.contains("title") && d.src["title"] == str;
 }
 
-template <> bool IsAbstractClass(const json_t &d, std::string name)
+template <> bool IsAbstractClass(const json_t &d, QualifiedName cls)
 {
-    auto e = get_element(d.src, expand_name(d.src, name));
+    auto e = get_element(d.src, expand_name(d.src, cls));
     return e && e->at("type") == "class" && e->at("is_abstract");
 }
 
-template <> bool IsEnum(const json_t &d, std::string name)
+template <> bool IsEnum(const json_t &d, QualifiedName enm)
 {
-    auto e = get_element(d.src, expand_name(d.src, name));
+    auto e = get_element(d.src, expand_name(d.src, enm));
     return e && e->at("type") == "enum";
 }
 
-template <> bool IsClass(const json_t &d, std::string name)
+template <> bool IsUnion(const json_t &d, QualifiedName enm)
 {
-    auto e = get_element(d.src, expand_name(d.src, name));
+    auto e = get_element(d.src, expand_name(d.src, enm));
+    return e && e->at("type") == "class" && e->at("is_union");
+}
+
+template <> bool IsClass(const json_t &d, QualifiedName cls)
+{
+    auto e = get_element(d.src, expand_name(d.src, cls));
     return e && e->at("type") == "class" && !e->at("is_abstract");
 }
 
-template <> bool IsClassTemplate(const json_t &d, std::string name)
+template <> bool IsClassTemplate(const json_t &d, QualifiedName cls)
 {
-    auto e = get_element(d.src, expand_name(d.src, name));
+    auto e = get_element(d.src, expand_name(d.src, cls));
     return e && e->at("type") == "class";
 }
 
+template <> bool IsAbstractClassTemplate(const json_t &d, QualifiedName cls)
+{
+    auto e = get_element(d.src, expand_name(d.src, cls));
+    return e && e->at("type") == "class" && e->at("is_abstract");
+}
+
 template <>
-bool IsBaseClass(const json_t &d, std::string base, std::string subclass)
+bool IsBaseClass(const json_t &d, QualifiedName base, QualifiedName subclass)
 {
     const auto &j = d.src;
     auto base_el = get_element(j, expand_name(j, base));
@@ -1459,8 +1567,8 @@ bool IsMethod(const json_t &d, const std::string &cls, std::string const &name,
 
     const nlohmann::json &methods = (*sc)["methods"];
 
-    return std::find_if(methods.begin(), methods.end(), [&](const auto &it) {
+    return std::find_if(methods.begin(), methods.end(), [name](const auto &it) {
-        return it["name"] == name;
+        return it["display_name"] == name;
     }) != methods.end();
 }
 
@@ -1522,7 +1630,7 @@ bool IsComposition(const json_t &d, std::string const &from,
     const auto &j = d.src;
 
     auto rel = get_relationship(
-        j, expand_name(j, to), expand_name(j, from), "composition", label);
+        j, expand_name(j, from), expand_name(j, to), "composition", label);
 
     if (rel == j["relationships"].end())
         return false;
@@ -1591,8 +1699,8 @@ bool IsInstantiation(const json_t &d, std::string const &from,
 }
 
 template <>
-bool IsDependency(const json_t &d, std::string const &from,
+bool IsDependency(
-    std::string const &to, std::string style)
+    const json_t &d, QualifiedName from, QualifiedName to, std::string style)
 {
     const auto &j = d.src;
 
@@ -1655,18 +1763,48 @@ bool IsIncludeDependency(
     return true;
 }
 
+template <> bool IsConcept(const json_t &d, std::string const &cpt)
+{
+    const auto &j = d.src;
+
+    auto e = get_element(j, expand_name(j, cpt));
+    return e && e->at("type") == "concept";
+}
+
 template <>
 bool IsConstraint(const json_t &d, std::string const &from,
     std::string const &to, std::string label, std::string style)
 {
-    return false;
+    const auto &j = d.src;
+
+    auto rel = get_relationship(
+        j, expand_name(j, from), expand_name(j, to), "constraint", label);
+
+    if (rel == j["relationships"].end())
+        return false;
+
+    if ((*rel)["label"] != label)
+        return false;
+
+    return true;
 }
 
 template <>
 bool IsConceptRequirement(
     const json_t &d, std::string const &cpt, std::string requirement)
 {
-    return false;
+    const auto &j = d.src;
+
+    auto e = get_element(j, expand_name(j, cpt));
+
+    if (!e)
+        return false;
+
+    const nlohmann::json &statements = (*e)["statements"];
+
+    return std::find_if(statements.begin(), statements.end(),
+               [requirement](const auto &it) { return it == requirement; }) !=
+        statements.end();
 }
 
 template <>