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

Refactoring sequence diagrams test cases (#266)

Browse Source
This commit is contained in:
Bartek Kryza
2024-05-16 21:58:45 +02:00
parent 5d69f5063a
commit 7c1e0420c6
49 changed files with 2807 additions and 1576 deletions
Download Patch File Download Diff File Expand all files Collapse all files

63
tests/t20001/test_case.h
View File

@@ -1,5 +1,5 @@
/**
* tests/t20001/test_case.cc
* tests/t20001/test_case.h
*
* Copyright (c) 2021-2024 Bartek Kryza <bkryza@gmail.com>
*
@@ -16,18 +16,66 @@
* limitations under the License.
*/
TEST_CASE("t20001", "[test-case][sequence]")
TEST_CASE("t20001")
{
auto [config, db] = load_config("t20001");
using namespace clanguml::test;
auto diagram = config.diagrams["t20001_sequence"];
auto [config, db, diagram, model] =
CHECK_SEQUENCE_MODEL("t20001", "t20001_sequence");
REQUIRE(diagram->name == "t20001_sequence");
CHECK_SEQUENCE_DIAGRAM(
config, diagram, *model,
[](const auto &src) {
REQUIRE(HasTitle(src, "Basic sequence diagram example"));
auto model = generate_sequence_diagram(*db, diagram);
REQUIRE(MessageOrder(src,
{
//
{"tmain()", "A", "A()"}, //
{"tmain()", "B", "B(A &)"}, //
REQUIRE(model->name() == "t20001_sequence");
{"tmain()", "A", "add(int,int)"}, //
{"tmain()", "B", "wrap_add3(int,int,int)"}, //
{"B", "A", "add3(int,int,int)"}, //
{"A", "A", "add(int,int)"}, //
{"A", "A", "log_result(int)", Static{}}, //
{"B", "A", "log_result(int)", Static{}} //
}));
REQUIRE(!HasMessage(src, {"A", {"detail", "C"}, "add(int,int)"}));
REQUIRE(HasComment(src, "t20001 test diagram of type sequence"));
REQUIRE(HasMessageComment(src, "tmain()", "Just add 2 numbers"));
REQUIRE(HasMessageComment(src, "tmain()", "And now add another 2"));
},
[](const json_t &src) {
const auto &A = get_participant(src.src, "A");
CHECK(A.has_value());
CHECK(A.value()["type"] == "class");
CHECK(A.value()["name"] == "A");
CHECK(A.value()["display_name"] == "A");
CHECK(A.value()["namespace"] == "clanguml::t20001");
CHECK(A.value()["source_location"]["file"] == "t20001.cc");
CHECK(A.value()["source_location"]["line"] == 13);
const auto &tmain = get_participant(src.src, "tmain()");
CHECK(tmain.has_value());
CHECK(tmain.value()["type"] == "function");
CHECK(tmain.value()["name"] == "tmain");
CHECK(tmain.value()["display_name"] == "tmain()");
CHECK(tmain.value()["namespace"] == "clanguml::t20001");
CHECK(tmain.value()["source_location"]["file"] == "t20001.cc");
CHECK(tmain.value()["source_location"]["line"] == 61);
});
/*
{
auto src = generate_sequence_puml(diagram, *model);
AliasMatcher _A(src);
@@ -118,4 +166,5 @@ TEST_CASE("t20001", "[test-case][sequence]")
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}
*/
}

30
tests/t20002/test_case.h
View File

@@ -1,5 +1,5 @@
/**
* tests/t20002/test_case.cc
* tests/t20002/test_case.h
*
* Copyright (c) 2021-2024 Bartek Kryza <bkryza@gmail.com>
*
@@ -16,18 +16,28 @@
* limitations under the License.
*/
TEST_CASE("t20002", "[test-case][sequence]")
TEST_CASE("t20002")
{
auto [config, db] = load_config("t20002");
using namespace clanguml::test;
auto diagram = config.diagrams["t20002_sequence"];
auto [config, db, diagram, model] =
CHECK_SEQUENCE_MODEL("t20002", "t20002_sequence");
REQUIRE(diagram->name == "t20002_sequence");
auto model = generate_sequence_diagram(*db, diagram);
REQUIRE(model->name() == "t20002_sequence");
CHECK_SEQUENCE_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(IsFunctionParticipant(src, "m1()"));
REQUIRE(IsFunctionParticipant(src, "m2()"));
REQUIRE(IsFunctionParticipant(src, "m3()"));
REQUIRE(IsFunctionParticipant(src, "m4()"));
REQUIRE(MessageOrder(src,
{
//
{"m1()", "m2()", ""}, //
{"m2()", "m3()", ""}, //
{"m3()", "m4()", ""} //
}));
});
/*
{
auto src = generate_sequence_puml(diagram, *model);
AliasMatcher _A(src);
@@ -72,5 +82,5 @@ TEST_CASE("t20002", "[test-case][sequence]")
REQUIRE_THAT(src, HasCall(_A("m3()"), _A("m4()"), ""));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}
}*/
}

85
tests/t20003/test_case.h
View File

@@ -1,5 +1,5 @@
/**
* tests/t20003/test_case.cc
* tests/t20003/test_case.h
*
* Copyright (c) 2021-2024 Bartek Kryza <bkryza@gmail.com>
*
@@ -16,56 +16,67 @@
* limitations under the License.
*/
TEST_CASE("t20003", "[test-case][sequence]")
TEST_CASE("t20003")
{
auto [config, db] = load_config("t20003");
using namespace clanguml::test;
auto diagram = config.diagrams["t20003_sequence"];
auto [config, db, diagram, model] =
CHECK_SEQUENCE_MODEL("t20003", "t20003_sequence");
REQUIRE(diagram->name == "t20003_sequence");
CHECK_SEQUENCE_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(IsFunctionTemplateParticipant(src, "m1<T>(T)"));
REQUIRE(IsFunctionTemplateParticipant(src, "m2<T>(T)"));
REQUIRE(IsFunctionTemplateParticipant(src, "m3<T>(T)"));
REQUIRE(IsFunctionTemplateParticipant(src, "m4<T>(T)"));
auto model = generate_sequence_diagram(*db, diagram);
REQUIRE(MessageOrder(src,
{
//
{"m1<T>(T)", "m2<T>(T)", ""}, //
{"m2<T>(T)", "m3<T>(T)", ""}, //
{"m3<T>(T)", "m4<T>(T)", ""} //
}));
});
/*
{
auto src = generate_sequence_puml(diagram, *model);
AliasMatcher _A(src);
REQUIRE(model->name() == "t20003_sequence");
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
{
auto src = generate_sequence_puml(diagram, *model);
AliasMatcher _A(src);
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)"), ""));
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
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)"), ""));
{
auto j = generate_sequence_json(diagram, *model);
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
using namespace json;
{
auto j = generate_sequence_json(diagram, *model);
std::vector<int> messages = {FindMessage(j, "m1<T>(T)", "m2<T>(T)",
""), FindMessage(j, "m2<T>(T)", "m3<T>(T)", ""), FindMessage(j,
"m3<T>(T)", "m4<T>(T)", "")};
using namespace json;
REQUIRE(std::is_sorted(messages.begin(), messages.end()));
std::vector<int> messages = {FindMessage(j, "m1<T>(T)", "m2<T>(T)", ""),
FindMessage(j, "m2<T>(T)", "m3<T>(T)", ""),
FindMessage(j, "m3<T>(T)", "m4<T>(T)", "")};
save_json(config.output_directory(), diagram->name + ".json", j);
}
REQUIRE(std::is_sorted(messages.begin(), messages.end()));
{
auto src = generate_sequence_mermaid(diagram, *model);
save_json(config.output_directory(), diagram->name + ".json", j);
}
mermaid::SequenceDiagramAliasMatcher _A(src);
using mermaid::HasCall;
{
auto src = generate_sequence_mermaid(diagram, *model);
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)"), ""));
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);
}
save_mermaid(config.output_directory(), diagram->name + ".mmd",
src);
}*/
}

167
tests/t20004/test_case.h
View File

@@ -16,102 +16,115 @@
* limitations under the License.
*/
TEST_CASE("t20004", "[test-case][sequence]")
TEST_CASE("t20004")
{
auto [config, db] = load_config("t20004");
using namespace clanguml::test;
auto diagram = config.diagrams["t20004_sequence"];
auto [config, db, diagram, model] =
CHECK_SEQUENCE_MODEL("t20004", "t20004_sequence");
REQUIRE(diagram->name == "t20004_sequence");
CHECK_SEQUENCE_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(MessageOrder(src,
{
//
{"main()", "m1<float>(float)", ""}, //
{"main()", "m1<unsigned long>(unsigned long)", ""}, //
{"m1<unsigned long>(unsigned long)",
"m4<unsigned long>(unsigned long)", ""}, //
{"main()", "m1<std::string>(std::string)", ""}, //
{"m1<std::string>(std::string)", "m2<std::string>(std::string)",
""}, //
{"main()", "m1<int>(int)", ""}, //
{"m1<int>(int)", "m2<int>(int)", ""}, //
{"m2<int>(int)", "m3<int>(int)", ""}, //
{"m3<int>(int)", "m4<int>(int)", ""} //
}));
auto model = generate_sequence_diagram(*db, diagram);
REQUIRE(!HasMessage(src, {"m1<float>(float)", "m1<float>(float)", ""}));
});
/*
{
auto src = generate_sequence_puml(diagram, *model);
AliasMatcher _A(src);
REQUIRE(model->name() == "t20004_sequence");
REQUIRE_THAT(src, StartsWith("@startuml"));
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)"), ""));
{
auto src = generate_sequence_puml(diagram, *model);
AliasMatcher _A(src);
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, StartsWith("@startuml"));
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<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<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<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"));
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)"), ""));
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
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"));
{
auto j = generate_sequence_json(diagram, *model);
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
using namespace json;
{
auto j = generate_sequence_json(diagram, *model);
std::vector<int> messages = {
FindMessage(j, "main()", "m1<float>(float)", ""),
FindMessage(j, "main()", "m1<unsigned long>(unsigned long)",
""), FindMessage(j, "m1<unsigned long>(unsigned long)", "m4<unsigned
long>(unsigned long)", ""), FindMessage(j, "main()",
"m1<std::string>(std::string)", ""), FindMessage(j,
"m1<std::string>(std::string)", "m2<std::string>(std::string)", ""),
FindMessage(j, "main()", "m1<int>(int)", ""),
FindMessage(j, "m1<int>(int)", "m2<int>(int)", ""),
FindMessage(j, "m2<int>(int)", "m3<int>(int)", ""),
FindMessage(j, "m3<int>(int)", "m4<int>(int)", "")};
using namespace json;
REQUIRE(std::is_sorted(messages.begin(), messages.end()));
std::vector<int> messages = {
FindMessage(j, "main()", "m1<float>(float)", ""),
FindMessage(j, "main()", "m1<unsigned long>(unsigned long)", ""),
FindMessage(j, "m1<unsigned long>(unsigned long)",
"m4<unsigned long>(unsigned long)", ""),
FindMessage(j, "main()", "m1<std::string>(std::string)", ""),
FindMessage(j, "m1<std::string>(std::string)",
"m2<std::string>(std::string)", ""),
FindMessage(j, "main()", "m1<int>(int)", ""),
FindMessage(j, "m1<int>(int)", "m2<int>(int)", ""),
FindMessage(j, "m2<int>(int)", "m3<int>(int)", ""),
FindMessage(j, "m3<int>(int)", "m4<int>(int)", "")};
save_json(config.output_directory(), diagram->name + ".json", j);
}
REQUIRE(std::is_sorted(messages.begin(), messages.end()));
{
auto src = generate_sequence_mermaid(diagram, *model);
save_json(config.output_directory(), diagram->name + ".json", j);
}
mermaid::SequenceDiagramAliasMatcher _A(src);
using mermaid::HasCall;
{
auto src = generate_sequence_mermaid(diagram, *model);
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)"), ""));
mermaid::SequenceDiagramAliasMatcher _A(src);
using mermaid::HasCall;
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<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<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<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<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, 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);
}
save_mermaid(config.output_directory(), diagram->name + ".mmd",
src);
}*/
}

89
tests/t20005/test_case.h
View File

@@ -16,60 +16,67 @@
* limitations under the License.
*/
TEST_CASE("t20005", "[test-case][sequence]")
TEST_CASE("t20005")
{
auto [config, db] = load_config("t20005");
using namespace clanguml::test;
auto diagram = config.diagrams["t20005_sequence"];
auto [config, db, diagram, model] =
CHECK_SEQUENCE_MODEL("t20005", "t20005_sequence");
REQUIRE(diagram->name == "t20005_sequence");
CHECK_SEQUENCE_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(MessageOrder(src,
{
//
{Entrypoint{}, "C<T>", "c(T)"}, //
{"C<T>", "B<T>", "b(T)"}, //
{"B<T>", "A<T>", "a(T)"}, //
{Exitpoint{}, "C<T>"} //
}));
});
/*
{
auto src = generate_sequence_puml(diagram, *model);
AliasMatcher _A(src);
auto model = generate_sequence_diagram(*db, diagram);
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
REQUIRE(model->name() == "t20005_sequence");
// Check if all calls exist
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>")));
{
auto src = generate_sequence_puml(diagram, *model);
AliasMatcher _A(src);
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
{
auto j = generate_sequence_json(diagram, *model);
// Check if all calls exist
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>")));
using namespace json;
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
std::vector<int> messages = {FindMessage(j, "C<T>", "B<T>", "b(T)"),
FindMessage(j, "B<T>", "A<T>", "a(T)")};
{
auto j = generate_sequence_json(diagram, *model);
REQUIRE(std::is_sorted(messages.begin(), messages.end()));
using namespace json;
save_json(config.output_directory(), diagram->name + ".json", j);
}
std::vector<int> messages = {FindMessage(j, "C<T>", "B<T>", "b(T)"),
FindMessage(j, "B<T>", "A<T>", "a(T)")};
{
auto src = generate_sequence_mermaid(diagram, *model);
REQUIRE(std::is_sorted(messages.begin(), messages.end()));
mermaid::SequenceDiagramAliasMatcher _A(src);
using mermaid::HasCall;
using mermaid::HasEntrypoint;
using mermaid::HasExitpoint;
save_json(config.output_directory(), diagram->name + ".json", j);
}
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>")));
{
auto src = generate_sequence_mermaid(diagram, *model);
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);
}
save_mermaid(config.output_directory(), diagram->name + ".mmd",
src);
}*/
}

224
tests/t20006/test_case.h
View File

