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

2
src/class_diagram/generators/json/class_diagram_generator.cc
View File

@@ -248,7 +248,7 @@ void generator::generate(const class_ &c, nlohmann::json &parent) const
{ {
nlohmann::json object = c; nlohmann::json object = c;
// Perform config dependent postprocessing on generated class; // Perform config dependent postprocessing on generated class
if (!config().generate_fully_qualified_name()) if (!config().generate_fully_qualified_name())
object["display_name"] = object["display_name"] =
common::generators::json::render_name(c.full_name_no_ns()); common::generators::json::render_name(c.full_name_no_ns());

10
src/sequence_diagram/generators/json/sequence_diagram_generator.cc
View File

@@ -286,6 +286,8 @@ void generator::process_call_message(
else else
LOG_DBG("Skipping activity {} --> {} - missing sequence {}", m.from(), LOG_DBG("Skipping activity {} --> {} - missing sequence {}", m.from(),
m.to(), m.to()); m.to(), m.to());
visited.pop_back();
} }
void generator::process_while_message(const message &m) const void generator::process_while_message(const message &m) const
@@ -816,6 +818,14 @@ void generator::generate_diagram(nlohmann::json &parent) const
} }
} }
// Perform config dependent postprocessing on generated participants
for (auto &p : json_["participants"]) {
if (p.contains("display_name")) {
p["display_name"] =
config().simplify_template_type(p["display_name"]);
}
}
parent["participants"] = json_["participants"]; parent["participants"] = json_["participants"];
} }
} // namespace clanguml::sequence_diagram::generators::json } // namespace clanguml::sequence_diagram::generators::json

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> * Copyright (c) 2021-2024 Bartek Kryza <bkryza@gmail.com>
* *
@@ -16,18 +16,66 @@
* limitations under the License. * 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); auto src = generate_sequence_puml(diagram, *model);
AliasMatcher _A(src); AliasMatcher _A(src);
@@ -118,4 +166,5 @@ TEST_CASE("t20001", "[test-case][sequence]")
save_mermaid(config.output_directory(), diagram->name + ".mmd", src); 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> * Copyright (c) 2021-2024 Bartek Kryza <bkryza@gmail.com>
* *
@@ -16,18 +16,28 @@
* limitations under the License. * 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"); CHECK_SEQUENCE_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(IsFunctionParticipant(src, "m1()"));
auto model = generate_sequence_diagram(*db, diagram); REQUIRE(IsFunctionParticipant(src, "m2()"));
REQUIRE(IsFunctionParticipant(src, "m3()"));
REQUIRE(model->name() == "t20002_sequence"); REQUIRE(IsFunctionParticipant(src, "m4()"));
REQUIRE(MessageOrder(src,
{
//
{"m1()", "m2()", ""}, //
{"m2()", "m3()", ""}, //
{"m3()", "m4()", ""} //
}));
});
/*
{ {
auto src = generate_sequence_puml(diagram, *model); auto src = generate_sequence_puml(diagram, *model);
AliasMatcher _A(src); AliasMatcher _A(src);
@@ -72,5 +82,5 @@ TEST_CASE("t20002", "[test-case][sequence]")
REQUIRE_THAT(src, HasCall(_A("m3()"), _A("m4()"), "")); REQUIRE_THAT(src, HasCall(_A("m3()"), _A("m4()"), ""));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src); 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> * Copyright (c) 2021-2024 Bartek Kryza <bkryza@gmail.com>
* *
@@ -16,56 +16,67 @@
* limitations under the License. * 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"));
{ REQUIRE_THAT(src, HasCall(_A("m1<T>(T)"), _A("m2<T>(T)"), ""));
auto src = generate_sequence_puml(diagram, *model); REQUIRE_THAT(src, HasCall(_A("m2<T>(T)"), _A("m3<T>(T)"), ""));
AliasMatcher _A(src); REQUIRE_THAT(src, HasCall(_A("m3<T>(T)"), _A("m4<T>(T)"), ""));
REQUIRE_THAT(src, StartsWith("@startuml")); save_puml(config.output_directory(), diagram->name + ".puml", src);
REQUIRE_THAT(src, EndsWith("@enduml\n")); }
REQUIRE_THAT(src, HasCall(_A("m1<T>(T)"), _A("m2<T>(T)"), "")); {
REQUIRE_THAT(src, HasCall(_A("m2<T>(T)"), _A("m3<T>(T)"), "")); auto j = generate_sequence_json(diagram, *model);
REQUIRE_THAT(src, HasCall(_A("m3<T>(T)"), _A("m4<T>(T)"), ""));
save_puml(config.output_directory(), diagram->name + ".puml", src); using namespace json;
}
{ std::vector<int> messages = {FindMessage(j, "m1<T>(T)", "m2<T>(T)",
auto j = generate_sequence_json(diagram, *model); ""), 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)", ""), save_json(config.output_directory(), diagram->name + ".json", j);
FindMessage(j, "m2<T>(T)", "m3<T>(T)", ""), }
FindMessage(j, "m3<T>(T)", "m4<T>(T)", "")};
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;
{ REQUIRE_THAT(src, HasCall(_A("m1<T>(T)"), _A("m2<T>(T)"), ""));
auto src = generate_sequence_mermaid(diagram, *model); 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); save_mermaid(config.output_directory(), diagram->name + ".mmd",
using mermaid::HasCall; 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)"), ""));
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. * 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)"), ""));
{ REQUIRE_THAT(src,
auto src = generate_sequence_puml(diagram, *model); HasCall(_A("main()"), _A("m1<unsigned long>(unsigned long)"),
AliasMatcher _A(src); ""));
REQUIRE_THAT(src, HasCall(_A("m1<unsigned long>(unsigned long)"),
_A("m4<unsigned long>(unsigned long)"), ""));
REQUIRE_THAT(src, StartsWith("@startuml")); REQUIRE_THAT(
REQUIRE_THAT(src, HasCall(_A("main()"), _A("m1<float>(float)"), "")); src, HasCall(_A("main()"), _A("m1<std::string>(std::string)"),
REQUIRE_THAT( "")); REQUIRE_THAT(src, HasCall(_A("m1<std::string>(std::string)"),
src, !HasCall(_A("m1<float>(float)"), _A("m1<float>(float)"), "")); _A("m2<std::string>(std::string)"), ""));
REQUIRE_THAT(
src, !HasCall(_A("m1<float>(float)"), _A("m1<float>(float)"), ""));
REQUIRE_THAT(src, REQUIRE_THAT(src, HasCall(_A("main()"), _A("m1<int>(int)"), ""));
HasCall(_A("main()"), _A("m1<unsigned long>(unsigned long)"), "")); REQUIRE_THAT(src, HasCall(_A("m1<int>(int)"), _A("m2<int>(int)"),
REQUIRE_THAT(src, "")); REQUIRE_THAT(src, HasCall(_A("m2<int>(int)"), _A("m3<int>(int)"),
HasCall(_A("m1<unsigned long>(unsigned long)"), "")); REQUIRE_THAT(src, HasCall(_A("m3<int>(int)"), _A("m4<int>(int)"),
_A("m4<unsigned long>(unsigned long)"), "")); "")); REQUIRE_THAT(src, EndsWith("@enduml\n"));
REQUIRE_THAT( save_puml(config.output_directory(), diagram->name + ".puml", src);
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)"), "")); auto j = generate_sequence_json(diagram, *model);
REQUIRE_THAT(src, HasCall(_A("m2<int>(int)"), _A("m3<int>(int)"), ""));
REQUIRE_THAT(src, HasCall(_A("m3<int>(int)"), _A("m4<int>(int)"), ""));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
save_puml(config.output_directory(), diagram->name + ".puml", src); using namespace json;
}
{ std::vector<int> messages = {
auto j = generate_sequence_json(diagram, *model); 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 = { save_json(config.output_directory(), diagram->name + ".json", j);
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)", "")};
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;
{ REQUIRE_THAT(src, HasCall(_A("main()"), _A("m1<float>(float)"),
auto src = generate_sequence_mermaid(diagram, *model); "")); 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); REQUIRE_THAT(src,
using mermaid::HasCall; 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(
REQUIRE_THAT( src, HasCall(_A("main()"), _A("m1<std::string>(std::string)"),
src, !HasCall(_A("m1<float>(float)"), _A("m1<float>(float)"), "")); "")); REQUIRE_THAT(src, HasCall(_A("m1<std::string>(std::string)"),
REQUIRE_THAT( _A("m2<std::string>(std::string)"), ""));
src, !HasCall(_A("m1<float>(float)"), _A("m1<float>(float)"), ""));
REQUIRE_THAT(src, REQUIRE_THAT(src, HasCall(_A("main()"), _A("m1<int>(int)"), ""));
HasCall(_A("main()"), _A("m1<unsigned long>(unsigned long)"), "")); REQUIRE_THAT(src, HasCall(_A("m1<int>(int)"), _A("m2<int>(int)"),
REQUIRE_THAT(src, "")); REQUIRE_THAT(src, HasCall(_A("m2<int>(int)"), _A("m3<int>(int)"),
HasCall(_A("m1<unsigned long>(unsigned long)"), "")); REQUIRE_THAT(src, HasCall(_A("m3<int>(int)"), _A("m4<int>(int)"),
_A("m4<unsigned long>(unsigned long)"), "")); ""));
REQUIRE_THAT( save_mermaid(config.output_directory(), diagram->name + ".mmd",
src, HasCall(_A("main()"), _A("m1<std::string>(std::string)"), "")); src);
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);
}
} }

89
tests/t20005/test_case.h
View File

@@ -16,60 +16,67 @@
* limitations under the License. * 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>")));
{ save_puml(config.output_directory(), diagram->name + ".puml", src);
auto src = generate_sequence_puml(diagram, *model); }
AliasMatcher _A(src);
REQUIRE_THAT(src, StartsWith("@startuml")); {
REQUIRE_THAT(src, EndsWith("@enduml\n")); auto j = generate_sequence_json(diagram, *model);
// Check if all calls exist using namespace json;
REQUIRE_THAT(src, HasEntrypoint(_A("C<T>"), "c(T)"));
REQUIRE_THAT(src, HasCall(_A("C<T>"), _A("B<T>"), "b(T)"));
REQUIRE_THAT(src, HasCall(_A("B<T>"), _A("A<T>"), "a(T)"));
REQUIRE_THAT(src, HasExitpoint(_A("C<T>")));
save_puml(config.output_directory(), diagram->name + ".puml", src); std::vector<int> messages = {FindMessage(j, "C<T>", "B<T>", "b(T)"),
} FindMessage(j, "B<T>", "A<T>", "a(T)")};
{ REQUIRE(std::is_sorted(messages.begin(), messages.end()));
auto j = generate_sequence_json(diagram, *model);
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>")));
{ save_mermaid(config.output_directory(), diagram->name + ".mmd",
auto src = generate_sequence_mermaid(diagram, *model); src);
}*/
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);
}
} }

