diff --git a/src/sequence_diagram/generators/mermaid/sequence_diagram_generator.cc b/src/sequence_diagram/generators/mermaid/sequence_diagram_generator.cc
index 65870510..63f84a5f 100644
--- a/src/sequence_diagram/generators/mermaid/sequence_diagram_generator.cc
+++ b/src/sequence_diagram/generators/mermaid/sequence_diagram_generator.cc
@@ -94,7 +94,7 @@ void generator::generate_call(const message &m, std::ostream &ostr) const
     ostr << indent(1) << from_alias << " "
          << common::generators::mermaid::to_mermaid(message_t::kCall) << " ";
 
-    ostr << indent(1) << to_alias;
+    ostr << to_alias;
 
     ostr << " : ";
 
diff --git a/tests/t20001/.clang-uml b/tests/t20001/.clang-uml
index 8ed2b5b8..2124dc35 100644
--- a/tests/t20001/.clang-uml
+++ b/tests/t20001/.clang-uml
@@ -20,3 +20,8 @@ diagrams:
         - "' t20001 test diagram of type {{ diagram.type }}"
       after:
         - '{% set e=element("clanguml::t20001::tmain()") %} note over {{ e.alias) }}: Main test function'
+    mermaid:
+      before:
+        - "%% t20001 test diagram of type {{ diagram.type }}"
+      after:
+        - '{% set e=element("clanguml::t20001::tmain()") %} Note over {{ e.alias) }}: Main test function'
diff --git a/tests/t20001/test_case.h b/tests/t20001/test_case.h
index f8706b2d..45a315e2 100644
--- a/tests/t20001/test_case.h
+++ b/tests/t20001/test_case.h
@@ -29,21 +29,21 @@ TEST_CASE("t20001", "[test-case][sequence]")
     REQUIRE(model->name() == "t20001_sequence");
 
     {
-        auto puml = generate_sequence_puml(diagram, *model);
-        AliasMatcher _A(puml);
+        auto src = generate_sequence_puml(diagram, *model);
+        AliasMatcher _A(src);
 
-        REQUIRE_THAT(puml, StartsWith("@startuml"));
-        REQUIRE_THAT(puml, EndsWith("@enduml\n"));
+        REQUIRE_THAT(src, StartsWith("@startuml"));
+        REQUIRE_THAT(src, EndsWith("@enduml\n"));
 
-        REQUIRE_THAT(puml, HasCall(_A("B"), _A("A"), "add3(int,int,int)"));
-        REQUIRE_THAT(puml, HasCall(_A("A"), "add(int,int)"));
-        REQUIRE_THAT(puml, !HasCall(_A("A"), _A("detail::C"), "add(int,int)"));
-        REQUIRE_THAT(puml, HasCall(_A("A"), "__log_result(int)__"));
-        REQUIRE_THAT(puml, HasCall(_A("B"), _A("A"), "__log_result(int)__"));
+        REQUIRE_THAT(src, HasCall(_A("B"), _A("A"), "add3(int,int,int)"));
+        REQUIRE_THAT(src, HasCall(_A("A"), "add(int,int)"));
+        REQUIRE_THAT(src, !HasCall(_A("A"), _A("detail::C"), "add(int,int)"));
+        REQUIRE_THAT(src, HasCall(_A("A"), "__log_result(int)__"));
+        REQUIRE_THAT(src, HasCall(_A("B"), _A("A"), "__log_result(int)__"));
 
-        REQUIRE_THAT(puml, HasComment("t20001 test diagram of type sequence"));
+        REQUIRE_THAT(src, HasComment("t20001 test diagram of type sequence"));
 
-        save_puml(config.output_directory(), diagram->name + ".puml", puml);
+        save_puml(config.output_directory(), diagram->name + ".puml", src);
     }
     {
         auto j = generate_sequence_json(diagram, *model);
@@ -67,8 +67,19 @@ TEST_CASE("t20001", "[test-case][sequence]")
         save_json(config.output_directory(), diagram->name + ".json", j);
     }
     {
-        auto mmd = generate_sequence_mermaid(diagram, *model);
+        auto src = generate_sequence_mermaid(diagram, *model);
+        mermaid::SequenceDiagramAliasMatcher _A(src);
+        using mermaid::HasCall;
+        using mermaid::HasComment;
 
-        save_mermaid(config.output_directory(), diagram->name + ".mmd", mmd);
+        REQUIRE_THAT(src, HasCall(_A("B"), _A("A"), "add3(int,int,int)"));
+        REQUIRE_THAT(src, HasCall(_A("A"), "add(int,int)"));
+        REQUIRE_THAT(src, !HasCall(_A("A"), _A("detail::C"), "add(int,int)"));
+        REQUIRE_THAT(src, HasCall(_A("A"), "log_result(int)"));
+        REQUIRE_THAT(src, HasCall(_A("B"), _A("A"), "log_result(int)"));
+
+        REQUIRE_THAT(src, HasComment("t20001 test diagram of type sequence"));
+
+        save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
     }
 }
diff --git a/tests/t20002/test_case.h b/tests/t20002/test_case.h
index fdfd4081..03986b0c 100644
--- a/tests/t20002/test_case.h
+++ b/tests/t20002/test_case.h
@@ -29,17 +29,17 @@ TEST_CASE("t20002", "[test-case][sequence]")
     REQUIRE(model->name() == "t20002_sequence");
 
     {
-        auto puml = generate_sequence_puml(diagram, *model);
-        AliasMatcher _A(puml);
+        auto src = generate_sequence_puml(diagram, *model);
+        AliasMatcher _A(src);
 
-        REQUIRE_THAT(puml, StartsWith("@startuml"));
-        REQUIRE_THAT(puml, EndsWith("@enduml\n"));
+        REQUIRE_THAT(src, StartsWith("@startuml"));
+        REQUIRE_THAT(src, EndsWith("@enduml\n"));
 
-        REQUIRE_THAT(puml, HasCall(_A("m1()"), _A("m2()"), ""));
-        REQUIRE_THAT(puml, HasCall(_A("m2()"), _A("m3()"), ""));
-        REQUIRE_THAT(puml, HasCall(_A("m3()"), _A("m4()"), ""));
+        REQUIRE_THAT(src, HasCall(_A("m1()"), _A("m2()"), ""));
+        REQUIRE_THAT(src, HasCall(_A("m2()"), _A("m3()"), ""));
+        REQUIRE_THAT(src, HasCall(_A("m3()"), _A("m4()"), ""));
 
-        save_puml(config.output_directory(), diagram->name + ".puml", puml);
+        save_puml(config.output_directory(), diagram->name + ".puml", src);
     }
 
     {
@@ -62,8 +62,15 @@ TEST_CASE("t20002", "[test-case][sequence]")
     }
 
     {
-        auto mmd = generate_sequence_mermaid(diagram, *model);
+        auto src = generate_sequence_mermaid(diagram, *model);
 
-        save_mermaid(config.output_directory(), diagram->name + ".mmd", mmd);
+        mermaid::SequenceDiagramAliasMatcher _A(src);
+        using mermaid::HasCall;
+
+        REQUIRE_THAT(src, HasCall(_A("m1()"), _A("m2()"), ""));
+        REQUIRE_THAT(src, HasCall(_A("m2()"), _A("m3()"), ""));
+        REQUIRE_THAT(src, HasCall(_A("m3()"), _A("m4()"), ""));
+
+        save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
     }
 }
diff --git a/tests/t20003/test_case.h b/tests/t20003/test_case.h
index f27ced2e..7a5dce25 100644
--- a/tests/t20003/test_case.h
+++ b/tests/t20003/test_case.h
@@ -29,17 +29,17 @@ TEST_CASE("t20003", "[test-case][sequence]")
     REQUIRE(model->name() == "t20003_sequence");
 
     {
-        auto puml = generate_sequence_puml(diagram, *model);
-        AliasMatcher _A(puml);
+        auto src = generate_sequence_puml(diagram, *model);
+        AliasMatcher _A(src);
 
-        REQUIRE_THAT(puml, StartsWith("@startuml"));
-        REQUIRE_THAT(puml, EndsWith("@enduml\n"));
+        REQUIRE_THAT(src, StartsWith("@startuml"));
+        REQUIRE_THAT(src, EndsWith("@enduml\n"));
 
-        REQUIRE_THAT(puml, HasCall(_A("m1<T>(T)"), _A("m2<T>(T)"), ""));
-        REQUIRE_THAT(puml, HasCall(_A("m2<T>(T)"), _A("m3<T>(T)"), ""));
-        REQUIRE_THAT(puml, HasCall(_A("m3<T>(T)"), _A("m4<T>(T)"), ""));
+        REQUIRE_THAT(src, HasCall(_A("m1<T>(T)"), _A("m2<T>(T)"), ""));
+        REQUIRE_THAT(src, HasCall(_A("m2<T>(T)"), _A("m3<T>(T)"), ""));
+        REQUIRE_THAT(src, HasCall(_A("m3<T>(T)"), _A("m4<T>(T)"), ""));
 
-        save_puml(config.output_directory(), diagram->name + ".puml", puml);
+        save_puml(config.output_directory(), diagram->name + ".puml", src);
     }
 
     {
@@ -57,8 +57,15 @@ TEST_CASE("t20003", "[test-case][sequence]")
     }
 
     {
-        auto mmd = generate_sequence_mermaid(diagram, *model);
+        auto src = generate_sequence_mermaid(diagram, *model);
 
-        save_mermaid(config.output_directory(), diagram->name + ".mmd", mmd);
+        mermaid::SequenceDiagramAliasMatcher _A(src);
+        using mermaid::HasCall;
+
+        REQUIRE_THAT(src, HasCall(_A("m1<T>(T)"), _A("m2<T>(T)"), ""));
+        REQUIRE_THAT(src, HasCall(_A("m2<T>(T)"), _A("m3<T>(T)"), ""));
+        REQUIRE_THAT(src, HasCall(_A("m3<T>(T)"), _A("m4<T>(T)"), ""));
+
+        save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
     }
 }
diff --git a/tests/t20004/test_case.h b/tests/t20004/test_case.h
index eb6ac747..70747fb6 100644
--- a/tests/t20004/test_case.h
+++ b/tests/t20004/test_case.h
@@ -29,35 +29,35 @@ TEST_CASE("t20004", "[test-case][sequence]")
     REQUIRE(model->name() == "t20004_sequence");
 
     {
-        auto puml = generate_sequence_puml(diagram, *model);
-        AliasMatcher _A(puml);
+        auto src = generate_sequence_puml(diagram, *model);
+        AliasMatcher _A(src);
 
-        REQUIRE_THAT(puml, StartsWith("@startuml"));
-        REQUIRE_THAT(puml, HasCall(_A("main()"), _A("m1<float>(float)"), ""));
+        REQUIRE_THAT(src, StartsWith("@startuml"));
+        REQUIRE_THAT(src, HasCall(_A("main()"), _A("m1<float>(float)"), ""));
         REQUIRE_THAT(
-            puml, !HasCall(_A("m1<float>(float)"), _A("m1<float>(float)"), ""));
+            src, !HasCall(_A("m1<float>(float)"), _A("m1<float>(float)"), ""));
         REQUIRE_THAT(
-            puml, !HasCall(_A("m1<float>(float)"), _A("m1<float>(float)"), ""));
+            src, !HasCall(_A("m1<float>(float)"), _A("m1<float>(float)"), ""));
 
-        REQUIRE_THAT(puml,
+        REQUIRE_THAT(src,
             HasCall(_A("main()"), _A("m1<unsigned long>(unsigned long)"), ""));
-        REQUIRE_THAT(puml,
+        REQUIRE_THAT(src,
             HasCall(_A("m1<unsigned long>(unsigned long)"),
                 _A("m4<unsigned long>(unsigned long)"), ""));
 
-        REQUIRE_THAT(puml,
-            HasCall(_A("main()"), _A("m1<std::string>(std::string)"), ""));
-        REQUIRE_THAT(puml,
+        REQUIRE_THAT(
+            src, HasCall(_A("main()"), _A("m1<std::string>(std::string)"), ""));
+        REQUIRE_THAT(src,
             HasCall(_A("m1<std::string>(std::string)"),
                 _A("m2<std::string>(std::string)"), ""));
 
-        REQUIRE_THAT(puml, HasCall(_A("main()"), _A("m1<int>(int)"), ""));
-        REQUIRE_THAT(puml, HasCall(_A("m1<int>(int)"), _A("m2<int>(int)"), ""));
-        REQUIRE_THAT(puml, HasCall(_A("m2<int>(int)"), _A("m3<int>(int)"), ""));
-        REQUIRE_THAT(puml, HasCall(_A("m3<int>(int)"), _A("m4<int>(int)"), ""));
-        REQUIRE_THAT(puml, EndsWith("@enduml\n"));
+        REQUIRE_THAT(src, HasCall(_A("main()"), _A("m1<int>(int)"), ""));
+        REQUIRE_THAT(src, HasCall(_A("m1<int>(int)"), _A("m2<int>(int)"), ""));
+        REQUIRE_THAT(src, HasCall(_A("m2<int>(int)"), _A("m3<int>(int)"), ""));
+        REQUIRE_THAT(src, HasCall(_A("m3<int>(int)"), _A("m4<int>(int)"), ""));
+        REQUIRE_THAT(src, EndsWith("@enduml\n"));
 
-        save_puml(config.output_directory(), diagram->name + ".puml", puml);
+        save_puml(config.output_directory(), diagram->name + ".puml", src);
     }
 
     {
@@ -84,8 +84,34 @@ TEST_CASE("t20004", "[test-case][sequence]")
     }
 
     {
-        auto mmd = generate_sequence_mermaid(diagram, *model);
+        auto src = generate_sequence_mermaid(diagram, *model);
 
-        save_mermaid(config.output_directory(), diagram->name + ".mmd", mmd);
+        mermaid::SequenceDiagramAliasMatcher _A(src);
+        using mermaid::HasCall;
+
+        REQUIRE_THAT(src, HasCall(_A("main()"), _A("m1<float>(float)"), ""));
+        REQUIRE_THAT(
+            src, !HasCall(_A("m1<float>(float)"), _A("m1<float>(float)"), ""));
+        REQUIRE_THAT(
+            src, !HasCall(_A("m1<float>(float)"), _A("m1<float>(float)"), ""));
+
+        REQUIRE_THAT(src,
+            HasCall(_A("main()"), _A("m1<unsigned long>(unsigned long)"), ""));
+        REQUIRE_THAT(src,
+            HasCall(_A("m1<unsigned long>(unsigned long)"),
+                _A("m4<unsigned long>(unsigned long)"), ""));
+
+        REQUIRE_THAT(
+            src, HasCall(_A("main()"), _A("m1<std::string>(std::string)"), ""));
+        REQUIRE_THAT(src,
+            HasCall(_A("m1<std::string>(std::string)"),
+                _A("m2<std::string>(std::string)"), ""));
+
+        REQUIRE_THAT(src, HasCall(_A("main()"), _A("m1<int>(int)"), ""));
+        REQUIRE_THAT(src, HasCall(_A("m1<int>(int)"), _A("m2<int>(int)"), ""));
+        REQUIRE_THAT(src, HasCall(_A("m2<int>(int)"), _A("m3<int>(int)"), ""));
+        REQUIRE_THAT(src, HasCall(_A("m3<int>(int)"), _A("m4<int>(int)"), ""));
+
+        save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
     }
 }
\ No newline at end of file
diff --git a/tests/t20005/test_case.h b/tests/t20005/test_case.h
index 49f0babe..ac336b83 100644
--- a/tests/t20005/test_case.h
+++ b/tests/t20005/test_case.h
@@ -29,19 +29,19 @@ TEST_CASE("t20005", "[test-case][sequence]")
     REQUIRE(model->name() == "t20005_sequence");
 
     {
-        auto puml = generate_sequence_puml(diagram, *model);
-        AliasMatcher _A(puml);
+        auto src = generate_sequence_puml(diagram, *model);
+        AliasMatcher _A(src);
 
-        REQUIRE_THAT(puml, StartsWith("@startuml"));
-        REQUIRE_THAT(puml, EndsWith("@enduml\n"));
+        REQUIRE_THAT(src, StartsWith("@startuml"));
+        REQUIRE_THAT(src, EndsWith("@enduml\n"));
 
         // Check if all calls exist
-        REQUIRE_THAT(puml, HasEntrypoint(_A("C<T>"), "c(T)"));
-        REQUIRE_THAT(puml, HasCall(_A("C<T>"), _A("B<T>"), "b(T)"));
-        REQUIRE_THAT(puml, HasCall(_A("B<T>"), _A("A<T>"), "a(T)"));
-        REQUIRE_THAT(puml, HasExitpoint(_A("C<T>")));
+        REQUIRE_THAT(src, HasEntrypoint(_A("C<T>"), "c(T)"));
+        REQUIRE_THAT(src, HasCall(_A("C<T>"), _A("B<T>"), "b(T)"));
+        REQUIRE_THAT(src, HasCall(_A("B<T>"), _A("A<T>"), "a(T)"));
+        REQUIRE_THAT(src, HasExitpoint(_A("C<T>")));
 
-        save_puml(config.output_directory(), diagram->name + ".puml", puml);
+        save_puml(config.output_directory(), diagram->name + ".puml", src);
     }
 
     {
@@ -58,8 +58,18 @@ TEST_CASE("t20005", "[test-case][sequence]")
     }
 
     {
-        auto mmd = generate_sequence_mermaid(diagram, *model);
+        auto src = generate_sequence_mermaid(diagram, *model);
 
-        save_mermaid(config.output_directory(), diagram->name + ".mmd", mmd);
+        mermaid::SequenceDiagramAliasMatcher _A(src);
+        using mermaid::HasCall;
+        using mermaid::HasEntrypoint;
+        using mermaid::HasExitpoint;
+
+        REQUIRE_THAT(src, HasEntrypoint(_A("C<T>"), "c(T)"));
+        REQUIRE_THAT(src, HasCall(_A("C<T>"), _A("B<T>"), "b(T)"));
+        REQUIRE_THAT(src, HasCall(_A("B<T>"), _A("A<T>"), "a(T)"));
+        REQUIRE_THAT(src, HasExitpoint(_A("C<T>")));
+
+        save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
     }
 }