@@ -16,132 +16,156 @@
* limitations under the License.
*/
TEST_CASE("t20006", "[test-case][sequence]")
TEST_CASE("t20006")
{
auto [config, db] = load_config("t20006");
using namespace clanguml::test;
auto diagram = config.diagrams["t20006_sequence"];
auto [config, db, diagram, model] =
CHECK_SEQUENCE_MODEL("t20006", "t20006_sequence");
REQUIRE(diagram->name == "t20006_sequence");
CHECK_SEQUENCE_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(MessageOrder(src,
{
//
{"tmain()", "B<int>", "b(int)"}, //
{"B<int>", "A<int>", "a1(int)"}, //
{"tmain()", "B<std::string>", "b(std::string)"}, //
{"B<std::string>", "A<std::string>", "a2(std::string)"}, //
{"tmain()", "BB<int,int>", "bb1(int,int)"}, //
{"BB<int,int>", "AA<int>", "aa1(int)"}, //
{"tmain()", "BB<int,int>", "bb2(int,int)"}, //
{"BB<int,int>", "AA<int>", "aa2(int)"}, //
{"tmain()", "BB<int,std::string>", "bb1(int,std::string)"}, //
{"BB<int,std::string>", "AA<int>", "aa2(int)"}, //
{"tmain()", "BB<int,std::string>", "bb2(int,std::string)"}, //
{"BB<int,std::string>", "AA<int>", "aa1(int)"}, //
{"tmain()", "BB<int,float>", "bb1(int,float)"}, //
{"BB<int,float>", "BB<int,float>", "bb2(int,float)"}, //
{"BB<int,float>", "AA<int>", "aa2(int)"} //
auto model = generate_sequence_diagram(*db, diagram);
}));
});
/*
{
auto src = generate_sequence_puml(diagram, *model);
AliasMatcher _A(src);
REQUIRE(model->name() == "t20006_sequence");
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
{
auto src = generate_sequence_puml(diagram, *model);
AliasMatcher _A(src);
// Check if all calls exist
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, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
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)"));
// Check if all calls exist
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("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("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>"), "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,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,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,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>"),
"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,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,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)"));
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)"));
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
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)"));
{
auto j = generate_sequence_json(diagram, *model);
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
using namespace json;
{
auto j = generate_sequence_json(diagram, *model);
std::vector<int> messages = {
FindMessage(j, "tmain()", "B<int>", "b(int)"),
FindMessage(j, "B<int>", "A<int>", "a1(int)"),
FindMessage(j, "tmain()", "B<std::string>", "b(std::string)"),
FindMessage(j, "tmain()", "BB<int,int>", "bb1(int,int)"),
FindMessage(j, "BB<int,int>", "AA<int>", "aa1(int)"),
FindMessage(
j, "tmain()", "BB<int,std::string>",
"bb1(int,std::string)")};
using namespace json;
REQUIRE(std::is_sorted(messages.begin(), messages.end()));
std::vector<int> messages = {
FindMessage(j, "tmain()", "B<int>", "b(int)"),
FindMessage(j, "B<int>", "A<int>", "a1(int)"),
FindMessage(j, "tmain()", "B<std::string>", "b(std::string)"),
FindMessage(j, "tmain()", "BB<int,int>", "bb1(int,int)"),
FindMessage(j, "BB<int,int>", "AA<int>", "aa1(int)"),
FindMessage(
j, "tmain()", "BB<int,std::string>", "bb1(int,std::string)")};
save_json(config.output_directory(), diagram->name + ".json", j);
}
REQUIRE(std::is_sorted(messages.begin(), messages.end()));
{
auto src = generate_sequence_mermaid(diagram, *model);
save_json(config.output_directory(), diagram->name + ".json", j);
}
mermaid::SequenceDiagramAliasMatcher _A(src);
using mermaid::HasCall;
{
auto src = generate_sequence_mermaid(diagram, *model);
REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B<int>"), "b(int)"));
REQUIRE_THAT(src, HasCall(_A("B<int>"), _A("A<int>"), "a1(int)"));
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>"),
"a2(std::string)"));
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("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("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>"), "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,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,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,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>"),
"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,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,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)"));
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);
}
save_mermaid(config.output_directory(), diagram->name + ".mmd",
src);
}*/
}

114
tests/t20007/test_case.h
View File

@@ -16,73 +16,79 @@
* limitations under the License.
*/
TEST_CASE("t20007", "[test-case][sequence]")
TEST_CASE("t20007")
{
auto [config, db] = load_config("t20007");
using namespace clanguml::test;
auto diagram = config.diagrams["t20007_sequence"];
auto [config, db, diagram, model] =
CHECK_SEQUENCE_MODEL("t20007", "t20007_sequence");
REQUIRE(diagram->name == "t20007_sequence");
CHECK_SEQUENCE_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(MessageOrder(src,
{
{"tmain()", "Adder<int,int>", "add(int &&,int &&)"}, //
{"tmain()", "Adder<int,float,double>",
"add(int &&,float &&,double &&)"}, //
{"tmain()", "Adder<std::string,std::string,std::string>",
"add(std::string &&,std::string &&,std::string &&)"} //
}));
});
/*
{
auto src = generate_sequence_puml(diagram, *model);
AliasMatcher _A(src);
auto model = generate_sequence_diagram(*db, diagram);
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
REQUIRE(model->name() == "t20007_sequence");
// Check if all calls exist
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 &&)"));
{
auto src = generate_sequence_puml(diagram, *model);
AliasMatcher _A(src);
save_puml(config.output_directory(), diagram->name + ".puml",
src);
}
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
{
auto j = generate_sequence_json(diagram, *model);
// Check if all calls exist
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 &&)"));
using namespace json;
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
std::vector<int> messages = {
FindMessage(j, "tmain()", "Adder<int,int>", "add(int &&,int
&&)"), FindMessage(j, "tmain()", "Adder<int,float,double>", "add(int
&&,float &&,double &&)"), FindMessage(j, "tmain()",
"Adder<std::string,std::string,std::string>",
"add(std::string &&,std::string &&,std::string &&)")};
{
auto j = generate_sequence_json(diagram, *model);
REQUIRE(std::is_sorted(messages.begin(), messages.end()));
using namespace json;
save_json(config.output_directory(), diagram->name + ".json",
j);
}
std::vector<int> messages = {
FindMessage(j, "tmain()", "Adder<int,int>", "add(int &&,int &&)"),
FindMessage(j, "tmain()", "Adder<int,float,double>",
"add(int &&,float &&,double &&)"),
FindMessage(j, "tmain()",
"Adder<std::string,std::string,std::string>",
"add(std::string &&,std::string &&,std::string &&)")};
{
auto src = generate_sequence_mermaid(diagram, *model);
REQUIRE(std::is_sorted(messages.begin(), messages.end()));
mermaid::SequenceDiagramAliasMatcher _A(src);
using mermaid::HasCall;
save_json(config.output_directory(), diagram->name + ".json", j);
}
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 &&)"));
{
auto src = generate_sequence_mermaid(diagram, *model);
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);
}
save_mermaid(config.output_directory(), diagram->name + ".mmd",
src);
}*/
}

143
tests/t20008/test_case.h
View File

@@ -16,91 +16,104 @@
* limitations under the License.
*/
TEST_CASE("t20008", "[test-case][sequence]")
TEST_CASE("t20008")
{
auto [config, db] = load_config("t20008");
using namespace clanguml::test;
auto diagram = config.diagrams["t20008_sequence"];
auto [config, db, diagram, model] =
CHECK_SEQUENCE_MODEL("t20008", "t20008_sequence");
REQUIRE(diagram->name == "t20008_sequence");
CHECK_SEQUENCE_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(MessageOrder(src,
{
//
{"tmain()", "B<int>", "b(int)"}, //
{"B<int>", "A<int>", "a1(int)"}, //
auto model = generate_sequence_diagram(*db, diagram);
{"tmain()", "B<const char *>", "b(const char *)"}, //
{"B<const char *>", "A<const char *>", "a2(const char *)"}, //
REQUIRE(model->name() == "t20008_sequence");
{"tmain()", "B<std::string>", "b(std::string)"}, //
{"B<std::string>", "A<std::string>", "a3(std::string)"} //
}));
{
auto src = generate_sequence_puml(diagram, *model);
AliasMatcher _A(src);
REQUIRE(!HasMessage(src, {"B<int>", "A<int>", "a2(int)"}));
REQUIRE(!HasMessage(src, {"B<int>", "A<int>", "a3(int)"}));
});
/*
{
auto src = generate_sequence_puml(diagram, *model);
AliasMatcher _A(src);
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, 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()"), _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)"));
// Check if all calls exist
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<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)"));
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_puml(config.output_directory(), diagram->name + ".puml", src);
}
save_puml(config.output_directory(), diagram->name + ".puml",
src);
}
{
auto j = generate_sequence_json(diagram, *model);
{
auto j = generate_sequence_json(diagram, *model);
using namespace json;
using namespace json;
std::vector<int> messages = {
FindMessage(j, "tmain()", "B<int>", "b(int)"),
FindMessage(j, "B<int>", "A<int>", "a1(int)"),
FindMessage(j, "tmain()", "B<const char *>", "b(const char *)"),
FindMessage(
j, "B<const char *>", "A<const char *>", "a2(const char *)"),
FindMessage(j, "tmain()", "B<std::string>", "b(std::string)"),
FindMessage(
j, "B<std::string>", "A<std::string>", "a3(std::string)")};
std::vector<int> messages = {
FindMessage(j, "tmain()", "B<int>", "b(int)"),
FindMessage(j, "B<int>", "A<int>", "a1(int)"),
FindMessage(j, "tmain()", "B<const char *>", "b(const char
*)"), FindMessage( j, "B<const char *>", "A<const char *>", "a2(const
char *)"), FindMessage(j, "tmain()", "B<std::string>",
"b(std::string)"), FindMessage( j, "B<std::string>",
"A<std::string>", "a3(std::string)")};
REQUIRE(std::is_sorted(messages.begin(), messages.end()));
REQUIRE(std::is_sorted(messages.begin(), messages.end()));
save_json(config.output_directory(), diagram->name + ".json", j);
}
save_json(config.output_directory(), diagram->name + ".json",
j);
}
{
auto src = generate_sequence_mermaid(diagram, *model);
{
auto src = generate_sequence_mermaid(diagram, *model);
mermaid::SequenceDiagramAliasMatcher _A(src);
using mermaid::HasCall;
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<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<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)"));
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);
}
save_mermaid(config.output_directory(), diagram->name + ".mmd",
src);
}*/
}

121
tests/t20009/test_case.h
View File

@@ -16,78 +16,93 @@
* limitations under the License.
*/
TEST_CASE("t20009", "[test-case][sequence]")
TEST_CASE("t20009")
{
auto [config, db] = load_config("t20009");
using namespace clanguml::test;
auto diagram = config.diagrams["t20009_sequence"];
auto [config, db, diagram, model] =
CHECK_SEQUENCE_MODEL("t20009", "t20009_sequence");
REQUIRE(diagram->name == "t20009_sequence");
CHECK_SEQUENCE_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(MessageOrder(src,
{
//
{"tmain()", "B<std::string>", "b(std::string)"}, //
{"B<std::string>", "A<std::string>", "a(std::string)"}, //
auto model = generate_sequence_diagram(*db, diagram);
{"tmain()", "B<int>", "b(int)"}, //
{"B<int>", "A<int>", "a(int)"}, //
REQUIRE(model->name() == "t20009_sequence");
{"tmain()", "B<float>", "b(float)"}, //
{"B<float>", "A<float>", "a(float)"} //
}));
});
/*
{
auto src = generate_sequence_puml(diagram, *model);
AliasMatcher _A(src);
{
auto src = generate_sequence_puml(diagram, *model);
AliasMatcher _A(src);
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, 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()"), _A("B<std::string>"), "b(std::string)"));
REQUIRE_THAT(src,
HasCall(
_A("B<std::string>"), _A("A<std::string>"),
"a(std::string)"));
// Check if all calls exist
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<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)"));
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);
}
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
{
auto j = generate_sequence_json(diagram, *model);
{
auto j = generate_sequence_json(diagram, *model);
using namespace json;
using namespace json;
std::vector<int> messages = {
FindMessage(j, "tmain()", "B<std::string>", "b(std::string)"),
FindMessage(
j, "B<std::string>", "A<std::string>", "a(std::string)"),
FindMessage(j, "tmain()", "B<int>", "b(int)"),
FindMessage(j, "B<int>", "A<int>", "a(int)"),
FindMessage(j, "tmain()", "B<float>", "b(float)"),
FindMessage(j, "B<float>", "A<float>", "a(float)")};
std::vector<int> messages = {
FindMessage(j, "tmain()", "B<std::string>", "b(std::string)"),
FindMessage(
j, "B<std::string>", "A<std::string>", "a(std::string)"),
FindMessage(j, "tmain()", "B<int>", "b(int)"),
FindMessage(j, "B<int>", "A<int>", "a(int)"),
FindMessage(j, "tmain()", "B<float>", "b(float)"),
FindMessage(j, "B<float>", "A<float>", "a(float)")};
REQUIRE(std::is_sorted(messages.begin(), messages.end()));
REQUIRE(std::is_sorted(messages.begin(), messages.end()));
save_json(config.output_directory(), diagram->name + ".json", j);
}
save_json(config.output_directory(), diagram->name + ".json", j);
}
{
auto src = generate_sequence_mermaid(diagram, *model);
{
auto src = generate_sequence_mermaid(diagram, *model);
mermaid::SequenceDiagramAliasMatcher _A(src);
using mermaid::HasCall;
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<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<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)"));
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);
}
save_mermaid(config.output_directory(), diagram->name + ".mmd",
src);
}*/
}

115
tests/t20010/test_case.h
View File

@@ -16,79 +16,92 @@
* limitations under the License.
*/
TEST_CASE("t20010", "[test-case][sequence]")
TEST_CASE("t20010")
{
auto [config, db] = load_config("t20010");
using namespace clanguml::test;
auto diagram = config.diagrams["t20010_sequence"];
auto [config, db, diagram, model] =
CHECK_SEQUENCE_MODEL("t20010", "t20010_sequence");
REQUIRE(diagram->name == "t20010_sequence");
CHECK_SEQUENCE_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(MessageOrder(src,
{
{"tmain()", "B<int>", "b1()"}, //
{"B<int>", "A", "a1()"}, //
auto model = generate_sequence_diagram(*db, diagram);
{"tmain()", "B<int>", "b2()"}, //
{"B<int>", "A", "a2()"}, //
REQUIRE(model->name() == "t20010_sequence");
{"tmain()", "B<int>", "b3()"}, //
{"B<int>", "A", "a3()"}, //
{
auto src = generate_sequence_puml(diagram, *model);
AliasMatcher _A(src);
{"tmain()", "B<int>", "b4()"}, //
{"B<int>", "A", "a4()"} //
}));
});
/*
{
auto src = generate_sequence_puml(diagram, *model);
AliasMatcher _A(src);
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, 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()"), _A("B<int>"), "b1()"));
REQUIRE_THAT(src, HasCall(_A("B<int>"), _A("A"), "a1()"));
// Check if all calls exist
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>"), "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>"), "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()"));
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", src);
}
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
{
auto j = generate_sequence_json(diagram, *model);
{
auto j = generate_sequence_json(diagram, *model);
using namespace json;
using namespace json;
std::vector<int> messages = {
FindMessage(j, "tmain()", "B<int>", "b1()"),
FindMessage(j, "B<int>", "A", "a1()"),
FindMessage(j, "tmain()", "B<int>", "b2()"),
FindMessage(j, "B<int>", "A", "a2()"),
FindMessage(j, "tmain()", "B<int>", "b3()"),
FindMessage(j, "B<int>", "A", "a3()"),
FindMessage(j, "tmain()", "B<int>", "b4()"),
FindMessage(j, "B<int>", "A", "a4()")};
std::vector<int> messages = {
FindMessage(j, "tmain()", "B<int>", "b1()"),
FindMessage(j, "B<int>", "A", "a1()"),
FindMessage(j, "tmain()", "B<int>", "b2()"),
FindMessage(j, "B<int>", "A", "a2()"),
FindMessage(j, "tmain()", "B<int>", "b3()"),
FindMessage(j, "B<int>", "A", "a3()"),
FindMessage(j, "tmain()", "B<int>", "b4()"),
FindMessage(j, "B<int>", "A", "a4()")};
REQUIRE(std::is_sorted(messages.begin(), messages.end()));
REQUIRE(std::is_sorted(messages.begin(), messages.end()));
save_json(config.output_directory(), diagram->name + ".json", j);
}
save_json(config.output_directory(), diagram->name + ".json", j);
}
{
auto src = generate_sequence_mermaid(diagram, *model);
{
auto src = generate_sequence_mermaid(diagram, *model);
mermaid::SequenceDiagramAliasMatcher _A(src);
using mermaid::HasCall;
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>"), "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>"), "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>"), "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()"));
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);
}
save_mermaid(config.output_directory(), diagram->name + ".mmd",
src);
}*/
}

24
tests/t20011/test_case.h
View File

@@ -16,17 +16,28 @@
* limitations under the License.
*/
TEST_CASE("t20011", "[test-case][sequence]")
TEST_CASE("t20011")
{
auto [config, db] = load_config("t20011");
using namespace clanguml::test;
auto diagram = config.diagrams["t20011_sequence"];
auto [config, db, diagram, model] =
CHECK_SEQUENCE_MODEL("t20011", "t20011_sequence");
REQUIRE(diagram->name == "t20011_sequence");
CHECK_SEQUENCE_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(MessageOrder(src,
{
//
{"tmain()", "A", "a(int)"}, //
{"A", "A", "a(int)"}, //
auto model = generate_sequence_diagram(*db, diagram);
{"tmain()", "A", "b(int)"}, //
{"A", "A", "c(int)"}, //
{"A", "A", "d(int)"}, //
{"A", "A", "b(int)"} //
}));
});
REQUIRE(model->name() == "t20011_sequence");
/*
{
auto src = generate_sequence_puml(diagram, *model);
AliasMatcher _A(src);
@@ -80,4 +91,5 @@ TEST_CASE("t20011", "[test-case][sequence]")
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}
*/
}