224
tests/t20006/test_case.h
View File

@@ -16,132 +16,156 @@
* limitations under the License. * 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"));
{ // Check if all calls exist
auto src = generate_sequence_puml(diagram, *model); REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B<int>"), "b(int)"));
AliasMatcher _A(src); REQUIRE_THAT(src, HasCall(_A("B<int>"), _A("A<int>"), "a1(int)"));
REQUIRE_THAT(src, StartsWith("@startuml")); REQUIRE_THAT(src,
REQUIRE_THAT(src, EndsWith("@enduml\n")); 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(
REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B<int>"), "b(int)")); src, HasCall(_A("tmain()"), _A("BB<int,int>"), "bb1(int,int)"));
REQUIRE_THAT(src, HasCall(_A("B<int>"), _A("A<int>"), "a1(int)")); REQUIRE_THAT(
src, HasCall(_A("BB<int,int>"), _A("AA<int>"), "aa1(int)"));
REQUIRE_THAT(src, REQUIRE_THAT(
HasCall(_A("tmain()"), _A("B<std::string>"), "b(std::string)")); src, HasCall(_A("tmain()"), _A("BB<int,int>"), "bb2(int,int)"));
REQUIRE_THAT(src, REQUIRE_THAT(
HasCall( src, HasCall(_A("BB<int,int>"), _A("AA<int>"), "aa2(int)"));
_A("B<std::string>"), _A("A<std::string>"), "a2(std::string)"));
REQUIRE_THAT( REQUIRE_THAT(src,
src, HasCall(_A("tmain()"), _A("BB<int,int>"), "bb1(int,int)")); HasCall(_A("tmain()"), _A("BB<int,std::string>"),
REQUIRE_THAT( "bb1(int,std::string)"));
src, HasCall(_A("BB<int,int>"), _A("AA<int>"), "aa1(int)")); REQUIRE_THAT(
src, HasCall(_A("BB<int,std::string>"), _A("AA<int>"),
"aa2(int)"));
REQUIRE_THAT( REQUIRE_THAT(src,
src, HasCall(_A("tmain()"), _A("BB<int,int>"), "bb2(int,int)")); HasCall(_A("tmain()"), _A("BB<int,std::string>"),
REQUIRE_THAT( "bb2(int,std::string)"));
src, HasCall(_A("BB<int,int>"), _A("AA<int>"), "aa2(int)")); REQUIRE_THAT(
src, HasCall(_A("BB<int,std::string>"), _A("AA<int>"),
"aa1(int)"));
REQUIRE_THAT(src, REQUIRE_THAT(
HasCall(_A("tmain()"), _A("BB<int,std::string>"), src, HasCall(_A("tmain()"), _A("BB<int,float>"),
"bb1(int,std::string)")); "bb1(int,float)"));
REQUIRE_THAT( REQUIRE_THAT(src, HasCall( _A("BB<int,float>"),
src, HasCall(_A("BB<int,std::string>"), _A("AA<int>"), "aa2(int)")); _A("BB<int,float>"), "bb2(int,float)"));
REQUIRE_THAT( src,
HasCall(_A("BB<int,float>"), _A("AA<int>"), "aa2(int)"));
REQUIRE_THAT(src, save_puml(config.output_directory(), diagram->name + ".puml", 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)")); auto j = generate_sequence_json(diagram, *model);
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_puml(config.output_directory(), diagram->name + ".puml", src); using namespace json;
}
{ std::vector<int> messages = {
auto j = generate_sequence_json(diagram, *model); 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 = { save_json(config.output_directory(), diagram->name + ".json", j);
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)")};
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;
{ REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B<int>"), "b(int)"));
auto src = generate_sequence_mermaid(diagram, *model); REQUIRE_THAT(src, HasCall(_A("B<int>"), _A("A<int>"), "a1(int)"));
mermaid::SequenceDiagramAliasMatcher _A(src); REQUIRE_THAT(src,
using mermaid::HasCall; 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(
REQUIRE_THAT(src, HasCall(_A("B<int>"), _A("A<int>"), "a1(int)")); 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, REQUIRE_THAT(
HasCall(_A("tmain()"), _A("B<std::string>"), "b(std::string)")); src, HasCall(_A("tmain()"), _A("BB<int,int>"), "bb2(int,int)"));
REQUIRE_THAT(src, REQUIRE_THAT(
HasCall( src, HasCall(_A("BB<int,int>"), _A("AA<int>"), "aa2(int)"));
_A("B<std::string>"), _A("A<std::string>"), "a2(std::string)"));
REQUIRE_THAT( REQUIRE_THAT(src,
src, HasCall(_A("tmain()"), _A("BB<int,int>"), "bb1(int,int)")); HasCall(_A("tmain()"), _A("BB<int,std::string>"),
REQUIRE_THAT( "bb1(int,std::string)"));
src, HasCall(_A("BB<int,int>"), _A("AA<int>"), "aa1(int)")); REQUIRE_THAT(
src, HasCall(_A("BB<int,std::string>"), _A("AA<int>"),
"aa2(int)"));
REQUIRE_THAT( REQUIRE_THAT(src,
src, HasCall(_A("tmain()"), _A("BB<int,int>"), "bb2(int,int)")); HasCall(_A("tmain()"), _A("BB<int,std::string>"),
REQUIRE_THAT( "bb2(int,std::string)"));
src, HasCall(_A("BB<int,int>"), _A("AA<int>"), "aa2(int)")); REQUIRE_THAT(
src, HasCall(_A("BB<int,std::string>"), _A("AA<int>"),
"aa1(int)"));
REQUIRE_THAT(src, REQUIRE_THAT(
HasCall(_A("tmain()"), _A("BB<int,std::string>"), src, HasCall(_A("tmain()"), _A("BB<int,float>"),
"bb1(int,std::string)")); "bb1(int,float)")); REQUIRE_THAT(src, HasCall( _A("BB<int,float>"),
REQUIRE_THAT( _A("BB<int,float>"), "bb2(int,float)")); REQUIRE_THAT( src,
src, HasCall(_A("BB<int,std::string>"), _A("AA<int>"), "aa2(int)")); HasCall(_A("BB<int,float>"), _A("AA<int>"), "aa2(int)"));
REQUIRE_THAT(src, save_mermaid(config.output_directory(), diagram->name + ".mmd",
HasCall(_A("tmain()"), _A("BB<int,std::string>"), src);
"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);
}
} }

114
tests/t20007/test_case.h
View File

@@ -16,73 +16,79 @@
* limitations under the License. * 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 &&)"));
{ save_puml(config.output_directory(), diagram->name + ".puml",
auto src = generate_sequence_puml(diagram, *model); src);
AliasMatcher _A(src); }
REQUIRE_THAT(src, StartsWith("@startuml")); {
REQUIRE_THAT(src, EndsWith("@enduml\n")); auto j = generate_sequence_json(diagram, *model);
// Check if all calls exist using namespace json;
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_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 &&)")};
{ REQUIRE(std::is_sorted(messages.begin(), messages.end()));
auto j = generate_sequence_json(diagram, *model);
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 &&)"), auto src = generate_sequence_mermaid(diagram, *model);
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 &&)")};
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 &&)"));
{ save_mermaid(config.output_directory(), diagram->name + ".mmd",
auto src = generate_sequence_mermaid(diagram, *model); src);
}*/
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);
}
} }

143
tests/t20008/test_case.h
View File