\ No newline at end of file
diff --git a/tests/t20006/test_case.h b/tests/t20006/test_case.h
index d2913f07..65c2bed2 100644
--- a/tests/t20006/test_case.h
+++ b/tests/t20006/test_case.h
@@ -29,53 +29,53 @@ TEST_CASE("t20006", "[test-case][sequence]")
     REQUIRE(model->name() == "t20006_sequence");
 
     {
-        auto puml = generate_sequence_puml(diagram, *model);
-        AliasMatcher _A(puml);
+        auto src = generate_sequence_puml(diagram, *model);
+        AliasMatcher _A(src);
 
-        REQUIRE_THAT(puml, StartsWith("@startuml"));
-        REQUIRE_THAT(puml, EndsWith("@enduml\n"));
+        REQUIRE_THAT(src, StartsWith("@startuml"));
+        REQUIRE_THAT(src, EndsWith("@enduml\n"));
 
         // Check if all calls exist
-        REQUIRE_THAT(puml, HasCall(_A("tmain()"), _A("B<int>"), "b(int)"));
-        REQUIRE_THAT(puml, HasCall(_A("B<int>"), _A("A<int>"), "a1(int)"));
+        REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B<int>"), "b(int)"));
+        REQUIRE_THAT(src, HasCall(_A("B<int>"), _A("A<int>"), "a1(int)"));
 
-        REQUIRE_THAT(puml,
+        REQUIRE_THAT(src,
             HasCall(_A("tmain()"), _A("B<std::string>"), "b(std::string)"));
-        REQUIRE_THAT(puml,
+        REQUIRE_THAT(src,
             HasCall(
                 _A("B<std::string>"), _A("A<std::string>"), "a2(std::string)"));
 
         REQUIRE_THAT(
-            puml, HasCall(_A("tmain()"), _A("BB<int,int>"), "bb1(int,int)"));
+            src, HasCall(_A("tmain()"), _A("BB<int,int>"), "bb1(int,int)"));
         REQUIRE_THAT(
-            puml, HasCall(_A("BB<int,int>"), _A("AA<int>"), "aa1(int)"));
+            src, HasCall(_A("BB<int,int>"), _A("AA<int>"), "aa1(int)"));
 
         REQUIRE_THAT(
-            puml, HasCall(_A("tmain()"), _A("BB<int,int>"), "bb2(int,int)"));
+            src, HasCall(_A("tmain()"), _A("BB<int,int>"), "bb2(int,int)"));
         REQUIRE_THAT(
-            puml, HasCall(_A("BB<int,int>"), _A("AA<int>"), "aa2(int)"));
+            src, HasCall(_A("BB<int,int>"), _A("AA<int>"), "aa2(int)"));
 
-        REQUIRE_THAT(puml,
+        REQUIRE_THAT(src,
             HasCall(_A("tmain()"), _A("BB<int,std::string>"),
                 "bb1(int,std::string)"));
-        REQUIRE_THAT(puml,
-            HasCall(_A("BB<int,std::string>"), _A("AA<int>"), "aa2(int)"));
+        REQUIRE_THAT(
+            src, HasCall(_A("BB<int,std::string>"), _A("AA<int>"), "aa2(int)"));
 
-        REQUIRE_THAT(puml,
+        REQUIRE_THAT(src,
             HasCall(_A("tmain()"), _A("BB<int,std::string>"),
                 "bb2(int,std::string)"));
-        REQUIRE_THAT(puml,
-            HasCall(_A("BB<int,std::string>"), _A("AA<int>"), "aa1(int)"));
+        REQUIRE_THAT(
+            src, HasCall(_A("BB<int,std::string>"), _A("AA<int>"), "aa1(int)"));
 
-        REQUIRE_THAT(puml,
-            HasCall(_A("tmain()"), _A("BB<int,float>"), "bb1(int,float)"));
-        REQUIRE_THAT(puml,
+        REQUIRE_THAT(
+            src, HasCall(_A("tmain()"), _A("BB<int,float>"), "bb1(int,float)"));
+        REQUIRE_THAT(src,
             HasCall(
                 _A("BB<int,float>"), _A("BB<int,float>"), "bb2(int,float)"));
         REQUIRE_THAT(
-            puml, HasCall(_A("BB<int,float>"), _A("AA<int>"), "aa2(int)"));
+            src, HasCall(_A("BB<int,float>"), _A("AA<int>"), "aa2(int)"));
 
-        save_puml(config.output_directory(), diagram->name + ".puml", puml);
+        save_puml(config.output_directory(), diagram->name + ".puml", src);
     }
 
     {
@@ -98,8 +98,50 @@ TEST_CASE("t20006", "[test-case][sequence]")
     }
 
     {
-        auto mmd = generate_sequence_mermaid(diagram, *model);
+        auto src = generate_sequence_mermaid(diagram, *model);
 
-        save_mermaid(config.output_directory(), diagram->name + ".mmd", mmd);
+        mermaid::SequenceDiagramAliasMatcher _A(src);
+        using mermaid::HasCall;
+
+        REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B<int>"), "b(int)"));
+        REQUIRE_THAT(src, HasCall(_A("B<int>"), _A("A<int>"), "a1(int)"));
+
+        REQUIRE_THAT(src,
+            HasCall(_A("tmain()"), _A("B<std::string>"), "b(std::string)"));
+        REQUIRE_THAT(src,
+            HasCall(
+                _A("B<std::string>"), _A("A<std::string>"), "a2(std::string)"));
+
+        REQUIRE_THAT(
+            src, HasCall(_A("tmain()"), _A("BB<int,int>"), "bb1(int,int)"));
+        REQUIRE_THAT(
+            src, HasCall(_A("BB<int,int>"), _A("AA<int>"), "aa1(int)"));
+
+        REQUIRE_THAT(
+            src, HasCall(_A("tmain()"), _A("BB<int,int>"), "bb2(int,int)"));
+        REQUIRE_THAT(
+            src, HasCall(_A("BB<int,int>"), _A("AA<int>"), "aa2(int)"));
+
+        REQUIRE_THAT(src,
+            HasCall(_A("tmain()"), _A("BB<int,std::string>"),
+                "bb1(int,std::string)"));
+        REQUIRE_THAT(
+            src, HasCall(_A("BB<int,std::string>"), _A("AA<int>"), "aa2(int)"));
+
+        REQUIRE_THAT(src,
+            HasCall(_A("tmain()"), _A("BB<int,std::string>"),
+                "bb2(int,std::string)"));
+        REQUIRE_THAT(
+            src, HasCall(_A("BB<int,std::string>"), _A("AA<int>"), "aa1(int)"));
+
+        REQUIRE_THAT(
+            src, HasCall(_A("tmain()"), _A("BB<int,float>"), "bb1(int,float)"));
+        REQUIRE_THAT(src,
+            HasCall(
+                _A("BB<int,float>"), _A("BB<int,float>"), "bb2(int,float)"));
+        REQUIRE_THAT(
+            src, HasCall(_A("BB<int,float>"), _A("AA<int>"), "aa2(int)"));
+
+        save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
     }
 }
\ No newline at end of file
diff --git a/tests/t20007/test_case.h b/tests/t20007/test_case.h
index c16b95d6..d6ee8025 100644
--- a/tests/t20007/test_case.h
+++ b/tests/t20007/test_case.h
@@ -29,24 +29,24 @@ TEST_CASE("t20007", "[test-case][sequence]")
     REQUIRE(model->name() == "t20007_sequence");
 
     {
-        auto puml = generate_sequence_puml(diagram, *model);
-        AliasMatcher _A(puml);
+        auto src = generate_sequence_puml(diagram, *model);
+        AliasMatcher _A(src);
 
-        REQUIRE_THAT(puml, StartsWith("@startuml"));
-        REQUIRE_THAT(puml, EndsWith("@enduml\n"));
+        REQUIRE_THAT(src, StartsWith("@startuml"));
+        REQUIRE_THAT(src, EndsWith("@enduml\n"));
 
         // Check if all calls exist
-        REQUIRE_THAT(puml,
+        REQUIRE_THAT(src,
             HasCall(_A("tmain()"), _A("Adder<int,int>"), "add(int &&,int &&)"));
-        REQUIRE_THAT(puml,
+        REQUIRE_THAT(src,
             HasCall(_A("tmain()"), _A("Adder<int,float,double>"),
                 "add(int &&,float &&,double &&)"));
-        REQUIRE_THAT(puml,
+        REQUIRE_THAT(src,
             HasCall(_A("tmain()"),
                 _A("Adder<std::string,std::string,std::string>"),
                 "add(std::string &&,std::string &&,std::string &&)"));
 
-        save_puml(config.output_directory(), diagram->name + ".puml", puml);
+        save_puml(config.output_directory(), diagram->name + ".puml", src);
     }
 
     {
@@ -68,8 +68,21 @@ TEST_CASE("t20007", "[test-case][sequence]")
     }
 
     {
-        auto mmd = generate_sequence_mermaid(diagram, *model);
+        auto src = generate_sequence_mermaid(diagram, *model);
 
-        save_mermaid(config.output_directory(), diagram->name + ".mmd", mmd);
+        mermaid::SequenceDiagramAliasMatcher _A(src);
+        using mermaid::HasCall;
+
+        REQUIRE_THAT(src,
+            HasCall(_A("tmain()"), _A("Adder<int,int>"), "add(int &&,int &&)"));
+        REQUIRE_THAT(src,
+            HasCall(_A("tmain()"), _A("Adder<int,float,double>"),
+                "add(int &&,float &&,double &&)"));
+        REQUIRE_THAT(src,
+            HasCall(_A("tmain()"),
+                _A("Adder<std::string,std::string,std::string>"),
+                "add(std::string &&,std::string &&,std::string &&)"));
+
+        save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
     }
 }
\ No newline at end of file
diff --git a/tests/t20008/test_case.h b/tests/t20008/test_case.h
index 47f8a529..c6bc3497 100644
--- a/tests/t20008/test_case.h
+++ b/tests/t20008/test_case.h
@@ -29,32 +29,32 @@ TEST_CASE("t20008", "[test-case][sequence]")
     REQUIRE(model->name() == "t20008_sequence");
 
     {
-        auto puml = generate_sequence_puml(diagram, *model);
-        AliasMatcher _A(puml);
+        auto src = generate_sequence_puml(diagram, *model);
+        AliasMatcher _A(src);
 
-        REQUIRE_THAT(puml, StartsWith("@startuml"));
-        REQUIRE_THAT(puml, EndsWith("@enduml\n"));
+        REQUIRE_THAT(src, StartsWith("@startuml"));
+        REQUIRE_THAT(src, EndsWith("@enduml\n"));
 
         // Check if all calls exist
-        REQUIRE_THAT(puml, HasCall(_A("tmain()"), _A("B<int>"), "b(int)"));
-        REQUIRE_THAT(puml, HasCall(_A("B<int>"), _A("A<int>"), "a1(int)"));
+        REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B<int>"), "b(int)"));
+        REQUIRE_THAT(src, HasCall(_A("B<int>"), _A("A<int>"), "a1(int)"));
         //    REQUIRE_THAT(puml, !HasCall(_A("B<int>"), _A("A<int>"),
         //    "a2(int)")); REQUIRE_THAT(puml, !HasCall(_A("B<int>"),
         //    _A("A<int>"), "a3(int)"));
 
-        REQUIRE_THAT(puml,
+        REQUIRE_THAT(src,
             HasCall(_A("tmain()"), _A("B<const char *>"), "b(const char *)"));
-        REQUIRE_THAT(puml,
+        REQUIRE_THAT(src,
             HasCall(_A("B<const char *>"), _A("A<const char *>"),
                 "a2(const char *)"));
 
-        REQUIRE_THAT(puml,
+        REQUIRE_THAT(src,
             HasCall(_A("tmain()"), _A("B<std::string>"), "b(std::string)"));
-        REQUIRE_THAT(puml,
+        REQUIRE_THAT(src,
             HasCall(
                 _A("B<std::string>"), _A("A<std::string>"), "a3(std::string)"));
 
-        save_puml(config.output_directory(), diagram->name + ".puml", puml);
+        save_puml(config.output_directory(), diagram->name + ".puml", src);
     }
 
     {
@@ -78,8 +78,29 @@ TEST_CASE("t20008", "[test-case][sequence]")
     }
 
     {
-        auto mmd = generate_sequence_mermaid(diagram, *model);
+        auto src = generate_sequence_mermaid(diagram, *model);
 
-        save_mermaid(config.output_directory(), diagram->name + ".mmd", mmd);
+        mermaid::SequenceDiagramAliasMatcher _A(src);
+        using mermaid::HasCall;
+
+        REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B<int>"), "b(int)"));
+        REQUIRE_THAT(src, HasCall(_A("B<int>"), _A("A<int>"), "a1(int)"));
+        //    REQUIRE_THAT(puml, !HasCall(_A("B<int>"), _A("A<int>"),
+        //    "a2(int)")); REQUIRE_THAT(puml, !HasCall(_A("B<int>"),
+        //    _A("A<int>"), "a3(int)"));
+
+        REQUIRE_THAT(src,
+            HasCall(_A("tmain()"), _A("B<const char *>"), "b(const char *)"));
+        REQUIRE_THAT(src,
+            HasCall(_A("B<const char *>"), _A("A<const char *>"),
+                "a2(const char *)"));
+
+        REQUIRE_THAT(src,
+            HasCall(_A("tmain()"), _A("B<std::string>"), "b(std::string)"));
+        REQUIRE_THAT(src,
+            HasCall(
+                _A("B<std::string>"), _A("A<std::string>"), "a3(std::string)"));
+
+        save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
     }
 }
\ No newline at end of file
diff --git a/tests/t20009/test_case.h b/tests/t20009/test_case.h
index b11a4597..905d034f 100644
--- a/tests/t20009/test_case.h
+++ b/tests/t20009/test_case.h
@@ -29,25 +29,26 @@ TEST_CASE("t20009", "[test-case][sequence]")
     REQUIRE(model->name() == "t20009_sequence");
 
     {
-        auto puml = generate_sequence_puml(diagram, *model);
-        AliasMatcher _A(puml);
+        auto src = generate_sequence_puml(diagram, *model);
+        AliasMatcher _A(src);
 
-        REQUIRE_THAT(puml, StartsWith("@startuml"));
-        REQUIRE_THAT(puml, EndsWith("@enduml\n"));
+        REQUIRE_THAT(src, StartsWith("@startuml"));
+        REQUIRE_THAT(src, EndsWith("@enduml\n"));
 
         // Check if all calls exist
-        REQUIRE_THAT(puml,
+        REQUIRE_THAT(src,
             HasCall(_A("tmain()"), _A("B<std::string>"), "b(std::string)"));
-        REQUIRE_THAT(puml,
+        REQUIRE_THAT(src,
             HasCall(
                 _A("B<std::string>"), _A("A<std::string>"), "a(std::string)"));
 
-        REQUIRE_THAT(puml, HasCall(_A("tmain()"), _A("B<int>"), "b(int)"));
-        REQUIRE_THAT(puml, HasCall(_A("B<int>"), _A("A<int>"), "a(int)"));
+        REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B<int>"), "b(int)"));
+        REQUIRE_THAT(src, HasCall(_A("B<int>"), _A("A<int>"), "a(int)"));
 
-        REQUIRE_THAT(puml, HasCall(_A("tmain()"), _A("B<float>"), "b(float)"));
-        REQUIRE_THAT(puml, HasCall(_A("B<float>"), _A("A<float>"), "a(float)"));
-        save_puml(config.output_directory(), diagram->name + ".puml", puml);
+        REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B<float>"), "b(float)"));
+        REQUIRE_THAT(src, HasCall(_A("B<float>"), _A("A<float>"), "a(float)"));
+
+        save_puml(config.output_directory(), diagram->name + ".puml", src);
     }
 
     {
@@ -70,8 +71,23 @@ TEST_CASE("t20009", "[test-case][sequence]")
     }
 
     {
-        auto mmd = generate_sequence_mermaid(diagram, *model);
+        auto src = generate_sequence_mermaid(diagram, *model);
 
-        save_mermaid(config.output_directory(), diagram->name + ".mmd", mmd);
+        mermaid::SequenceDiagramAliasMatcher _A(src);
+        using mermaid::HasCall;
+
+        REQUIRE_THAT(src,
+            HasCall(_A("tmain()"), _A("B<std::string>"), "b(std::string)"));
+        REQUIRE_THAT(src,
+            HasCall(
+                _A("B<std::string>"), _A("A<std::string>"), "a(std::string)"));
+
+        REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B<int>"), "b(int)"));
+        REQUIRE_THAT(src, HasCall(_A("B<int>"), _A("A<int>"), "a(int)"));
+
+        REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B<float>"), "b(float)"));
+        REQUIRE_THAT(src, HasCall(_A("B<float>"), _A("A<float>"), "a(float)"));
+
+        save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
     }
 }
\ No newline at end of file
diff --git a/tests/t20010/test_case.h b/tests/t20010/test_case.h
index 600784b0..99f842d4 100644
--- a/tests/t20010/test_case.h
+++ b/tests/t20010/test_case.h
@@ -29,26 +29,26 @@ TEST_CASE("t20010", "[test-case][sequence]")
     REQUIRE(model->name() == "t20010_sequence");
 
     {
-        auto puml = generate_sequence_puml(diagram, *model);
-        AliasMatcher _A(puml);
+        auto src = generate_sequence_puml(diagram, *model);
+        AliasMatcher _A(src);
 
-        REQUIRE_THAT(puml, StartsWith("@startuml"));
-        REQUIRE_THAT(puml, EndsWith("@enduml\n"));
+        REQUIRE_THAT(src, StartsWith("@startuml"));
+        REQUIRE_THAT(src, EndsWith("@enduml\n"));
 
         // Check if all calls exist
-        REQUIRE_THAT(puml, HasCall(_A("tmain()"), _A("B<int>"), "b1()"));
-        REQUIRE_THAT(puml, HasCall(_A("B<int>"), _A("A"), "a1()"));
+        REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B<int>"), "b1()"));
+        REQUIRE_THAT(src, HasCall(_A("B<int>"), _A("A"), "a1()"));
 
-        REQUIRE_THAT(puml, HasCall(_A("tmain()"), _A("B<int>"), "b2()"));
-        REQUIRE_THAT(puml, HasCall(_A("B<int>"), _A("A"), "a2()"));
+        REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B<int>"), "b2()"));
+        REQUIRE_THAT(src, HasCall(_A("B<int>"), _A("A"), "a2()"));
 
-        REQUIRE_THAT(puml, HasCall(_A("tmain()"), _A("B<int>"), "b3()"));
-        REQUIRE_THAT(puml, HasCall(_A("B<int>"), _A("A"), "a3()"));
+        REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B<int>"), "b3()"));
+        REQUIRE_THAT(src, HasCall(_A("B<int>"), _A("A"), "a3()"));
 
-        REQUIRE_THAT(puml, HasCall(_A("tmain()"), _A("B<int>"), "b4()"));
-        REQUIRE_THAT(puml, HasCall(_A("B<int>"), _A("A"), "a4()"));
+        REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B<int>"), "b4()"));
+        REQUIRE_THAT(src, HasCall(_A("B<int>"), _A("A"), "a4()"));
 
-        save_puml(config.output_directory(), diagram->name + ".puml", puml);
+        save_puml(config.output_directory(), diagram->name + ".puml", src);
     }
 
     {
@@ -72,8 +72,23 @@ TEST_CASE("t20010", "[test-case][sequence]")
     }
 
     {
-        auto mmd = generate_sequence_mermaid(diagram, *model);
+        auto src = generate_sequence_mermaid(diagram, *model);
 
-        save_mermaid(config.output_directory(), diagram->name + ".mmd", mmd);
+        mermaid::SequenceDiagramAliasMatcher _A(src);
+        using mermaid::HasCall;
+
+        REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B<int>"), "b1()"));
+        REQUIRE_THAT(src, HasCall(_A("B<int>"), _A("A"), "a1()"));
+
+        REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B<int>"), "b2()"));
+        REQUIRE_THAT(src, HasCall(_A("B<int>"), _A("A"), "a2()"));
+
+        REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B<int>"), "b3()"));
+        REQUIRE_THAT(src, HasCall(_A("B<int>"), _A("A"), "a3()"));
+
+        REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B<int>"), "b4()"));
+        REQUIRE_THAT(src, HasCall(_A("B<int>"), _A("A"), "a4()"));
+
+        save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
     }
 }
\ No newline at end of file
diff --git a/tests/t20011/test_case.h b/tests/t20011/test_case.h
index 26cea6ef..bda7d30b 100644
--- a/tests/t20011/test_case.h
+++ b/tests/t20011/test_case.h
@@ -28,22 +28,22 @@ TEST_CASE("t20011", "[test-case][sequence]")
 
     REQUIRE(model->name() == "t20011_sequence");
     {
-        auto puml = generate_sequence_puml(diagram, *model);
-        AliasMatcher _A(puml);
+        auto src = generate_sequence_puml(diagram, *model);
+        AliasMatcher _A(src);
 
-        REQUIRE_THAT(puml, StartsWith("@startuml"));
-        REQUIRE_THAT(puml, EndsWith("@enduml\n"));
+        REQUIRE_THAT(src, StartsWith("@startuml"));
+        REQUIRE_THAT(src, EndsWith("@enduml\n"));
 
         // Check if all calls exist
-        REQUIRE_THAT(puml, HasCall(_A("tmain()"), _A("A"), "a(int)"));
-        REQUIRE_THAT(puml, HasCall(_A("A"), _A("A"), "a(int)"));
+        REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("A"), "a(int)"));
+        REQUIRE_THAT(src, HasCall(_A("A"), _A("A"), "a(int)"));
 
-        REQUIRE_THAT(puml, HasCall(_A("tmain()"), _A("A"), "b(int)"));
-        REQUIRE_THAT(puml, HasCall(_A("A"), _A("A"), "c(int)"));
-        REQUIRE_THAT(puml, HasCall(_A("A"), _A("A"), "d(int)"));
-        REQUIRE_THAT(puml, HasCall(_A("A"), _A("A"), "b(int)"));
+        REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("A"), "b(int)"));
+        REQUIRE_THAT(src, HasCall(_A("A"), _A("A"), "c(int)"));
+        REQUIRE_THAT(src, HasCall(_A("A"), _A("A"), "d(int)"));
+        REQUIRE_THAT(src, HasCall(_A("A"), _A("A"), "b(int)"));
 
-        save_puml(config.output_directory(), diagram->name + ".puml", puml);
+        save_puml(config.output_directory(), diagram->name + ".puml", src);
     }
 
     {
@@ -65,8 +65,19 @@ TEST_CASE("t20011", "[test-case][sequence]")
     }
 
     {
-        auto mmd = generate_sequence_mermaid(diagram, *model);
+        auto src = generate_sequence_mermaid(diagram, *model);
 
-        save_mermaid(config.output_directory(), diagram->name + ".mmd", mmd);
+        mermaid::SequenceDiagramAliasMatcher _A(src);
+        using mermaid::HasCall;
+
+        REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("A"), "a(int)"));
+        REQUIRE_THAT(src, HasCall(_A("A"), _A("A"), "a(int)"));
+
+        REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("A"), "b(int)"));
+        REQUIRE_THAT(src, HasCall(_A("A"), _A("A"), "c(int)"));
+        REQUIRE_THAT(src, HasCall(_A("A"), _A("A"), "d(int)"));
+        REQUIRE_THAT(src, HasCall(_A("A"), _A("A"), "b(int)"));
+
+        save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
     }
 }