56
tests/t20012/test_case.h
View File

@@ -16,17 +16,60 @@
* limitations under the License.
*/
TEST_CASE("t20012", "[test-case][sequence]")
TEST_CASE("t20012")
{
auto [config, db] = load_config("t20012");
using namespace clanguml::test;
auto diagram = config.diagrams["t20012_sequence"];
auto [config, db, diagram, model] =
CHECK_SEQUENCE_MODEL("t20012", "t20012_sequence");
REQUIRE(diagram->name == "t20012_sequence");
CHECK_SEQUENCE_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(MessageOrder(src,
{
{"tmain()", "tmain()::(lambda t20012.cc:67:20)",
"operator()() const"}, //
{"tmain()::(lambda t20012.cc:67:20)", "A", "a()"}, //
{"A", "A", "aa()"}, //
{"A", "A", "aaa()"}, //
auto model = generate_sequence_diagram(*db, diagram);
{"tmain()::(lambda t20012.cc:67:20)", "B", "b()"}, //
{"B", "B", "bb()"}, //
{"B", "B", "bbb()"}, //
REQUIRE(model->name() == "t20012_sequence");
{"tmain()", "tmain()::(lambda t20012.cc:80:20)",
"operator()() const"}, //
{"tmain()::(lambda t20012.cc:80:20)", "C", "c()"}, //
{"C", "C", "cc()"}, //
{"C", "C", "ccc()"}, //
{"tmain()::(lambda t20012.cc:80:20)",
"tmain()::(lambda t20012.cc:67:20)",
"operator()() const"}, //
{"tmain()::(lambda t20012.cc:67:20)", "A", "a()"}, //
{"A", "A", "aa()"}, //
{"A", "A", "aaa()"}, //
{"tmain()::(lambda t20012.cc:67:20)", "B", "b()"}, //
{"B", "B", "bb()"}, //
{"B", "B", "bbb()"}, //
{"tmain()", "R<(lambda at t20012.cc:86:9)>",
"R((lambda at t20012.cc:86:9) &&)"}, //
{"tmain()", "R<(lambda at t20012.cc:86:9)>", "r()"}, //
{"R<(lambda at t20012.cc:86:9)>",
"tmain()::(lambda t20012.cc:86:9)",
"operator()() const"}, //
{"tmain()::(lambda t20012.cc:86:9)", "C", "c()"}, //
{"tmain()", "tmain()::(lambda t20012.cc:94:9)",
"operator()(auto) const"}, //
{"tmain()::(lambda t20012.cc:94:9)", "D", "add5(int) const"} //
}));
});
/*
{
auto src = generate_sequence_puml(diagram, *model);
AliasMatcher _A(src);
@@ -155,4 +198,5 @@ TEST_CASE("t20012", "[test-case][sequence]")
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}
*/
}

25
tests/t20013/test_case.h
View File

@@ -16,17 +16,28 @@
* limitations under the License.
*/
TEST_CASE("t20013", "[test-case][sequence]")
TEST_CASE("t20013")
{
auto [config, db] = load_config("t20013");
using namespace clanguml::test;
auto diagram = config.diagrams["t20013_sequence"];
auto [config, db, diagram, model] =
CHECK_SEQUENCE_MODEL("t20013", "t20013_sequence");
REQUIRE(diagram->name == "t20013_sequence");
CHECK_SEQUENCE_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(MessageOrder(src,
{
//
{"tmain(int,char **)", "B", "b(int)"}, //
{"B", "A", "a1(int)"}, //
auto model = generate_sequence_diagram(*db, diagram);
{"tmain(int,char **)", "B", "b(double)"}, //
{"B", "A", "a2(double)"}, //
REQUIRE(model->name() == "t20013_sequence");
{"tmain(int,char **)", "B", "b(const char *)"}, //
{"B", "A", "a3(const char *)"} //
}));
});
/*
{
auto src = generate_sequence_puml(diagram, *model);
AliasMatcher _A(src);
@@ -85,5 +96,5 @@ TEST_CASE("t20013", "[test-case][sequence]")
REQUIRE_THAT(src, HasCall(_A("B"), _A("A"), "a3(const char *)"));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}
}*/
}

26
tests/t20014/test_case.h
View File

@@ -16,17 +16,28 @@
* limitations under the License.
*/
TEST_CASE("t20014", "[test-case][sequence]")
TEST_CASE("t20014")
{
auto [config, db] = load_config("t20014");
using namespace clanguml::test;
auto diagram = config.diagrams["t20014_sequence"];
auto [config, db, diagram, model] =
CHECK_SEQUENCE_MODEL("t20014", "t20014_sequence");
REQUIRE(diagram->name == "t20014_sequence");
CHECK_SEQUENCE_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(MessageOrder(src,
{
//
{"tmain()", "B", "b1(int,int)"}, //
{"B", "A", "a1(int,int)"}, //
auto model = generate_sequence_diagram(*db, diagram);
{"tmain()", "B", "b2(int,int)"}, //
{"B", "A", "a2(int,int)"}, //
REQUIRE(model->name() == "t20014_sequence");
{"tmain()", "C<B,int>", "c1(int,int)"}, //
{"C<B,int>", "B", "b1(int,int)"}, //
}));
});
/*
{
auto src = generate_sequence_puml(diagram, *model);
AliasMatcher _A(src);
@@ -84,4 +95,5 @@ TEST_CASE("t20014", "[test-case][sequence]")
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}
}
*/
}

105
tests/t20015/test_case.h
View File

@@ -16,69 +16,82 @@
* limitations under the License.
*/
TEST_CASE("t20015", "[test-case][sequence]")
TEST_CASE("t20015")
{
auto [config, db] = load_config("t20015");
using namespace clanguml::test;
auto diagram = config.diagrams["t20015_sequence"];
auto [config, db, diagram, model] =
CHECK_SEQUENCE_MODEL("t20015", "t20015_sequence");
REQUIRE(diagram->name == "t20015_sequence");
CHECK_SEQUENCE_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(MessageOrder(src,
{
{"tmain()", "B", "setup_a(std::shared_ptr<detail::A> &)"} //
}));
auto model = generate_sequence_diagram(*db, diagram);
REQUIRE(!HasMessage(src, {"B", {"detail", "A"}, "set_x(int)"}));
REQUIRE(!HasMessage(src, {"B", {"detail" ,"A"}, "set_y(int)"}));
REQUIRE(!HasMessage(src, {"B", {"detail", "A"}, "set_z(int)"}));
REQUIRE(model->name() == "t20015_sequence");
{
auto src = generate_sequence_puml(diagram, *model);
AliasMatcher _A(src);
REQUIRE(!HasMessage(src, {"B", "B", "set_x(int)"}));
REQUIRE(!HasMessage(src, {"B", "B", "set_y(int)"}));
REQUIRE(!HasMessage(src, {"B", "B", "set_z(int)"}));
});
/*
{
auto src = generate_sequence_puml(diagram, *model);
AliasMatcher _A(src);
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, 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()"), _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)"));
// Check if all calls exist
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)"));
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", src);
}
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
{
auto j = generate_sequence_json(diagram, *model);
{
auto j = generate_sequence_json(diagram, *model);
using namespace json;
using namespace json;
std::vector<int> messages = {FindMessage(
j, "tmain()", "B", "setup_a(std::shared_ptr<detail::A> &)")};
std::vector<int> messages = {FindMessage(
j, "tmain()", "B", "setup_a(std::shared_ptr<detail::A> &)")};
REQUIRE(std::is_sorted(messages.begin(), messages.end()));
REQUIRE(std::is_sorted(messages.begin(), messages.end()));
save_json(config.output_directory(), diagram->name + ".json", j);
}
save_json(config.output_directory(), diagram->name + ".json", j);
}
{
auto src = generate_sequence_mermaid(diagram, *model);
{
auto src = generate_sequence_mermaid(diagram, *model);
mermaid::SequenceDiagramAliasMatcher _A(src);
using mermaid::HasCall;
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("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)"));
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);
}
save_mermaid(config.output_directory(), diagram->name + ".mmd",
src);
}
*/
}

97
tests/t20016/test_case.h
View File

@@ -16,62 +16,77 @@
* limitations under the License.
*/
TEST_CASE("t20016", "[test-case][sequence]")
TEST_CASE("t20016")
{
auto [config, db] = load_config("t20016");
using namespace clanguml::test;
auto diagram = config.diagrams["t20016_sequence"];
auto [config, db, diagram, model] =
CHECK_SEQUENCE_MODEL("t20016", "t20016_sequence");
REQUIRE(diagram->name == "t20016_sequence");
CHECK_SEQUENCE_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(MessageOrder(src,
{
//
{"tmain()", "B<long>", "b1(long)"}, //
{"B<long>", "A", "a1(int)"}, //
{"tmain()", "B<long>", "b2(long)"}, //
{"B<long>", "A", "a2(const long &)"} //
}));
});
/*
{
auto src = generate_sequence_puml(diagram, *model);
AliasMatcher _A(src);
auto model = generate_sequence_diagram(*db, diagram);
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
REQUIRE(model->name() == "t20016_sequence");
{
auto src = generate_sequence_puml(diagram, *model);
AliasMatcher _A(src);
// Check if all calls exist
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, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B<long>"),
"b2(long)")); REQUIRE_THAT(src, HasCall(_A("B<long>"), _A("A"),
"a2(const long &)"));
// Check if all calls exist
REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B<long>"), "b1(long)"));
REQUIRE_THAT(src, HasCall(_A("B<long>"), _A("A"), "a1(int)"));
save_puml(config.output_directory(), diagram->name + ".puml",
src);
}
REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B<long>"), "b2(long)"));
REQUIRE_THAT(src, HasCall(_A("B<long>"), _A("A"), "a2(const long &)"));
{
auto j = generate_sequence_json(diagram, *model);
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
using namespace json;
{
auto j = generate_sequence_json(diagram, *model);
std::vector<int> messages = {
FindMessage(j, "tmain()", "B<long>", "b1(long)"),
FindMessage(j, "B<long>", "A", "a1(int)"),
FindMessage(j, "tmain()", "B<long>", "b2(long)"),
FindMessage(j, "B<long>", "A", "a2(const long &)")};
using namespace json;
REQUIRE(std::is_sorted(messages.begin(), messages.end()));
std::vector<int> messages = {
FindMessage(j, "tmain()", "B<long>", "b1(long)"),
FindMessage(j, "B<long>", "A", "a1(int)"),
FindMessage(j, "tmain()", "B<long>", "b2(long)"),
FindMessage(j, "B<long>", "A", "a2(const long &)")};
save_json(config.output_directory(), diagram->name + ".json",
j);
}
REQUIRE(std::is_sorted(messages.begin(), messages.end()));
{
auto src = generate_sequence_mermaid(diagram, *model);
save_json(config.output_directory(), diagram->name + ".json", j);
}
mermaid::SequenceDiagramAliasMatcher _A(src);
using mermaid::HasCall;
{
auto src = generate_sequence_mermaid(diagram, *model);
REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B<long>"),
"b1(long)")); REQUIRE_THAT(src, HasCall(_A("B<long>"), _A("A"),
"a1(int)"));
mermaid::SequenceDiagramAliasMatcher _A(src);
using mermaid::HasCall;
REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B<long>"),
"b2(long)")); REQUIRE_THAT(src, HasCall(_A("B<long>"), _A("A"),
"a2(const long &)"));
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);
}
save_mermaid(config.output_directory(), diagram->name + ".mmd",
src);
}
*/
}

28
tests/t20017/test_case.h
View File

@@ -16,17 +16,27 @@
* limitations under the License.
*/
TEST_CASE("t20017", "[test-case][sequence]")
TEST_CASE("t20017")
{
auto [config, db] = load_config("t20017");
using namespace clanguml::test;
auto diagram = config.diagrams["t20017_sequence"];
auto [config, db, diagram, model] =
CHECK_SEQUENCE_MODEL("t20017", "t20017_sequence");
REQUIRE(diagram->name == "t20017_sequence");
auto model = generate_sequence_diagram(*db, diagram);
REQUIRE(model->name() == "t20017_sequence");
CHECK_SEQUENCE_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(MessageOrder(src,
{
//
// {Entrypoint{}, "t20017.cc", "tmain()"}, //
{"t20017.cc", "include/t20017_a.h", "a3(int,int)"}, //
{"t20017.cc", "include/t20017_b.h", "b1(int,int)"}, //
/* {"t20017.cc", "include/t20017_a.h", "a2(int,int)"}, //
{"t20017.cc", "include/t20017_a.h", "a1(int,int)"}, //
{"t20017.cc", "include/t20017_b.h", "b2<int>(int,int)"}, //
{Exitpoint{}, "t20017.cc"}, //*/
}));
});
/*
{
auto src = generate_sequence_puml(diagram, *model);
AliasMatcher _A(src);
@@ -105,5 +115,5 @@ TEST_CASE("t20017", "[test-case][sequence]")
REQUIRE_THAT(src, HasExitpoint(_A("t20017.cc")));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}
}*/
}

147
tests/t20018/test_case.h
View File

@@ -16,88 +16,97 @@
* limitations under the License.
*/
TEST_CASE("t20018", "[test-case][sequence]")
TEST_CASE("t20018")
{
auto [config, db] = load_config("t20018");
using namespace clanguml::test;
auto diagram = config.diagrams["t20018_sequence"];
auto [config, db, diagram, model] =
CHECK_SEQUENCE_MODEL("t20018", "t20018_sequence");
REQUIRE(diagram->name == "t20018_sequence");
CHECK_SEQUENCE_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(MessageOrder(src,
{
//
{"tmain()", "Answer<Factorial<5>,120>", "print()", Static{}}, //
{"Answer<Factorial<5>,120>", "Factorial<5>", "print(int)",
Static{}}, //
{"Factorial<5>", "Factorial<4>", "print(int)", Static{}}, //
{"Factorial<4>", "Factorial<3>", "print(int)", Static{}}, //
{"Factorial<3>", "Factorial<2>", "print(int)", Static{}}, //
{"Factorial<2>", "Factorial<1>", "print(int)", Static{}}, //
{"Factorial<1>", "Factorial<0>", "print(int)", Static{}}, //
}));
});
/*
{
auto src = generate_sequence_puml(diagram, *model);
AliasMatcher _A(src);
auto model = generate_sequence_diagram(*db, diagram);
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
REQUIRE(model->name() == "t20018_sequence");
// Check if all calls exist
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)__"));
{
auto src = generate_sequence_puml(diagram, *model);
AliasMatcher _A(src);
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
{
auto j = generate_sequence_json(diagram, *model);
// Check if all calls exist
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)__"));
using namespace json;
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
std::vector<int> messages = {
FindMessage(j, "tmain()", "Answer<Factorial<5>,120>",
"print()"), FindMessage( j, "Answer<Factorial<5>,120>", "Factorial<5>",
"print(int)"), FindMessage(j, "Factorial<5>", "Factorial<4>",
"print(int)"), FindMessage(j, "Factorial<4>", "Factorial<3>",
"print(int)"), FindMessage(j, "Factorial<3>", "Factorial<2>",
"print(int)"), FindMessage(j, "Factorial<2>", "Factorial<1>",
"print(int)"), FindMessage(j, "Factorial<1>", "Factorial<0>",
"print(int)")};
{
auto j = generate_sequence_json(diagram, *model);
REQUIRE(std::is_sorted(messages.begin(), messages.end()));
using namespace json;
save_json(config.output_directory(), diagram->name + ".json", j);
}
std::vector<int> messages = {
FindMessage(j, "tmain()", "Answer<Factorial<5>,120>", "print()"),
FindMessage(
j, "Answer<Factorial<5>,120>", "Factorial<5>", "print(int)"),
FindMessage(j, "Factorial<5>", "Factorial<4>", "print(int)"),
FindMessage(j, "Factorial<4>", "Factorial<3>", "print(int)"),
FindMessage(j, "Factorial<3>", "Factorial<2>", "print(int)"),
FindMessage(j, "Factorial<2>", "Factorial<1>", "print(int)"),
FindMessage(j, "Factorial<1>", "Factorial<0>", "print(int)")};
{
auto src = generate_sequence_mermaid(diagram, *model);
REQUIRE(std::is_sorted(messages.begin(), messages.end()));
mermaid::SequenceDiagramAliasMatcher _A(src);
using mermaid::HasCall;
save_json(config.output_directory(), diagram->name + ".json", j);
}
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)"));
{
auto src = generate_sequence_mermaid(diagram, *model);
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);
}
save_mermaid(config.output_directory(), diagram->name + ".mmd",
src);
}
*/
}

