matthias/clang-uml
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Added mermaid test cases for sequence diagrams

Browse Source
This commit is contained in:
Bartek Kryza
2023-09-12 23:04:54 +02:00
parent 59180efebf
commit 57af380dfa
39 changed files with 1224 additions and 528 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
tests/t20001/.clang-uml
View File

@@ -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'

37
tests/t20001/test_case.h
View File

@@ -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);
}
}

27
tests/t20002/test_case.h
View File

@@ -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);
}
}

27
tests/t20003/test_case.h
View File

@@ -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);
}
}

64
tests/t20004/test_case.h
View File

@@ -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);
}
}

32
tests/t20005/test_case.h
View File

@@ -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);
}
}

92
tests/t20006/test_case.h
View File

@@ -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);
}
}

33
tests/t20007/test_case.h
View File

@@ -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);
}
}

47
tests/t20008/test_case.h
View File

@@ -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);
}
}

42
tests/t20009/test_case.h
View File

@@ -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);
}
}

45
tests/t20010/test_case.h
View File

@@ -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);
}
}

37
tests/t20011/test_case.h
View File

@@ -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);
}
}

86
tests/t20012/test_case.h
View File

@@ -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);
}
}

43
tests/t20013/test_case.h
View File

@@ -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);
}
}

39
tests/t20014/test_case.h
View File

@@ -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);
}
}

42
tests/t20015/test_case.h
View File

@@ -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);
}
}

31
tests/t20016/test_case.h
View File

@@ -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);
}
}

47
tests/t20017/test_case.h
View File

@@ -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);
}
}

47
tests/t20018/test_case.h
View File

@@ -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);
}
}

30
tests/t20019/test_case.h
View File

@@ -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);
}
}

56
tests/t20020/test_case.h
View File

@@ -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);
}
}

57
tests/t20021/test_case.h
View File

@@ -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);
}
}

24
tests/t20022/test_case.h
View File

@@ -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);
}
}

33
tests/t20023/test_case.h
View File

@@ -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);
}
}

46
tests/t20024/test_case.h
View File

@@ -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);
}
}

31
tests/t20025/test_case.h
View File

@@ -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);
}
}

21
tests/t20026/test_case.h
View File

@@ -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);
}
}

27
tests/t20027/test_case.h
View File

@@ -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);
}
}

35
tests/t20028/test_case.h
View File

@@ -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);
}
}

54
tests/t20029/test_case.h
View File

@@ -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);
}
}

53
tests/t20030/test_case.h
View File

@@ -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);
}
}

59
tests/t20031/test_case.h
View File

@@ -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);
}
}

58
tests/t20032/test_case.h
View File

@@ -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);
}
}

34
tests/t20033/test_case.h
View File

@@ -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);
}
}

42
tests/t20034/test_case.h
View File

@@ -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);
}
}

27
tests/t20035/test_case.h
View File

@@ -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);
}
}

45
tests/t20036/test_case.h
View File

@@ -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);
}
}

195
tests/test_cases.h
View File

@@ -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)