\ No newline at end of file
diff --git a/tests/t20012/test_case.h b/tests/t20012/test_case.h
index 2b9f099f..1ffbf6df 100644
--- a/tests/t20012/test_case.h
+++ b/tests/t20012/test_case.h
@@ -28,56 +28,56 @@ TEST_CASE("t20012", "[test-case][sequence]")
 
     REQUIRE(model->name() == "t20012_sequence");
     {
-        auto puml = generate_sequence_puml(diagram, *model);
-        AliasMatcher _A(puml);
+        auto src = generate_sequence_puml(diagram, *model);
+        AliasMatcher _A(src);
 
-        REQUIRE_THAT(puml, StartsWith("@startuml"));
-        REQUIRE_THAT(puml, EndsWith("@enduml\n"));
+        REQUIRE_THAT(src, StartsWith("@startuml"));
+        REQUIRE_THAT(src, EndsWith("@enduml\n"));
 
         // Check if all calls exist
-        REQUIRE_THAT(puml,
+        REQUIRE_THAT(src,
             HasCall(_A("tmain()"),
                 _A("tmain()::(lambda ../../tests/t20012/t20012.cc:67:20)"),
                 "operator()()"));
-        REQUIRE_THAT(puml,
+        REQUIRE_THAT(src,
             HasCall(_A("tmain()::(lambda ../../tests/t20012/t20012.cc:67:20)"),
                 _A("A"), "a()"));
-        REQUIRE_THAT(puml, HasCall(_A("A"), _A("A"), "aa()"));
-        REQUIRE_THAT(puml, HasCall(_A("A"), _A("A"), "aaa()"));
+        REQUIRE_THAT(src, HasCall(_A("A"), _A("A"), "aa()"));
+        REQUIRE_THAT(src, HasCall(_A("A"), _A("A"), "aaa()"));
 
-        REQUIRE_THAT(puml,
+        REQUIRE_THAT(src,
             HasCall(_A("tmain()::(lambda ../../tests/t20012/t20012.cc:67:20)"),
                 _A("B"), "b()"));
-        REQUIRE_THAT(puml, HasCall(_A("B"), _A("B"), "bb()"));
-        REQUIRE_THAT(puml, HasCall(_A("B"), _A("B"), "bbb()"));
+        REQUIRE_THAT(src, HasCall(_A("B"), _A("B"), "bb()"));
+        REQUIRE_THAT(src, HasCall(_A("B"), _A("B"), "bbb()"));
 
-        REQUIRE_THAT(puml,
+        REQUIRE_THAT(src,
             HasCall(_A("tmain()::(lambda ../../tests/t20012/t20012.cc:80:20)"),
                 _A("C"), "c()"));
-        REQUIRE_THAT(puml, HasCall(_A("C"), _A("C"), "cc()"));
-        REQUIRE_THAT(puml, HasCall(_A("C"), _A("C"), "ccc()"));
-        REQUIRE_THAT(puml,
+        REQUIRE_THAT(src, HasCall(_A("C"), _A("C"), "cc()"));
+        REQUIRE_THAT(src, HasCall(_A("C"), _A("C"), "ccc()"));
+        REQUIRE_THAT(src,
             HasCall(_A("tmain()::(lambda ../../tests/t20012/t20012.cc:80:20)"),
                 _A("tmain()::(lambda ../../tests/t20012/t20012.cc:67:20)"),
                 "operator()()"));
 
-        REQUIRE_THAT(puml, HasCall(_A("C"), _A("C"), "ccc()"));
+        REQUIRE_THAT(src, HasCall(_A("C"), _A("C"), "ccc()"));
 
-        REQUIRE_THAT(puml,
+        REQUIRE_THAT(src,
             HasCall(_A("tmain()"),
                 _A("R<R::(lambda ../../tests/t20012/t20012.cc:86:9)>"), "r()"));
-        REQUIRE_THAT(puml,
+        REQUIRE_THAT(src,
             HasCall(_A("R<R::(lambda ../../tests/t20012/t20012.cc:86:9)>"),
                 _A("tmain()::(lambda ../../tests/t20012/t20012.cc:86:9)"),
                 "operator()()"));
-        REQUIRE_THAT(puml,
+        REQUIRE_THAT(src,
             HasCall(_A("tmain()::(lambda ../../tests/t20012/t20012.cc:86:9)"),
                 _A("C"), "c()"));
 
         // @todo #168
         // REQUIRE_THAT(puml, HasCall(_A("tmain()"), _A("D"), "add5(int)"));
 
-        save_puml(config.output_directory(), diagram->name + ".puml", puml);
+        save_puml(config.output_directory(), diagram->name + ".puml", src);
     }
 
     {
@@ -123,8 +123,50 @@ TEST_CASE("t20012", "[test-case][sequence]")
     }
 
     {
-        auto mmd = generate_sequence_mermaid(diagram, *model);
+        auto src = generate_sequence_mermaid(diagram, *model);
 
-        save_mermaid(config.output_directory(), diagram->name + ".mmd", mmd);
+        mermaid::SequenceDiagramAliasMatcher _A(src);
+        using mermaid::HasCall;
+
+        REQUIRE_THAT(src,
+            HasCall(_A("tmain()"),
+                _A("tmain()::(lambda ../../tests/t20012/t20012.cc:67:20)"),
+                "operator()()"));
+        REQUIRE_THAT(src,
+            HasCall(_A("tmain()::(lambda ../../tests/t20012/t20012.cc:67:20)"),
+                _A("A"), "a()"));
+        REQUIRE_THAT(src, HasCall(_A("A"), _A("A"), "aa()"));
+        REQUIRE_THAT(src, HasCall(_A("A"), _A("A"), "aaa()"));
+
+        REQUIRE_THAT(src,
+            HasCall(_A("tmain()::(lambda ../../tests/t20012/t20012.cc:67:20)"),
+                _A("B"), "b()"));
+        REQUIRE_THAT(src, HasCall(_A("B"), _A("B"), "bb()"));
+        REQUIRE_THAT(src, HasCall(_A("B"), _A("B"), "bbb()"));
+
+        REQUIRE_THAT(src,
+            HasCall(_A("tmain()::(lambda ../../tests/t20012/t20012.cc:80:20)"),
+                _A("C"), "c()"));
+        REQUIRE_THAT(src, HasCall(_A("C"), _A("C"), "cc()"));
+        REQUIRE_THAT(src, HasCall(_A("C"), _A("C"), "ccc()"));
+        REQUIRE_THAT(src,
+            HasCall(_A("tmain()::(lambda ../../tests/t20012/t20012.cc:80:20)"),
+                _A("tmain()::(lambda ../../tests/t20012/t20012.cc:67:20)"),
+                "operator()()"));
+
+        REQUIRE_THAT(src, HasCall(_A("C"), _A("C"), "ccc()"));
+
+        REQUIRE_THAT(src,
+            HasCall(_A("tmain()"),
+                _A("R<R::(lambda ../../tests/t20012/t20012.cc:86:9)>"), "r()"));
+        REQUIRE_THAT(src,
+            HasCall(_A("R<R::(lambda ../../tests/t20012/t20012.cc:86:9)>"),
+                _A("tmain()::(lambda ../../tests/t20012/t20012.cc:86:9)"),
+                "operator()()"));
+        REQUIRE_THAT(src,
+            HasCall(_A("tmain()::(lambda ../../tests/t20012/t20012.cc:86:9)"),
+                _A("C"), "c()"));
+
+        save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
     }
 }
diff --git a/tests/t20013/test_case.h b/tests/t20013/test_case.h
index b885fe88..3f3144d2 100644
--- a/tests/t20013/test_case.h
+++ b/tests/t20013/test_case.h
@@ -28,26 +28,25 @@ TEST_CASE("t20013", "[test-case][sequence]")
 
     REQUIRE(model->name() == "t20013_sequence");
     {
-        auto puml = generate_sequence_puml(diagram, *model);
-        AliasMatcher _A(puml);
+        auto src = generate_sequence_puml(diagram, *model);
+        AliasMatcher _A(src);
 
-        REQUIRE_THAT(puml, StartsWith("@startuml"));
-        REQUIRE_THAT(puml, EndsWith("@enduml\n"));
+        REQUIRE_THAT(src, StartsWith("@startuml"));
+        REQUIRE_THAT(src, EndsWith("@enduml\n"));
 
         // Check if all calls exist
-        REQUIRE_THAT(
-            puml, HasCall(_A("tmain(int,char **)"), _A("B"), "b(int)"));
-        REQUIRE_THAT(puml, HasCall(_A("B"), _A("A"), "a1(int)"));
+        REQUIRE_THAT(src, HasCall(_A("tmain(int,char **)"), _A("B"), "b(int)"));
+        REQUIRE_THAT(src, HasCall(_A("B"), _A("A"), "a1(int)"));
 
         REQUIRE_THAT(
-            puml, HasCall(_A("tmain(int,char **)"), _A("B"), "b(double)"));
-        REQUIRE_THAT(puml, HasCall(_A("B"), _A("A"), "a2(double)"));
+            src, HasCall(_A("tmain(int,char **)"), _A("B"), "b(double)"));
+        REQUIRE_THAT(src, HasCall(_A("B"), _A("A"), "a2(double)"));
 
-        REQUIRE_THAT(puml,
-            HasCall(_A("tmain(int,char **)"), _A("B"), "b(const char *)"));
-        REQUIRE_THAT(puml, HasCall(_A("B"), _A("A"), "a3(const char *)"));
+        REQUIRE_THAT(
+            src, HasCall(_A("tmain(int,char **)"), _A("B"), "b(const char *)"));
+        REQUIRE_THAT(src, HasCall(_A("B"), _A("A"), "a3(const char *)"));
 
-        save_puml(config.output_directory(), diagram->name + ".puml", puml);
+        save_puml(config.output_directory(), diagram->name + ".puml", src);
     }
 
     {
@@ -69,8 +68,22 @@ TEST_CASE("t20013", "[test-case][sequence]")
     }
 
     {
-        auto mmd = generate_sequence_mermaid(diagram, *model);
+        auto src = generate_sequence_mermaid(diagram, *model);
 
-        save_mermaid(config.output_directory(), diagram->name + ".mmd", mmd);
+        mermaid::SequenceDiagramAliasMatcher _A(src);
+        using mermaid::HasCall;
+
+        REQUIRE_THAT(src, HasCall(_A("tmain(int,char **)"), _A("B"), "b(int)"));
+        REQUIRE_THAT(src, HasCall(_A("B"), _A("A"), "a1(int)"));
+
+        REQUIRE_THAT(
+            src, HasCall(_A("tmain(int,char **)"), _A("B"), "b(double)"));
+        REQUIRE_THAT(src, HasCall(_A("B"), _A("A"), "a2(double)"));
+
+        REQUIRE_THAT(
+            src, HasCall(_A("tmain(int,char **)"), _A("B"), "b(const char *)"));
+        REQUIRE_THAT(src, HasCall(_A("B"), _A("A"), "a3(const char *)"));
+
+        save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
     }
 }
\ No newline at end of file
diff --git a/tests/t20014/test_case.h b/tests/t20014/test_case.h
index e5910ec7..6f99d24e 100644
--- a/tests/t20014/test_case.h
+++ b/tests/t20014/test_case.h
@@ -28,24 +28,24 @@ TEST_CASE("t20014", "[test-case][sequence]")
 
     REQUIRE(model->name() == "t20014_sequence");
     {
-        auto puml = generate_sequence_puml(diagram, *model);
-        AliasMatcher _A(puml);
+        auto src = generate_sequence_puml(diagram, *model);
+        AliasMatcher _A(src);
 
-        REQUIRE_THAT(puml, StartsWith("@startuml"));
-        REQUIRE_THAT(puml, EndsWith("@enduml\n"));
+        REQUIRE_THAT(src, StartsWith("@startuml"));
+        REQUIRE_THAT(src, EndsWith("@enduml\n"));
 
         // Check if all calls exist
-        REQUIRE_THAT(puml, HasCall(_A("tmain()"), _A("B"), "b1(int,int)"));
-        REQUIRE_THAT(puml, HasCall(_A("B"), _A("A"), "a1(int,int)"));
+        REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B"), "b1(int,int)"));
+        REQUIRE_THAT(src, HasCall(_A("B"), _A("A"), "a1(int,int)"));
 
-        REQUIRE_THAT(puml, HasCall(_A("tmain()"), _A("B"), "b2(int,int)"));
-        REQUIRE_THAT(puml, HasCall(_A("B"), _A("A"), "a2(int,int)"));
+        REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B"), "b2(int,int)"));
+        REQUIRE_THAT(src, HasCall(_A("B"), _A("A"), "a2(int,int)"));
 
         REQUIRE_THAT(
-            puml, HasCall(_A("tmain()"), _A("C<B,int>"), "c1(int,int)"));
-        REQUIRE_THAT(puml, HasCall(_A("C<B,int>"), _A("B"), "b1(int,int)"));
+            src, HasCall(_A("tmain()"), _A("C<B,int>"), "c1(int,int)"));
+        REQUIRE_THAT(src, HasCall(_A("C<B,int>"), _A("B"), "b1(int,int)"));
 
-        save_puml(config.output_directory(), diagram->name + ".puml", puml);
+        save_puml(config.output_directory(), diagram->name + ".puml", src);
     }
 
     {
@@ -68,8 +68,21 @@ TEST_CASE("t20014", "[test-case][sequence]")
     }
 
     {
-        auto mmd = generate_sequence_mermaid(diagram, *model);
+        auto src = generate_sequence_mermaid(diagram, *model);
 
-        save_mermaid(config.output_directory(), diagram->name + ".mmd", mmd);
+        mermaid::SequenceDiagramAliasMatcher _A(src);
+        using mermaid::HasCall;
+
+        REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B"), "b1(int,int)"));
+        REQUIRE_THAT(src, HasCall(_A("B"), _A("A"), "a1(int,int)"));
+
+        REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B"), "b2(int,int)"));
+        REQUIRE_THAT(src, HasCall(_A("B"), _A("A"), "a2(int,int)"));
+
+        REQUIRE_THAT(
+            src, HasCall(_A("tmain()"), _A("C<B,int>"), "c1(int,int)"));
+        REQUIRE_THAT(src, HasCall(_A("C<B,int>"), _A("B"), "b1(int,int)"));
+
+        save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
     }
 }
\ No newline at end of file
diff --git a/tests/t20015/test_case.h b/tests/t20015/test_case.h
index c56f2499..c2c50ddc 100644
--- a/tests/t20015/test_case.h
+++ b/tests/t20015/test_case.h
@@ -28,25 +28,25 @@ TEST_CASE("t20015", "[test-case][sequence]")
 
     REQUIRE(model->name() == "t20015_sequence");
     {
-        auto puml = generate_sequence_puml(diagram, *model);
-        AliasMatcher _A(puml);
+        auto src = generate_sequence_puml(diagram, *model);
+        AliasMatcher _A(src);
 
-        REQUIRE_THAT(puml, StartsWith("@startuml"));
-        REQUIRE_THAT(puml, EndsWith("@enduml\n"));
+        REQUIRE_THAT(src, StartsWith("@startuml"));
+        REQUIRE_THAT(src, EndsWith("@enduml\n"));
 
         // Check if all calls exist
-        REQUIRE_THAT(puml,
+        REQUIRE_THAT(src,
             HasCall(_A("tmain()"), _A("B"),
                 "setup_a(std::shared_ptr<detail::A> &)"));
-        REQUIRE_THAT(puml, !HasCall(_A("B"), _A("detail::A"), "set_x(int)"));
-        REQUIRE_THAT(puml, !HasCall(_A("B"), _A("detail::A"), "set_y(int)"));
-        REQUIRE_THAT(puml, !HasCall(_A("B"), _A("detail::A"), "set_z(int)"));
+        REQUIRE_THAT(src, !HasCall(_A("B"), _A("detail::A"), "set_x(int)"));
+        REQUIRE_THAT(src, !HasCall(_A("B"), _A("detail::A"), "set_y(int)"));
+        REQUIRE_THAT(src, !HasCall(_A("B"), _A("detail::A"), "set_z(int)"));
 
-        REQUIRE_THAT(puml, !HasCall(_A("B"), _A("B"), "set_x(int)"));
-        REQUIRE_THAT(puml, !HasCall(_A("B"), _A("B"), "set_y(int)"));
-        REQUIRE_THAT(puml, !HasCall(_A("B"), _A("B"), "set_z(int)"));
+        REQUIRE_THAT(src, !HasCall(_A("B"), _A("B"), "set_x(int)"));
+        REQUIRE_THAT(src, !HasCall(_A("B"), _A("B"), "set_y(int)"));
+        REQUIRE_THAT(src, !HasCall(_A("B"), _A("B"), "set_z(int)"));
 
-        save_puml(config.output_directory(), diagram->name + ".puml", puml);
+        save_puml(config.output_directory(), diagram->name + ".puml", src);
     }
 
     {
@@ -63,8 +63,22 @@ TEST_CASE("t20015", "[test-case][sequence]")
     }
 
     {
-        auto mmd = generate_sequence_mermaid(diagram, *model);
+        auto src = generate_sequence_mermaid(diagram, *model);
 
-        save_mermaid(config.output_directory(), diagram->name + ".mmd", mmd);
+        mermaid::SequenceDiagramAliasMatcher _A(src);
+        using mermaid::HasCall;
+
+        REQUIRE_THAT(src,
+            HasCall(_A("tmain()"), _A("B"),
+                "setup_a(std::shared_ptr<detail::A> &)"));
+        REQUIRE_THAT(src, !HasCall(_A("B"), _A("detail::A"), "set_x(int)"));
+        REQUIRE_THAT(src, !HasCall(_A("B"), _A("detail::A"), "set_y(int)"));
+        REQUIRE_THAT(src, !HasCall(_A("B"), _A("detail::A"), "set_z(int)"));
+
+        REQUIRE_THAT(src, !HasCall(_A("B"), _A("B"), "set_x(int)"));
+        REQUIRE_THAT(src, !HasCall(_A("B"), _A("B"), "set_y(int)"));
+        REQUIRE_THAT(src, !HasCall(_A("B"), _A("B"), "set_z(int)"));
+
+        save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
     }
 }
\ No newline at end of file
diff --git a/tests/t20016/test_case.h b/tests/t20016/test_case.h
index 92ef295f..5110b8fe 100644
--- a/tests/t20016/test_case.h
+++ b/tests/t20016/test_case.h
@@ -28,20 +28,20 @@ TEST_CASE("t20016", "[test-case][sequence]")
 
     REQUIRE(model->name() == "t20016_sequence");
     {
-        auto puml = generate_sequence_puml(diagram, *model);
-        AliasMatcher _A(puml);
+        auto src = generate_sequence_puml(diagram, *model);
+        AliasMatcher _A(src);
 
-        REQUIRE_THAT(puml, StartsWith("@startuml"));
-        REQUIRE_THAT(puml, EndsWith("@enduml\n"));
+        REQUIRE_THAT(src, StartsWith("@startuml"));
+        REQUIRE_THAT(src, EndsWith("@enduml\n"));
 
         // Check if all calls exist
-        REQUIRE_THAT(puml, HasCall(_A("tmain()"), _A("B<long>"), "b1(long)"));
-        REQUIRE_THAT(puml, HasCall(_A("B<long>"), _A("A"), "a1(int)"));
+        REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B<long>"), "b1(long)"));
+        REQUIRE_THAT(src, HasCall(_A("B<long>"), _A("A"), "a1(int)"));
 
-        REQUIRE_THAT(puml, HasCall(_A("tmain()"), _A("B<long>"), "b2(long)"));
-        REQUIRE_THAT(puml, HasCall(_A("B<long>"), _A("A"), "a2(const long &)"));
+        REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B<long>"), "b2(long)"));
+        REQUIRE_THAT(src, HasCall(_A("B<long>"), _A("A"), "a2(const long &)"));
 
-        save_puml(config.output_directory(), diagram->name + ".puml", puml);
+        save_puml(config.output_directory(), diagram->name + ".puml", src);
     }
 
     {
@@ -61,8 +61,17 @@ TEST_CASE("t20016", "[test-case][sequence]")
     }
 
     {
-        auto mmd = generate_sequence_mermaid(diagram, *model);
+        auto src = generate_sequence_mermaid(diagram, *model);
 
-        save_mermaid(config.output_directory(), diagram->name + ".mmd", mmd);
+        mermaid::SequenceDiagramAliasMatcher _A(src);
+        using mermaid::HasCall;
+
+        REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B<long>"), "b1(long)"));
+        REQUIRE_THAT(src, HasCall(_A("B<long>"), _A("A"), "a1(int)"));
+
+        REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B<long>"), "b2(long)"));
+        REQUIRE_THAT(src, HasCall(_A("B<long>"), _A("A"), "a2(const long &)"));
+
+        save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
     }
 }
\ No newline at end of file
diff --git a/tests/t20017/test_case.h b/tests/t20017/test_case.h
index e617b4a8..aa72a696 100644
--- a/tests/t20017/test_case.h
+++ b/tests/t20017/test_case.h
@@ -28,28 +28,28 @@ TEST_CASE("t20017", "[test-case][sequence]")
 
     REQUIRE(model->name() == "t20017_sequence");
     {
-        auto puml = generate_sequence_puml(diagram, *model);
-        AliasMatcher _A(puml);
+        auto src = generate_sequence_puml(diagram, *model);
+        AliasMatcher _A(src);
 
-        REQUIRE_THAT(puml, StartsWith("@startuml"));
-        REQUIRE_THAT(puml, EndsWith("@enduml\n"));
+        REQUIRE_THAT(src, StartsWith("@startuml"));
+        REQUIRE_THAT(src, EndsWith("@enduml\n"));
 
         // Check if all calls exist
-        REQUIRE_THAT(puml, HasEntrypoint(_A("t20017.cc"), "tmain()"));
-        REQUIRE_THAT(puml,
+        REQUIRE_THAT(src, HasEntrypoint(_A("t20017.cc"), "tmain()"));
+        REQUIRE_THAT(src,
             HasCall(_A("t20017.cc"), _A("include/t20017_a.h"), "a1(int,int)"));
-        REQUIRE_THAT(puml,
+        REQUIRE_THAT(src,
             HasCall(_A("t20017.cc"), _A("include/t20017_a.h"), "a2(int,int)"));
-        REQUIRE_THAT(puml,
+        REQUIRE_THAT(src,
             HasCall(_A("t20017.cc"), _A("include/t20017_a.h"), "a3(int,int)"));
-        REQUIRE_THAT(puml,
+        REQUIRE_THAT(src,
             HasCall(_A("t20017.cc"), _A("include/t20017_b.h"), "b1(int,int)"));
-        REQUIRE_THAT(puml,
+        REQUIRE_THAT(src,
             HasCall(
                 _A("t20017.cc"), _A("include/t20017_b.h"), "b2<int>(int,int)"));
-        REQUIRE_THAT(puml, HasExitpoint(_A("t20017.cc")));
+        REQUIRE_THAT(src, HasExitpoint(_A("t20017.cc")));
 
-        save_puml(config.output_directory(), diagram->name + ".puml", puml);
+        save_puml(config.output_directory(), diagram->name + ".puml", src);
     }
 
     {
@@ -75,8 +75,27 @@ TEST_CASE("t20017", "[test-case][sequence]")
     }
 
     {
-        auto mmd = generate_sequence_mermaid(diagram, *model);
+        auto src = generate_sequence_mermaid(diagram, *model);
 
-        save_mermaid(config.output_directory(), diagram->name + ".mmd", mmd);
+        mermaid::SequenceDiagramAliasMatcher _A(src);
+        using mermaid::HasCall;
+        using mermaid::HasEntrypoint;
+        using mermaid::HasExitpoint;
+
+        REQUIRE_THAT(src, HasEntrypoint(_A("t20017.cc"), "tmain()"));
+        REQUIRE_THAT(src,
+            HasCall(_A("t20017.cc"), _A("include/t20017_a.h"), "a1(int,int)"));
+        REQUIRE_THAT(src,
+            HasCall(_A("t20017.cc"), _A("include/t20017_a.h"), "a2(int,int)"));
+        REQUIRE_THAT(src,
+            HasCall(_A("t20017.cc"), _A("include/t20017_a.h"), "a3(int,int)"));
+        REQUIRE_THAT(src,
+            HasCall(_A("t20017.cc"), _A("include/t20017_b.h"), "b1(int,int)"));
+        REQUIRE_THAT(src,
+            HasCall(
+                _A("t20017.cc"), _A("include/t20017_b.h"), "b2<int>(int,int)"));
+        REQUIRE_THAT(src, HasExitpoint(_A("t20017.cc")));
+
+        save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
     }
 }
\ No newline at end of file
diff --git a/tests/t20018/test_case.h b/tests/t20018/test_case.h
index cb3d8d69..5a2448f1 100644
--- a/tests/t20018/test_case.h
+++ b/tests/t20018/test_case.h
@@ -29,31 +29,31 @@ TEST_CASE("t20018", "[test-case][sequence]")
     REQUIRE(model->name() == "t20018_sequence");
 
     {
-        auto puml = generate_sequence_puml(diagram, *model);
-        AliasMatcher _A(puml);
+        auto src = generate_sequence_puml(diagram, *model);
+        AliasMatcher _A(src);
 
-        REQUIRE_THAT(puml, StartsWith("@startuml"));
-        REQUIRE_THAT(puml, EndsWith("@enduml\n"));
+        REQUIRE_THAT(src, StartsWith("@startuml"));
+        REQUIRE_THAT(src, EndsWith("@enduml\n"));
 
         // Check if all calls exist
-        REQUIRE_THAT(puml,
+        REQUIRE_THAT(src,
             HasCall(
                 _A("tmain()"), _A("Answer<Factorial<5>,120>"), "__print()__"));
-        REQUIRE_THAT(puml,
+        REQUIRE_THAT(src,
             HasCall(_A("Answer<Factorial<5>,120>"), _A("Factorial<5>"),
                 "__print(int)__"));
-        REQUIRE_THAT(puml,
+        REQUIRE_THAT(src,
             HasCall(_A("Factorial<5>"), _A("Factorial<4>"), "__print(int)__"));
-        REQUIRE_THAT(puml,
+        REQUIRE_THAT(src,
             HasCall(_A("Factorial<4>"), _A("Factorial<3>"), "__print(int)__"));
-        REQUIRE_THAT(puml,
+        REQUIRE_THAT(src,
             HasCall(_A("Factorial<3>"), _A("Factorial<2>"), "__print(int)__"));
-        REQUIRE_THAT(puml,
+        REQUIRE_THAT(src,
             HasCall(_A("Factorial<2>"), _A("Factorial<1>"), "__print(int)__"));
-        REQUIRE_THAT(puml,
+        REQUIRE_THAT(src,
             HasCall(_A("Factorial<1>"), _A("Factorial<0>"), "__print(int)__"));
 
-        save_puml(config.output_directory(), diagram->name + ".puml", puml);
+        save_puml(config.output_directory(), diagram->name + ".puml", src);
     }
 
     {
@@ -78,8 +78,27 @@ TEST_CASE("t20018", "[test-case][sequence]")
     }
 
     {
-        auto mmd = generate_sequence_mermaid(diagram, *model);
+        auto src = generate_sequence_mermaid(diagram, *model);
 
-        save_mermaid(config.output_directory(), diagram->name + ".mmd", mmd);
+        mermaid::SequenceDiagramAliasMatcher _A(src);
+        using mermaid::HasCall;
+
+        REQUIRE_THAT(src,
+            HasCall(_A("tmain()"), _A("Answer<Factorial<5>,120>"), "print()"));
+        REQUIRE_THAT(src,
+            HasCall(_A("Answer<Factorial<5>,120>"), _A("Factorial<5>"),
+                "print(int)"));
+        REQUIRE_THAT(
+            src, HasCall(_A("Factorial<5>"), _A("Factorial<4>"), "print(int)"));
+        REQUIRE_THAT(
+            src, HasCall(_A("Factorial<4>"), _A("Factorial<3>"), "print(int)"));
+        REQUIRE_THAT(
+            src, HasCall(_A("Factorial<3>"), _A("Factorial<2>"), "print(int)"));
+        REQUIRE_THAT(
+            src, HasCall(_A("Factorial<2>"), _A("Factorial<1>"), "print(int)"));
+        REQUIRE_THAT(
+            src, HasCall(_A("Factorial<1>"), _A("Factorial<0>"), "print(int)"));
+
+        save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
     }
 }
\ No newline at end of file
diff --git a/tests/t20019/test_case.h b/tests/t20019/test_case.h
index 68de2fbd..e7622860 100644
--- a/tests/t20019/test_case.h
+++ b/tests/t20019/test_case.h
@@ -29,19 +29,19 @@ TEST_CASE("t20019", "[test-case][sequence]")
     REQUIRE(model->name() == "t20019_sequence");
 
     {
-        auto puml = generate_sequence_puml(diagram, *model);
-        AliasMatcher _A(puml);
+        auto src = generate_sequence_puml(diagram, *model);
+        AliasMatcher _A(src);
 
-        REQUIRE_THAT(puml, StartsWith("@startuml"));
-        REQUIRE_THAT(puml, EndsWith("@enduml\n"));
+        REQUIRE_THAT(src, StartsWith("@startuml"));
+        REQUIRE_THAT(src, EndsWith("@enduml\n"));
 
         // Check if all calls exist
-        REQUIRE_THAT(puml, HasCall(_A("tmain()"), _A("Base<D1>"), "name()"));
-        REQUIRE_THAT(puml, HasCall(_A("Base<D1>"), _A("D1"), "impl()"));
-        REQUIRE_THAT(puml, HasCall(_A("tmain()"), _A("Base<D2>"), "name()"));
-        REQUIRE_THAT(puml, HasCall(_A("Base<D2>"), _A("D2"), "impl()"));
+        REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("Base<D1>"), "name()"));
+        REQUIRE_THAT(src, HasCall(_A("Base<D1>"), _A("D1"), "impl()"));
+        REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("Base<D2>"), "name()"));
+        REQUIRE_THAT(src, HasCall(_A("Base<D2>"), _A("D2"), "impl()"));
 
-        save_puml(config.output_directory(), diagram->name + ".puml", puml);
+        save_puml(config.output_directory(), diagram->name + ".puml", src);
     }
 
     {
@@ -61,8 +61,16 @@ TEST_CASE("t20019", "[test-case][sequence]")
     }
 
     {
-        auto mmd = generate_sequence_mermaid(diagram, *model);
+        auto src = generate_sequence_mermaid(diagram, *model);
 
-        save_mermaid(config.output_directory(), diagram->name + ".mmd", mmd);
+        mermaid::SequenceDiagramAliasMatcher _A(src);
+        using mermaid::HasCall;
+
+        REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("Base<D1>"), "name()"));
+        REQUIRE_THAT(src, HasCall(_A("Base<D1>"), _A("D1"), "impl()"));
+        REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("Base<D2>"), "name()"));
+        REQUIRE_THAT(src, HasCall(_A("Base<D2>"), _A("D2"), "impl()"));
+
+        save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
     }
 }
\ No newline at end of file
diff --git a/tests/t20020/test_case.h b/tests/t20020/test_case.h
index 63538cbf..b68a840d 100644
--- a/tests/t20020/test_case.h
+++ b/tests/t20020/test_case.h
@@ -28,32 +28,32 @@ TEST_CASE("t20020", "[test-case][sequence]")
 
     REQUIRE(model->name() == "t20020_sequence");
     {
-        auto puml = generate_sequence_puml(diagram, *model);
-        AliasMatcher _A(puml);
+        auto src = generate_sequence_puml(diagram, *model);
+        AliasMatcher _A(src);
 
-        REQUIRE_THAT(puml, StartsWith("@startuml"));
-        REQUIRE_THAT(puml, EndsWith("@enduml\n"));
+        REQUIRE_THAT(src, StartsWith("@startuml"));
+        REQUIRE_THAT(src, EndsWith("@enduml\n"));
 
         // Check if all calls exist
-        REQUIRE_THAT(puml, HasCall(_A("tmain()"), _A("A"), "a1()"));
+        REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("A"), "a1()"));
         REQUIRE_THAT(
-            puml, HasCallInControlCondition(_A("tmain()"), _A("A"), "a2()"));
+            src, HasCallInControlCondition(_A("tmain()"), _A("A"), "a2()"));
         REQUIRE_THAT(
-            puml, HasCallInControlCondition(_A("tmain()"), _A("A"), "a3()"));
+            src, HasCallInControlCondition(_A("tmain()"), _A("A"), "a3()"));
 