25
tests/t20019/test_case.h
View File

@@ -16,18 +16,24 @@
* limitations under the License.
*/
TEST_CASE("t20019", "[test-case][sequence]")
TEST_CASE("t20019")
{
auto [config, db] = load_config("t20019");
using namespace clanguml::test;
auto diagram = config.diagrams["t20019_sequence"];
REQUIRE(diagram->name == "t20019_sequence");
auto model = generate_sequence_diagram(*db, diagram);
REQUIRE(model->name() == "t20019_sequence");
auto [config, db, diagram, model] =
CHECK_SEQUENCE_MODEL("t20019", "t20019_sequence");
CHECK_SEQUENCE_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(MessageOrder(src,
{
//
{"tmain()", "Base<D1>", "name()"}, //
{"Base<D1>", "D1", "impl()"}, //
{"tmain()", "Base<D2>", "name()"}, //
{"Base<D2>", "D2", "impl()"} //
}));
});
/*
{
auto src = generate_sequence_puml(diagram, *model);
AliasMatcher _A(src);
@@ -73,4 +79,5 @@ TEST_CASE("t20019", "[test-case][sequence]")
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}
*/
}

160
tests/t20020/test_case.h
View File

@@ -16,95 +16,115 @@
* limitations under the License.
*/
TEST_CASE("t20020", "[test-case][sequence]")
TEST_CASE("t20020")
{
auto [config, db] = load_config("t20020");
using namespace clanguml::test;
auto diagram = config.diagrams["t20020_sequence"];
auto [config, db, diagram, model] =
CHECK_SEQUENCE_MODEL("t20020", "t20020_sequence");
REQUIRE(diagram->name == "t20020_sequence");
CHECK_SEQUENCE_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(MessageOrder(src,
{
//
{"tmain()", "A", "a1()"}, //
{"tmain()", "A", "a5()"}, //
{"tmain()", "A", "a2()", InControlCondition{}}, //
{"tmain()", "C", "c3(int)", InControlCondition{}}, //
{"tmain()", "B", "b1()"}, //
{"tmain()", "A", "a3()", InControlCondition{}}, //
{"tmain()", "B", "b2()"}, //
{"tmain()", "A", "a4()"}, //
{"tmain()", "B", "log()"}, //
{"tmain()", "C", "c1() const"}, //
{"C", "C", "c2() const", InControlCondition{}}, //
{"C", "C", "log() const"}, //
{"tmain()", "D<int>", "d1(int,int)"}, //
}));
});
/*
{
auto src = generate_sequence_puml(diagram, *model);
AliasMatcher _A(src);
auto model = generate_sequence_diagram(*db, diagram);
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
REQUIRE(model->name() == "t20020_sequence");
{
auto src = generate_sequence_puml(diagram, *model);
AliasMatcher _A(src);
// Check if all calls exist
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, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
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()"));
// Check if all calls exist
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("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, 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, HasCallInControlCondition(_A("tmain()"), _A("C"),
"c3(int)"));
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"));
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
REQUIRE_THAT(
src, HasCallInControlCondition(_A("tmain()"), _A("C"), "c3(int)"));
{
auto j = generate_sequence_json(diagram, *model);
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
using namespace json;
{
auto j = generate_sequence_json(diagram, *model);
std::vector<int> messages = {FindMessage(j, "tmain()", "A", "a1()"),
FindMessage(j, "tmain()", "A", "a5()"),
FindMessage(j, "tmain()", "A", "a2()"),
FindMessage(j, "tmain()", "C", "c3(int)"),
FindMessage(j, "tmain()", "B", "b1()"),
FindMessage(j, "tmain()", "A", "a3()"),
FindMessage(j, "tmain()", "B", "b2()"),
FindMessage(j, "tmain()", "A", "a4()"),
FindMessage(j, "tmain()", "B", "log()"),
FindMessage(j, "tmain()", "C", "c1() const"),
FindMessage(j, "C", "C", "c2() const"),
FindMessage(j, "C", "C", "log() const"),
FindMessage(j, "tmain()", "D<int>", "d1(int,int)")};
using namespace json;
REQUIRE(std::is_sorted(messages.begin(), messages.end()));
std::vector<int> messages = {FindMessage(j, "tmain()", "A", "a1()"),
FindMessage(j, "tmain()", "A", "a5()"),
FindMessage(j, "tmain()", "A", "a2()"),
FindMessage(j, "tmain()", "C", "c3(int)"),
FindMessage(j, "tmain()", "B", "b1()"),
FindMessage(j, "tmain()", "A", "a3()"),
FindMessage(j, "tmain()", "B", "b2()"),
FindMessage(j, "tmain()", "A", "a4()"),
FindMessage(j, "tmain()", "B", "log()"),
FindMessage(j, "tmain()", "C", "c1() const"),
FindMessage(j, "C", "C", "c2() const"),
FindMessage(j, "C", "C", "log() const"),
FindMessage(j, "tmain()", "D<int>", "d1(int,int)")};
save_json(config.output_directory(), diagram->name + ".json", j);
}
REQUIRE(std::is_sorted(messages.begin(), messages.end()));
{
auto src = generate_sequence_mermaid(diagram, *model);
save_json(config.output_directory(), diagram->name + ".json", j);
}
mermaid::SequenceDiagramAliasMatcher _A(src);
using mermaid::HasCall;
using mermaid::HasCallInControlCondition;
{
auto src = generate_sequence_mermaid(diagram, *model);
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()"));
mermaid::SequenceDiagramAliasMatcher _A(src);
using mermaid::HasCall;
using mermaid::HasCallInControlCondition;
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("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("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, 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, HasCallInControlCondition(_A("tmain()"), _A("C"),
"c3(int)"));
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);
}
save_mermaid(config.output_directory(), diagram->name + ".mmd",
src);
}
*/
}

32
tests/t20021/test_case.h
View File

@@ -16,17 +16,31 @@
* limitations under the License.
*/
TEST_CASE("t20021", "[test-case][sequence]")
TEST_CASE("t20021")
{
auto [config, db] = load_config("t20021");
using namespace clanguml::test;
auto diagram = config.diagrams["t20021_sequence"];
auto [config, db, diagram, model] =
CHECK_SEQUENCE_MODEL("t20021", "t20021_sequence");
REQUIRE(diagram->name == "t20021_sequence");
auto model = generate_sequence_diagram(*db, diagram);
REQUIRE(model->name() == "t20021_sequence");
CHECK_SEQUENCE_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(MessageOrder(src,
{
//
{"tmain()", "C", "c4()", InControlCondition{}}, //
{"C", "C", "c5()"}, //
{"tmain()", "A", "a3()"}, //
{"tmain()", "A", "a2()", InControlCondition{}}, //
{"tmain()", "C", "c1()", InControlCondition{}}, //
{"tmain()", "C", "c2()", InControlCondition{}}, //
{"tmain()", "A", "a1()"}, //
{"tmain()", "C", "c3()", InControlCondition{}}, //
{"tmain()", "B", "b2() const"}, //
{"tmain()", "C", "contents()", InControlCondition{}}, //
{"tmain()", "B", "b2() const"}, //
}));
});
/*
{
auto src = generate_sequence_puml(diagram, *model);
AliasMatcher _A(src);
@@ -113,5 +127,5 @@ TEST_CASE("t20021", "[test-case][sequence]")
HasCallInControlCondition(_A("tmain()"), _A("C"), "contents()"));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}
}*/
}

77
tests/t20022/test_case.h
View File

@@ -16,53 +16,64 @@
* limitations under the License.
*/
TEST_CASE("t20022", "[test-case][sequence]")
TEST_CASE("t20022")
{
auto [config, db] = load_config("t20022");
using namespace clanguml::test;
auto diagram = config.diagrams["t20022_sequence"];
auto [config, db, diagram, model] =
CHECK_SEQUENCE_MODEL("t20022", "t20022_sequence");
REQUIRE(diagram->name == "t20022_sequence");
CHECK_SEQUENCE_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(MessageOrder(src,
{
//
// TODO: "<B>)" is incorrently rendered by PlantUML
// in a way that ) is bold, if it was <A>) it's rendered
// properly
{"tmain()", "A", "A(std::unique_ptr<B>)"}, //
{"tmain()", "A", "a()"}, //
{"A", "B", "b()"}, //
}));
});
auto model = generate_sequence_diagram(*db, diagram);
/*
{
auto src = generate_sequence_puml(diagram, *model);
AliasMatcher _A(src);
REQUIRE(model->name() == "t20022_sequence");
{
auto src = generate_sequence_puml(diagram, *model);
AliasMatcher _A(src);
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, 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()"), _A("A"), "a()"));
REQUIRE_THAT(src, HasCall(_A("A"), _A("B"), "b()"));
// Check if all calls exist
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", src);
}
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
{
auto j = generate_sequence_json(diagram, *model);
{
auto j = generate_sequence_json(diagram, *model);
using namespace json;
using namespace json;
std::vector<int> messages = {FindMessage(j, "tmain()", "A", "a()"),
FindMessage(j, "A", "B", "b()")};
std::vector<int> messages = {FindMessage(j, "tmain()", "A", "a()"),
FindMessage(j, "A", "B", "b()")};
REQUIRE(std::is_sorted(messages.begin(), messages.end()));
REQUIRE(std::is_sorted(messages.begin(), messages.end()));
save_json(config.output_directory(), diagram->name + ".json", j);
}
save_json(config.output_directory(), diagram->name + ".json", j);
}
{
auto src = generate_sequence_mermaid(diagram, *model);
{
auto src = generate_sequence_mermaid(diagram, *model);
mermaid::SequenceDiagramAliasMatcher _A(src);
using mermaid::HasCall;
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()"));
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);
}
save_mermaid(config.output_directory(), diagram->name + ".mmd",
src);
}*/
}

92
tests/t20023/test_case.h
View File

@@ -16,60 +16,72 @@
* limitations under the License.
*/
TEST_CASE("t20023", "[test-case][sequence]")
TEST_CASE("t20023")
{
auto [config, db] = load_config("t20023");
using namespace clanguml::test;
auto diagram = config.diagrams["t20023_sequence"];
auto [config, db, diagram, model] =
CHECK_SEQUENCE_MODEL("t20023", "t20023_sequence");
REQUIRE(diagram->name == "t20023_sequence");
CHECK_SEQUENCE_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(MessageOrder(src,
{
//
{"tmain()", "A", "a()"}, //
{"A", "A", "a2()"}, //
{"A", "A", "a2()"}, //
{"A", "A", "a3()"}, //
{"A", "A", "a4()"}, //
auto model = generate_sequence_diagram(*db, diagram);
}));
});
/*
{
auto src = generate_sequence_puml(diagram, *model);
AliasMatcher _A(src);
REQUIRE(model->name() == "t20023_sequence");
{
auto src = generate_sequence_puml(diagram, *model);
AliasMatcher _A(src);
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, 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()"), _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()"));
// Check if all calls exist
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", src);
}
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
{
auto j = generate_sequence_json(diagram, *model);
{
auto j = generate_sequence_json(diagram, *model);
using namespace json;
using namespace json;
std::vector<int> messages = {FindMessage(j, "tmain()", "A", "a()"),
FindMessage(j, "A", "A", "a1()"), FindMessage(j, "A", "A",
"a2()"), FindMessage(j, "A", "A", "a3()"), FindMessage(j, "A", "A",
"a4()")};
std::vector<int> messages = {FindMessage(j, "tmain()", "A", "a()"),
FindMessage(j, "A", "A", "a1()"), FindMessage(j, "A", "A", "a2()"),
FindMessage(j, "A", "A", "a3()"), FindMessage(j, "A", "A", "a4()")};
REQUIRE(std::is_sorted(messages.begin(), messages.end()));
REQUIRE(std::is_sorted(messages.begin(), messages.end()));
save_json(config.output_directory(), diagram->name + ".json", j);
}
save_json(config.output_directory(), diagram->name + ".json", j);
}
{
auto src = generate_sequence_mermaid(diagram, *model);
{
auto src = generate_sequence_mermaid(diagram, *model);
mermaid::SequenceDiagramAliasMatcher _A(src);
using mermaid::HasCall;
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()"));
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);
}
save_mermaid(config.output_directory(), diagram->name + ".mmd",
src);
}
*/
}

30
tests/t20024/test_case.h
View File

@@ -16,17 +16,31 @@
* limitations under the License.
*/
TEST_CASE("t20024", "[test-case][sequence]")
TEST_CASE("t20024")
{
auto [config, db] = load_config("t20024");
using namespace clanguml::test;
auto diagram = config.diagrams["t20024_sequence"];
auto [config, db, diagram, model] =
CHECK_SEQUENCE_MODEL("t20024", "t20024_sequence");
REQUIRE(diagram->name == "t20024_sequence");
CHECK_SEQUENCE_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(MessageOrder(src,
{
//
{"tmain()", "A", "select(enum_a)"}, //
{"A", "A", "a0()"}, //
{"A", "A", "a1()"}, //
{"A", "A", "a2()"}, //
{"A", "A", "a3()"}, //
auto model = generate_sequence_diagram(*db, diagram);
REQUIRE(model->name() == "t20024_sequence");
{"tmain()", "B", "select(colors)"}, //
{"B", "B", "red()"}, //
{"B", "B", "orange()"}, //
{"B", "B", "green()"}, //
{"B", "B", "grey()"} //
}));
});
/*
{
auto src = generate_sequence_puml(diagram, *model);
AliasMatcher _A(src);
@@ -82,5 +96,5 @@ TEST_CASE("t20024", "[test-case][sequence]")
REQUIRE_THAT(src, HasCall(_A("B"), _A("B"), "green()"));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}
}*/
}

23
tests/t20025/test_case.h
View File

@@ -16,17 +16,22 @@
* limitations under the License.
*/
TEST_CASE("t20025", "[test-case][sequence]")
TEST_CASE("t20025")
{
auto [config, db] = load_config("t20025");
using namespace clanguml::test;
auto diagram = config.diagrams["t20025_sequence"];
auto [config, db, diagram, model] =
CHECK_SEQUENCE_MODEL("t20025", "t20025_sequence");
REQUIRE(diagram->name == "t20025_sequence");
auto model = generate_sequence_diagram(*db, diagram);
REQUIRE(model->name() == "t20025_sequence");
CHECK_SEQUENCE_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(MessageOrder(src,
{
//
{"tmain()", "A", "a()"}, //
{"tmain()", "add(int,int)", ""} //
}));
});
/*
{
auto src = generate_sequence_puml(diagram, *model);
AliasMatcher _A(src);
@@ -71,5 +76,5 @@ TEST_CASE("t20025", "[test-case][sequence]")
REQUIRE_THAT(src, !HasCall(_A("tmain()"), _A("add2(int,int)"), ""));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}
}*/
}

22
tests/t20026/test_case.h
View File

@@ -16,17 +16,21 @@
* limitations under the License.
*/
TEST_CASE("t20026", "[test-case][sequence]")
TEST_CASE("t20026")
{
auto [config, db] = load_config("t20026");
using namespace clanguml::test;
auto diagram = config.diagrams["t20026_sequence"];
auto [config, db, diagram, model] =
CHECK_SEQUENCE_MODEL("t20026", "t20026_sequence");
REQUIRE(diagram->name == "t20026_sequence");
auto model = generate_sequence_diagram(*db, diagram);
REQUIRE(model->name() == "t20026_sequence");
CHECK_SEQUENCE_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(MessageOrder(src,
{
//
{"tmain()", "A", "a()"} //
}));
});
/*
{
auto src = generate_sequence_puml(diagram, *model);
AliasMatcher _A(src);
@@ -61,5 +65,5 @@ TEST_CASE("t20026", "[test-case][sequence]")
REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("A"), "a()"));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}
}*/
}