@@ -16,91 +16,104 @@
* limitations under the License. * 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)"} //
}));
{ REQUIRE(!HasMessage(src, {"B<int>", "A<int>", "a2(int)"}));
auto src = generate_sequence_puml(diagram, *model); REQUIRE(!HasMessage(src, {"B<int>", "A<int>", "a3(int)"}));
AliasMatcher _A(src); });
/*
{
auto src = generate_sequence_puml(diagram, *model);
AliasMatcher _A(src);
REQUIRE_THAT(src, StartsWith("@startuml")); REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n")); REQUIRE_THAT(src, EndsWith("@enduml\n"));
// Check if all calls exist // Check if all calls exist
REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B<int>"), "b(int)")); REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B<int>"),
REQUIRE_THAT(src, HasCall(_A("B<int>"), _A("A<int>"), "a1(int)")); "b(int)")); REQUIRE_THAT(src, HasCall(_A("B<int>"), _A("A<int>"),
// REQUIRE_THAT(puml, !HasCall(_A("B<int>"), _A("A<int>"), "a1(int)"));
// "a2(int)")); REQUIRE_THAT(puml, !HasCall(_A("B<int>"), // REQUIRE_THAT(puml, !HasCall(_A("B<int>"), _A("A<int>"),
// _A("A<int>"), "a3(int)")); // "a2(int)")); REQUIRE_THAT(puml, !HasCall(_A("B<int>"),
// _A("A<int>"), "a3(int)"));
REQUIRE_THAT(src, REQUIRE_THAT(src,
HasCall(_A("tmain()"), _A("B<const char *>"), "b(const char *)")); HasCall(_A("tmain()"), _A("B<const char *>"), "b(const char
REQUIRE_THAT(src, *)")); REQUIRE_THAT(src, HasCall(_A("B<const char *>"), _A("A<const
HasCall(_A("B<const char *>"), _A("A<const char *>"), char *>"), "a2(const char *)"));
"a2(const char *)"));
REQUIRE_THAT(src, REQUIRE_THAT(src,
HasCall(_A("tmain()"), _A("B<std::string>"), "b(std::string)")); HasCall(_A("tmain()"), _A("B<std::string>"),
REQUIRE_THAT(src, "b(std::string)")); REQUIRE_THAT(src, HasCall( _A("B<std::string>"),
HasCall( _A("A<std::string>"), "a3(std::string)"));
_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 = { std::vector<int> messages = {
FindMessage(j, "tmain()", "B<int>", "b(int)"), FindMessage(j, "tmain()", "B<int>", "b(int)"),
FindMessage(j, "B<int>", "A<int>", "a1(int)"), FindMessage(j, "B<int>", "A<int>", "a1(int)"),
FindMessage(j, "tmain()", "B<const char *>", "b(const char *)"), FindMessage(j, "tmain()", "B<const char *>", "b(const char
FindMessage( *)"), FindMessage( j, "B<const char *>", "A<const char *>", "a2(const
j, "B<const char *>", "A<const char *>", "a2(const char *)"), char *)"), FindMessage(j, "tmain()", "B<std::string>",
FindMessage(j, "tmain()", "B<std::string>", "b(std::string)"), "b(std::string)"), FindMessage( j, "B<std::string>",
FindMessage( "A<std::string>", "a3(std::string)")};
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); mermaid::SequenceDiagramAliasMatcher _A(src);
using mermaid::HasCall; using mermaid::HasCall;
REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B<int>"), "b(int)")); REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B<int>"),
REQUIRE_THAT(src, HasCall(_A("B<int>"), _A("A<int>"), "a1(int)")); "b(int)")); REQUIRE_THAT(src, HasCall(_A("B<int>"), _A("A<int>"),
// REQUIRE_THAT(puml, !HasCall(_A("B<int>"), _A("A<int>"), "a1(int)"));
// "a2(int)")); REQUIRE_THAT(puml, !HasCall(_A("B<int>"), // REQUIRE_THAT(puml, !HasCall(_A("B<int>"), _A("A<int>"),
// _A("A<int>"), "a3(int)")); // "a2(int)")); REQUIRE_THAT(puml, !HasCall(_A("B<int>"),
// _A("A<int>"), "a3(int)"));
REQUIRE_THAT(src, REQUIRE_THAT(src,
HasCall(_A("tmain()"), _A("B<const char *>"), "b(const char *)")); HasCall(_A("tmain()"), _A("B<const char *>"), "b(const char
REQUIRE_THAT(src, *)")); REQUIRE_THAT(src, HasCall(_A("B<const char *>"), _A("A<const
HasCall(_A("B<const char *>"), _A("A<const char *>"), char *>"), "a2(const char *)"));
"a2(const char *)"));
REQUIRE_THAT(src, REQUIRE_THAT(src,
HasCall(_A("tmain()"), _A("B<std::string>"), "b(std::string)")); HasCall(_A("tmain()"), _A("B<std::string>"),
REQUIRE_THAT(src, "b(std::string)")); REQUIRE_THAT(src, HasCall( _A("B<std::string>"),
HasCall( _A("A<std::string>"), "a3(std::string)"));
_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. * 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);
{ REQUIRE_THAT(src, StartsWith("@startuml"));
auto src = generate_sequence_puml(diagram, *model); REQUIRE_THAT(src, EndsWith("@enduml\n"));
AliasMatcher _A(src);
REQUIRE_THAT(src, StartsWith("@startuml")); // Check if all calls exist
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>"),
"a(std::string)"));
// Check if all calls exist REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B<int>"), "b(int)"));
REQUIRE_THAT(src, REQUIRE_THAT(src, HasCall(_A("B<int>"), _A("A<int>"), "a(int)"));
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("tmain()"), _A("B<float>"),
REQUIRE_THAT(src, HasCall(_A("B<int>"), _A("A<int>"), "a(int)")); "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)")); save_puml(config.output_directory(), diagram->name + ".puml", src);
REQUIRE_THAT(src, HasCall(_A("B<float>"), _A("A<float>"), "a(float)")); }
save_puml(config.output_directory(), diagram->name + ".puml", src); {
} auto j = generate_sequence_json(diagram, *model);
{ using namespace json;
auto j = generate_sequence_json(diagram, *model);
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 = { REQUIRE(std::is_sorted(messages.begin(), messages.end()));
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())); 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);
{ mermaid::SequenceDiagramAliasMatcher _A(src);
auto src = generate_sequence_mermaid(diagram, *model); using mermaid::HasCall;
mermaid::SequenceDiagramAliasMatcher _A(src); REQUIRE_THAT(src,
using mermaid::HasCall; 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, REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B<int>"), "b(int)"));
HasCall(_A("tmain()"), _A("B<std::string>"), "b(std::string)")); REQUIRE_THAT(src, HasCall(_A("B<int>"), _A("A<int>"), "a(int)"));
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("tmain()"), _A("B<float>"),
REQUIRE_THAT(src, HasCall(_A("B<int>"), _A("A<int>"), "a(int)")); "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)")); save_mermaid(config.output_directory(), diagram->name + ".mmd",
REQUIRE_THAT(src, HasCall(_A("B<float>"), _A("A<float>"), "a(float)")); 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. * 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()"}, //
{ {"tmain()", "B<int>", "b4()"}, //
auto src = generate_sequence_puml(diagram, *model); {"B<int>", "A", "a4()"} //
AliasMatcher _A(src); }));
});
/*
{
auto src = generate_sequence_puml(diagram, *model);
AliasMatcher _A(src);
REQUIRE_THAT(src, StartsWith("@startuml")); REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n")); REQUIRE_THAT(src, EndsWith("@enduml\n"));
// Check if all calls exist // Check if all calls exist
REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B<int>"), "b1()")); 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("B<int>"), _A("A"), "a1()"));
REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B<int>"), "b2()")); 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("B<int>"), _A("A"), "a2()"));
REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B<int>"), "b3()")); 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("B<int>"), _A("A"), "a3()"));
REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B<int>"), "b4()")); 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("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 = { std::vector<int> messages = {
FindMessage(j, "tmain()", "B<int>", "b1()"), FindMessage(j, "tmain()", "B<int>", "b1()"),
FindMessage(j, "B<int>", "A", "a1()"), FindMessage(j, "B<int>", "A", "a1()"),
FindMessage(j, "tmain()", "B<int>", "b2()"), FindMessage(j, "tmain()", "B<int>", "b2()"),
FindMessage(j, "B<int>", "A", "a2()"), FindMessage(j, "B<int>", "A", "a2()"),
FindMessage(j, "tmain()", "B<int>", "b3()"), FindMessage(j, "tmain()", "B<int>", "b3()"),
FindMessage(j, "B<int>", "A", "a3()"), FindMessage(j, "B<int>", "A", "a3()"),
FindMessage(j, "tmain()", "B<int>", "b4()"), FindMessage(j, "tmain()", "B<int>", "b4()"),
FindMessage(j, "B<int>", "A", "a4()")}; 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); mermaid::SequenceDiagramAliasMatcher _A(src);
using mermaid::HasCall; using mermaid::HasCall;
REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B<int>"), "b1()")); 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("B<int>"), _A("A"), "a1()"));
REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B<int>"), "b2()")); 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("B<int>"), _A("A"), "a2()"));
REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B<int>"), "b3()")); 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("B<int>"), _A("A"), "a3()"));
REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B<int>"), "b4()")); 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("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. * 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); auto src = generate_sequence_puml(diagram, *model);
AliasMatcher _A(src); AliasMatcher _A(src);
@@ -80,4 +91,5 @@ TEST_CASE("t20011", "[test-case][sequence]")
save_mermaid(config.output_directory(), diagram->name + ".mmd", src); 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. * 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); auto src = generate_sequence_puml(diagram, *model);
AliasMatcher _A(src); AliasMatcher _A(src);
@@ -155,4 +198,5 @@ TEST_CASE("t20012", "[test-case][sequence]")
save_mermaid(config.output_directory(), diagram->name + ".mmd", src); 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. * 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); auto src = generate_sequence_puml(diagram, *model);
AliasMatcher _A(src); AliasMatcher _A(src);
@@ -85,5 +96,5 @@ TEST_CASE("t20013", "[test-case][sequence]")
REQUIRE_THAT(src, HasCall(_A("B"), _A("A"), "a3(const char *)")); REQUIRE_THAT(src, HasCall(_A("B"), _A("A"), "a3(const char *)"));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src); 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. * 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); auto src = generate_sequence_puml(diagram, *model);
AliasMatcher _A(src); AliasMatcher _A(src);
@@ -84,4 +95,5 @@ TEST_CASE("t20014", "[test-case][sequence]")
save_mermaid(config.output_directory(), diagram->name + ".mmd", src); 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. * 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"); REQUIRE(!HasMessage(src, {"B", "B", "set_x(int)"}));
{ REQUIRE(!HasMessage(src, {"B", "B", "set_y(int)"}));
auto src = generate_sequence_puml(diagram, *model); REQUIRE(!HasMessage(src, {"B", "B", "set_z(int)"}));
AliasMatcher _A(src); });
/*
{
auto src = generate_sequence_puml(diagram, *model);
AliasMatcher _A(src);
REQUIRE_THAT(src, StartsWith("@startuml")); REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n")); REQUIRE_THAT(src, EndsWith("@enduml\n"));
// Check if all calls exist // Check if all calls exist
REQUIRE_THAT(src, REQUIRE_THAT(src,
HasCall(_A("tmain()"), _A("B"), HasCall(_A("tmain()"), _A("B"),
"setup_a(std::shared_ptr<detail::A> &)")); "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_x(int)"));
REQUIRE_THAT(src, !HasCall(_A("B"), _A("detail::A"), "set_y(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("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_x(int)"));
REQUIRE_THAT(src, !HasCall(_A("B"), _A("B"), "set_y(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_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( std::vector<int> messages = {FindMessage(
j, "tmain()", "B", "setup_a(std::shared_ptr<detail::A> &)")}; 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); mermaid::SequenceDiagramAliasMatcher _A(src);
using mermaid::HasCall; using mermaid::HasCall;
REQUIRE_THAT(src, REQUIRE_THAT(src,
HasCall(_A("tmain()"), _A("B"), HasCall(_A("tmain()"), _A("B"),
"setup_a(std::shared_ptr<detail::A> &)")); "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_x(int)"));
REQUIRE_THAT(src, !HasCall(_A("B"), _A("detail::A"), "set_y(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("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_x(int)"));
REQUIRE_THAT(src, !HasCall(_A("B"), _A("B"), "set_y(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_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. * 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"); // Check if all calls exist
{ REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B<long>"),
auto src = generate_sequence_puml(diagram, *model); "b1(long)")); REQUIRE_THAT(src, HasCall(_A("B<long>"), _A("A"),
AliasMatcher _A(src); "a1(int)"));
REQUIRE_THAT(src, StartsWith("@startuml")); REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B<long>"),
REQUIRE_THAT(src, EndsWith("@enduml\n")); "b2(long)")); REQUIRE_THAT(src, HasCall(_A("B<long>"), _A("A"),
"a2(const long &)"));
// Check if all calls exist save_puml(config.output_directory(), diagram->name + ".puml",
REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B<long>"), "b1(long)")); src);
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 &)")); auto j = generate_sequence_json(diagram, *model);
save_puml(config.output_directory(), diagram->name + ".puml", src); using namespace json;
}
{ std::vector<int> messages = {
auto j = generate_sequence_json(diagram, *model); 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 = { save_json(config.output_directory(), diagram->name + ".json",
FindMessage(j, "tmain()", "B<long>", "b1(long)"), j);
FindMessage(j, "B<long>", "A", "a1(int)"), }
FindMessage(j, "tmain()", "B<long>", "b2(long)"),
FindMessage(j, "B<long>", "A", "a2(const long &)")};
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;
{ REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B<long>"),
auto src = generate_sequence_mermaid(diagram, *model); "b1(long)")); REQUIRE_THAT(src, HasCall(_A("B<long>"), _A("A"),
"a1(int)"));
mermaid::SequenceDiagramAliasMatcher _A(src); REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B<long>"),
using mermaid::HasCall; "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)")); save_mermaid(config.output_directory(), diagram->name + ".mmd",
REQUIRE_THAT(src, HasCall(_A("B<long>"), _A("A"), "a1(int)")); src);
}
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);
}
} }

28
tests/t20017/test_case.h
View File

@@ -16,17 +16,27 @@
* limitations under the License. * 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"); CHECK_SEQUENCE_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(MessageOrder(src,
auto model = generate_sequence_diagram(*db, diagram); {
//
REQUIRE(model->name() == "t20017_sequence"); // {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); auto src = generate_sequence_puml(diagram, *model);
AliasMatcher _A(src); AliasMatcher _A(src);
@@ -105,5 +115,5 @@ TEST_CASE("t20017", "[test-case][sequence]")
REQUIRE_THAT(src, HasExitpoint(_A("t20017.cc"))); REQUIRE_THAT(src, HasExitpoint(_A("t20017.cc")));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src); 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. * 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)__"));
{ save_puml(config.output_directory(), diagram->name + ".puml", src);
auto src = generate_sequence_puml(diagram, *model); }
AliasMatcher _A(src);
REQUIRE_THAT(src, StartsWith("@startuml")); {
REQUIRE_THAT(src, EndsWith("@enduml\n")); auto j = generate_sequence_json(diagram, *model);
// Check if all calls exist using namespace json;
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_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)")};
{ REQUIRE(std::is_sorted(messages.begin(), messages.end()));
auto j = generate_sequence_json(diagram, *model);
using namespace json; save_json(config.output_directory(), diagram->name + ".json", j);
}
std::vector<int> messages = { {
FindMessage(j, "tmain()", "Answer<Factorial<5>,120>", "print()"), auto src = generate_sequence_mermaid(diagram, *model);
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)")};
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)"));
{ save_mermaid(config.output_directory(), diagram->name + ".mmd",
auto src = generate_sequence_mermaid(diagram, *model); src);
}
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);
}
} }

25
tests/t20019/test_case.h
View File

@@ -16,18 +16,24 @@
* limitations under the License. * 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"]; auto [config, db, diagram, model] =
CHECK_SEQUENCE_MODEL("t20019", "t20019_sequence");
REQUIRE(diagram->name == "t20019_sequence");
auto model = generate_sequence_diagram(*db, diagram);
REQUIRE(model->name() == "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); auto src = generate_sequence_puml(diagram, *model);
AliasMatcher _A(src); AliasMatcher _A(src);
@@ -73,4 +79,5 @@ TEST_CASE("t20019", "[test-case][sequence]")
save_mermaid(config.output_directory(), diagram->name + ".mmd", src); 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. * 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"); // Check if all calls exist
{ REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("A"), "a1()"));
auto src = generate_sequence_puml(diagram, *model); REQUIRE_THAT(
AliasMatcher _A(src); src, HasCallInControlCondition(_A("tmain()"), _A("A"), "a2()"));
REQUIRE_THAT(
src, HasCallInControlCondition(_A("tmain()"), _A("A"), "a3()"));
REQUIRE_THAT(src, StartsWith("@startuml")); REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B"), "b1()"));
REQUIRE_THAT(src, EndsWith("@enduml\n")); 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("C"), "c1() const"));
REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("A"), "a1()")); REQUIRE_THAT(
REQUIRE_THAT( src, HasCallInControlCondition(_A("C"), _A("C"), "c2() const"));
src, HasCallInControlCondition(_A("tmain()"), _A("A"), "a2()")); REQUIRE_THAT(src, HasCall(_A("C"), _A("C"), "log() const"));
REQUIRE_THAT(
src, HasCallInControlCondition(_A("tmain()"), _A("A"), "a3()"));
REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B"), "b1()")); REQUIRE_THAT(
REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B"), "b2()")); src, HasCallInControlCondition(_A("tmain()"), _A("C"),
REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B"), "log()")); "c3(int)"));
REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("C"), "c1() const")); save_puml(config.output_directory(), diagram->name + ".puml", src);
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)")); auto j = generate_sequence_json(diagram, *model);
save_puml(config.output_directory(), diagram->name + ".puml", src); using namespace json;
}
{ std::vector<int> messages = {FindMessage(j, "tmain()", "A", "a1()"),
auto j = generate_sequence_json(diagram, *model); 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()"), save_json(config.output_directory(), diagram->name + ".json", j);
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)")};
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;
{ REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("A"), "a1()"));
auto src = generate_sequence_mermaid(diagram, *model); REQUIRE_THAT(
src, HasCallInControlCondition(_A("tmain()"), _A("A"), "a2()"));
REQUIRE_THAT(
src, HasCallInControlCondition(_A("tmain()"), _A("A"), "a3()"));
mermaid::SequenceDiagramAliasMatcher _A(src); REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B"), "b1()"));
using mermaid::HasCall; REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B"), "b2()"));
using mermaid::HasCallInControlCondition; REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B"), "log()"));
REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("A"), "a1()")); REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("C"), "c1() const"));
REQUIRE_THAT( REQUIRE_THAT(
src, HasCallInControlCondition(_A("tmain()"), _A("A"), "a2()")); src, HasCallInControlCondition(_A("C"), _A("C"), "c2() const"));
REQUIRE_THAT( REQUIRE_THAT(src, HasCall(_A("C"), _A("C"), "log() const"));
src, HasCallInControlCondition(_A("tmain()"), _A("A"), "a3()"));
REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B"), "b1()")); REQUIRE_THAT(
REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B"), "b2()")); src, HasCallInControlCondition(_A("tmain()"), _A("C"),
REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B"), "log()")); "c3(int)"));
REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("C"), "c1() const")); save_mermaid(config.output_directory(), diagram->name + ".mmd",
REQUIRE_THAT( src);
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);
}
} }

32
tests/t20021/test_case.h
View File

@@ -16,17 +16,31 @@
* limitations under the License. * 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"); CHECK_SEQUENCE_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(MessageOrder(src,
auto model = generate_sequence_diagram(*db, diagram); {
//
REQUIRE(model->name() == "t20021_sequence"); {"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); auto src = generate_sequence_puml(diagram, *model);
AliasMatcher _A(src); AliasMatcher _A(src);
@@ -113,5 +127,5 @@ TEST_CASE("t20021", "[test-case][sequence]")
HasCallInControlCondition(_A("tmain()"), _A("C"), "contents()")); HasCallInControlCondition(_A("tmain()"), _A("C"), "contents()"));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src); 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. * 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"); REQUIRE_THAT(src, StartsWith("@startuml"));
{ REQUIRE_THAT(src, EndsWith("@enduml\n"));
auto src = generate_sequence_puml(diagram, *model);
AliasMatcher _A(src);
REQUIRE_THAT(src, StartsWith("@startuml")); // Check if all calls exist
REQUIRE_THAT(src, EndsWith("@enduml\n")); REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("A"), "a()"));
REQUIRE_THAT(src, HasCall(_A("A"), _A("B"), "b()"));
// Check if all calls exist save_puml(config.output_directory(), diagram->name + ".puml", src);
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); {
} auto j = generate_sequence_json(diagram, *model);
{ using namespace json;
auto j = generate_sequence_json(diagram, *model);
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()"), REQUIRE(std::is_sorted(messages.begin(), messages.end()));
FindMessage(j, "A", "B", "b()")};
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);
{ mermaid::SequenceDiagramAliasMatcher _A(src);
auto src = generate_sequence_mermaid(diagram, *model); using mermaid::HasCall;
mermaid::SequenceDiagramAliasMatcher _A(src); REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("A"), "a()"));
using mermaid::HasCall; REQUIRE_THAT(src, HasCall(_A("A"), _A("B"), "b()"));
REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("A"), "a()")); save_mermaid(config.output_directory(), diagram->name + ".mmd",
REQUIRE_THAT(src, HasCall(_A("A"), _A("B"), "b()")); 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. * 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"); REQUIRE_THAT(src, StartsWith("@startuml"));
{ REQUIRE_THAT(src, EndsWith("@enduml\n"));
auto src = generate_sequence_puml(diagram, *model);
AliasMatcher _A(src);
REQUIRE_THAT(src, StartsWith("@startuml")); // Check if all calls exist
REQUIRE_THAT(src, EndsWith("@enduml\n")); 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 save_puml(config.output_directory(), diagram->name + ".puml", src);
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); {
} auto j = generate_sequence_json(diagram, *model);
{ using namespace json;
auto j = generate_sequence_json(diagram, *model);
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()"), REQUIRE(std::is_sorted(messages.begin(), messages.end()));
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())); 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);
{ mermaid::SequenceDiagramAliasMatcher _A(src);
auto src = generate_sequence_mermaid(diagram, *model); using mermaid::HasCall;
mermaid::SequenceDiagramAliasMatcher _A(src); REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("A"), "a()"));
using mermaid::HasCall; 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()")); save_mermaid(config.output_directory(), diagram->name + ".mmd",
REQUIRE_THAT(src, HasCall(_A("A"), _A("A"), "a1()")); src);
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);
}
} }

30
tests/t20024/test_case.h
View File

@@ -16,17 +16,31 @@
* limitations under the License. * 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); {"tmain()", "B", "select(colors)"}, //
{"B", "B", "red()"}, //
REQUIRE(model->name() == "t20024_sequence"); {"B", "B", "orange()"}, //
{"B", "B", "green()"}, //
{"B", "B", "grey()"} //
}));
});
/*
{ {
auto src = generate_sequence_puml(diagram, *model); auto src = generate_sequence_puml(diagram, *model);
AliasMatcher _A(src); AliasMatcher _A(src);
@@ -82,5 +96,5 @@ TEST_CASE("t20024", "[test-case][sequence]")
REQUIRE_THAT(src, HasCall(_A("B"), _A("B"), "green()")); REQUIRE_THAT(src, HasCall(_A("B"), _A("B"), "green()"));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src); 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. * 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"); CHECK_SEQUENCE_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(MessageOrder(src,
auto model = generate_sequence_diagram(*db, diagram); {
//
REQUIRE(model->name() == "t20025_sequence"); {"tmain()", "A", "a()"}, //
{"tmain()", "add(int,int)", ""} //
}));
});
/*
{ {
auto src = generate_sequence_puml(diagram, *model); auto src = generate_sequence_puml(diagram, *model);
AliasMatcher _A(src); AliasMatcher _A(src);
@@ -71,5 +76,5 @@ TEST_CASE("t20025", "[test-case][sequence]")
REQUIRE_THAT(src, !HasCall(_A("tmain()"), _A("add2(int,int)"), "")); REQUIRE_THAT(src, !HasCall(_A("tmain()"), _A("add2(int,int)"), ""));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src); 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. * 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"); CHECK_SEQUENCE_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(MessageOrder(src,
auto model = generate_sequence_diagram(*db, diagram); {
//
REQUIRE(model->name() == "t20026_sequence"); {"tmain()", "A", "a()"} //
}));
});
/*
{ {
auto src = generate_sequence_puml(diagram, *model); auto src = generate_sequence_puml(diagram, *model);
AliasMatcher _A(src); AliasMatcher _A(src);
@@ -61,5 +65,5 @@ TEST_CASE("t20026", "[test-case][sequence]")
REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("A"), "a()")); REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("A"), "a()"));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src); 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. * 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); auto src = generate_sequence_puml(diagram, *model);
AliasMatcher _A(src); AliasMatcher _A(src);
@@ -65,5 +73,5 @@ TEST_CASE("t20027", "[test-case][sequence]")
REQUIRE_THAT(src, !HasCall(_A("A"), _A("A"), "aaa()")); REQUIRE_THAT(src, !HasCall(_A("A"), _A("A"), "aaa()"));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src); 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. * 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); auto src = generate_sequence_puml(diagram, *model);
AliasMatcher _A(src); AliasMatcher _A(src);
@@ -75,5 +85,5 @@ TEST_CASE("t20028", "[test-case][sequence]")
REQUIRE_THAT(src, !HasCall(_A("tmain()"), _A("B"), "e()")); REQUIRE_THAT(src, !HasCall(_A("tmain()"), _A("B"), "e()"));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src); 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. * 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"); REQUIRE(HasMessageComment(src, "tmain()",
{ "Establish connection to the\\n"
auto src = generate_sequence_puml(diagram, *model); "remote server synchronously"));
AliasMatcher _A(src);
REQUIRE_THAT(src, StartsWith("@startuml")); REQUIRE(HasMessageComment(src, "tmain()",
REQUIRE_THAT(src, EndsWith("@enduml\n")); "Repeat for each line in the\\n"
"input stream"));
// Check if all calls exist REQUIRE(HasMessageComment(src, "Encoder<Retrier<ConnectionPool>>",
REQUIRE_THAT( "Encode the message using\\n"
src, HasCall(_A("tmain()"), _A("ConnectionPool"), "connect()")); "Base64 encoding and pass\\n"
REQUIRE_THAT(src, "it to the next layer"));
HasCallInControlCondition(_A("tmain()"),
_A("Encoder<Retrier<ConnectionPool>>"),
"send(std::string &&)"));
REQUIRE_THAT(src, REQUIRE(HasMessageComment(src, "Retrier<ConnectionPool>",
HasCall(_A("Encoder<Retrier<ConnectionPool>>"), "Repeat until send() succeeds\\n"
_A("Encoder<Retrier<ConnectionPool>>"), "or retry count is exceeded"));
"encode(std::string &&)")); });
/*
{
auto src = generate_sequence_puml(diagram, *model);
AliasMatcher _A(src);
REQUIRE_THAT(src, REQUIRE_THAT(src, StartsWith("@startuml"));
HasCall(_A("Encoder<Retrier<ConnectionPool>>"), REQUIRE_THAT(src, EndsWith("@enduml\n"));
_A("encode_b64(std::string &&)"), ""));
REQUIRE_THAT(src, // Check if all calls exist
HasCallInControlCondition(_A("Retrier<ConnectionPool>"), REQUIRE_THAT(
_A("ConnectionPool"), "send(const std::string &)")); src, HasCall(_A("tmain()"), _A("ConnectionPool"), "connect()"));
REQUIRE_THAT(src,
HasCallInControlCondition(_A("tmain()"),
_A("Encoder<Retrier<ConnectionPool>>"),
"send(std::string &&)"));
REQUIRE_THAT(src, REQUIRE_THAT(src,
!HasCall( HasCall(_A("Encoder<Retrier<ConnectionPool>>"),
_A("ConnectionPool"), _A("ConnectionPool"), "connect_impl()")); _A("Encoder<Retrier<ConnectionPool>>"),
"encode(std::string &&)"));
REQUIRE_THAT(src, REQUIRE_THAT(src,
HasMessageComment(_A("tmain()"), HasCall(_A("Encoder<Retrier<ConnectionPool>>"),
"Establish connection to the\\n" _A("encode_b64(std::string &&)"), ""));
"remote server synchronously"));
REQUIRE_THAT(src, REQUIRE_THAT(src,
HasMessageComment(_A("tmain()"), HasCallInControlCondition(_A("Retrier<ConnectionPool>"),
"Repeat for each line in the\\n" _A("ConnectionPool"), "send(const std::string &)"));
"input stream"));
REQUIRE_THAT(src, REQUIRE_THAT(src,
HasMessageComment(_A("Encoder<Retrier<ConnectionPool>>"), !HasCall(
"Encode the message using\\n" _A("ConnectionPool"), _A("ConnectionPool"),
"Base64 encoding and pass\\n" "connect_impl()"));
"it to the next layer"));
REQUIRE_THAT(src, REQUIRE_THAT(src,
HasMessageComment(_A("Retrier<ConnectionPool>"), HasMessageComment(_A("tmain()"),
"Repeat until send\\(\\) succeeds\\n" "Establish connection to the\\n"
"or retry count is exceeded")); "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"));
{ REQUIRE_THAT(src,
auto j = generate_sequence_json(diagram, *model); 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()"), auto j = generate_sequence_json(diagram, *model);
FindMessage(j, "tmain()", "Encoder<Retrier<ConnectionPool>>",
"send(std::string &&)")};
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());
}
{ std::vector<int> messages = {
auto src = generate_sequence_mermaid(diagram, *model); FindMessage(j, "tmain()", "ConnectionPool", "connect()"),
FindMessage(j, "tmain()", "Encoder<Retrier<ConnectionPool>>",
"send(std::string &&)")};
mermaid::SequenceDiagramAliasMatcher _A(src); REQUIRE(std::is_sorted(messages.begin(), messages.end()));
using mermaid::HasCall;
using mermaid::HasCallInControlCondition;
using mermaid::HasMessageComment;
REQUIRE_THAT( save_json(config.output_directory(), diagram->name + ".json", j);
src, HasCall(_A("tmain()"), _A("ConnectionPool"), "connect()")); }
REQUIRE_THAT(src,
HasCallInControlCondition(_A("tmain()"),
_A("Encoder<Retrier<ConnectionPool>>"),
"send(std::string &&)"));
REQUIRE_THAT(src, {
HasCall(_A("Encoder<Retrier<ConnectionPool>>"), auto src = generate_sequence_mermaid(diagram, *model);
_A("Encoder<Retrier<ConnectionPool>>"),
"encode(std::string &&)"));
REQUIRE_THAT(src, mermaid::SequenceDiagramAliasMatcher _A(src);
HasCall(_A("Encoder<Retrier<ConnectionPool>>"), using mermaid::HasCall;
_A("encode_b64(std::string &&)"), "")); using mermaid::HasCallInControlCondition;
using mermaid::HasMessageComment;
REQUIRE_THAT(src, REQUIRE_THAT(
HasCallInControlCondition(_A("Retrier<ConnectionPool>"), src, HasCall(_A("tmain()"), _A("ConnectionPool"), "connect()"));
_A("ConnectionPool"), "send(const std::string &)")); REQUIRE_THAT(src,
HasCallInControlCondition(_A("tmain()"),
_A("Encoder<Retrier<ConnectionPool>>"),
"send(std::string &&)"));
REQUIRE_THAT(src, REQUIRE_THAT(src,
!HasCall( HasCall(_A("Encoder<Retrier<ConnectionPool>>"),
_A("ConnectionPool"), _A("ConnectionPool"), "connect_impl()")); _A("Encoder<Retrier<ConnectionPool>>"),
"encode(std::string &&)"));
REQUIRE_THAT(src, REQUIRE_THAT(src,
HasMessageComment(_A("tmain()"), HasCall(_A("Encoder<Retrier<ConnectionPool>>"),
"Establish connection to the<br/>" _A("encode_b64(std::string &&)"), ""));
"remote server synchronously"));
REQUIRE_THAT(src, REQUIRE_THAT(src,
HasMessageComment(_A("tmain()"), HasCallInControlCondition(_A("Retrier<ConnectionPool>"),
"Repeat for each line in the<br/>" _A("ConnectionPool"), "send(const std::string &)"));
"input stream"));
REQUIRE_THAT(src, REQUIRE_THAT(src,
HasMessageComment(_A("Encoder<Retrier<ConnectionPool>>"), !HasCall(
"Encode the message using<br/>" _A("ConnectionPool"), _A("ConnectionPool"),
"Base64 encoding and pass<br/>" "connect_impl()"));
"it to the next layer"));
REQUIRE_THAT(src, REQUIRE_THAT(src,
HasMessageComment(_A("Retrier<ConnectionPool>"), HasMessageComment(_A("tmain()"),
"Repeat until send\\(\\) succeeds<br/>" "Establish connection to the<br/>"
"or retry count is exceeded")); "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. * 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()"), ""));
{ REQUIRE_THAT(src, HasCall(_A("A"), _A("A"), "create()"));
auto src = generate_sequence_puml(diagram, *model); REQUIRE_THAT(
AliasMatcher _A(src); 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, HasCall(_A("tmain(bool,int)"), _A("A"), "A()"));
REQUIRE_THAT(src, EndsWith("@enduml\n")); 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 save_puml(config.output_directory(), diagram->name + ".puml", src);
REQUIRE_THAT(src, HasCall(_A("tmain(int)"), _A("magic()"), "")); }
REQUIRE_THAT(src, HasCall(_A("A"), _A("A"), "create()")); {
REQUIRE_THAT( auto j = generate_sequence_json(diagram, *model);
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()")); using namespace json;
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_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()"), ""));
}
{ REQUIRE_THAT(src, HasCall(_A("A"), _A("A"), "create()"));
auto src = generate_sequence_mermaid(diagram, *model); 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); REQUIRE_THAT(src, HasCall(_A("tmain(bool,int)"), _A("A"), "A()"));
using mermaid::HasCall; 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()"), "")); save_mermaid(config.output_directory(), diagram->name + ".mmd",
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, 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);
}
} }

26
tests/t20031/test_case.h
View File

@@ -16,18 +16,23 @@
* limitations under the License. * 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"]; auto [config, db, diagram, model] =
CHECK_SEQUENCE_MODEL("t20031", "t20031_sequence");
REQUIRE(diagram->name == "t20031_sequence");
auto model = generate_sequence_diagram(*db, diagram);
REQUIRE(model->name() == "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); auto src = generate_sequence_puml(diagram, *model);
AliasMatcher _A(src); AliasMatcher _A(src);
@@ -94,4 +99,5 @@ TEST_CASE("t20031", "[test-case][sequence]")
save_mermaid(config.output_directory(), diagram->name + ".mmd", src); 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. * 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"); {"tmain(int,char **)", "B", "b(const char *)"}, //
{"B", "A", "a3(const char *)"}, //
REQUIRE(model->name() == "t20032_sequence"); {"A", "B", "const char *", Response{}}, //
{"B", "tmain(int,char **)", "const char *", Response{}} //
}));
});
/*
{ {
auto src = generate_sequence_puml(diagram, *model); auto src = generate_sequence_puml(diagram, *model);
AliasMatcher _A(src); AliasMatcher _A(src);
@@ -100,5 +115,5 @@ TEST_CASE("t20032", "[test-case][sequence]")
REQUIRE_THAT(src, HasResponse(_A("B"), _A("A"), "const char *")); REQUIRE_THAT(src, HasResponse(_A("B"), _A("A"), "const char *"));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src); 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. * 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()"}, //
{ {"tmain()", "A", "a3()"}, //
auto src = generate_sequence_puml(diagram, *model);
AliasMatcher _A(src);
REQUIRE_THAT(src, StartsWith("@startuml")); {"tmain()", "A", "a2()"}, //
REQUIRE_THAT(src, EndsWith("@enduml\n"));
// Check if all calls exist {"tmain()", "A", "a4()"}, //
REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("A"), "a1()")); {"tmain()", "A", "a3()", InControlCondition{}}, //
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_puml(config.output_directory(), diagram->name + ".puml", src); {"tmain()", "A", "a4()", InControlCondition{}}, //
}
{ {"tmain()", "A", "a4()"} //
auto j = generate_sequence_json(diagram, *model); }));
});
/*
{
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()"));
{ save_puml(config.output_directory(), diagram->name + ".puml", src);
auto src = generate_sequence_mermaid(diagram, *model); }
mermaid::SequenceDiagramAliasMatcher _A(src); {
using mermaid::HasCall; auto j = generate_sequence_json(diagram, *model);
using mermaid::HasCallInControlCondition;
REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("A"), "a1()")); using namespace json;
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); 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. * 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()"));
{ REQUIRE_THAT(src, HasCall(_A("D"), _A("C"), "c3()"));
auto src = generate_sequence_puml(diagram, *model); REQUIRE_THAT(src, HasCall(_A("C"), _A("C"), "c2()"));
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, HasCall(_A("D"), _A("C"), "c4()"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
// Check if all calls exist REQUIRE_THAT(src, !HasCall(_A("C"), _A("B"), "b3()"));
REQUIRE_THAT(src, HasCall(_A("D"), _A("A"), "a2()"));
REQUIRE_THAT(src, HasCall(_A("D"), _A("C"), "c3()")); save_puml(config.output_directory(), diagram->name +
REQUIRE_THAT(src, HasCall(_A("C"), _A("C"), "c2()")); ".puml", src);
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()")); {
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"}}));
{ save_json(config.output_directory(), diagram->name +
auto j = generate_sequence_json(diagram, *model); ".json", j);
}
using namespace json; {
auto src = generate_sequence_mermaid(diagram, *model);
REQUIRE(HasMessageChain(j, mermaid::SequenceDiagramAliasMatcher _A(src);
{{"d2()", "c3()", "void"}, {"c3()", "c2()", "void"}, using mermaid::HasCall;
{"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"}}));
save_json(config.output_directory(), diagram->name + ".json", j); REQUIRE_THAT(src, HasCall(_A("D"), _A("A"), "a2()"));
}
{ REQUIRE_THAT(src, HasCall(_A("D"), _A("C"), "c3()"));
auto src = generate_sequence_mermaid(diagram, *model); 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); REQUIRE_THAT(src, HasCall(_A("D"), _A("C"), "c4()"));
using mermaid::HasCall;
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()")); save_mermaid(config.output_directory(), diagram->name +
REQUIRE_THAT(src, HasCall(_A("C"), _A("C"), "c2()")); ".mmd", src);
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);
}
} }

80
tests/t20035/test_case.h
View File

@@ -16,54 +16,62 @@
* limitations under the License. * 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)"), ""));
{ save_puml(config.output_directory(), diagram->name + ".puml", src);
auto src = generate_sequence_puml(diagram, *model); }
AliasMatcher _A(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)"), "")); using namespace json;
REQUIRE_THAT(src, HasCall(_A("a(int)"), _A("b1(int)"), ""));
REQUIRE_THAT(src, HasCall(_A("b1(int)"), _A("c(int)"), ""));
save_puml(config.output_directory(), diagram->name + ".puml", src); REQUIRE(HasMessageChain(j,
} {{"tmain(int,char **)", "a(int)", "int"},
{"a(int)", "b1(int)", "int"}, {"b1(int)", "c(int)",
"int"}}));
{ save_json(config.output_directory(), diagram->name + ".json", j);
auto j = generate_sequence_json(diagram, *model); }
using namespace json; {
auto src = generate_sequence_mermaid(diagram, *model);
REQUIRE(HasMessageChain(j, mermaid::SequenceDiagramAliasMatcher _A(src);
{{"tmain(int,char **)", "a(int)", "int"}, using mermaid::HasCall;
{"a(int)", "b1(int)", "int"}, {"b1(int)", "c(int)", "int"}}));
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)"), ""));
{ save_mermaid(config.output_directory(), diagram->name + ".mmd",
auto src = generate_sequence_mermaid(diagram, *model); src);
}
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);
}
} }

149
tests/t20036/test_case.h
View File

@@ -16,78 +16,119 @@
* limitations under the License. * 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()"));
{ REQUIRE_THAT(src, HasCall(_A("C"), _A("B"), "b2()"));
auto src = generate_sequence_puml(diagram, *model); REQUIRE_THAT(src, HasCall(_A("B"), _A("A"), "a2()"));
AliasMatcher _A(src);
REQUIRE_THAT(src, StartsWith("@startuml")); REQUIRE_THAT(src, HasCall(_A("D"), _A("A"), "a2()"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
REQUIRE_THAT(src, HasCall(_A("C"), _A("C"), "c2()")); REQUIRE_THAT(src, HasCall(_A("C"), _A("B"), "b1()"));
REQUIRE_THAT(src, HasCall(_A("C"), _A("B"), "b2()")); REQUIRE_THAT(src, HasCall(_A("B"), _A("A"), "a2()"));
REQUIRE_THAT(src, HasCall(_A("B"), _A("A"), "a2()"));
REQUIRE_THAT(src, HasCall(_A("C"), _A("B"), "b2()")); save_puml(config.output_directory(), diagram->name + ".puml", src);
REQUIRE_THAT(src, HasCall(_A("B"), _A("A"), "a2()")); }
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()")); using namespace json;
REQUIRE_THAT(src, HasCall(_A("B"), _A("A"), "a2()"));
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"}}));
{ save_json(config.output_directory(), diagram->name + ".json", j);
auto j = generate_sequence_json(diagram, *model); }
using namespace json; {
auto src = generate_sequence_mermaid(diagram, *model);
REQUIRE(HasMessageChain(j, mermaid::SequenceDiagramAliasMatcher _A(src);
{{"c3()", "c2()", "void"}, {"c2()", "b2()", "void"}, using mermaid::HasCall;
{"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"}}));
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()"));
{ REQUIRE_THAT(src, HasCall(_A("C"), _A("B"), "b2()"));
auto src = generate_sequence_mermaid(diagram, *model); REQUIRE_THAT(src, HasCall(_A("B"), _A("A"), "a2()"));
mermaid::SequenceDiagramAliasMatcher _A(src); REQUIRE_THAT(src, HasCall(_A("D"), _A("A"), "a2()"));
using mermaid::HasCall;
REQUIRE_THAT(src, HasCall(_A("C"), _A("C"), "c2()")); REQUIRE_THAT(src, HasCall(_A("C"), _A("B"), "b1()"));
REQUIRE_THAT(src, HasCall(_A("C"), _A("B"), "b2()")); REQUIRE_THAT(src, HasCall(_A("B"), _A("A"), "a2()"));
REQUIRE_THAT(src, HasCall(_A("B"), _A("A"), "a2()"));
REQUIRE_THAT(src, HasCall(_A("C"), _A("B"), "b2()")); save_mermaid(config.output_directory(), diagram->name + ".mmd",
REQUIRE_THAT(src, HasCall(_A("B"), _A("A"), "a2()")); src);
}*/
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);
}
} }