-        REQUIRE_THAT(puml, HasCall(_A("tmain()"), _A("B"), "b1()"));
-        REQUIRE_THAT(puml, HasCall(_A("tmain()"), _A("B"), "b2()"));
-        REQUIRE_THAT(puml, HasCall(_A("tmain()"), _A("B"), "log()"));
+        REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B"), "b1()"));
+        REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B"), "b2()"));
+        REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B"), "log()"));
 
-        REQUIRE_THAT(puml, HasCall(_A("tmain()"), _A("C"), "c1() const"));
+        REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("C"), "c1() const"));
         REQUIRE_THAT(
-            puml, HasCallInControlCondition(_A("C"), _A("C"), "c2() const"));
-        REQUIRE_THAT(puml, HasCall(_A("C"), _A("C"), "log() const"));
+            src, HasCallInControlCondition(_A("C"), _A("C"), "c2() const"));
+        REQUIRE_THAT(src, HasCall(_A("C"), _A("C"), "log() const"));
 
         REQUIRE_THAT(
-            puml, HasCallInControlCondition(_A("tmain()"), _A("C"), "c3(int)"));
+            src, HasCallInControlCondition(_A("tmain()"), _A("C"), "c3(int)"));
 
-        save_puml(config.output_directory(), diagram->name + ".puml", puml);
+        save_puml(config.output_directory(), diagram->name + ".puml", src);
     }
 
     {
@@ -81,8 +81,30 @@ TEST_CASE("t20020", "[test-case][sequence]")
     }
 
     {
-        auto mmd = generate_sequence_mermaid(diagram, *model);
+        auto src = generate_sequence_mermaid(diagram, *model);
 
-        save_mermaid(config.output_directory(), diagram->name + ".mmd", mmd);
+        mermaid::SequenceDiagramAliasMatcher _A(src);
+        using mermaid::HasCall;
+        using mermaid::HasCallInControlCondition;
+
+        REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("A"), "a1()"));
+        REQUIRE_THAT(
+            src, HasCallInControlCondition(_A("tmain()"), _A("A"), "a2()"));
+        REQUIRE_THAT(
+            src, HasCallInControlCondition(_A("tmain()"), _A("A"), "a3()"));
+
+        REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B"), "b1()"));
+        REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B"), "b2()"));
+        REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B"), "log()"));
+
+        REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("C"), "c1() const"));
+        REQUIRE_THAT(
+            src, HasCallInControlCondition(_A("C"), _A("C"), "c2() const"));
+        REQUIRE_THAT(src, HasCall(_A("C"), _A("C"), "log() const"));
+
+        REQUIRE_THAT(
+            src, HasCallInControlCondition(_A("tmain()"), _A("C"), "c3(int)"));
+
+        save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
     }
 }