22
tests/t20027/test_case.h
View File

@@ -16,17 +16,25 @@
* limitations under the License.
*/
TEST_CASE("t20027", "[test-case][sequence]")
TEST_CASE("t20027")
{
auto [config, db] = load_config("t20027");
using namespace clanguml::test;
auto diagram = config.diagrams["t20027_sequence"];
auto [config, db, diagram, model] =
CHECK_SEQUENCE_MODEL("t20027", "t20027_sequence");
REQUIRE(diagram->name == "t20027_sequence");
CHECK_SEQUENCE_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(MessageOrder(src,
{
//
{"tmain()", "A", "a()"} //
}));
auto model = generate_sequence_diagram(*db, diagram);
REQUIRE(!HasMessage(src, {"A", "A", "aa()"}));
REQUIRE(!HasMessage(src, {"A", "A", "aaa()"}));
});
REQUIRE(model->name() == "t20027_sequence");
/*
{
auto src = generate_sequence_puml(diagram, *model);
AliasMatcher _A(src);
@@ -65,5 +73,5 @@ TEST_CASE("t20027", "[test-case][sequence]")
REQUIRE_THAT(src, !HasCall(_A("A"), _A("A"), "aaa()"));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}
}*/
}

24
tests/t20028/test_case.h
View File

@@ -16,17 +16,27 @@
* limitations under the License.
*/
TEST_CASE("t20028", "[test-case][sequence]")
TEST_CASE("t20028")
{
auto [config, db] = load_config("t20028");
using namespace clanguml::test;
auto diagram = config.diagrams["t20028_sequence"];
auto [config, db, diagram, model] =
CHECK_SEQUENCE_MODEL("t20028", "t20028_sequence");
REQUIRE(diagram->name == "t20028_sequence");
CHECK_SEQUENCE_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(MessageOrder(src,
{
//
{"tmain()", "A", "a()", InControlCondition{}}, //
{"tmain()", "A", "b()"}, //
{"tmain()", "A", "c()"}, //
{"tmain()", "A", "d()"}, //
}));
auto model = generate_sequence_diagram(*db, diagram);
REQUIRE(!HasMessage(src, {"tmain()", "B", "e()"}));
});
REQUIRE(model->name() == "t20028_sequence");
/*
{
auto src = generate_sequence_puml(diagram, *model);
AliasMatcher _A(src);
@@ -75,5 +85,5 @@ TEST_CASE("t20028", "[test-case][sequence]")
REQUIRE_THAT(src, !HasCall(_A("tmain()"), _A("B"), "e()"));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}
}*/
}

249
tests/t20029/test_case.h
View File

@@ -16,143 +16,182 @@
* limitations under the License.
*/
TEST_CASE("t20029", "[test-case][sequence]")
TEST_CASE("t20029")
{
auto [config, db] = load_config("t20029");
using namespace clanguml::test;
auto diagram = config.diagrams["t20029_sequence"];
auto [config, db, diagram, model] =
CHECK_SEQUENCE_MODEL("t20029", "t20029_sequence");
REQUIRE(diagram->name == "t20029_sequence");
CHECK_SEQUENCE_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(MessageOrder(src,
{
//
{"tmain()", "ConnectionPool", "connect()"}, //
{"tmain()", "Encoder<Retrier<ConnectionPool>>",
"send(std::string &&)", InControlCondition{}}, //
{"Encoder<Retrier<ConnectionPool>>",
"Encoder<Retrier<ConnectionPool>>",
"encode(std::string &&)"}, //
{"Encoder<Retrier<ConnectionPool>>",
"encode_b64(std::string &&)", ""}, //
{"Encoder<Retrier<ConnectionPool>>", "Retrier<ConnectionPool>",
"send(std::string &&)"}, //
{"Retrier<ConnectionPool>", "ConnectionPool",
"send(const std::string &)", InControlCondition{}} //
}));
auto model = generate_sequence_diagram(*db, diagram);
REQUIRE(!HasMessage(
src, {"ConnectionPool", "ConnectionPool", "connect_impl()"}));
REQUIRE(model->name() == "t20029_sequence");
{
auto src = generate_sequence_puml(diagram, *model);
AliasMatcher _A(src);
REQUIRE(HasMessageComment(src, "tmain()",
"Establish connection to the\\n"
"remote server synchronously"));
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
REQUIRE(HasMessageComment(src, "tmain()",
"Repeat for each line in the\\n"
"input stream"));
// Check if all calls exist
REQUIRE_THAT(
src, HasCall(_A("tmain()"), _A("ConnectionPool"), "connect()"));
REQUIRE_THAT(src,
HasCallInControlCondition(_A("tmain()"),
_A("Encoder<Retrier<ConnectionPool>>"),
"send(std::string &&)"));
REQUIRE(HasMessageComment(src, "Encoder<Retrier<ConnectionPool>>",
"Encode the message using\\n"
"Base64 encoding and pass\\n"
"it to the next layer"));
REQUIRE_THAT(src,
HasCall(_A("Encoder<Retrier<ConnectionPool>>"),
_A("Encoder<Retrier<ConnectionPool>>"),
"encode(std::string &&)"));
REQUIRE(HasMessageComment(src, "Retrier<ConnectionPool>",
"Repeat until send() succeeds\\n"
"or retry count is exceeded"));
});
/*
{
auto src = generate_sequence_puml(diagram, *model);
AliasMatcher _A(src);
REQUIRE_THAT(src,
HasCall(_A("Encoder<Retrier<ConnectionPool>>"),
_A("encode_b64(std::string &&)"), ""));
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
REQUIRE_THAT(src,
HasCallInControlCondition(_A("Retrier<ConnectionPool>"),
_A("ConnectionPool"), "send(const std::string &)"));
// Check if all calls exist
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("ConnectionPool"), _A("ConnectionPool"), "connect_impl()"));
REQUIRE_THAT(src,
HasCall(_A("Encoder<Retrier<ConnectionPool>>"),
_A("Encoder<Retrier<ConnectionPool>>"),
"encode(std::string &&)"));
REQUIRE_THAT(src,
HasMessageComment(_A("tmain()"),
"Establish connection to the\\n"
"remote server synchronously"));
REQUIRE_THAT(src,
HasCall(_A("Encoder<Retrier<ConnectionPool>>"),
_A("encode_b64(std::string &&)"), ""));
REQUIRE_THAT(src,
HasMessageComment(_A("tmain()"),
"Repeat for each line in the\\n"
"input stream"));
REQUIRE_THAT(src,
HasCallInControlCondition(_A("Retrier<ConnectionPool>"),
_A("ConnectionPool"), "send(const std::string &)"));
REQUIRE_THAT(src,
HasMessageComment(_A("Encoder<Retrier<ConnectionPool>>"),
"Encode the message using\\n"
"Base64 encoding and pass\\n"
"it to the next layer"));
REQUIRE_THAT(src,
!HasCall(
_A("ConnectionPool"), _A("ConnectionPool"),
"connect_impl()"));
REQUIRE_THAT(src,
HasMessageComment(_A("Retrier<ConnectionPool>"),
"Repeat until send\\(\\) succeeds\\n"
"or retry count is exceeded"));
REQUIRE_THAT(src,
HasMessageComment(_A("tmain()"),
"Establish connection to the\\n"
"remote server synchronously"));
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
REQUIRE_THAT(src,
HasMessageComment(_A("tmain()"),
"Repeat for each line in the\\n"
"input stream"));
{
auto j = generate_sequence_json(diagram, *model);
REQUIRE_THAT(src,
HasMessageComment(_A("Encoder<Retrier<ConnectionPool>>"),
"Encode the message using\\n"
"Base64 encoding and pass\\n"
"it to the next layer"));
using namespace json;
REQUIRE_THAT(src,
HasMessageComment(_A("Retrier<ConnectionPool>"),
"Repeat until send\\(\\) succeeds\\n"
"or retry count is exceeded"));
REQUIRE(!j["participants"].is_null());
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
std::vector<int> messages = {
FindMessage(j, "tmain()", "ConnectionPool", "connect()"),
FindMessage(j, "tmain()", "Encoder<Retrier<ConnectionPool>>",
"send(std::string &&)")};
{
auto j = generate_sequence_json(diagram, *model);
REQUIRE(std::is_sorted(messages.begin(), messages.end()));
using namespace json;
save_json(config.output_directory(), diagram->name + ".json", j);
}
REQUIRE(!j["participants"].is_null());
{
auto src = generate_sequence_mermaid(diagram, *model);
std::vector<int> messages = {
FindMessage(j, "tmain()", "ConnectionPool", "connect()"),
FindMessage(j, "tmain()", "Encoder<Retrier<ConnectionPool>>",
"send(std::string &&)")};
mermaid::SequenceDiagramAliasMatcher _A(src);
using mermaid::HasCall;
using mermaid::HasCallInControlCondition;
using mermaid::HasMessageComment;
REQUIRE(std::is_sorted(messages.begin(), messages.end()));
REQUIRE_THAT(
src, HasCall(_A("tmain()"), _A("ConnectionPool"), "connect()"));
REQUIRE_THAT(src,
HasCallInControlCondition(_A("tmain()"),
_A("Encoder<Retrier<ConnectionPool>>"),
"send(std::string &&)"));
save_json(config.output_directory(), diagram->name + ".json", j);
}
REQUIRE_THAT(src,
HasCall(_A("Encoder<Retrier<ConnectionPool>>"),
_A("Encoder<Retrier<ConnectionPool>>"),
"encode(std::string &&)"));
{
auto src = generate_sequence_mermaid(diagram, *model);
REQUIRE_THAT(src,
HasCall(_A("Encoder<Retrier<ConnectionPool>>"),
_A("encode_b64(std::string &&)"), ""));
mermaid::SequenceDiagramAliasMatcher _A(src);
using mermaid::HasCall;
using mermaid::HasCallInControlCondition;
using mermaid::HasMessageComment;
REQUIRE_THAT(src,
HasCallInControlCondition(_A("Retrier<ConnectionPool>"),
_A("ConnectionPool"), "send(const std::string &)"));
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("ConnectionPool"), _A("ConnectionPool"), "connect_impl()"));
REQUIRE_THAT(src,
HasCall(_A("Encoder<Retrier<ConnectionPool>>"),
_A("Encoder<Retrier<ConnectionPool>>"),
"encode(std::string &&)"));
REQUIRE_THAT(src,
HasMessageComment(_A("tmain()"),
"Establish connection to the<br/>"
"remote server synchronously"));
REQUIRE_THAT(src,
HasCall(_A("Encoder<Retrier<ConnectionPool>>"),
_A("encode_b64(std::string &&)"), ""));
REQUIRE_THAT(src,
HasMessageComment(_A("tmain()"),
"Repeat for each line in the<br/>"
"input stream"));
REQUIRE_THAT(src,
HasCallInControlCondition(_A("Retrier<ConnectionPool>"),
_A("ConnectionPool"), "send(const std::string &)"));
REQUIRE_THAT(src,
HasMessageComment(_A("Encoder<Retrier<ConnectionPool>>"),
"Encode the message using<br/>"
"Base64 encoding and pass<br/>"
"it to the next layer"));
REQUIRE_THAT(src,
!HasCall(
_A("ConnectionPool"), _A("ConnectionPool"),
"connect_impl()"));
REQUIRE_THAT(src,
HasMessageComment(_A("Retrier<ConnectionPool>"),
"Repeat until send\\(\\) succeeds<br/>"
"or retry count is exceeded"));
REQUIRE_THAT(src,
HasMessageComment(_A("tmain()"),
"Establish connection to the<br/>"
"remote server synchronously"));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}
REQUIRE_THAT(src,
HasMessageComment(_A("tmain()"),
"Repeat for each line in the<br/>"
"input stream"));
REQUIRE_THAT(src,
HasMessageComment(_A("Encoder<Retrier<ConnectionPool>>"),
"Encode the message using<br/>"
"Base64 encoding and pass<br/>"
"it to the next layer"));
REQUIRE_THAT(src,
HasMessageComment(_A("Retrier<ConnectionPool>"),
"Repeat until send\\(\\) succeeds<br/>"
"or retry count is exceeded"));
save_mermaid(config.output_directory(), diagram->name + ".mmd",
src);
}
*/
}

126
tests/t20030/test_case.h
View File

@@ -16,75 +16,93 @@
* limitations under the License.
*/
TEST_CASE("t20030", "[test-case][sequence]")
TEST_CASE("t20030")
{
auto [config, db] = load_config("t20030");
using namespace clanguml::test;
auto diagram = config.diagrams["t20030_sequence"];
auto [config, db, diagram, model] =
CHECK_SEQUENCE_MODEL("t20030", "t20030_sequence");
REQUIRE(diagram->name == "t20030_sequence");
CHECK_SEQUENCE_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(MessageOrder(src,
{
//
{"tmain(int)", "magic()", ""}, //
{"tmain(int)", "A", "A(int)"}, //
{"tmain(int)", "A", "operator+=(int)"}, //
{"A", "A", "add(int)"}, //
{"tmain(bool,int)", "A", "A()"}, //
// {"A", "A", "create()"}, //
// {"tmain(bool,int)", "A", "A()"}, //
// {"A", "A", "create()"}, //
// {"tmain(bool,int)", "A", "operator+=(int)"},
// //
// {"A", "A", "add(int)"}, //
// {"tmain(bool,int)", "A", "operator=(const A
// &)"}, //
// {"A", "A", "set(int)"}, //
// {"tmain(bool,int)", "A", "value() const"} //
}));
});
/*
{
auto src = generate_sequence_puml(diagram, *model);
AliasMatcher _A(src);
auto model = generate_sequence_diagram(*db, diagram);
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
REQUIRE(model->name() == "t20030_sequence");
// Check if all calls exist
REQUIRE_THAT(src, HasCall(_A("tmain(int)"), _A("magic()"), ""));
{
auto src = generate_sequence_puml(diagram, *model);
AliasMatcher _A(src);
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, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
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()"));
// Check if all calls exist
REQUIRE_THAT(src, HasCall(_A("tmain(int)"), _A("magic()"), ""));
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
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)"));
{
auto j = generate_sequence_json(diagram, *model);
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()"));
using namespace json;
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
save_json(config.output_directory(), diagram->name + ".json", j);
}
{
auto j = generate_sequence_json(diagram, *model);
{
auto src = generate_sequence_mermaid(diagram, *model);
using namespace json;
mermaid::SequenceDiagramAliasMatcher _A(src);
using mermaid::HasCall;
save_json(config.output_directory(), diagram->name + ".json", j);
}
REQUIRE_THAT(src, HasCall(_A("tmain(int)"), _A("magic()"), ""));
{
auto src = generate_sequence_mermaid(diagram, *model);
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)"));
mermaid::SequenceDiagramAliasMatcher _A(src);
using mermaid::HasCall;
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(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);
}
save_mermaid(config.output_directory(), diagram->name + ".mmd",
src);
}*/
}

26
tests/t20031/test_case.h
View File

@@ -16,18 +16,23 @@
* limitations under the License.
*/
TEST_CASE("t20031", "[test-case][sequence]")
TEST_CASE("t20031")
{
auto [config, db] = load_config("t20031");
using namespace clanguml::test;
auto diagram = config.diagrams["t20031_sequence"];
REQUIRE(diagram->name == "t20031_sequence");
auto model = generate_sequence_diagram(*db, diagram);
REQUIRE(model->name() == "t20031_sequence");
auto [config, db, diagram, model] =
CHECK_SEQUENCE_MODEL("t20031", "t20031_sequence");
CHECK_SEQUENCE_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(MessageOrder(src,
{
//
{"tmain(int)", "magic()", ""}, //
{"tmain(bool,int)", "execute(std::function<int ()>)", ""}, //
{"tmain(bool,int)", "A", "value() const"} //
}));
});
/*
{
auto src = generate_sequence_puml(diagram, *model);
AliasMatcher _A(src);
@@ -94,4 +99,5 @@ TEST_CASE("t20031", "[test-case][sequence]")
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}
}
*/
}