96
tests/t20037/test_case.h
View File

@@ -16,60 +16,76 @@
* limitations under the License. * 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"));
{ REQUIRE_THAT(src, HasCall(_A("tmain(int,char **)"), _A("a()"), ""));
auto src = generate_sequence_puml(diagram, *model); REQUIRE_THAT(src, HasCall(_A("a()"), _A("initb()"), ""));
AliasMatcher _A(src); REQUIRE_THAT(src, HasCall(_A("a()"), _A("B"), "get()"));
REQUIRE_THAT(src, HasCall(_A("a()"), _A("c()"), ""));
REQUIRE_THAT(src, StartsWith("@startuml")); save_puml(config.output_directory(), diagram->name + ".puml", src);
REQUIRE_THAT(src, EndsWith("@enduml\n")); }
REQUIRE_THAT(src, HasCall(_A("tmain(int,char **)"), _A("a()"), "")); {
REQUIRE_THAT(src, HasCall(_A("a()"), _A("initb()"), "")); auto j = generate_sequence_json(diagram, *model);
REQUIRE_THAT(src, HasCall(_A("a()"), _A("B"), "get()"));
REQUIRE_THAT(src, HasCall(_A("a()"), _A("c()"), ""));
save_puml(config.output_directory(), diagram->name + ".puml", src); using namespace json;
}
{ std::vector<int> messages = {
auto j = generate_sequence_json(diagram, *model); 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 = { save_json(config.output_directory(), diagram->name + ".json", j);
FindMessage(j, "tmain(int,char **)", "a()", ""), }
FindMessage(j, "a()", "initb()", ""),
FindMessage(j, "a()", "B", "get()"),
FindMessage(j, "a()", "c()", "")};
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;
{ REQUIRE_THAT(src, HasCall(_A("tmain(int,char **)"), _A("a()"), ""));
auto src = generate_sequence_mermaid(diagram, *model); 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); save_mermaid(config.output_directory(), diagram->name + ".mmd",
using mermaid::HasCall; 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()"), ""));
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. * 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)", ""}, //
{ {"tmain()", "B", "wrap(int)"}, //
auto src = generate_sequence_puml(diagram, *model);
AliasMatcher _A(src);
REQUIRE_THAT(src, StartsWith("@startuml")); {"tmain()", "add_impl<double>(double,double)", ""}, //
REQUIRE_THAT(src, EndsWith("@enduml\n"));
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, REQUIRE_THAT(src, !HasCall(_A("tmain()"), _A("B"), "bb()"));
HasMessageComment(_A("tmain()"),
"This comment should be rendered only\\n"
"once"));
REQUIRE_THAT(src, REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B"), "bbb()"));
HasCall(_A("tmain()"), _A("add_impl<double>(double,double)"), ""));
REQUIRE_THAT( REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B"), "bbbb()"));
src, HasMessageComment(_A("tmain()"), "What is 2 \\+ 2\\?"));
REQUIRE_THAT(src, REQUIRE_THAT(src,
!HasMessageComment( HasMessageComment(_A("tmain()"),
_A("tmain()"), "This is specific for some_other_diagram")); "This comment should be rendered only\\n"
"once"));
REQUIRE_THAT( REQUIRE_THAT(src,
src, HasMessageComment(_A("tmain()"), "Calling B::bbbbb\\(\\)")); 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, REQUIRE_THAT(src,
HasMessageComment(_A("tmain()"), "This is a conditional operator")); !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\\(\\)"));
{ REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B"), "bbbbb()"));
auto j = generate_sequence_json(diagram, *model);
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 namespace json;
using mermaid::HasCall;
using mermaid::HasCallInControlCondition;
using mermaid::HasMessageComment;
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, REQUIRE_THAT(src, !HasCall(_A("tmain()"), _A("B"), "bb()"));
HasMessageComment(_A("tmain()"),
"This comment should be rendered only<br/>"
"once"));
REQUIRE_THAT(src, REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B"), "bbb()"));
HasCall(_A("tmain()"), _A("add_impl<double>(double,double)"), ""));
REQUIRE_THAT( REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B"), "bbbb()"));
src, HasMessageComment(_A("tmain()"), "What is 2 \\+ 2\\?"));
REQUIRE_THAT(src, REQUIRE_THAT(src,
!HasMessageComment( HasMessageComment(_A("tmain()"),
_A("tmain()"), "This is specific for some_other_diagram")); "This comment should be rendered only<br/>"
"once"));
REQUIRE_THAT( REQUIRE_THAT(src,
src, HasMessageComment(_A("tmain()"), "Calling B::bbbbb\\(\\)")); 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, REQUIRE_THAT(src,
!HasMessageComment( !HasMessageComment(
_A("tmain()"), "This is specific for some_other_diagram")); _A("tmain()"), "This is specific for some_other_diagram"));
REQUIRE_THAT( REQUIRE_THAT(
src, HasMessageComment(_A("tmain()"), "Calling B::bbbbb\\(\\)")); 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. * 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"]; auto [config, db, diagram, model] =
CHECK_SEQUENCE_MODEL("t20039", "t20039_sequence");
REQUIRE(diagram->name == "t20039_sequence");
auto model = generate_sequence_diagram(*db, diagram);
REQUIRE(model->name() == "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); auto src = generate_sequence_puml(diagram, *model);
AliasMatcher _A(src); 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)")); src, HasCall(_A("R"), _A("A<string_map_t>"), "a(string_map_t)"));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src); 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. * 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"));
{ REQUIRE_THAT(src,
auto src = generate_sequence_puml(diagram, *model); HasCall(_A("tmain()"),
AliasMatcher _A(src); _A("print<int,double,std::string>(int,double,std::string)"),
""));
REQUIRE_THAT(src, StartsWith("@startuml")); REQUIRE_THAT(src,
REQUIRE_THAT(src, EndsWith("@enduml\n")); HasCall(_A("print<int,double,std::string>(int,double,std::string)"),
_A("print<double,std::string>(double,std::string)"), ""));
REQUIRE_THAT(src, REQUIRE_THAT(src,
HasCall(_A("tmain()"), HasCall(_A("print<double,std::string>(double,std::string)"),
_A("print<int,double,std::string>(int,double,std::string)"), _A("print<std::string>(std::string)"), ""));
""));
REQUIRE_THAT(src, REQUIRE_THAT(src,
HasCall(_A("print<int,double,std::string>(int,double,std::string)"), HasCall(_A("print<std::string>(std::string)"), _A("print()"),
_A("print<double,std::string>(double,std::string)"), "")); ""));
REQUIRE_THAT(src, save_puml(config.output_directory(), diagram->name + ".puml", 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()"), "")); auto j = generate_sequence_json(diagram, *model);
save_puml(config.output_directory(), diagram->name + ".puml", src); using namespace json;
}
{ save_json(config.output_directory(), diagram->name + ".json", j);
auto j = generate_sequence_json(diagram, *model); }
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;
{ REQUIRE_THAT(src,
auto src = generate_sequence_mermaid(diagram, *model); HasCall(_A("tmain()"),
_A("print<int,double,std::string>(int,double,std::string)"),
""));
mermaid::SequenceDiagramAliasMatcher _A(src); REQUIRE_THAT(src,
using mermaid::HasCall; HasCall(_A("print<int,double,std::string>(int,double,std::string)"),
_A("print<double,std::string>(double,std::string)"), ""));
REQUIRE_THAT(src, REQUIRE_THAT(src,
HasCall(_A("tmain()"), HasCall(_A("print<double,std::string>(double,std::string)"),
_A("print<int,double,std::string>(int,double,std::string)"), _A("print<std::string>(std::string)"), ""));
""));
REQUIRE_THAT(src, REQUIRE_THAT(src,
HasCall(_A("print<int,double,std::string>(int,double,std::string)"), HasCall(_A("print<std::string>(std::string)"), _A("print()"),
_A("print<double,std::string>(double,std::string)"), "")); ""));
REQUIRE_THAT(src, save_mermaid(config.output_directory(), diagram->name + ".mmd",
HasCall(_A("print<double,std::string>(double,std::string)"), src);
_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);
}
} }

120
tests/t20041/test_case.h
View File

@@ -16,74 +16,84 @@
* limitations under the License. * 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()"));
{ save_puml(config.output_directory(), diagram->name + ".puml", src);
auto src = generate_sequence_puml(diagram, *model); }
AliasMatcher _A(src);
REQUIRE_THAT(src, StartsWith("@startuml")); {
REQUIRE_THAT(src, EndsWith("@enduml\n")); auto j = generate_sequence_json(diagram, *model);
REQUIRE_THAT(src, using namespace json;
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()"));
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()")};
{ REQUIRE(std::is_sorted(messages.begin(), messages.end()));
auto j = generate_sequence_json(diagram, *model);
using namespace json; save_json(config.output_directory(), diagram->name + ".json", j);
}
std::vector<int> messages = { {
FindMessage(j, "tmain()", "A<int,double,std::string>", auto src = generate_sequence_mermaid(diagram, *model);
"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()")};
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)"));
{ save_mermaid(config.output_directory(), diagram->name + ".mmd",
auto src = generate_sequence_mermaid(diagram, *model); src);
}*/
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);
}
} }