\ No newline at end of file
diff --git a/tests/t20021/test_case.h b/tests/t20021/test_case.h
index c4016afb..2eed83c1 100644
--- a/tests/t20021/test_case.h
+++ b/tests/t20021/test_case.h
@@ -28,37 +28,37 @@ TEST_CASE("t20021", "[test-case][sequence]")
 
     REQUIRE(model->name() == "t20021_sequence");
     {
-        auto puml = generate_sequence_puml(diagram, *model);
-        AliasMatcher _A(puml);
+        auto src = generate_sequence_puml(diagram, *model);
+        AliasMatcher _A(src);
 
-        REQUIRE_THAT(puml, StartsWith("@startuml"));
-        REQUIRE_THAT(puml, EndsWith("@enduml\n"));
+        REQUIRE_THAT(src, StartsWith("@startuml"));
+        REQUIRE_THAT(src, EndsWith("@enduml\n"));
 
         // Check if all calls exist
-        REQUIRE_THAT(puml, HasCall(_A("tmain()"), _A("A"), "a1()"));
+        REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("A"), "a1()"));
         REQUIRE_THAT(
-            puml, HasCallInControlCondition(_A("tmain()"), _A("A"), "a2()"));
-        REQUIRE_THAT(puml, HasCall(_A("tmain()"), _A("A"), "a3()"));
+            src, HasCallInControlCondition(_A("tmain()"), _A("A"), "a2()"));
+        REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("A"), "a3()"));
 
-        REQUIRE_THAT(puml, !HasCall(_A("tmain()"), _A("B"), "b1()"));
-        REQUIRE_THAT(puml, HasCall(_A("tmain()"), _A("B"), "b2()"));
+        REQUIRE_THAT(src, !HasCall(_A("tmain()"), _A("B"), "b1()"));
+        REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B"), "b2()"));
 
         REQUIRE_THAT(
-            puml, HasCallInControlCondition(_A("tmain()"), _A("C"), "c1()"));
+            src, HasCallInControlCondition(_A("tmain()"), _A("C"), "c1()"));
         REQUIRE_THAT(
-            puml, HasCallInControlCondition(_A("tmain()"), _A("C"), "c2()"));
+            src, HasCallInControlCondition(_A("tmain()"), _A("C"), "c2()"));
 
         // TODO: Why is this not working?
         //    REQUIRE_THAT(
         //        puml, HasCallInControlCondition(_A("tmain()"), _A("C"),
         //        "c3()"));
         REQUIRE_THAT(
-            puml, HasCallInControlCondition(_A("tmain()"), _A("C"), "c4()"));
-        REQUIRE_THAT(puml, HasCall(_A("C"), _A("C"), "c5()"));
-        REQUIRE_THAT(puml,
+            src, HasCallInControlCondition(_A("tmain()"), _A("C"), "c4()"));
+        REQUIRE_THAT(src, HasCall(_A("C"), _A("C"), "c5()"));
+        REQUIRE_THAT(src,
             HasCallInControlCondition(_A("tmain()"), _A("C"), "contents()"));
 
-        save_puml(config.output_directory(), diagram->name + ".puml", puml);
+        save_puml(config.output_directory(), diagram->name + ".puml", src);
     }
 
     {
@@ -87,8 +87,31 @@ TEST_CASE("t20021", "[test-case][sequence]")
     }
 
     {
-        auto mmd = generate_sequence_mermaid(diagram, *model);
+        auto src = generate_sequence_mermaid(diagram, *model);
 
-        save_mermaid(config.output_directory(), diagram->name + ".mmd", mmd);
+        mermaid::SequenceDiagramAliasMatcher _A(src);
+        using mermaid::HasCall;
+        using mermaid::HasCallInControlCondition;
+
+        REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("A"), "a1()"));
+        REQUIRE_THAT(
+            src, HasCallInControlCondition(_A("tmain()"), _A("A"), "a2()"));
+        REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("A"), "a3()"));
+
+        REQUIRE_THAT(src, !HasCall(_A("tmain()"), _A("B"), "b1()"));
+        REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B"), "b2()"));
+
+        REQUIRE_THAT(
+            src, HasCallInControlCondition(_A("tmain()"), _A("C"), "c1()"));
+        REQUIRE_THAT(
+            src, HasCallInControlCondition(_A("tmain()"), _A("C"), "c2()"));
+
+        REQUIRE_THAT(
+            src, HasCallInControlCondition(_A("tmain()"), _A("C"), "c4()"));
+        REQUIRE_THAT(src, HasCall(_A("C"), _A("C"), "c5()"));
+        REQUIRE_THAT(src,
+            HasCallInControlCondition(_A("tmain()"), _A("C"), "contents()"));
+
+        save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
     }
 }
\ No newline at end of file
diff --git a/tests/t20022/test_case.h b/tests/t20022/test_case.h
index a3a2bbf0..19b88900 100644
--- a/tests/t20022/test_case.h
+++ b/tests/t20022/test_case.h
@@ -28,17 +28,17 @@ TEST_CASE("t20022", "[test-case][sequence]")
 
     REQUIRE(model->name() == "t20022_sequence");
     {
-        auto puml = generate_sequence_puml(diagram, *model);
-        AliasMatcher _A(puml);
+        auto src = generate_sequence_puml(diagram, *model);
+        AliasMatcher _A(src);
 
-        REQUIRE_THAT(puml, StartsWith("@startuml"));
-        REQUIRE_THAT(puml, EndsWith("@enduml\n"));
+        REQUIRE_THAT(src, StartsWith("@startuml"));
+        REQUIRE_THAT(src, EndsWith("@enduml\n"));
 
         // Check if all calls exist
-        REQUIRE_THAT(puml, HasCall(_A("tmain()"), _A("A"), "a()"));
-        REQUIRE_THAT(puml, HasCall(_A("A"), _A("B"), "b()"));
+        REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("A"), "a()"));
+        REQUIRE_THAT(src, HasCall(_A("A"), _A("B"), "b()"));
 
-        save_puml(config.output_directory(), diagram->name + ".puml", puml);
+        save_puml(config.output_directory(), diagram->name + ".puml", src);
     }
 
     {
@@ -55,8 +55,14 @@ TEST_CASE("t20022", "[test-case][sequence]")
     }
 
     {
-        auto mmd = generate_sequence_mermaid(diagram, *model);
+        auto src = generate_sequence_mermaid(diagram, *model);
 
-        save_mermaid(config.output_directory(), diagram->name + ".mmd", mmd);
+        mermaid::SequenceDiagramAliasMatcher _A(src);
+        using mermaid::HasCall;
+
+        REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("A"), "a()"));
+        REQUIRE_THAT(src, HasCall(_A("A"), _A("B"), "b()"));
+
+        save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
     }
 }
\ No newline at end of file
diff --git a/tests/t20023/test_case.h b/tests/t20023/test_case.h
index 087e2b93..ad50dbb6 100644
--- a/tests/t20023/test_case.h
+++ b/tests/t20023/test_case.h
@@ -28,20 +28,20 @@ TEST_CASE("t20023", "[test-case][sequence]")
 
     REQUIRE(model->name() == "t20023_sequence");
     {
-        auto puml = generate_sequence_puml(diagram, *model);
-        AliasMatcher _A(puml);
+        auto src = generate_sequence_puml(diagram, *model);
+        AliasMatcher _A(src);
 
-        REQUIRE_THAT(puml, StartsWith("@startuml"));
-        REQUIRE_THAT(puml, EndsWith("@enduml\n"));
+        REQUIRE_THAT(src, StartsWith("@startuml"));
+        REQUIRE_THAT(src, EndsWith("@enduml\n"));
 
         // Check if all calls exist
-        REQUIRE_THAT(puml, HasCall(_A("tmain()"), _A("A"), "a()"));
-        REQUIRE_THAT(puml, HasCall(_A("A"), _A("A"), "a1()"));
-        REQUIRE_THAT(puml, HasCall(_A("A"), _A("A"), "a2()"));
-        REQUIRE_THAT(puml, HasCall(_A("A"), _A("A"), "a3()"));
-        REQUIRE_THAT(puml, HasCall(_A("A"), _A("A"), "a4()"));
+        REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("A"), "a()"));
+        REQUIRE_THAT(src, HasCall(_A("A"), _A("A"), "a1()"));
+        REQUIRE_THAT(src, HasCall(_A("A"), _A("A"), "a2()"));
+        REQUIRE_THAT(src, HasCall(_A("A"), _A("A"), "a3()"));
+        REQUIRE_THAT(src, HasCall(_A("A"), _A("A"), "a4()"));
 
-        save_puml(config.output_directory(), diagram->name + ".puml", puml);
+        save_puml(config.output_directory(), diagram->name + ".puml", src);
     }
 
     {
@@ -59,8 +59,17 @@ TEST_CASE("t20023", "[test-case][sequence]")
     }
 
     {
-        auto mmd = generate_sequence_mermaid(diagram, *model);
+        auto src = generate_sequence_mermaid(diagram, *model);
 
-        save_mermaid(config.output_directory(), diagram->name + ".mmd", mmd);
+        mermaid::SequenceDiagramAliasMatcher _A(src);
+        using mermaid::HasCall;
+
+        REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("A"), "a()"));
+        REQUIRE_THAT(src, HasCall(_A("A"), _A("A"), "a1()"));
+        REQUIRE_THAT(src, HasCall(_A("A"), _A("A"), "a2()"));
+        REQUIRE_THAT(src, HasCall(_A("A"), _A("A"), "a3()"));
+        REQUIRE_THAT(src, HasCall(_A("A"), _A("A"), "a4()"));
+
+        save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
     }
 }
\ No newline at end of file
diff --git a/tests/t20024/test_case.h b/tests/t20024/test_case.h
index 9f5768b0..00257fe8 100644
--- a/tests/t20024/test_case.h
+++ b/tests/t20024/test_case.h
@@ -28,25 +28,25 @@ TEST_CASE("t20024", "[test-case][sequence]")
 
     REQUIRE(model->name() == "t20024_sequence");
     {
-        auto puml = generate_sequence_puml(diagram, *model);
-        AliasMatcher _A(puml);
+        auto src = generate_sequence_puml(diagram, *model);
+        AliasMatcher _A(src);
 
-        REQUIRE_THAT(puml, StartsWith("@startuml"));
-        REQUIRE_THAT(puml, EndsWith("@enduml\n"));
+        REQUIRE_THAT(src, StartsWith("@startuml"));
+        REQUIRE_THAT(src, EndsWith("@enduml\n"));
 
         // Check if all calls exist
-        REQUIRE_THAT(puml, HasCall(_A("tmain()"), _A("A"), "select(enum_a)"));
-        REQUIRE_THAT(puml, HasCall(_A("A"), _A("A"), "a0()"));
-        REQUIRE_THAT(puml, HasCall(_A("A"), _A("A"), "a1()"));
-        REQUIRE_THAT(puml, HasCall(_A("A"), _A("A"), "a2()"));
-        REQUIRE_THAT(puml, HasCall(_A("A"), _A("A"), "a3()"));
+        REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("A"), "select(enum_a)"));
+        REQUIRE_THAT(src, HasCall(_A("A"), _A("A"), "a0()"));
+        REQUIRE_THAT(src, HasCall(_A("A"), _A("A"), "a1()"));
+        REQUIRE_THAT(src, HasCall(_A("A"), _A("A"), "a2()"));
+        REQUIRE_THAT(src, HasCall(_A("A"), _A("A"), "a3()"));
 