33
tests/t20032/test_case.h
View File

@@ -16,19 +16,34 @@
* limitations under the License.
*/
TEST_CASE("t20032", "[test-case][sequence]")
TEST_CASE("t20032")
{
auto [config, db] = load_config("t20032");
using namespace clanguml::test;
auto diagram = config.diagrams["t20032_sequence"];
auto [config, db, diagram, model] =
CHECK_SEQUENCE_MODEL("t20032", "t20032_sequence");
REQUIRE(diagram->name == "t20032_sequence");
CHECK_SEQUENCE_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(MessageOrder(src,
{
//
{"tmain(int,char **)", "B", "b(int)"}, //
{"B", "A", "a1(int)"}, //
{"A", "B", "int", Response{}}, //
{"B", "tmain(int,char **)", "int", Response{}}, //
auto model = generate_sequence_diagram(*db, diagram);
{"tmain(int,char **)", "B", "b(double)"}, //
{"B", "A", "a2(double)"}, //
{"A", "B", "double", Response{}}, //
{"B", "tmain(int,char **)", "double", Response{}}, //
REQUIRE(model->name() == "t20032_sequence");
REQUIRE(model->name() == "t20032_sequence");
{"tmain(int,char **)", "B", "b(const char *)"}, //
{"B", "A", "a3(const char *)"}, //
{"A", "B", "const char *", Response{}}, //
{"B", "tmain(int,char **)", "const char *", Response{}} //
}));
});
/*
{
auto src = generate_sequence_puml(diagram, *model);
AliasMatcher _A(src);
@@ -100,5 +115,5 @@ TEST_CASE("t20032", "[test-case][sequence]")
REQUIRE_THAT(src, HasResponse(_A("B"), _A("A"), "const char *"));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}
}*/
}

106
tests/t20033/test_case.h
View File

@@ -16,60 +16,86 @@
* limitations under the License.
*/
TEST_CASE("t20033", "[test-case][sequence]")
TEST_CASE("t20033")
{
auto [config, db] = load_config("t20033");
using namespace clanguml::test;
auto diagram = config.diagrams["t20033_sequence"];
auto [config, db, diagram, model] =
CHECK_SEQUENCE_MODEL("t20033", "t20033_sequence");
REQUIRE(diagram->name == "t20033_sequence");
CHECK_SEQUENCE_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(MessageOrder(src,
{
//
{"tmain()", "A", "a1()"}, //
{"tmain()", "A", "a2()"}, //
{"tmain()", "A", "a2()", InControlCondition{}}, //
{"tmain()", "A", "a3()", InControlCondition{}}, //
{"tmain()", "A", "a3()"}, //
{"tmain()", "A", "a4()"}, //
auto model = generate_sequence_diagram(*db, diagram);
{"tmain()", "A", "a2()", InControlCondition{}}, //
{"tmain()", "A", "a3()"}, //
REQUIRE(model->name() == "t20033_sequence");
{"tmain()", "A", "a2()", InControlCondition{}}, //
{"tmain()", "A", "a3()"}, //
{
auto src = generate_sequence_puml(diagram, *model);
AliasMatcher _A(src);
{"tmain()", "A", "a3()"}, //
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
{"tmain()", "A", "a2()"}, //
// Check if all calls exist
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()"));
{"tmain()", "A", "a4()"}, //
{"tmain()", "A", "a3()", InControlCondition{}}, //
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
{"tmain()", "A", "a4()", InControlCondition{}}, //
{
auto j = generate_sequence_json(diagram, *model);
{"tmain()", "A", "a4()"} //
}));
});
/*
{
auto src = generate_sequence_puml(diagram, *model);
AliasMatcher _A(src);
using namespace json;
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
save_json(config.output_directory(), diagram->name + ".json", j);
}
// Check if all calls exist
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()"));
{
auto src = generate_sequence_mermaid(diagram, *model);
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
mermaid::SequenceDiagramAliasMatcher _A(src);
using mermaid::HasCall;
using mermaid::HasCallInControlCondition;
{
auto j = generate_sequence_json(diagram, *model);
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()"));
using namespace json;
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}
save_json(config.output_directory(), diagram->name + ".json", j);
}
{
auto src = generate_sequence_mermaid(diagram, *model);
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);
}*/
}

158
tests/t20034/test_case.h
View File

@@ -16,79 +16,127 @@
* limitations under the License.
*/
TEST_CASE("t20034", "[test-case][sequence]")
TEST_CASE("t20034")
{
auto [config, db] = load_config("t20034");
using namespace clanguml::test;
auto diagram = config.diagrams["t20034_sequence"];
auto [config, db, diagram, model] =
CHECK_SEQUENCE_MODEL("t20034", "t20034_sequence");
REQUIRE(diagram->name == "t20034_sequence");
CHECK_SEQUENCE_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(MessageChainsOrder(src,
{
//
{
//
{Entrypoint{}, "D", "d2()"}, //
{"D", "C", "c2()"}, //
{"C", "B", "b2()"}, //
{"B", "A", "a2()"} //
}, //
{
//
{Entrypoint{}, "D", "d2()"}, //
{"D", "D::d2()::(lambda t20034.cc:56:18)",
"operator()() const"}, //
{"D::d2()::(lambda t20034.cc:56:18)", "A", "a2()"} //
}, //
{
//
{Entrypoint{}, "D", "d2()"}, //
{"D", "A", "a2()"} //
}, //
{
//
{Entrypoint{}, "D", "d2()"}, //
{"D", "C", "c4()"}, //
{"C", "B", "b4()"}, //
{"B", "B", "b2()"}, //
{"B", "A", "a2()"} //
}, //
{
//
{Entrypoint{}, "D", "d2()"}, //
{"D", "C", "c1()"}, //
{"C", "B", "b1()"}, //
{"B", "A", "a2()"} //
}, //
{
//
{Entrypoint{}, "D", "d2()"}, //
{"D", "C", "c3()"}, //
{"C", "C", "c2()"}, //
{"C", "B", "b2()"}, //
{"B", "A", "a2()"} //
} //
}));
});
/*
{
auto src = generate_sequence_puml(diagram, *model);
AliasMatcher _A(src);
auto model = generate_sequence_diagram(*db, diagram);
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
REQUIRE(model->name() == "t20034_sequence");
// Check if all calls exist
REQUIRE_THAT(src, HasCall(_A("D"), _A("A"), "a2()"));
{
auto src = generate_sequence_puml(diagram, *model);
AliasMatcher _A(src);
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, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
REQUIRE_THAT(src, HasCall(_A("D"), _A("C"), "c4()"));
// Check if all calls exist
REQUIRE_THAT(src, HasCall(_A("D"), _A("A"), "a2()"));
REQUIRE_THAT(src, !HasCall(_A("C"), _A("B"), "b3()"));
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()"));
save_puml(config.output_directory(), diagram->name +
".puml", src);
}
REQUIRE_THAT(src, HasCall(_A("D"), _A("C"), "c4()"));
{
auto j = generate_sequence_json(diagram, *model);
REQUIRE_THAT(src, !HasCall(_A("C"), _A("B"), "b3()"));
using namespace json;
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
REQUIRE(HasMessageChain(j,
{{"d2()", "c3()", "void"}, {"c3()", "c2()", "void"},
{"c2()", "b2()", "void"}, {"b2()", "a2()",
"void"}})); REQUIRE(HasMessageChain(j,
{{"d2()", "c4()", "void"}, {"c4()", "b4()", "void"},
{"b4()", "b2()", "void"}, {"b2()", "a2()",
"void"}})); REQUIRE(HasMessageChain(j, {{"d2()", "a2()",
"void"}})); REQUIRE(HasMessageChain(j,
{{"d2()", "c1()", "void"}, {"c1()", "b1()", "void"},
{"b1()", "a2()", "void"}}));
REQUIRE(HasMessageChain(j,
{{"d2()", "c2()", "void"}, {"c2()", "b2()", "void"},
{"b2()", "a2()", "void"}}));
{
auto j = generate_sequence_json(diagram, *model);
save_json(config.output_directory(), diagram->name +
".json", j);
}
using namespace json;
{
auto src = generate_sequence_mermaid(diagram, *model);
REQUIRE(HasMessageChain(j,
{{"d2()", "c3()", "void"}, {"c3()", "c2()", "void"},
{"c2()", "b2()", "void"}, {"b2()", "a2()", "void"}}));
REQUIRE(HasMessageChain(j,
{{"d2()", "c4()", "void"}, {"c4()", "b4()", "void"},
{"b4()", "b2()", "void"}, {"b2()", "a2()", "void"}}));
REQUIRE(HasMessageChain(j, {{"d2()", "a2()", "void"}}));
REQUIRE(HasMessageChain(j,
{{"d2()", "c1()", "void"}, {"c1()", "b1()", "void"},
{"b1()", "a2()", "void"}}));
REQUIRE(HasMessageChain(j,
{{"d2()", "c2()", "void"}, {"c2()", "b2()", "void"},
{"b2()", "a2()", "void"}}));
mermaid::SequenceDiagramAliasMatcher _A(src);
using mermaid::HasCall;
save_json(config.output_directory(), diagram->name + ".json", j);
}
REQUIRE_THAT(src, HasCall(_A("D"), _A("A"), "a2()"));
{
auto src = generate_sequence_mermaid(diagram, *model);
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()"));
mermaid::SequenceDiagramAliasMatcher _A(src);
using mermaid::HasCall;
REQUIRE_THAT(src, HasCall(_A("D"), _A("C"), "c4()"));
REQUIRE_THAT(src, HasCall(_A("D"), _A("A"), "a2()"));
REQUIRE_THAT(src, !HasCall(_A("C"), _A("B"), "b3()"));
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);
}
save_mermaid(config.output_directory(), diagram->name +
".mmd", src);
}
*/
}

80
tests/t20035/test_case.h
View File

@@ -16,54 +16,62 @@
* limitations under the License.
*/
TEST_CASE("t20035", "[test-case][sequence]")
TEST_CASE("t20035")
{
auto [config, db] = load_config("t20035");
using namespace clanguml::test;
auto diagram = config.diagrams["t20035_sequence"];
auto [config, db, diagram, model] =
CHECK_SEQUENCE_MODEL("t20035", "t20035_sequence");
REQUIRE(diagram->name == "t20035_sequence");
CHECK_SEQUENCE_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(MessageChainsOrder(src,
{{
//
{"tmain(int,char **)", "a(int)", ""}, //
{"a(int)", "b1(int)", ""}, //
{"b1(int)", "c(int)", ""} //
}}));
});
/*
{
auto src = generate_sequence_puml(diagram, *model);
AliasMatcher _A(src);
auto model = generate_sequence_diagram(*db, diagram);
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
REQUIRE(model->name() == "t20035_sequence");
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)"), ""));
{
auto src = generate_sequence_puml(diagram, *model);
AliasMatcher _A(src);
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
{
auto j = generate_sequence_json(diagram, *model);
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)"), ""));
using namespace json;
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
REQUIRE(HasMessageChain(j,
{{"tmain(int,char **)", "a(int)", "int"},
{"a(int)", "b1(int)", "int"}, {"b1(int)", "c(int)",
"int"}}));
{
auto j = generate_sequence_json(diagram, *model);
save_json(config.output_directory(), diagram->name + ".json", j);
}
using namespace json;
{
auto src = generate_sequence_mermaid(diagram, *model);
REQUIRE(HasMessageChain(j,
{{"tmain(int,char **)", "a(int)", "int"},
{"a(int)", "b1(int)", "int"}, {"b1(int)", "c(int)", "int"}}));
mermaid::SequenceDiagramAliasMatcher _A(src);
using mermaid::HasCall;
save_json(config.output_directory(), diagram->name + ".json", j);
}
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)"), ""));
{
auto src = generate_sequence_mermaid(diagram, *model);
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);
}
save_mermaid(config.output_directory(), diagram->name + ".mmd",
src);
}
*/
}

149
tests/t20036/test_case.h
View File

@@ -16,78 +16,119 @@
* limitations under the License.
*/
TEST_CASE("t20036", "[test-case][sequence]")
TEST_CASE("t20036")
{
auto [config, db] = load_config("t20036");
using namespace clanguml::test;
auto diagram = config.diagrams["t20036_sequence"];
auto [config, db, diagram, model] =
CHECK_SEQUENCE_MODEL("t20036", "t20036_sequence");
REQUIRE(diagram->name == "t20036_sequence");
CHECK_SEQUENCE_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(MessageChainsOrder(src,
{
//
{
//
{Entrypoint{}, "C", "c1()"}, //
{"C", "B", "b1()"}, //
{"B", "A", "a2()"}, //
}, //
{
//
{Entrypoint{}, "D", "d1()"}, //
{"D", "C", "c2()"}, //
{"C", "B", "b2()"}, //
{"B", "A", "a2()"}, //
}, //
{
//
{Entrypoint{}, "D", "d3()"}, //
{"D", "A", "a2()"}, //
}, //
{
//
{Entrypoint{}, "C", "c4()"}, //
{"C", "B", "b2()"}, //
{"B", "A", "a2()"}, //
}, //
{
//
{Entrypoint{}, "C", "c3()"}, //
{"C", "C", "c2()"}, //
{"C", "B", "b2()"}, //
{"B", "A", "a2()"}, //
}, //
{
//
{Entrypoint{}, "D", "d2()"}, //
{"D", "C", "c2()"}, //
{"C", "B", "b2()"}, //
{"B", "A", "a2()"}, //
}, //
}));
});
/*
{
auto src = generate_sequence_puml(diagram, *model);
AliasMatcher _A(src);
auto model = generate_sequence_diagram(*db, diagram);
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
REQUIRE(model->name() == "t20036_sequence");
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()"));
{
auto src = generate_sequence_puml(diagram, *model);
AliasMatcher _A(src);
REQUIRE_THAT(src, HasCall(_A("C"), _A("B"), "b2()"));
REQUIRE_THAT(src, HasCall(_A("B"), _A("A"), "a2()"));
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
REQUIRE_THAT(src, HasCall(_A("D"), _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(src, HasCall(_A("C"), _A("B"), "b1()"));
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()"));
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
REQUIRE_THAT(src, HasCall(_A("D"), _A("A"), "a2()"));
{
auto j = generate_sequence_json(diagram, *model);
REQUIRE_THAT(src, HasCall(_A("C"), _A("B"), "b1()"));
REQUIRE_THAT(src, HasCall(_A("B"), _A("A"), "a2()"));
using namespace json;
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
REQUIRE(HasMessageChain(j,
{{"c3()", "c2()", "void"}, {"c2()", "b2()", "void"},
{"b2()", "a2()", "void"}}));
REQUIRE(HasMessageChain(
j, {{"c4()", "b2()", "void"}, {"b2()", "a2()", "void"}}));
REQUIRE(HasMessageChain(j, {{"d3()", "a2()", "void"}}));
REQUIRE(HasMessageChain(j,
{{"d1()", "c2()", "void"}, {"c2()", "b2()", "void"},
{"b2()", "a2()", "void"}}));
REQUIRE(HasMessageChain(
j, {{"c1()", "b1()", "void"}, {"b1()", "a2()", "void"}}));
{
auto j = generate_sequence_json(diagram, *model);
save_json(config.output_directory(), diagram->name + ".json", j);
}
using namespace json;
{
auto src = generate_sequence_mermaid(diagram, *model);
REQUIRE(HasMessageChain(j,
{{"c3()", "c2()", "void"}, {"c2()", "b2()", "void"},
{"b2()", "a2()", "void"}}));
REQUIRE(HasMessageChain(
j, {{"c4()", "b2()", "void"}, {"b2()", "a2()", "void"}}));
REQUIRE(HasMessageChain(j, {{"d3()", "a2()", "void"}}));
REQUIRE(HasMessageChain(j,
{{"d1()", "c2()", "void"}, {"c2()", "b2()", "void"},
{"b2()", "a2()", "void"}}));
REQUIRE(HasMessageChain(
j, {{"c1()", "b1()", "void"}, {"b1()", "a2()", "void"}}));
mermaid::SequenceDiagramAliasMatcher _A(src);
using mermaid::HasCall;
save_json(config.output_directory(), diagram->name + ".json", j);
}
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()"));
{
auto src = generate_sequence_mermaid(diagram, *model);
REQUIRE_THAT(src, HasCall(_A("C"), _A("B"), "b2()"));
REQUIRE_THAT(src, HasCall(_A("B"), _A("A"), "a2()"));
mermaid::SequenceDiagramAliasMatcher _A(src);
using mermaid::HasCall;
REQUIRE_THAT(src, HasCall(_A("D"), _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(src, HasCall(_A("C"), _A("B"), "b1()"));
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);
}
save_mermaid(config.output_directory(), diagram->name + ".mmd",
src);
}*/
}