88
tests/t20042/test_case.h
View File

@@ -16,60 +16,64 @@
* limitations under the License. * 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"));
{ REQUIRE_THAT(src,
auto src = generate_sequence_puml(diagram, *model); HasCall(_A("tmain()"), _A("AHandler"), "operator()(A &)
AliasMatcher _A(src); 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")); save_puml(config.output_directory(), diagram->name + ".puml", src);
REQUIRE_THAT(src, EndsWith("@enduml\n")); }
REQUIRE_THAT(src, {
HasCall(_A("tmain()"), _A("AHandler"), "operator()(A &) const")); auto j = generate_sequence_json(diagram, *model);
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_puml(config.output_directory(), diagram->name + ".puml", src); using namespace json;
}
{ save_json(config.output_directory(), diagram->name + ".json", j);
auto j = generate_sequence_json(diagram, *model); }
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;
{ REQUIRE_THAT(src,
auto src = generate_sequence_mermaid(diagram, *model); 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); save_mermaid(config.output_directory(), diagram->name + ".mmd",
using mermaid::HasCall; 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"));
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. * 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(!HasMessage(src, {"tmain()", "F", "f()"}));
REQUIRE(model->name() == "t20043_sequence");
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); auto src = generate_sequence_puml(diagram, *model);
AliasMatcher _A(src); AliasMatcher _A(src);
@@ -69,5 +79,5 @@ TEST_CASE("t20043", "[test-case][sequence]")
REQUIRE_THAT(src, !HasCall(_A("B"), _A("A"), "a()")); REQUIRE_THAT(src, !HasCall(_A("B"), _A("A"), "a()"));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src); 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. * 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); auto src = generate_sequence_puml(diagram, *model);
AliasMatcher _A(src); AliasMatcher _A(src);
@@ -88,5 +117,5 @@ TEST_CASE("t20044", "[test-case][sequence]")
using mermaid::IsClass; using mermaid::IsClass;
save_mermaid(config.output_directory(), diagram->name + ".mmd", src); 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. * 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"]; auto [config, db, diagram, model] =
CHECK_SEQUENCE_MODEL("t20045", "t20045_sequence");
REQUIRE(diagram->name == "t20045_sequence");
auto model = generate_sequence_diagram(*db, diagram);
REQUIRE(model->name() == "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); auto src = generate_sequence_puml(diagram, *model);
AliasMatcher _A(src); AliasMatcher _A(src);
@@ -80,4 +87,5 @@ TEST_CASE("t20045", "[test-case][sequence]")
save_mermaid(config.output_directory(), diagram->name + ".mmd", src); 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 << "-----------------------------------------------------" std::cout << "-----------------------------------------------------"
"--------------------------\n"; "--------------------------\n";
std::cout << "Test case failed for diagram type " std::cout << "Test case failed for diagram type "
<< T::diagram_type_name << ": " << T::diagram_type_name << ": " << "\n\n";
<< "\n\n";
std::cout << diagrams.get<T>().to_string() << "\n"; std::cout << diagrams.get<T>().to_string() << "\n";
throw e; throw e;
@@ -591,7 +590,6 @@ void CHECK_INCLUDE_DIAGRAM(const clanguml::config::config &config,
save_mermaid(config.output_directory(), diagram->name + ".mmd", save_mermaid(config.output_directory(), diagram->name + ".mmd",
diagram_sources.mermaid.src); diagram_sources.mermaid.src);
} }
} // namespace clanguml::test } // namespace clanguml::test
/* /*
@@ -1174,7 +1172,7 @@ template <> bool IsClass(json_t d, std::string name)
#include "t00074/test_case.h" #include "t00074/test_case.h"
#include "t00075/test_case.h" #include "t00075/test_case.h"
#endif #endif
/*
/// ///
/// Sequence diagram tests /// Sequence diagram tests
/// ///
@@ -1188,6 +1186,7 @@ template <> bool IsClass(json_t d, std::string name)
#include "t20005/test_case.h" #include "t20005/test_case.h"
#endif #endif
#include "t20006/test_case.h" #include "t20006/test_case.h"
#include "t20007/test_case.h" #include "t20007/test_case.h"
#include "t20008/test_case.h" #include "t20008/test_case.h"
#include "t20009/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 "t20038/test_case.h"
#include "t20039/test_case.h" #include "t20039/test_case.h"
#include "t20040/test_case.h" #include "t20040/test_case.h"
#include "t20041/test_case.h" #include "t20041/test_case.h"
#include "t20042/test_case.h" #include "t20042/test_case.h"
#include "t20043/test_case.h" #include "t20043/test_case.h"
#include "t20044/test_case.h" #include "t20044/test_case.h"
#include "t20045/test_case.h" #include "t20045/test_case.h"
/*
#include "t20046/test_case.h" #include "t20046/test_case.h"
#include "t20047/test_case.h" #include "t20047/test_case.h"
#include "t20048/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