-        REQUIRE_THAT(puml, HasCall(_A("tmain()"), _A("B"), "select(colors)"));
-        REQUIRE_THAT(puml, HasCall(_A("B"), _A("B"), "red()"));
-        REQUIRE_THAT(puml, HasCall(_A("B"), _A("B"), "orange()"));
-        REQUIRE_THAT(puml, HasCall(_A("B"), _A("B"), "green()"));
+        REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B"), "select(colors)"));
+        REQUIRE_THAT(src, HasCall(_A("B"), _A("B"), "red()"));
+        REQUIRE_THAT(src, HasCall(_A("B"), _A("B"), "orange()"));
+        REQUIRE_THAT(src, HasCall(_A("B"), _A("B"), "green()"));
 
-        save_puml(config.output_directory(), diagram->name + ".puml", puml);
+        save_puml(config.output_directory(), diagram->name + ".puml", src);
     }
 
     {
@@ -65,8 +65,22 @@ TEST_CASE("t20024", "[test-case][sequence]")
     }
 
     {
-        auto mmd = generate_sequence_mermaid(diagram, *model);
+        auto src = generate_sequence_mermaid(diagram, *model);
 
-        save_mermaid(config.output_directory(), diagram->name + ".mmd", mmd);
+        mermaid::SequenceDiagramAliasMatcher _A(src);
+        using mermaid::HasCall;
+
+        REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("A"), "select(enum_a)"));
+        REQUIRE_THAT(src, HasCall(_A("A"), _A("A"), "a0()"));
+        REQUIRE_THAT(src, HasCall(_A("A"), _A("A"), "a1()"));
+        REQUIRE_THAT(src, HasCall(_A("A"), _A("A"), "a2()"));
+        REQUIRE_THAT(src, HasCall(_A("A"), _A("A"), "a3()"));
+
+        REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B"), "select(colors)"));
+        REQUIRE_THAT(src, HasCall(_A("B"), _A("B"), "red()"));
+        REQUIRE_THAT(src, HasCall(_A("B"), _A("B"), "orange()"));
+        REQUIRE_THAT(src, HasCall(_A("B"), _A("B"), "green()"));
+
+        save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
     }
 }
\ No newline at end of file
diff --git a/tests/t20025/test_case.h b/tests/t20025/test_case.h
index b46e0245..3ece860b 100644
--- a/tests/t20025/test_case.h
+++ b/tests/t20025/test_case.h
@@ -28,20 +28,20 @@ TEST_CASE("t20025", "[test-case][sequence]")
 
     REQUIRE(model->name() == "t20025_sequence");
     {
-        auto puml = generate_sequence_puml(diagram, *model);
-        AliasMatcher _A(puml);
+        auto src = generate_sequence_puml(diagram, *model);
+        AliasMatcher _A(src);
 
-        REQUIRE_THAT(puml, StartsWith("@startuml"));
-        REQUIRE_THAT(puml, EndsWith("@enduml\n"));
+        REQUIRE_THAT(src, StartsWith("@startuml"));
+        REQUIRE_THAT(src, EndsWith("@enduml\n"));
 
         // Check if all calls exist
-        REQUIRE_THAT(puml, HasCall(_A("tmain()"), _A("A"), "a()"));
-        REQUIRE_THAT(puml, !HasCall(_A("A"), _A("A"), "a1()"));
+        REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("A"), "a()"));
+        REQUIRE_THAT(src, !HasCall(_A("A"), _A("A"), "a1()"));
         // REQUIRE_THAT(puml, !HasCall(_A("A"), _A("A"), "a2()"));
-        REQUIRE_THAT(puml, HasCall(_A("tmain()"), _A("add(int,int)"), ""));
-        REQUIRE_THAT(puml, !HasCall(_A("tmain()"), _A("add2(int,int)"), ""));
+        REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("add(int,int)"), ""));
+        REQUIRE_THAT(src, !HasCall(_A("tmain()"), _A("add2(int,int)"), ""));
 
-        save_puml(config.output_directory(), diagram->name + ".puml", puml);
+        save_puml(config.output_directory(), diagram->name + ".puml", src);
     }
 
     {
@@ -59,8 +59,17 @@ TEST_CASE("t20025", "[test-case][sequence]")
     }
 
     {
-        auto mmd = generate_sequence_mermaid(diagram, *model);
+        auto src = generate_sequence_mermaid(diagram, *model);
 
-        save_mermaid(config.output_directory(), diagram->name + ".mmd", mmd);
+        mermaid::SequenceDiagramAliasMatcher _A(src);
+        using mermaid::HasCall;
+
+        REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("A"), "a()"));
+        REQUIRE_THAT(src, !HasCall(_A("A"), _A("A"), "a1()"));
+        // REQUIRE_THAT(puml, !HasCall(_A("A"), _A("A"), "a2()"));
+        REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("add(int,int)"), ""));
+        REQUIRE_THAT(src, !HasCall(_A("tmain()"), _A("add2(int,int)"), ""));
+
+        save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
     }
 }
\ No newline at end of file
diff --git a/tests/t20026/test_case.h b/tests/t20026/test_case.h
index da5dd601..1151622a 100644
--- a/tests/t20026/test_case.h
+++ b/tests/t20026/test_case.h
@@ -28,16 +28,16 @@ TEST_CASE("t20026", "[test-case][sequence]")
 
     REQUIRE(model->name() == "t20026_sequence");
     {
-        auto puml = generate_sequence_puml(diagram, *model);
-        AliasMatcher _A(puml);
+        auto src = generate_sequence_puml(diagram, *model);
+        AliasMatcher _A(src);
 
-        REQUIRE_THAT(puml, StartsWith("@startuml"));
-        REQUIRE_THAT(puml, EndsWith("@enduml\n"));
+        REQUIRE_THAT(src, StartsWith("@startuml"));
+        REQUIRE_THAT(src, EndsWith("@enduml\n"));
 
         // Check if all calls exist
-        REQUIRE_THAT(puml, HasCall(_A("tmain()"), _A("A"), "a()"));
+        REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("A"), "a()"));
 
-        save_puml(config.output_directory(), diagram->name + ".puml", puml);
+        save_puml(config.output_directory(), diagram->name + ".puml", src);
     }
 
     {
@@ -53,8 +53,13 @@ TEST_CASE("t20026", "[test-case][sequence]")
     }
 
     {
-        auto mmd = generate_sequence_mermaid(diagram, *model);
+        auto src = generate_sequence_mermaid(diagram, *model);
 
-        save_mermaid(config.output_directory(), diagram->name + ".mmd", mmd);
+        mermaid::SequenceDiagramAliasMatcher _A(src);
+        using mermaid::HasCall;
+
+        REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("A"), "a()"));
+
+        save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
     }
 }
\ No newline at end of file
diff --git a/tests/t20027/test_case.h b/tests/t20027/test_case.h
index 5476d0fe..d91b462b 100644
--- a/tests/t20027/test_case.h
+++ b/tests/t20027/test_case.h
@@ -28,18 +28,18 @@ TEST_CASE("t20027", "[test-case][sequence]")
 
     REQUIRE(model->name() == "t20027_sequence");
     {
-        auto puml = generate_sequence_puml(diagram, *model);
-        AliasMatcher _A(puml);
+        auto src = generate_sequence_puml(diagram, *model);
+        AliasMatcher _A(src);
 
-        REQUIRE_THAT(puml, StartsWith("@startuml"));
-        REQUIRE_THAT(puml, EndsWith("@enduml\n"));
+        REQUIRE_THAT(src, StartsWith("@startuml"));
+        REQUIRE_THAT(src, EndsWith("@enduml\n"));
 
         // Check if all calls exist
-        REQUIRE_THAT(puml, HasCall(_A("tmain()"), _A("A"), "a()"));
-        REQUIRE_THAT(puml, !HasCall(_A("A"), _A("A"), "aa()"));
-        REQUIRE_THAT(puml, !HasCall(_A("A"), _A("A"), "aaa()"));
+        REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("A"), "a()"));
+        REQUIRE_THAT(src, !HasCall(_A("A"), _A("A"), "aa()"));
+        REQUIRE_THAT(src, !HasCall(_A("A"), _A("A"), "aaa()"));
 
-        save_puml(config.output_directory(), diagram->name + ".puml", puml);
+        save_puml(config.output_directory(), diagram->name + ".puml", src);
     }
 
     {
@@ -55,8 +55,15 @@ TEST_CASE("t20027", "[test-case][sequence]")
     }
 
     {
-        auto mmd = generate_sequence_mermaid(diagram, *model);
+        auto src = generate_sequence_mermaid(diagram, *model);
 
-        save_mermaid(config.output_directory(), diagram->name + ".mmd", mmd);
+        mermaid::SequenceDiagramAliasMatcher _A(src);
+        using mermaid::HasCall;
+
+        REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("A"), "a()"));
+        REQUIRE_THAT(src, !HasCall(_A("A"), _A("A"), "aa()"));
+        REQUIRE_THAT(src, !HasCall(_A("A"), _A("A"), "aaa()"));
+
+        save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
     }
 }
\ No newline at end of file
diff --git a/tests/t20028/test_case.h b/tests/t20028/test_case.h
index 01174a4d..48feb7a7 100644
--- a/tests/t20028/test_case.h
+++ b/tests/t20028/test_case.h
@@ -28,21 +28,21 @@ TEST_CASE("t20028", "[test-case][sequence]")
 
     REQUIRE(model->name() == "t20028_sequence");
     {
-        auto puml = generate_sequence_puml(diagram, *model);
-        AliasMatcher _A(puml);
+        auto src = generate_sequence_puml(diagram, *model);
+        AliasMatcher _A(src);
 
-        REQUIRE_THAT(puml, StartsWith("@startuml"));
-        REQUIRE_THAT(puml, EndsWith("@enduml\n"));
+        REQUIRE_THAT(src, StartsWith("@startuml"));
+        REQUIRE_THAT(src, EndsWith("@enduml\n"));
 
         // Check if all calls exist
         REQUIRE_THAT(
-            puml, HasCallInControlCondition(_A("tmain()"), _A("A"), "a()"));
-        REQUIRE_THAT(puml, HasCall(_A("tmain()"), _A("A"), "b()"));
-        REQUIRE_THAT(puml, HasCall(_A("tmain()"), _A("A"), "c()"));
-        REQUIRE_THAT(puml, HasCall(_A("tmain()"), _A("A"), "d()"));
-        REQUIRE_THAT(puml, !HasCall(_A("tmain()"), _A("B"), "e()"));
+            src, HasCallInControlCondition(_A("tmain()"), _A("A"), "a()"));
+        REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("A"), "b()"));
+        REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("A"), "c()"));
+        REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("A"), "d()"));
+        REQUIRE_THAT(src, !HasCall(_A("tmain()"), _A("B"), "e()"));
 
-        save_puml(config.output_directory(), diagram->name + ".puml", puml);
+        save_puml(config.output_directory(), diagram->name + ".puml", src);
     }
 
     {
@@ -61,8 +61,19 @@ TEST_CASE("t20028", "[test-case][sequence]")
     }
 
     {
-        auto mmd = generate_sequence_mermaid(diagram, *model);
+        auto src = generate_sequence_mermaid(diagram, *model);
 
-        save_mermaid(config.output_directory(), diagram->name + ".mmd", mmd);
+        mermaid::SequenceDiagramAliasMatcher _A(src);
+        using mermaid::HasCall;
+        using mermaid::HasCallInControlCondition;
+
+        REQUIRE_THAT(
+            src, HasCallInControlCondition(_A("tmain()"), _A("A"), "a()"));
+        REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("A"), "b()"));
+        REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("A"), "c()"));
+        REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("A"), "d()"));
+        REQUIRE_THAT(src, !HasCall(_A("tmain()"), _A("B"), "e()"));
+
+        save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
     }
 }