96
tests/t20037/test_case.h
View File

@@ -16,60 +16,76 @@
* limitations under the License.
*/
TEST_CASE("t20037", "[test-case][sequence]")
TEST_CASE("t20037")
{
auto [config, db] = load_config("t20037");
using namespace clanguml::test;
auto diagram = config.diagrams["t20037_sequence"];
auto [config, db, diagram, model] =
CHECK_SEQUENCE_MODEL("t20037", "t20037_sequence");
REQUIRE(diagram->name == "t20037_sequence");
CHECK_SEQUENCE_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(MessageOrder(src,
{
//
{"tmain(int,char **)", "a()", ""}, //
{"a()", "A", "A()"}, //
{"a()", "initb()", ""}, //
{"a()", "B", "get()"}, //
{"a()", "c()", ""}, //
auto model = generate_sequence_diagram(*db, diagram);
// {"tmain(int,char **)", "a()", ""}, //
// {"a()", "B", "get()"}, //
// {"a()", "c()", ""}, //
//
// {"tmain(int,char **)", "a()", ""}, //
// {"a()", "B", "get()"}, //
// {"a()", "c()", ""} //
}));
});
/*
{
auto src = generate_sequence_puml(diagram, *model);
AliasMatcher _A(src);
REQUIRE(model->name() == "t20037_sequence");
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
{
auto src = generate_sequence_puml(diagram, *model);
AliasMatcher _A(src);
REQUIRE_THAT(src, HasCall(_A("tmain(int,char **)"), _A("a()"), ""));
REQUIRE_THAT(src, HasCall(_A("a()"), _A("initb()"), ""));
REQUIRE_THAT(src, HasCall(_A("a()"), _A("B"), "get()"));
REQUIRE_THAT(src, HasCall(_A("a()"), _A("c()"), ""));
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
REQUIRE_THAT(src, HasCall(_A("tmain(int,char **)"), _A("a()"), ""));
REQUIRE_THAT(src, HasCall(_A("a()"), _A("initb()"), ""));
REQUIRE_THAT(src, HasCall(_A("a()"), _A("B"), "get()"));
REQUIRE_THAT(src, HasCall(_A("a()"), _A("c()"), ""));
{
auto j = generate_sequence_json(diagram, *model);
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
using namespace json;
{
auto j = generate_sequence_json(diagram, *model);
std::vector<int> messages = {
FindMessage(j, "tmain(int,char **)", "a()", ""),
FindMessage(j, "a()", "initb()", ""),
FindMessage(j, "a()", "B", "get()"),
FindMessage(j, "a()", "c()", "")};
using namespace json;
REQUIRE(std::is_sorted(messages.begin(), messages.end()));
std::vector<int> messages = {
FindMessage(j, "tmain(int,char **)", "a()", ""),
FindMessage(j, "a()", "initb()", ""),
FindMessage(j, "a()", "B", "get()"),
FindMessage(j, "a()", "c()", "")};
save_json(config.output_directory(), diagram->name + ".json", j);
}
REQUIRE(std::is_sorted(messages.begin(), messages.end()));
{
auto src = generate_sequence_mermaid(diagram, *model);
save_json(config.output_directory(), diagram->name + ".json", j);
}
mermaid::SequenceDiagramAliasMatcher _A(src);
using mermaid::HasCall;
{
auto src = generate_sequence_mermaid(diagram, *model);
REQUIRE_THAT(src, HasCall(_A("tmain(int,char **)"), _A("a()"), ""));
REQUIRE_THAT(src, HasCall(_A("a()"), _A("initb()"), ""));
REQUIRE_THAT(src, HasCall(_A("a()"), _A("B"), "get()"));
REQUIRE_THAT(src, HasCall(_A("a()"), _A("c()"), ""));
mermaid::SequenceDiagramAliasMatcher _A(src);
using mermaid::HasCall;
REQUIRE_THAT(src, HasCall(_A("tmain(int,char **)"), _A("a()"), ""));
REQUIRE_THAT(src, HasCall(_A("a()"), _A("initb()"), ""));
REQUIRE_THAT(src, HasCall(_A("a()"), _A("B"), "get()"));
REQUIRE_THAT(src, HasCall(_A("a()"), _A("c()"), ""));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}
save_mermaid(config.output_directory(), diagram->name + ".mmd",
src);
}*/
}

172
tests/t20038/test_case.h
View File

@@ -16,110 +16,144 @@
* limitations under the License.
*/
TEST_CASE("t20038", "[test-case][sequence]")
TEST_CASE("t20038")
{
auto [config, db] = load_config("t20038");
using namespace clanguml::test;
auto diagram = config.diagrams["t20038_sequence"];
auto [config, db, diagram, model] =
CHECK_SEQUENCE_MODEL("t20038", "t20038_sequence");
REQUIRE(diagram->name == "t20038_sequence");
CHECK_SEQUENCE_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(MessageOrder(src,
{
//
{"tmain()", "B", "b()"}, //
{"B", "A", "a()"}, //
{"tmain()", "B", "b()"}, //
{"B", "A", "a()"}, //
auto model = generate_sequence_diagram(*db, diagram);
{"tmain()", "B", "bbb()"}, //
{"B", "A", "aaa()"}, //
REQUIRE(model->name() == "t20038_sequence");
{"tmain()", "B", "bbbb()"}, //
{"B", "A", "aaaa()"}, //
{"A", "add<int>(int,int)", ""}, //
{"add<int>(int,int)", "add_impl<int>(int,int)", ""}, //
{
auto src = generate_sequence_puml(diagram, *model);
AliasMatcher _A(src);
{"tmain()", "B", "wrap(int)"}, //
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
{"tmain()", "add_impl<double>(double,double)", ""}, //
REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B"), "b()"));
{"tmain()", "B", "bbbbb()"}, //
{"B", "A", "aaaa()"}, //
{"A", "add<int>(int,int)", ""}, //
{"add<int>(int,int)", "add_impl<int>(int,int)", ""}, //
REQUIRE_THAT(src, !HasCall(_A("tmain()"), _A("B"), "bb()"));
{"tmain()", "B", "bbb()", InControlCondition{}}, //
{"B", "A", "aaa()"}, //
}));
});
/*
{
auto src = generate_sequence_puml(diagram, *model);
AliasMatcher _A(src);
REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B"), "bbb()"));
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B"), "bbbb()"));
REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B"), "b()"));
REQUIRE_THAT(src,
HasMessageComment(_A("tmain()"),
"This comment should be rendered only\\n"
"once"));
REQUIRE_THAT(src, !HasCall(_A("tmain()"), _A("B"), "bb()"));
REQUIRE_THAT(src,
HasCall(_A("tmain()"), _A("add_impl<double>(double,double)"), ""));
REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B"), "bbb()"));
REQUIRE_THAT(
src, HasMessageComment(_A("tmain()"), "What is 2 \\+ 2\\?"));
REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B"), "bbbb()"));
REQUIRE_THAT(src,
!HasMessageComment(
_A("tmain()"), "This is specific for some_other_diagram"));
REQUIRE_THAT(src,
HasMessageComment(_A("tmain()"),
"This comment should be rendered only\\n"
"once"));
REQUIRE_THAT(
src, HasMessageComment(_A("tmain()"), "Calling B::bbbbb\\(\\)"));
REQUIRE_THAT(src,
HasCall(_A("tmain()"), _A("add_impl<double>(double,double)"),
""));
REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B"), "bbbbb()"));
REQUIRE_THAT(
src, HasMessageComment(_A("tmain()"), "What is 2 \\+ 2\\?"));
REQUIRE_THAT(src,
HasMessageComment(_A("tmain()"), "This is a conditional operator"));
REQUIRE_THAT(src,
!HasMessageComment(
_A("tmain()"), "This is specific for some_other_diagram"));
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
REQUIRE_THAT(
src, HasMessageComment(_A("tmain()"), "Calling
B::bbbbb\\(\\)"));
{
auto j = generate_sequence_json(diagram, *model);
REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B"), "bbbbb()"));
using namespace json;
REQUIRE_THAT(src,
HasMessageComment(_A("tmain()"), "This is a conditional
operator"));
save_json(config.output_directory(), diagram->name + ".json", j);
}
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
{
auto src = generate_sequence_mermaid(diagram, *model);
{
auto j = generate_sequence_json(diagram, *model);
mermaid::SequenceDiagramAliasMatcher _A(src);
using mermaid::HasCall;
using mermaid::HasCallInControlCondition;
using mermaid::HasMessageComment;
using namespace json;
REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B"), "b()"));
save_json(config.output_directory(), diagram->name + ".json", j);
}
REQUIRE_THAT(src, !HasCall(_A("tmain()"), _A("B"), "bb()"));
{
auto src = generate_sequence_mermaid(diagram, *model);
REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B"), "bbb()"));
mermaid::SequenceDiagramAliasMatcher _A(src);
using mermaid::HasCall;
using mermaid::HasCallInControlCondition;
using mermaid::HasMessageComment;
REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B"), "bbbb()"));
REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B"), "b()"));
REQUIRE_THAT(src,
HasMessageComment(_A("tmain()"),
"This comment should be rendered only<br/>"
"once"));
REQUIRE_THAT(src, !HasCall(_A("tmain()"), _A("B"), "bb()"));
REQUIRE_THAT(src,
HasCall(_A("tmain()"), _A("add_impl<double>(double,double)"), ""));
REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B"), "bbb()"));
REQUIRE_THAT(
src, HasMessageComment(_A("tmain()"), "What is 2 \\+ 2\\?"));
REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B"), "bbbb()"));
REQUIRE_THAT(src,
!HasMessageComment(
_A("tmain()"), "This is specific for some_other_diagram"));
REQUIRE_THAT(src,
HasMessageComment(_A("tmain()"),
"This comment should be rendered only<br/>"
"once"));
REQUIRE_THAT(
src, HasMessageComment(_A("tmain()"), "Calling B::bbbbb\\(\\)"));
REQUIRE_THAT(src,
HasCall(_A("tmain()"), _A("add_impl<double>(double,double)"),
""));
REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B"), "bbbbb()"));
REQUIRE_THAT(
src, HasMessageComment(_A("tmain()"), "What is 2 \\+ 2\\?"));
REQUIRE_THAT(src,
!HasMessageComment(
_A("tmain()"), "This is specific for some_other_diagram"));
REQUIRE_THAT(src,
!HasMessageComment(
_A("tmain()"), "This is specific for some_other_diagram"));
REQUIRE_THAT(
src, HasMessageComment(_A("tmain()"), "Calling B::bbbbb\\(\\)"));
REQUIRE_THAT(
src, HasMessageComment(_A("tmain()"), "Calling
B::bbbbb\\(\\)"));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}
REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B"), "bbbbb()"));
REQUIRE_THAT(src,
!HasMessageComment(
_A("tmain()"), "This is specific for some_other_diagram"));
REQUIRE_THAT(
src, HasMessageComment(_A("tmain()"), "Calling
B::bbbbb\\(\\)"));
save_mermaid(config.output_directory(), diagram->name + ".mmd",
src);
}
*/
}

28
tests/t20039/test_case.h
View File

@@ -16,18 +16,26 @@
* limitations under the License.
*/
TEST_CASE("t20039", "[test-case][sequence]")
TEST_CASE("t20039")
{
auto [config, db] = load_config("t20039");
using namespace clanguml::test;
auto diagram = config.diagrams["t20039_sequence"];
REQUIRE(diagram->name == "t20039_sequence");
auto model = generate_sequence_diagram(*db, diagram);
REQUIRE(model->name() == "t20039_sequence");
auto [config, db, diagram, model] =
CHECK_SEQUENCE_MODEL("t20039", "t20039_sequence");
CHECK_SEQUENCE_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(MessageOrder(src,
{
//
{"tmain()", "R", "run()"}, //
{"R", "A<int>", "a(int)"}, //
{"R", "A<int_vec_t>", "a(int_vec_t)"}, //
{"R", "A<string_vec_t>", "a(string_vec_t)"}, //
{"R", "A<int_map_t>", "a(int_map_t)"}, //
{"R", "A<string_map_t>", "a(string_map_t)"} //
}));
});
/*
{
auto src = generate_sequence_puml(diagram, *model);
AliasMatcher _A(src);
@@ -72,5 +80,5 @@ TEST_CASE("t20039", "[test-case][sequence]")
src, HasCall(_A("R"), _A("A<string_map_t>"), "a(string_map_t)"));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}
}*/
}

121
tests/t20040/test_case.h
View File

@@ -16,74 +16,95 @@
* limitations under the License.
*/
TEST_CASE("t20040", "[test-case][sequence]")
TEST_CASE("t20040")
{
auto [config, db] = load_config("t20040");
using namespace clanguml::test;
auto diagram = config.diagrams["t20040_sequence"];
auto [config, db, diagram, model] =
CHECK_SEQUENCE_MODEL("t20040", "t20040_sequence");
REQUIRE(diagram->name == "t20040_sequence");
CHECK_SEQUENCE_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(MessageOrder(src,
{
//
{"tmain()",
"print<int,double,std::string>(int,double,std::string)",
""}, //
{"print<int,double,std::string>(int,double,std::string)",
"print<double,std::string>(double,std::string)", ""}, //
{"print<double,std::string>(double,std::string)",
"print<std::string>(std::string)", ""}, //
{"print<std::string>(std::string)", "print()", ""}, //
auto model = generate_sequence_diagram(*db, diagram);
{"tmain()", "doublePrint<std::string,int>(std::string,int)",
""}, //
{"doublePrint<std::string,int>(std::string,int)",
"print<std::string,int>(std::string,int)", ""}, //
{"print<std::string,int>(std::string,int)", "print<int>(int)",
""}, //
{"print<int>(int)", "print()", ""}, //
}));
});
/*
{
auto src = generate_sequence_puml(diagram, *model);
AliasMatcher _A(src);
REQUIRE(model->name() == "t20040_sequence");
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
{
auto src = generate_sequence_puml(diagram, *model);
AliasMatcher _A(src);
REQUIRE_THAT(src,
HasCall(_A("tmain()"),
_A("print<int,double,std::string>(int,double,std::string)"),
""));
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
REQUIRE_THAT(src,
HasCall(_A("print<int,double,std::string>(int,double,std::string)"),
_A("print<double,std::string>(double,std::string)"), ""));
REQUIRE_THAT(src,
HasCall(_A("tmain()"),
_A("print<int,double,std::string>(int,double,std::string)"),
""));
REQUIRE_THAT(src,
HasCall(_A("print<double,std::string>(double,std::string)"),
_A("print<std::string>(std::string)"), ""));
REQUIRE_THAT(src,
HasCall(_A("print<int,double,std::string>(int,double,std::string)"),
_A("print<double,std::string>(double,std::string)"), ""));
REQUIRE_THAT(src,
HasCall(_A("print<std::string>(std::string)"), _A("print()"),
""));
REQUIRE_THAT(src,
HasCall(_A("print<double,std::string>(double,std::string)"),
_A("print<std::string>(std::string)"), ""));
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
REQUIRE_THAT(src,
HasCall(_A("print<std::string>(std::string)"), _A("print()"), ""));
{
auto j = generate_sequence_json(diagram, *model);
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
using namespace json;
{
auto j = generate_sequence_json(diagram, *model);
save_json(config.output_directory(), diagram->name + ".json", j);
}
using namespace json;
{
auto src = generate_sequence_mermaid(diagram, *model);
save_json(config.output_directory(), diagram->name + ".json", j);
}
mermaid::SequenceDiagramAliasMatcher _A(src);
using mermaid::HasCall;
{
auto src = generate_sequence_mermaid(diagram, *model);
REQUIRE_THAT(src,
HasCall(_A("tmain()"),
_A("print<int,double,std::string>(int,double,std::string)"),
""));
mermaid::SequenceDiagramAliasMatcher _A(src);
using mermaid::HasCall;
REQUIRE_THAT(src,
HasCall(_A("print<int,double,std::string>(int,double,std::string)"),
_A("print<double,std::string>(double,std::string)"), ""));
REQUIRE_THAT(src,
HasCall(_A("tmain()"),
_A("print<int,double,std::string>(int,double,std::string)"),
""));
REQUIRE_THAT(src,
HasCall(_A("print<double,std::string>(double,std::string)"),
_A("print<std::string>(std::string)"), ""));
REQUIRE_THAT(src,
HasCall(_A("print<int,double,std::string>(int,double,std::string)"),
_A("print<double,std::string>(double,std::string)"), ""));
REQUIRE_THAT(src,
HasCall(_A("print<std::string>(std::string)"), _A("print()"),
""));
REQUIRE_THAT(src,
HasCall(_A("print<double,std::string>(double,std::string)"),
_A("print<std::string>(std::string)"), ""));
REQUIRE_THAT(src,
HasCall(_A("print<std::string>(std::string)"), _A("print()"), ""));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}
save_mermaid(config.output_directory(), diagram->name + ".mmd",
src);
}*/
}

120
tests/t20041/test_case.h
View File

@@ -16,74 +16,84 @@
* limitations under the License.
*/
TEST_CASE("t20041", "[test-case][sequence]")
TEST_CASE("t20041")
{
auto [config, db] = load_config("t20041");
using namespace clanguml::test;
auto diagram = config.diagrams["t20041_sequence"];
auto [config, db, diagram, model] =
CHECK_SEQUENCE_MODEL("t20041", "t20041_sequence");
REQUIRE(diagram->name == "t20041_sequence");
CHECK_SEQUENCE_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(MessageOrder(src,
{
//
{"tmain()", "A<int,double,std::string>",
"print(int,double,std::string)"}, //
{"A<int,double,std::string>", "A<double,std::string>",
"print(double,std::string)"}, //
{"A<double,std::string>", "A<std::string>",
"print(std::string)"}, //
{"A<std::string>", "A", "print()"}, //
}));
});
/*
{
auto src = generate_sequence_puml(diagram, *model);
AliasMatcher _A(src);
auto model = generate_sequence_diagram(*db, diagram);
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
REQUIRE(model->name() == "t20041_sequence");
REQUIRE_THAT(src,
HasCall(_A("tmain()"), _A("A<int,double,std::string>"),
"print(int,double,std::string)"));
REQUIRE_THAT(src,
HasCall(_A("A<int,double,std::string>"),
_A("A<double,std::string>"), "print(double,std::string)"));
REQUIRE_THAT(src,
HasCall(_A("A<double,std::string>"), _A("A<std::string>"),
"print(std::string)"));
REQUIRE_THAT(src, HasCall(_A("A<std::string>"), _A("A"),
"print()"));
{
auto src = generate_sequence_puml(diagram, *model);
AliasMatcher _A(src);
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
{
auto j = generate_sequence_json(diagram, *model);
REQUIRE_THAT(src,
HasCall(_A("tmain()"), _A("A<int,double,std::string>"),
"print(int,double,std::string)"));
REQUIRE_THAT(src,
HasCall(_A("A<int,double,std::string>"),
_A("A<double,std::string>"), "print(double,std::string)"));
REQUIRE_THAT(src,
HasCall(_A("A<double,std::string>"), _A("A<std::string>"),
"print(std::string)"));
REQUIRE_THAT(src, HasCall(_A("A<std::string>"), _A("A"), "print()"));
using namespace json;
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
std::vector<int> messages = {
FindMessage(j, "tmain()", "A<int,double,std::string>",
"print(int,double,std::string)"),
FindMessage(j, "A<int,double,std::string>",
"A<double,std::string>", "print(double,std::string)"), FindMessage(j,
"A<double,std::string>", "A<std::string>", "print(std::string)"),
FindMessage(j, "A<std::string>", "A", "print()")};
{
auto j = generate_sequence_json(diagram, *model);
REQUIRE(std::is_sorted(messages.begin(), messages.end()));
using namespace json;
save_json(config.output_directory(), diagram->name + ".json", j);
}
std::vector<int> messages = {
FindMessage(j, "tmain()", "A<int,double,std::string>",
"print(int,double,std::string)"),
FindMessage(j, "A<int,double,std::string>", "A<double,std::string>",
"print(double,std::string)"),
FindMessage(j, "A<double,std::string>", "A<std::string>",
"print(std::string)"),
FindMessage(j, "A<std::string>", "A", "print()")};
{
auto src = generate_sequence_mermaid(diagram, *model);
REQUIRE(std::is_sorted(messages.begin(), messages.end()));
mermaid::SequenceDiagramAliasMatcher _A(src);
using mermaid::HasCall;
save_json(config.output_directory(), diagram->name + ".json", j);
}
REQUIRE_THAT(src,
HasCall(_A("tmain()"), _A("A<int,double,std::string>"),
"print(int,double,std::string)"));
REQUIRE_THAT(src,
HasCall(_A("A<int,double,std::string>"),
_A("A<double,std::string>"), "print(double,std::string)"));
REQUIRE_THAT(src,
HasCall(_A("A<double,std::string>"), _A("A<std::string>"),
"print(std::string)"));
{
auto src = generate_sequence_mermaid(diagram, *model);
mermaid::SequenceDiagramAliasMatcher _A(src);
using mermaid::HasCall;
REQUIRE_THAT(src,
HasCall(_A("tmain()"), _A("A<int,double,std::string>"),
"print(int,double,std::string)"));
REQUIRE_THAT(src,
HasCall(_A("A<int,double,std::string>"),
_A("A<double,std::string>"), "print(double,std::string)"));
REQUIRE_THAT(src,
HasCall(_A("A<double,std::string>"), _A("A<std::string>"),
"print(std::string)"));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}
save_mermaid(config.output_directory(), diagram->name + ".mmd",
src);
}*/
}

88
tests/t20042/test_case.h
View File

@@ -16,60 +16,64 @@
* limitations under the License.
*/
TEST_CASE("t20042", "[test-case][sequence]")
TEST_CASE("t20042")
{
auto [config, db] = load_config("t20042");
using namespace clanguml::test;
auto diagram = config.diagrams["t20042_sequence"];
auto [config, db, diagram, model] =
CHECK_SEQUENCE_MODEL("t20042", "t20042_sequence");
REQUIRE(diagram->name == "t20042_sequence");
CHECK_SEQUENCE_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(MessageOrder(src,
{
//
{"tmain()", "AHandler", "operator()(A &) const"}, //
{"AHandler", "AHandler", "handle(A &) const"}, //
auto model = generate_sequence_diagram(*db, diagram);
{"tmain()", "BHandler", "operator()(B &) const"}, //
{"BHandler", "BHandler", "handle(B &) const"}, //
}));
});
/*
{
auto src = generate_sequence_puml(diagram, *model);
AliasMatcher _A(src);
REQUIRE(model->name() == "t20042_sequence");
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
{
auto src = generate_sequence_puml(diagram, *model);
AliasMatcher _A(src);
REQUIRE_THAT(src,
HasCall(_A("tmain()"), _A("AHandler"), "operator()(A &)
const")); REQUIRE_THAT( src, HasCall(_A("AHandler"), _A("AHandler"),
"handle(A &) const")); REQUIRE_THAT(src, HasCall(_A("tmain()"),
_A("BHandler"), "operator()(B &) const")); REQUIRE_THAT( src,
HasCall(_A("BHandler"), _A("BHandler"), "handle(B &) const"));
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
REQUIRE_THAT(src,
HasCall(_A("tmain()"), _A("AHandler"), "operator()(A &) const"));
REQUIRE_THAT(
src, HasCall(_A("AHandler"), _A("AHandler"), "handle(A &) const"));
REQUIRE_THAT(src,
HasCall(_A("tmain()"), _A("BHandler"), "operator()(B &) const"));
REQUIRE_THAT(
src, HasCall(_A("BHandler"), _A("BHandler"), "handle(B &) const"));
{
auto j = generate_sequence_json(diagram, *model);
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
using namespace json;
{
auto j = generate_sequence_json(diagram, *model);
save_json(config.output_directory(), diagram->name + ".json", j);
}
using namespace json;
{
auto src = generate_sequence_mermaid(diagram, *model);
save_json(config.output_directory(), diagram->name + ".json", j);
}
mermaid::SequenceDiagramAliasMatcher _A(src);
using mermaid::HasCall;
{
auto src = generate_sequence_mermaid(diagram, *model);
REQUIRE_THAT(src,
HasCall(_A("tmain()"), _A("AHandler"), "operator()(A &)
const")); REQUIRE_THAT( src, HasCall(_A("AHandler"), _A("AHandler"),
"handle(A &) const")); REQUIRE_THAT(src, HasCall(_A("tmain()"),
_A("BHandler"), "operator()(B &) const")); REQUIRE_THAT( src,
HasCall(_A("BHandler"), _A("BHandler"), "handle(B &) const"));
mermaid::SequenceDiagramAliasMatcher _A(src);
using mermaid::HasCall;
REQUIRE_THAT(src,
HasCall(_A("tmain()"), _A("AHandler"), "operator()(A &) const"));
REQUIRE_THAT(
src, HasCall(_A("AHandler"), _A("AHandler"), "handle(A &) const"));
REQUIRE_THAT(src,
HasCall(_A("tmain()"), _A("BHandler"), "operator()(B &) const"));
REQUIRE_THAT(
src, HasCall(_A("BHandler"), _A("BHandler"), "handle(B &) const"));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}
save_mermaid(config.output_directory(), diagram->name + ".mmd",
src);
}*/
}

26
tests/t20043/test_case.h
View File

@@ -16,18 +16,28 @@
* limitations under the License.
*/
TEST_CASE("t20043", "[test-case][sequence]")
TEST_CASE("t20043")
{
auto [config, db] = load_config("t20043");
using namespace clanguml::test;
auto diagram = config.diagrams["t20043_sequence"];
auto [config, db, diagram, model] =
CHECK_SEQUENCE_MODEL("t20043", "t20043_sequence");
REQUIRE(diagram->name == "t20043_sequence");
CHECK_SEQUENCE_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(MessageOrder(src,
{
//
{"tmain()", "D", "d()"}, //
{"D", "C", "c()"}, //
}));
auto model = generate_sequence_diagram(*db, diagram);
REQUIRE(model->name() == "t20043_sequence");
REQUIRE(!HasMessage(src, {"tmain()", "F", "f()"}));
REQUIRE(!HasMessage(src, {"D", {"detail", "E"}, "e()"}));
REQUIRE(!HasMessage(src, {"C", "B", "b()"}));
REQUIRE(!HasMessage(src, {"B", "A", "a()"}));
});
/*
{
auto src = generate_sequence_puml(diagram, *model);
AliasMatcher _A(src);
@@ -69,5 +79,5 @@ TEST_CASE("t20043", "[test-case][sequence]")
REQUIRE_THAT(src, !HasCall(_A("B"), _A("A"), "a()"));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}
}*/
}

43
tests/t20044/test_case.h
View File

@@ -16,18 +16,47 @@
* limitations under the License.
*/
TEST_CASE("t20044", "[test-case][sequence]")
TEST_CASE("t20044")
{
auto [config, db] = load_config("t20044");
using namespace clanguml::test;
auto diagram = config.diagrams["t20044_sequence"];
auto [config, db, diagram, model] =
CHECK_SEQUENCE_MODEL("t20044", "t20044_sequence");
REQUIRE(diagram->name == "t20044_sequence");
CHECK_SEQUENCE_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(MessageOrder(src,
{
//
{"tmain()", "R", "R((lambda at t20044.cc:74:9) &&)"}, //
{"R", "tmain()::(lambda t20044.cc:74:9)",
"operator()() const"}, //
{"tmain()::(lambda t20044.cc:74:9)", "A", "a() const"}, //
auto model = generate_sequence_diagram(*db, diagram);
{"tmain()", "tmain()::(lambda t20044.cc:84:18)",
"operator()() const"}, //
{"tmain()::(lambda t20044.cc:84:18)", "A", "a5()"}, //
REQUIRE(model->name() == "t20044_sequence");
{"tmain()", "A", "a1() const"}, //
{"A", "detail::expected<int,error>", "expected(int)"}, //
{"tmain()", "detail::expected<int,error>",
"and_then((lambda at t20044.cc:90:19) &&)"}, //
{"detail::expected<int,error>",
"tmain()::(lambda t20044.cc:90:19)",
"operator()(auto &&) const"}, //
{"tmain()::(lambda t20044.cc:90:19)", "A", "a2(int) const"}, //
{"A", "detail::expected<int,error>", "expected(int)"}, //
{"tmain()", "detail::expected<int,error>",
"and_then(result_t (&)(int))"}, // //
{"tmain()", "detail::expected<int,error>",
"and_then(std::function<result_t (int)> &)"}, // //
{"tmain()", "detail::expected<int,error>",
"value() const"}, // //
}));
});
/*
{
auto src = generate_sequence_puml(diagram, *model);
AliasMatcher _A(src);
@@ -88,5 +117,5 @@ TEST_CASE("t20044", "[test-case][sequence]")
using mermaid::IsClass;
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}
}*/
}

26
tests/t20045/test_case.h
View File

@@ -16,18 +16,25 @@
* limitations under the License.
*/
TEST_CASE("t20045", "[test-case][sequence]")
TEST_CASE("t20045")
{
auto [config, db] = load_config("t20045");
using namespace clanguml::test;
auto diagram = config.diagrams["t20045_sequence"];
REQUIRE(diagram->name == "t20045_sequence");
auto model = generate_sequence_diagram(*db, diagram);
REQUIRE(model->name() == "t20045_sequence");
auto [config, db, diagram, model] =
CHECK_SEQUENCE_MODEL("t20045", "t20045_sequence");
CHECK_SEQUENCE_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(MessageOrder(src,
{
//
{"tmain()", "a2(int)", ""}, //
{"tmain()",
"a1<(lambda at t20045.cc:35:18)>((lambda at "
"t20045.cc:35:18) &&)",
""}, //
}));
});
/*
{
auto src = generate_sequence_puml(diagram, *model);
AliasMatcher _A(src);
@@ -80,4 +87,5 @@ TEST_CASE("t20045", "[test-case][sequence]")
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}
*/
}

9
tests/test_cases.cc
View File

@@ -387,8 +387,7 @@ void try_run_test_case(const diagram_source_storage &diagrams, TC &&tc)
std::cout << "-----------------------------------------------------"
"--------------------------\n";
std::cout << "Test case failed for diagram type "
<< T::diagram_type_name << ": "
<< "\n\n";
<< T::diagram_type_name << ": " << "\n\n";
std::cout << diagrams.get<T>().to_string() << "\n";
throw e;
@@ -591,7 +590,6 @@ void CHECK_INCLUDE_DIAGRAM(const clanguml::config::config &config,
save_mermaid(config.output_directory(), diagram->name + ".mmd",
diagram_sources.mermaid.src);
}
} // namespace clanguml::test
/*
@@ -1174,7 +1172,7 @@ template <> bool IsClass(json_t d, std::string name)
#include "t00074/test_case.h"
#include "t00075/test_case.h"
#endif
/*
///
/// Sequence diagram tests
///
@@ -1188,6 +1186,7 @@ template <> bool IsClass(json_t d, std::string name)
#include "t20005/test_case.h"
#endif
#include "t20006/test_case.h"
#include "t20007/test_case.h"
#include "t20008/test_case.h"
#include "t20009/test_case.h"
@@ -1222,11 +1221,13 @@ template <> bool IsClass(json_t d, std::string name)
#include "t20038/test_case.h"
#include "t20039/test_case.h"
#include "t20040/test_case.h"
#include "t20041/test_case.h"
#include "t20042/test_case.h"
#include "t20043/test_case.h"
#include "t20044/test_case.h"
#include "t20045/test_case.h"
/*
#include "t20046/test_case.h"
#include "t20047/test_case.h"
#include "t20048/test_case.h"

549
tests/test_cases.h
View File

File diff suppressed because it is too large Load Diff