\ No newline at end of file
diff --git a/tests/t20029/test_case.h b/tests/t20029/test_case.h
index 17900066..80ac68e8 100644
--- a/tests/t20029/test_case.h
+++ b/tests/t20029/test_case.h
@@ -28,38 +28,38 @@ TEST_CASE("t20029", "[test-case][sequence]")
 
     REQUIRE(model->name() == "t20029_sequence");
     {
-        auto puml = generate_sequence_puml(diagram, *model);
-        AliasMatcher _A(puml);
+        auto src = generate_sequence_puml(diagram, *model);
+        AliasMatcher _A(src);
 
-        REQUIRE_THAT(puml, StartsWith("@startuml"));
-        REQUIRE_THAT(puml, EndsWith("@enduml\n"));
+        REQUIRE_THAT(src, StartsWith("@startuml"));
+        REQUIRE_THAT(src, EndsWith("@enduml\n"));
 
         // Check if all calls exist
         REQUIRE_THAT(
-            puml, HasCall(_A("tmain()"), _A("ConnectionPool"), "connect()"));
-        REQUIRE_THAT(puml,
+            src, HasCall(_A("tmain()"), _A("ConnectionPool"), "connect()"));
+        REQUIRE_THAT(src,
             HasCallInControlCondition(_A("tmain()"),
                 _A("Encoder<Retrier<ConnectionPool>>"),
                 "send(std::string &&)"));
 
-        REQUIRE_THAT(puml,
+        REQUIRE_THAT(src,
             HasCall(_A("Encoder<Retrier<ConnectionPool>>"),
                 _A("Encoder<Retrier<ConnectionPool>>"),
                 "encode(std::string &&)"));
 
-        REQUIRE_THAT(puml,
+        REQUIRE_THAT(src,
             HasCall(_A("Encoder<Retrier<ConnectionPool>>"),
                 _A("encode_b64(std::string &&)"), ""));
 
-        REQUIRE_THAT(puml,
+        REQUIRE_THAT(src,
             HasCallInControlCondition(_A("Retrier<ConnectionPool>"),
                 _A("ConnectionPool"), "send(const std::string &)"));
 
-        REQUIRE_THAT(puml,
+        REQUIRE_THAT(src,
             !HasCall(
                 _A("ConnectionPool"), _A("ConnectionPool"), "connect_impl()"));
 
-        save_puml(config.output_directory(), diagram->name + ".puml", puml);
+        save_puml(config.output_directory(), diagram->name + ".puml", src);
     }
 
     {
@@ -85,8 +85,36 @@ TEST_CASE("t20029", "[test-case][sequence]")
     }
 
     {
-        auto mmd = generate_sequence_mermaid(diagram, *model);
+        auto src = generate_sequence_mermaid(diagram, *model);
 
-        save_mermaid(config.output_directory(), diagram->name + ".mmd", mmd);
+        mermaid::SequenceDiagramAliasMatcher _A(src);
+        using mermaid::HasCall;
+        using mermaid::HasCallInControlCondition;
+
+        REQUIRE_THAT(
+            src, HasCall(_A("tmain()"), _A("ConnectionPool"), "connect()"));
+        REQUIRE_THAT(src,
+            HasCallInControlCondition(_A("tmain()"),
+                _A("Encoder<Retrier<ConnectionPool>>"),
+                "send(std::string &&)"));
+
+        REQUIRE_THAT(src,
+            HasCall(_A("Encoder<Retrier<ConnectionPool>>"),
+                _A("Encoder<Retrier<ConnectionPool>>"),
+                "encode(std::string &&)"));
+
+        REQUIRE_THAT(src,
+            HasCall(_A("Encoder<Retrier<ConnectionPool>>"),
+                _A("encode_b64(std::string &&)"), ""));
+
+        REQUIRE_THAT(src,
+            HasCallInControlCondition(_A("Retrier<ConnectionPool>"),
+                _A("ConnectionPool"), "send(const std::string &)"));
+
+        REQUIRE_THAT(src,
+            !HasCall(
+                _A("ConnectionPool"), _A("ConnectionPool"), "connect_impl()"));
+
+        save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
     }
 }
\ No newline at end of file
diff --git a/tests/t20030/test_case.h b/tests/t20030/test_case.h
index 167e5ebb..38b24cdb 100644
--- a/tests/t20030/test_case.h
+++ b/tests/t20030/test_case.h
@@ -29,30 +29,30 @@ TEST_CASE("t20030", "[test-case][sequence]")
     REQUIRE(model->name() == "t20030_sequence");
 
     {
-        auto puml = generate_sequence_puml(diagram, *model);
-        AliasMatcher _A(puml);
+        auto src = generate_sequence_puml(diagram, *model);
+        AliasMatcher _A(src);
 
-        REQUIRE_THAT(puml, StartsWith("@startuml"));
-        REQUIRE_THAT(puml, EndsWith("@enduml\n"));
+        REQUIRE_THAT(src, StartsWith("@startuml"));
+        REQUIRE_THAT(src, EndsWith("@enduml\n"));
 
         // Check if all calls exist
-        REQUIRE_THAT(puml, HasCall(_A("tmain(int)"), _A("magic()"), ""));
+        REQUIRE_THAT(src, HasCall(_A("tmain(int)"), _A("magic()"), ""));
 
-        REQUIRE_THAT(puml, HasCall(_A("A"), _A("A"), "create()"));
+        REQUIRE_THAT(src, HasCall(_A("A"), _A("A"), "create()"));
         REQUIRE_THAT(
-            puml, HasCall(_A("tmain(int)"), _A("A"), "operator+=(int)"));
-        REQUIRE_THAT(puml, HasCall(_A("A"), _A("A"), "add(int)"));
+            src, HasCall(_A("tmain(int)"), _A("A"), "operator+=(int)"));
+        REQUIRE_THAT(src, HasCall(_A("A"), _A("A"), "add(int)"));
 
-        REQUIRE_THAT(puml, HasCall(_A("tmain(bool,int)"), _A("A"), "A()"));
+        REQUIRE_THAT(src, HasCall(_A("tmain(bool,int)"), _A("A"), "A()"));
         REQUIRE_THAT(
-            puml, HasCall(_A("tmain(bool,int)"), _A("A"), "operator+=(int)"));
-        REQUIRE_THAT(puml, HasCall(_A("A"), _A("A"), "add(int)"));
-        REQUIRE_THAT(puml,
+            src, HasCall(_A("tmain(bool,int)"), _A("A"), "operator+=(int)"));
+        REQUIRE_THAT(src, HasCall(_A("A"), _A("A"), "add(int)"));
+        REQUIRE_THAT(src,
             HasCall(_A("tmain(bool,int)"), _A("A"), "operator=(const A &)"));
-        REQUIRE_THAT(puml, HasCall(_A("A"), _A("A"), "set(int)"));
-        REQUIRE_THAT(puml, HasCall(_A("tmain(bool,int)"), _A("A"), "value()"));
+        REQUIRE_THAT(src, HasCall(_A("A"), _A("A"), "set(int)"));
+        REQUIRE_THAT(src, HasCall(_A("tmain(bool,int)"), _A("A"), "value()"));
 
-        save_puml(config.output_directory(), diagram->name + ".puml", puml);
+        save_puml(config.output_directory(), diagram->name + ".puml", src);
     }
 
     {
@@ -64,8 +64,27 @@ TEST_CASE("t20030", "[test-case][sequence]")
     }
 
     {
-        auto mmd = generate_sequence_mermaid(diagram, *model);
+        auto src = generate_sequence_mermaid(diagram, *model);
 
-        save_mermaid(config.output_directory(), diagram->name + ".mmd", mmd);
+        mermaid::SequenceDiagramAliasMatcher _A(src);
+        using mermaid::HasCall;
+
+        REQUIRE_THAT(src, HasCall(_A("tmain(int)"), _A("magic()"), ""));
+
+        REQUIRE_THAT(src, HasCall(_A("A"), _A("A"), "create()"));
+        REQUIRE_THAT(
+            src, HasCall(_A("tmain(int)"), _A("A"), "operator+=(int)"));
+        REQUIRE_THAT(src, HasCall(_A("A"), _A("A"), "add(int)"));
+
+        REQUIRE_THAT(src, HasCall(_A("tmain(bool,int)"), _A("A"), "A()"));
+        REQUIRE_THAT(
+            src, HasCall(_A("tmain(bool,int)"), _A("A"), "operator+=(int)"));
+        REQUIRE_THAT(src, HasCall(_A("A"), _A("A"), "add(int)"));
+        REQUIRE_THAT(src,
+            HasCall(_A("tmain(bool,int)"), _A("A"), "operator=(const A &)"));
+        REQUIRE_THAT(src, HasCall(_A("A"), _A("A"), "set(int)"));
+        REQUIRE_THAT(src, HasCall(_A("tmain(bool,int)"), _A("A"), "value()"));
+
+        save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
     }
 }
\ No newline at end of file
diff --git a/tests/t20031/test_case.h b/tests/t20031/test_case.h
index 01a08bee..f9726b91 100644
--- a/tests/t20031/test_case.h
+++ b/tests/t20031/test_case.h
@@ -29,33 +29,33 @@ TEST_CASE("t20031", "[test-case][sequence]")
     REQUIRE(model->name() == "t20031_sequence");
 
     {
-        auto puml = generate_sequence_puml(diagram, *model);
-        AliasMatcher _A(puml);
+        auto src = generate_sequence_puml(diagram, *model);
+        AliasMatcher _A(src);
 
-        REQUIRE_THAT(puml, StartsWith("@startuml"));
-        REQUIRE_THAT(puml, EndsWith("@enduml\n"));
+        REQUIRE_THAT(src, StartsWith("@startuml"));
+        REQUIRE_THAT(src, EndsWith("@enduml\n"));
 
-        REQUIRE_THAT(puml, HasCall(_A("tmain(int)"), _A("magic()"), ""));
+        REQUIRE_THAT(src, HasCall(_A("tmain(int)"), _A("magic()"), ""));
 
-        REQUIRE_THAT(puml, !HasCall(_A("A"), _A("A"), "create()"));
+        REQUIRE_THAT(src, !HasCall(_A("A"), _A("A"), "create()"));
         REQUIRE_THAT(
-            puml, !HasCall(_A("tmain(int)"), _A("A"), "operator+=(int)"));
-        REQUIRE_THAT(puml, !HasCall(_A("A"), _A("A"), "add(int)"));
+            src, !HasCall(_A("tmain(int)"), _A("A"), "operator+=(int)"));
+        REQUIRE_THAT(src, !HasCall(_A("A"), _A("A"), "add(int)"));
 
-        REQUIRE_THAT(puml, !HasCall(_A("tmain(bool,int)"), _A("A"), "A()"));
+        REQUIRE_THAT(src, !HasCall(_A("tmain(bool,int)"), _A("A"), "A()"));
         REQUIRE_THAT(
-            puml, !HasCall(_A("tmain(bool,int)"), _A("A"), "operator+=(int)"));
-        REQUIRE_THAT(puml, !HasCall(_A("A"), _A("A"), "add(int)"));
-        REQUIRE_THAT(puml,
+            src, !HasCall(_A("tmain(bool,int)"), _A("A"), "operator+=(int)"));
+        REQUIRE_THAT(src, !HasCall(_A("A"), _A("A"), "add(int)"));
+        REQUIRE_THAT(src,
             !HasCall(_A("tmain(bool,int)"), _A("A"), "operator=(const A &)"));
-        REQUIRE_THAT(puml, !HasCall(_A("A"), _A("A"), "set(int)"));
-        REQUIRE_THAT(puml, HasCall(_A("tmain(bool,int)"), _A("A"), "value()"));
-        REQUIRE_THAT(puml,
+        REQUIRE_THAT(src, !HasCall(_A("A"), _A("A"), "set(int)"));
+        REQUIRE_THAT(src, HasCall(_A("tmain(bool,int)"), _A("A"), "value()"));
+        REQUIRE_THAT(src,
             !HasCall(_A("tmain(bool,int)::(lambda "
                         "../../tests/t20031/t20031.cc:47:26)"),
                 _A("zero()"), ""));
 
-        save_puml(config.output_directory(), diagram->name + ".puml", puml);
+        save_puml(config.output_directory(), diagram->name + ".puml", src);
     }
 
     {
@@ -67,8 +67,31 @@ TEST_CASE("t20031", "[test-case][sequence]")
     }
 
     {
-        auto mmd = generate_sequence_mermaid(diagram, *model);
+        auto src = generate_sequence_mermaid(diagram, *model);
 
-        save_mermaid(config.output_directory(), diagram->name + ".mmd", mmd);
+        mermaid::SequenceDiagramAliasMatcher _A(src);
+        using mermaid::HasCall;
+
+        REQUIRE_THAT(src, HasCall(_A("tmain(int)"), _A("magic()"), ""));
+
+        REQUIRE_THAT(src, !HasCall(_A("A"), _A("A"), "create()"));
+        REQUIRE_THAT(
+            src, !HasCall(_A("tmain(int)"), _A("A"), "operator+=(int)"));
+        REQUIRE_THAT(src, !HasCall(_A("A"), _A("A"), "add(int)"));
+
+        REQUIRE_THAT(src, !HasCall(_A("tmain(bool,int)"), _A("A"), "A()"));
+        REQUIRE_THAT(
+            src, !HasCall(_A("tmain(bool,int)"), _A("A"), "operator+=(int)"));
+        REQUIRE_THAT(src, !HasCall(_A("A"), _A("A"), "add(int)"));
+        REQUIRE_THAT(src,
+            !HasCall(_A("tmain(bool,int)"), _A("A"), "operator=(const A &)"));
+        REQUIRE_THAT(src, !HasCall(_A("A"), _A("A"), "set(int)"));
+        REQUIRE_THAT(src, HasCall(_A("tmain(bool,int)"), _A("A"), "value()"));
+        REQUIRE_THAT(src,
+            !HasCall(_A("tmain(bool,int)::(lambda "
+                        "../../tests/t20031/t20031.cc:47:26)"),
+                _A("zero()"), ""));
+
+        save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
     }
 }
\ No newline at end of file
diff --git a/tests/t20032/test_case.h b/tests/t20032/test_case.h
index 6003423a..5116c4ba 100644
--- a/tests/t20032/test_case.h
+++ b/tests/t20032/test_case.h
@@ -30,32 +30,31 @@ TEST_CASE("t20032", "[test-case][sequence]")
 
     REQUIRE(model->name() == "t20032_sequence");
     {
-        auto puml = generate_sequence_puml(diagram, *model);
-        AliasMatcher _A(puml);
+        auto src = generate_sequence_puml(diagram, *model);
+        AliasMatcher _A(src);
 
-        REQUIRE_THAT(puml, StartsWith("@startuml"));
-        REQUIRE_THAT(puml, EndsWith("@enduml\n"));
+        REQUIRE_THAT(src, StartsWith("@startuml"));
+        REQUIRE_THAT(src, EndsWith("@enduml\n"));
 
         // Check if all calls exist
+        REQUIRE_THAT(src, HasCall(_A("tmain(int,char **)"), _A("B"), "b(int)"));
         REQUIRE_THAT(
-            puml, HasCall(_A("tmain(int,char **)"), _A("B"), "b(int)"));
-        REQUIRE_THAT(
-            puml, HasResponse(_A("tmain(int,char **)"), _A("B"), "int"));
+            src, HasResponse(_A("tmain(int,char **)"), _A("B"), "int"));
 
-        REQUIRE_THAT(puml, HasCall(_A("B"), _A("A"), "a1(int)"));
-        REQUIRE_THAT(puml, HasResponse(_A("B"), _A("A"), "int"));
+        REQUIRE_THAT(src, HasCall(_A("B"), _A("A"), "a1(int)"));
+        REQUIRE_THAT(src, HasResponse(_A("B"), _A("A"), "int"));
 
         REQUIRE_THAT(
-            puml, HasCall(_A("tmain(int,char **)"), _A("B"), "b(double)"));
-        REQUIRE_THAT(puml, HasCall(_A("B"), _A("A"), "a2(double)"));
-        REQUIRE_THAT(puml, HasResponse(_A("B"), _A("A"), "double"));
+            src, HasCall(_A("tmain(int,char **)"), _A("B"), "b(double)"));
+        REQUIRE_THAT(src, HasCall(_A("B"), _A("A"), "a2(double)"));
+        REQUIRE_THAT(src, HasResponse(_A("B"), _A("A"), "double"));
 
-        REQUIRE_THAT(puml,
-            HasCall(_A("tmain(int,char **)"), _A("B"), "b(const char *)"));
-        REQUIRE_THAT(puml, HasCall(_A("B"), _A("A"), "a3(const char *)"));
-        REQUIRE_THAT(puml, HasResponse(_A("B"), _A("A"), "const char *"));
+        REQUIRE_THAT(
+            src, HasCall(_A("tmain(int,char **)"), _A("B"), "b(const char *)"));
+        REQUIRE_THAT(src, HasCall(_A("B"), _A("A"), "a3(const char *)"));
+        REQUIRE_THAT(src, HasResponse(_A("B"), _A("A"), "const char *"));
 
-        save_puml(config.output_directory(), diagram->name + ".puml", puml);
+        save_puml(config.output_directory(), diagram->name + ".puml", src);
     }
 
     {
@@ -77,8 +76,29 @@ TEST_CASE("t20032", "[test-case][sequence]")
     }
 
     {
-        auto mmd = generate_sequence_mermaid(diagram, *model);
+        auto src = generate_sequence_mermaid(diagram, *model);
 
-        save_mermaid(config.output_directory(), diagram->name + ".mmd", mmd);
+        mermaid::SequenceDiagramAliasMatcher _A(src);
+        using mermaid::HasCall;
+        using mermaid::HasResponse;
+
+        REQUIRE_THAT(src, HasCall(_A("tmain(int,char **)"), _A("B"), "b(int)"));
+        REQUIRE_THAT(
+            src, HasResponse(_A("tmain(int,char **)"), _A("B"), "int"));
+
+        REQUIRE_THAT(src, HasCall(_A("B"), _A("A"), "a1(int)"));
+        REQUIRE_THAT(src, HasResponse(_A("B"), _A("A"), "int"));
+
+        REQUIRE_THAT(
+            src, HasCall(_A("tmain(int,char **)"), _A("B"), "b(double)"));
+        REQUIRE_THAT(src, HasCall(_A("B"), _A("A"), "a2(double)"));
+        REQUIRE_THAT(src, HasResponse(_A("B"), _A("A"), "double"));
+
+        REQUIRE_THAT(
+            src, HasCall(_A("tmain(int,char **)"), _A("B"), "b(const char *)"));
+        REQUIRE_THAT(src, HasCall(_A("B"), _A("A"), "a3(const char *)"));
+        REQUIRE_THAT(src, HasResponse(_A("B"), _A("A"), "const char *"));
+
+        save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
     }
 }
\ No newline at end of file
diff --git a/tests/t20033/test_case.h b/tests/t20033/test_case.h
index 41703b18..131acc81 100644
--- a/tests/t20033/test_case.h
+++ b/tests/t20033/test_case.h
@@ -29,22 +29,22 @@ TEST_CASE("t20033", "[test-case][sequence]")
     REQUIRE(model->name() == "t20033_sequence");
 
     {
-        auto puml = generate_sequence_puml(diagram, *model);
-        AliasMatcher _A(puml);
+        auto src = generate_sequence_puml(diagram, *model);
+        AliasMatcher _A(src);
 
-        REQUIRE_THAT(puml, StartsWith("@startuml"));
-        REQUIRE_THAT(puml, EndsWith("@enduml\n"));
+        REQUIRE_THAT(src, StartsWith("@startuml"));
+        REQUIRE_THAT(src, EndsWith("@enduml\n"));
 
         // Check if all calls exist
-        REQUIRE_THAT(puml, HasCall(_A("tmain()"), _A("A"), "a1()"));
+        REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("A"), "a1()"));
         REQUIRE_THAT(
-            puml, HasCallInControlCondition(_A("tmain()"), _A("A"), "a2()"));
+            src, HasCallInControlCondition(_A("tmain()"), _A("A"), "a2()"));
         REQUIRE_THAT(
-            puml, HasCallInControlCondition(_A("tmain()"), _A("A"), "a3()"));
+            src, HasCallInControlCondition(_A("tmain()"), _A("A"), "a3()"));
         REQUIRE_THAT(
-            puml, HasCallInControlCondition(_A("tmain()"), _A("A"), "a4()"));
+            src, HasCallInControlCondition(_A("tmain()"), _A("A"), "a4()"));
 
-        save_puml(config.output_directory(), diagram->name + ".puml", puml);
+        save_puml(config.output_directory(), diagram->name + ".puml", src);
     }
 
     {
@@ -56,8 +56,20 @@ TEST_CASE("t20033", "[test-case][sequence]")
     }
 
     {
-        auto mmd = generate_sequence_mermaid(diagram, *model);
+        auto src = generate_sequence_mermaid(diagram, *model);
 
-        save_mermaid(config.output_directory(), diagram->name + ".mmd", mmd);
+        mermaid::SequenceDiagramAliasMatcher _A(src);
+        using mermaid::HasCall;
+        using mermaid::HasCallInControlCondition;
+
+        REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("A"), "a1()"));
+        REQUIRE_THAT(
+            src, HasCallInControlCondition(_A("tmain()"), _A("A"), "a2()"));
+        REQUIRE_THAT(
+            src, HasCallInControlCondition(_A("tmain()"), _A("A"), "a3()"));
+        REQUIRE_THAT(
+            src, HasCallInControlCondition(_A("tmain()"), _A("A"), "a4()"));
+
+        save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
     }
 }
\ No newline at end of file
diff --git a/tests/t20034/test_case.h b/tests/t20034/test_case.h
index 3ad62327..c08ef64f 100644
--- a/tests/t20034/test_case.h
+++ b/tests/t20034/test_case.h
@@ -29,25 +29,25 @@ TEST_CASE("t20034", "[test-case][sequence]")
     REQUIRE(model->name() == "t20034_sequence");
 
     {
-        auto puml = generate_sequence_puml(diagram, *model);
-        AliasMatcher _A(puml);
+        auto src = generate_sequence_puml(diagram, *model);
+        AliasMatcher _A(src);
 
-        REQUIRE_THAT(puml, StartsWith("@startuml"));
-        REQUIRE_THAT(puml, EndsWith("@enduml\n"));
+        REQUIRE_THAT(src, StartsWith("@startuml"));
+        REQUIRE_THAT(src, EndsWith("@enduml\n"));
 
         // Check if all calls exist
-        REQUIRE_THAT(puml, HasCall(_A("D"), _A("A"), "a2()"));
+        REQUIRE_THAT(src, HasCall(_A("D"), _A("A"), "a2()"));
 
-        REQUIRE_THAT(puml, HasCall(_A("D"), _A("C"), "c3()"));
-        REQUIRE_THAT(puml, HasCall(_A("C"), _A("C"), "c2()"));
-        REQUIRE_THAT(puml, HasCall(_A("C"), _A("B"), "b2()"));
-        REQUIRE_THAT(puml, HasCall(_A("B"), _A("A"), "a2()"));
+        REQUIRE_THAT(src, HasCall(_A("D"), _A("C"), "c3()"));
+        REQUIRE_THAT(src, HasCall(_A("C"), _A("C"), "c2()"));
+        REQUIRE_THAT(src, HasCall(_A("C"), _A("B"), "b2()"));
+        REQUIRE_THAT(src, HasCall(_A("B"), _A("A"), "a2()"));
 
-        REQUIRE_THAT(puml, HasCall(_A("D"), _A("C"), "c4()"));
+        REQUIRE_THAT(src, HasCall(_A("D"), _A("C"), "c4()"));
 
-        REQUIRE_THAT(puml, !HasCall(_A("C"), _A("B"), "b3()"));
+        REQUIRE_THAT(src, !HasCall(_A("C"), _A("B"), "b3()"));
 
-        save_puml(config.output_directory(), diagram->name + ".puml", puml);
+        save_puml(config.output_directory(), diagram->name + ".puml", src);
     }
 
     {
@@ -75,8 +75,22 @@ TEST_CASE("t20034", "[test-case][sequence]")
     }
 
     {
-        auto mmd = generate_sequence_mermaid(diagram, *model);
+        auto src = generate_sequence_mermaid(diagram, *model);
 
-        save_mermaid(config.output_directory(), diagram->name + ".mmd", mmd);
+        mermaid::SequenceDiagramAliasMatcher _A(src);
+        using mermaid::HasCall;
+
+        REQUIRE_THAT(src, HasCall(_A("D"), _A("A"), "a2()"));
+
+        REQUIRE_THAT(src, HasCall(_A("D"), _A("C"), "c3()"));
+        REQUIRE_THAT(src, HasCall(_A("C"), _A("C"), "c2()"));
+        REQUIRE_THAT(src, HasCall(_A("C"), _A("B"), "b2()"));
+        REQUIRE_THAT(src, HasCall(_A("B"), _A("A"), "a2()"));
+
+        REQUIRE_THAT(src, HasCall(_A("D"), _A("C"), "c4()"));
+
+        REQUIRE_THAT(src, !HasCall(_A("C"), _A("B"), "b3()"));
+
+        save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
     }
 }
\ No newline at end of file
diff --git a/tests/t20035/test_case.h b/tests/t20035/test_case.h
index b73c22f1..d4eb26dc 100644
--- a/tests/t20035/test_case.h
+++ b/tests/t20035/test_case.h
@@ -29,17 +29,17 @@ TEST_CASE("t20035", "[test-case][sequence]")
     REQUIRE(model->name() == "t20035_sequence");
 
     {
-        auto puml = generate_sequence_puml(diagram, *model);
-        AliasMatcher _A(puml);
+        auto src = generate_sequence_puml(diagram, *model);
+        AliasMatcher _A(src);
 
-        REQUIRE_THAT(puml, StartsWith("@startuml"));
-        REQUIRE_THAT(puml, EndsWith("@enduml\n"));
+        REQUIRE_THAT(src, StartsWith("@startuml"));
+        REQUIRE_THAT(src, EndsWith("@enduml\n"));
 
-        REQUIRE_THAT(puml, HasCall(_A("tmain(int,char **)"), _A("a(int)"), ""));
-        REQUIRE_THAT(puml, HasCall(_A("a(int)"), _A("b1(int)"), ""));
-        REQUIRE_THAT(puml, HasCall(_A("b1(int)"), _A("c(int)"), ""));
+        REQUIRE_THAT(src, HasCall(_A("tmain(int,char **)"), _A("a(int)"), ""));
+        REQUIRE_THAT(src, HasCall(_A("a(int)"), _A("b1(int)"), ""));
+        REQUIRE_THAT(src, HasCall(_A("b1(int)"), _A("c(int)"), ""));
 
-        save_puml(config.output_directory(), diagram->name + ".puml", puml);
+        save_puml(config.output_directory(), diagram->name + ".puml", src);
     }
 
     {
@@ -55,8 +55,15 @@ TEST_CASE("t20035", "[test-case][sequence]")
     }
 
     {
-        auto mmd = generate_sequence_mermaid(diagram, *model);
+        auto src = generate_sequence_mermaid(diagram, *model);
 
-        save_mermaid(config.output_directory(), diagram->name + ".mmd", mmd);
+        mermaid::SequenceDiagramAliasMatcher _A(src);
+        using mermaid::HasCall;
+
+        REQUIRE_THAT(src, HasCall(_A("tmain(int,char **)"), _A("a(int)"), ""));
+        REQUIRE_THAT(src, HasCall(_A("a(int)"), _A("b1(int)"), ""));
+        REQUIRE_THAT(src, HasCall(_A("b1(int)"), _A("c(int)"), ""));
+
+        save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
     }
 }
\ No newline at end of file
diff --git a/tests/t20036/test_case.h b/tests/t20036/test_case.h
index e3e6c548..3ecf5714 100644
--- a/tests/t20036/test_case.h
+++ b/tests/t20036/test_case.h
@@ -29,25 +29,25 @@ TEST_CASE("t20036", "[test-case][sequence]")
     REQUIRE(model->name() == "t20036_sequence");
 
     {
-        auto puml = generate_sequence_puml(diagram, *model);
-        AliasMatcher _A(puml);
+        auto src = generate_sequence_puml(diagram, *model);
+        AliasMatcher _A(src);
 
-        REQUIRE_THAT(puml, StartsWith("@startuml"));
-        REQUIRE_THAT(puml, EndsWith("@enduml\n"));
+        REQUIRE_THAT(src, StartsWith("@startuml"));
+        REQUIRE_THAT(src, EndsWith("@enduml\n"));
 
-        REQUIRE_THAT(puml, HasCall(_A("C"), _A("C"), "c2()"));
-        REQUIRE_THAT(puml, HasCall(_A("C"), _A("B"), "b2()"));
-        REQUIRE_THAT(puml, HasCall(_A("B"), _A("A"), "a2()"));
+        REQUIRE_THAT(src, HasCall(_A("C"), _A("C"), "c2()"));
+        REQUIRE_THAT(src, HasCall(_A("C"), _A("B"), "b2()"));
+        REQUIRE_THAT(src, HasCall(_A("B"), _A("A"), "a2()"));
 
-        REQUIRE_THAT(puml, HasCall(_A("C"), _A("B"), "b2()"));
-        REQUIRE_THAT(puml, HasCall(_A("B"), _A("A"), "a2()"));
+        REQUIRE_THAT(src, HasCall(_A("C"), _A("B"), "b2()"));
+        REQUIRE_THAT(src, HasCall(_A("B"), _A("A"), "a2()"));
 
-        REQUIRE_THAT(puml, HasCall(_A("D"), _A("A"), "a2()"));
+        REQUIRE_THAT(src, HasCall(_A("D"), _A("A"), "a2()"));
 
-        REQUIRE_THAT(puml, HasCall(_A("C"), _A("B"), "b1()"));
-        REQUIRE_THAT(puml, HasCall(_A("B"), _A("A"), "a2()"));
+        REQUIRE_THAT(src, HasCall(_A("C"), _A("B"), "b1()"));
+        REQUIRE_THAT(src, HasCall(_A("B"), _A("A"), "a2()"));
 
-        save_puml(config.output_directory(), diagram->name + ".puml", puml);
+        save_puml(config.output_directory(), diagram->name + ".puml", src);
     }
 
     {
@@ -71,8 +71,23 @@ TEST_CASE("t20036", "[test-case][sequence]")
     }
 
     {
-        auto mmd = generate_sequence_mermaid(diagram, *model);
+        auto src = generate_sequence_mermaid(diagram, *model);
 
-        save_mermaid(config.output_directory(), diagram->name + ".mmd", mmd);
+        mermaid::SequenceDiagramAliasMatcher _A(src);
+        using mermaid::HasCall;
+
+        REQUIRE_THAT(src, HasCall(_A("C"), _A("C"), "c2()"));
+        REQUIRE_THAT(src, HasCall(_A("C"), _A("B"), "b2()"));
+        REQUIRE_THAT(src, HasCall(_A("B"), _A("A"), "a2()"));
+
+        REQUIRE_THAT(src, HasCall(_A("C"), _A("B"), "b2()"));
+        REQUIRE_THAT(src, HasCall(_A("B"), _A("A"), "a2()"));
+
+        REQUIRE_THAT(src, HasCall(_A("D"), _A("A"), "a2()"));
+
+        REQUIRE_THAT(src, HasCall(_A("C"), _A("B"), "b1()"));
+        REQUIRE_THAT(src, HasCall(_A("B"), _A("A"), "a2()"));
+
+        save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
     }
 }
\ No newline at end of file
diff --git a/tests/test_cases.h b/tests/test_cases.h
index a6517616..7193e120 100644
--- a/tests/test_cases.h
+++ b/tests/test_cases.h
@@ -136,14 +136,19 @@ struct HasCallWithResultMatcher : ContainsMatcher {
 template <typename T> class HasCallMatcher : public Catch::MatcherBase<T> {
     T m_from, m_to, m_message;
     bool m_is_response;
+    std::string m_call_arrow, m_return_arrow;
     std::string call_pattern, response_pattern;
 
 public:
-    HasCallMatcher(T from, T to, T message, bool is_response = false)
+    HasCallMatcher(T from, T to, T message, bool is_response = false,
+        const std::string &call_arrow = "->",
+        const std::string &return_arrow = "-->")
         : m_from(from)
         , m_to{to}
         , m_message{message}
         , m_is_response{is_response}
+        , m_call_arrow{call_arrow}
+        , m_return_arrow{return_arrow}
     {
         util::replace_all(m_message, "(", "\\(");
         util::replace_all(m_message, ")", "\\)");
@@ -152,12 +157,12 @@ public:
         util::replace_all(m_message, "]", "\\]");
         util::replace_all(m_message, "+", "\\+");
 
-        call_pattern = fmt::format("{} -> {} "
+        call_pattern = fmt::format("{} {} {} "
                                    "(\\[\\[.*\\]\\] )?: {}",
-            m_from, m_to, m_message);
+            m_from, m_call_arrow, m_to, m_message);
 
-        response_pattern =
-            fmt::format("{} --> {} : //{}//", m_from, m_to, m_message);
+        response_pattern = fmt::format(
+            "{} {} {} : //{}//", m_from, m_return_arrow, m_to, m_message);
     }
 
     bool match(T const &in) const override
@@ -181,7 +186,8 @@ public:
     {
         std::ostringstream ss;
         ss << "has call "
-           << fmt::format("{} -> {} : {}", m_from, m_to, m_message);
+           << fmt::format(
+                  "{} {} {} : {}", m_from, m_call_arrow, m_to, m_message);
         return ss.str();
     }
 };
@@ -190,7 +196,7 @@ auto HasCall(std::string const &from, std::string const &to,
     std::string const &message,
     CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes)
 {
-    return HasCallMatcher(from, to, message);
+    return HasCallMatcher(from, to, message, false);
 }
 
 auto HasResponse(std::string const &from, std::string const &to,
@@ -213,13 +219,91 @@ auto HasCall(std::string const &from, std::string const &message,
     return HasCall(from, from, message, caseSensitivity);
 }
 
-auto HasCallWithResponse(std::string const &from, std::string const &to,
+namespace mermaid {
+template <typename T> class HasCallMatcher : public Catch::MatcherBase<T> {
+    T m_from, m_to, m_message;
+    bool m_is_response;
+    std::string m_call_arrow, m_return_arrow;
+    std::string call_pattern, response_pattern;
+
+public:
+    HasCallMatcher(T from, T to, T message, bool is_response = false,
+        const std::string &call_arrow = "->>",
+        const std::string &return_arrow = "-->>")
+        : m_from(from)
+        , m_to{to}
+        , m_message{message}
+        , m_is_response{is_response}
+        , m_call_arrow{call_arrow}
+        , m_return_arrow{return_arrow}
+    {
+        util::replace_all(m_message, "(", "\\(");
+        util::replace_all(m_message, ")", "\\)");
+        util::replace_all(m_message, "*", "\\*");
+        util::replace_all(m_message, "[", "\\[");
+        util::replace_all(m_message, "]", "\\]");
+        util::replace_all(m_message, "+", "\\+");
+
+        call_pattern =
+            fmt::format("{} {} {} : {}", m_from, m_call_arrow, m_to, m_message);
+
+        response_pattern = fmt::format(
+            "{} {} {} : {}", m_from, m_return_arrow, m_to, m_message);
+    }
+
+    bool match(T const &in) const override
+    {
+        std::istringstream fin(in);
+        std::string line;
+
+        std::regex r{m_is_response ? response_pattern : call_pattern};
+
+        while (std::getline(fin, line)) {
+            std::smatch base_match;
+            std::regex_search(in, base_match, r);
+            if (base_match.size() > 0)
+                return true;
+        }
+
+        return false;
+    }
+
+    std::string describe() const override
+    {
+        std::ostringstream ss;
+        ss << "has call "
+           << fmt::format(
+                  "{} {} {} : {}", m_from, m_call_arrow, m_to, m_message);
+        return ss.str();
+    }
+};
+
+auto HasCall(std::string const &from, std::string const &to,
     std::string const &message,
     CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes)
 {
-    return ContainsMatcher(CasedString(
-               fmt::format("{} --> {}", to, from), caseSensitivity)) &&
-        HasCallMatcher(from, to, message);
+    return mermaid::HasCallMatcher(from, to, message, false);
+}
+
+auto HasCallInControlCondition(std::string const &from, std::string const &to,
+    std::string const &message,
+    CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes)
+{
+    return mermaid::HasCallMatcher(from, to, fmt::format("[{}]", message));
+}
+
+auto HasResponse(std::string const &from, std::string const &to,
+    std::string const &message,
+    CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes)
+{
+    return HasCallMatcher(to, from, message, true, "->>", "-->>");
+}
+
+auto HasCall(std::string const &from, std::string const &message,
+    CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes)
+{
+    return mermaid::HasCall(from, from, message, caseSensitivity);
+}
 }
 
 ContainsMatcher HasEntrypoint(std::string const &to, std::string const &message,
@@ -229,6 +313,15 @@ ContainsMatcher HasEntrypoint(std::string const &to, std::string const &message,
         CasedString(fmt::format("[-> {} : {}", to, message), caseSensitivity));
 }
 
+namespace mermaid {
+ContainsMatcher HasEntrypoint(std::string const &to, std::string const &message,
+    CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes)
+{
+    return ContainsMatcher(CasedString(
+        fmt::format("* ->> {} : {}", to, message), caseSensitivity));
+}
+}
+
 ContainsMatcher HasExitpoint(std::string const &to,
     CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes)
 {
@@ -236,6 +329,15 @@ ContainsMatcher HasExitpoint(std::string const &to,
         CasedString(fmt::format("[<-- {}", to), caseSensitivity));
 }
 
+namespace mermaid {
+ContainsMatcher HasExitpoint(std::string const &to,
+    CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes)
+{
+    return ContainsMatcher(
+        CasedString(fmt::format("{} -->> *", to), caseSensitivity));
+}
+}
+
 std::string _NS(std::string_view s)
 {
     return fmt::format(
@@ -326,27 +428,47 @@ struct AliasMatcher {
 
         patterns.push_back(
             std::regex{"class\\s" + alias_regex + "\\[\"" + name + "\"\\]"});
-        //        patterns.push_back(
-        //            std::regex{"abstract\\s\"" + name + "\"\\sas\\s" +
-        //            alias_regex});
-        //        patterns.push_back(
-        //            std::regex{"enum\\s\"" + name + "\"\\sas\\s" +
-        //            alias_regex});
-        //        patterns.push_back(
-        //            std::regex{"package\\s\"" + name + "\"\\sas\\s" +
-        //            alias_regex});
-        //        patterns.push_back(
-        //            std::regex{"package\\s\\[" + name + "\\]\\sas\\s" +
-        //            alias_regex});
-        //        patterns.push_back(
-        //            std::regex{"file\\s\"" + name + "\"\\sas\\s" +
-        //            alias_regex});
-        //        patterns.push_back(
-        //            std::regex{"folder\\s\"" + name + "\"\\sas\\s" +
-        //            alias_regex});
-        //        patterns.push_back(
-        //            std::regex{"participant\\s\"" + name + "\"\\sas\\s" +
-        //            alias_regex});
+
+        std::smatch base_match;
+
+        for (const auto &line : mmd) {
+            for (const auto &pattern : patterns) {
+                if (std::regex_search(line, base_match, pattern) &&
+                    base_match.size() == 2) {
+                    std::ssub_match base_sub_match = base_match[1];
+                    std::string alias = base_sub_match.str();
+                    return trim(alias);
+                }
+            }
+        }
+
+        return "__INVALID__ALIAS__";
+    }
+
+    const std::vector<std::string> mmd;
+};
+
+struct SequenceDiagramAliasMatcher {
+    SequenceDiagramAliasMatcher(const std::string &mmd_)
+        : mmd{split(mmd_, "\n")}
+    {
+    }
+
+    std::string operator()(std::string name)
+    {
+        std::vector<std::regex> patterns;
+
+        const std::string alias_regex("([A-Z]_[0-9]+)");
+
+        util::replace_all(name, "(", "\\(");
+        util::replace_all(name, ")", "\\)");
+        util::replace_all(name, " ", "\\s");
+        util::replace_all(name, "*", "\\*");
+        util::replace_all(name, "[", "\\[");
+        util::replace_all(name, "]", "\\]");
+
+        patterns.push_back(
+            std::regex{"participant\\s" + alias_regex + "\\sas\\s" + name});
 
         std::smatch base_match;
 
@@ -678,6 +800,15 @@ ContainsMatcher HasComment(std::string const &comment,
         CasedString(fmt::format("' {}", comment), caseSensitivity));
 }
 
+namespace mermaid {
+ContainsMatcher HasComment(std::string const &comment,
+    CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes)
+{
+    return ContainsMatcher(
+        CasedString(fmt::format("%% {}", comment), caseSensitivity));
+}
+}
+
 ContainsMatcher HasNote(std::string const &cls, std::string const &position,
     std::string const &note = "",
     CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes)