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-20 00:09:30 +02:00
parent 7c1e0420c6
commit 4b5cfa7b48
47 changed files with 300 additions and 2709 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -40,6 +40,8 @@ void to_json(nlohmann::json &j, const participant &c)
j["name"] = dynamic_cast<const method &>(c).method_name();
}
j["full_name"] = c.full_name(false);
if (c.type_name() == "function" || c.type_name() == "function_template") {
const auto &f = dynamic_cast<const function &>(c);
if (f.is_cuda_kernel())
@@ -172,7 +174,7 @@ void generator::generate_call(const message &m, nlohmann::json &parent) const
dynamic_cast<const clanguml::common::model::source_location &>(m);
msg["scope"] = to_string(m.message_scope());
msg["return_type"] = m.return_type();
msg["return_type"] = config().simplify_template_type(m.return_type());
parent["messages"].push_back(std::move(msg));
@@ -568,6 +570,12 @@ common::id_t generator::generate_participant(
.value()
.class_id();
LOG_DBG("Generating JSON method participant: {}",
model()
.get_participant<model::method>(participant_id)
.value()
.full_name(false));
if (!is_participant_generated(class_participant_id)) {
const auto &class_participant =
model()
@@ -580,6 +588,13 @@ common::id_t generator::generate_participant(
json_["participants"].push_back(class_participant);
json_["participants"].back()["activities"].push_back(participant);
// Perform config dependent postprocessing on generated class
const auto class_participant_full_name =
class_participant.full_name(false);
json_["participants"].back().at("display_name") =
make_display_name(class_participant_full_name);
return class_participant_id;
}
@@ -807,7 +822,8 @@ void generator::generate_diagram(nlohmann::json &parent) const
if (from.value().type_name() == "method" ||
config().combine_free_functions_into_file_participants()) {
sequence["return_type"] = from.value().return_type();
sequence["return_type"] =
make_display_name(from.value().return_type());
}
parent["sequences"].push_back(std::move(sequence));
@@ -821,11 +837,21 @@ 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"]);
p["display_name"] = make_display_name(p["display_name"]);
}
}
parent["participants"] = json_["participants"];
}
std::string generator::make_display_name(const std::string &full_name) const
{
auto result = config().simplify_template_type(full_name);
result = config().using_namespace().relative(result);
common::ensure_lambda_type_is_relative(config(), result);
result = render_name(result);
return result;
}
} // namespace clanguml::sequence_diagram::generators::json

2
src/sequence_diagram/generators/json/sequence_diagram_generator.h
View File

@@ -111,6 +111,8 @@ public:
*/
nlohmann::json &current_block_statement() const;
std::string make_display_name(const std::string &full_name) const;
private:
/**
* @brief Check if specified participant has already been generated.

19
src/sequence_diagram/generators/plantuml/sequence_diagram_generator.cc
View File

@@ -388,8 +388,11 @@ void generator::generate_participant(
print_debug(class_participant, ostr);
auto participant_name =
config().using_namespace().relative(config().simplify_template_type(
class_participant.full_name(false)));
config().simplify_template_type(
class_participant.full_name(false));
participant_name =
config().using_namespace().relative(participant_name);
common::ensure_lambda_type_is_relative(config(), participant_name);
ostr << "participant \"" << render_name(participant_name) << "\" as "
@@ -531,8 +534,7 @@ void generator::generate_diagram(std::ostream &ostr) const
if (from.value().type_name() == "method" ||
config().combine_free_functions_into_file_participants()) {
generate_participant(ostr, from_activity_id);
ostr << "[->"
<< " " << generate_alias(from.value()) << " : "
ostr << "[->" << " " << generate_alias(from.value()) << " : "
<< from.value().message_name(
select_method_arguments_render_mode())
<< '\n';
@@ -571,8 +573,7 @@ void generator::generate_diagram(std::ostream &ostr) const
if (from.value().type_name() == "method" ||
config().combine_free_functions_into_file_participants()) {
generate_participant(ostr, from_activity_id);
ostr << "[->"
<< " " << generate_alias(from.value()) << " : "
ostr << "[->" << " " << generate_alias(from.value()) << " : "
<< from.value().message_name(
select_method_arguments_render_mode())
<< '\n';
@@ -636,8 +637,7 @@ void generator::generate_diagram(std::ostream &ostr) const
// first activity for this 'start_from' condition
if (from.value().type_name() == "method" ||
config().combine_free_functions_into_file_participants()) {
ostr << "[->"
<< " " << from_alias << " : "
ostr << "[->" << " " << from_alias << " : "
<< from.value().message_name(render_mode) << '\n';
}
@@ -650,8 +650,7 @@ void generator::generate_diagram(std::ostream &ostr) const
config().combine_free_functions_into_file_participants()) {
if (!from.value().is_void()) {
ostr << "[<--"
<< " " << from_alias;
ostr << "[<--" << " " << from_alias;
if (config().generate_return_types())
ostr << " : //" << from.value().return_type() << "//";

93
tests/t20001/test_case.h
View File

@@ -74,97 +74,4 @@ TEST_CASE("t20001")
CHECK(tmain.value()["source_location"]["file"] == "t20001.cc");
CHECK(tmain.value()["source_location"]["line"] == 61);
});
/*
{
auto src = generate_sequence_puml(diagram, *model);
AliasMatcher _A(src);
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
REQUIRE_THAT(src, HasTitle("Basic sequence diagram example"));
REQUIRE_THAT(src, HasCall(_A("B"), _A("A"), "add3(int,int,int)"));
REQUIRE_THAT(src, HasCall(_A("A"), "add(int,int)"));
REQUIRE_THAT(src, !HasCall(_A("A"), _A("detail::C"), "add(int,int)"));
REQUIRE_THAT(src, HasCall(_A("A"), "__log_result(int)__"));
REQUIRE_THAT(src, HasCall(_A("B"), _A("A"), "__log_result(int)__"));
REQUIRE_THAT(src, HasComment("t20001 test diagram of type sequence"));
REQUIRE_THAT(
src, HasMessageComment(_A("tmain()"), "Just add 2 numbers"));
REQUIRE_THAT(
src, HasMessageComment(_A("tmain()"), "And now add another 2"));
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
{
auto j = generate_sequence_json(diagram, *model);
using namespace json;
const auto &A = get_participant(j, "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(j, "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);
REQUIRE(HasTitle(j, "Basic sequence diagram example"));
REQUIRE(IsFunctionParticipant(j, "tmain()"));
REQUIRE(IsClassParticipant(j, "A"));
REQUIRE(IsClassParticipant(j, "B"));
std::vector<int> messages = {
FindMessage(j, "tmain()", "A", "add(int,int)"),
FindMessage(j, "tmain()", "B", "wrap_add3(int,int,int)"),
FindMessage(j, "B", "A", "add3(int,int,int)"),
FindMessage(j, "A", "A", "add(int,int)"),
FindMessage(j, "A", "A", "log_result(int)"),
FindMessage(j, "B", "A", "log_result(int)")};
REQUIRE(std::is_sorted(messages.begin(), messages.end()));
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::HasComment;
using mermaid::HasTitle;
REQUIRE_THAT(src, HasTitle("Basic sequence diagram example"));
REQUIRE_THAT(src, HasCall(_A("B"), _A("A"), "add3(int,int,int)"));
REQUIRE_THAT(src, HasCall(_A("A"), "add(int,int)"));
REQUIRE_THAT(src, !HasCall(_A("A"), _A("detail::C"), "add(int,int)"));
REQUIRE_THAT(src, HasCall(_A("A"), "log_result(int)"));
REQUIRE_THAT(src, HasCall(_A("B"), _A("A"), "log_result(int)"));
REQUIRE_THAT(src, HasComment("t20001 test diagram of type sequence"));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}
*/
}

46
tests/t20002/test_case.h
View File

@@ -37,50 +37,4 @@ TEST_CASE("t20002")
{"m3()", "m4()", ""} //
}));
});
/*
{
auto src = generate_sequence_puml(diagram, *model);
AliasMatcher _A(src);
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
REQUIRE_THAT(src, HasCall(_A("m1()"), _A("m2()"), ""));
REQUIRE_THAT(src, HasCall(_A("m2()"), _A("m3()"), ""));
REQUIRE_THAT(src, HasCall(_A("m3()"), _A("m4()"), ""));
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
{
auto j = generate_sequence_json(diagram, *model);
using namespace json;
REQUIRE(IsFunctionParticipant(j, "m1()"));
REQUIRE(IsFunctionParticipant(j, "m2()"));
REQUIRE(IsFunctionParticipant(j, "m3()"));
REQUIRE(IsFunctionParticipant(j, "m4()"));
std::vector<int> messages = {FindMessage(j, "m1()", "m2()", ""),
FindMessage(j, "m2()", "m3()", ""),
FindMessage(j, "m3()", "m4()", "")};
REQUIRE(std::is_sorted(messages.begin(), messages.end()));
save_json(config.output_directory(), diagram->name + ".json", j);
}
{
auto src = generate_sequence_mermaid(diagram, *model);
mermaid::SequenceDiagramAliasMatcher _A(src);
using mermaid::HasCall;
REQUIRE_THAT(src, HasCall(_A("m1()"), _A("m2()"), ""));
REQUIRE_THAT(src, HasCall(_A("m2()"), _A("m3()"), ""));
REQUIRE_THAT(src, HasCall(_A("m3()"), _A("m4()"), ""));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}*/
}

42
tests/t20003/test_case.h
View File

@@ -37,46 +37,4 @@ TEST_CASE("t20003")
{"m3<T>(T)", "m4<T>(T)", ""} //
}));
});
/*
{
auto src = generate_sequence_puml(diagram, *model);
AliasMatcher _A(src);
REQUIRE_THAT(src, StartsWith("@startuml"));
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)"), ""));
REQUIRE_THAT(src, HasCall(_A("m3<T>(T)"), _A("m4<T>(T)"), ""));
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
{
auto j = generate_sequence_json(diagram, *model);
using namespace json;
std::vector<int> messages = {FindMessage(j, "m1<T>(T)", "m2<T>(T)",
""), FindMessage(j, "m2<T>(T)", "m3<T>(T)", ""), FindMessage(j,
"m3<T>(T)", "m4<T>(T)", "")};
REQUIRE(std::is_sorted(messages.begin(), messages.end()));
save_json(config.output_directory(), diagram->name + ".json", j);
}
{
auto src = generate_sequence_mermaid(diagram, *model);
mermaid::SequenceDiagramAliasMatcher _A(src);
using mermaid::HasCall;
REQUIRE_THAT(src, HasCall(_A("m1<T>(T)"), _A("m2<T>(T)"), ""));
REQUIRE_THAT(src, HasCall(_A("m2<T>(T)"), _A("m3<T>(T)"), ""));
REQUIRE_THAT(src, HasCall(_A("m3<T>(T)"), _A("m4<T>(T)"), ""));
save_mermaid(config.output_directory(), diagram->name + ".mmd",
src);
}*/
}

85
tests/t20004/test_case.h
View File

@@ -42,89 +42,4 @@ TEST_CASE("t20004")
REQUIRE(!HasMessage(src, {"m1<float>(float)", "m1<float>(float)", ""}));
});
/*
{
auto src = generate_sequence_puml(diagram, *model);
AliasMatcher _A(src);
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, HasCall(_A("main()"), _A("m1<float>(float)"),
""));
REQUIRE_THAT( src, !HasCall(_A("m1<float>(float)"),
_A("m1<float>(float)"), ""));
REQUIRE_THAT( src,
!HasCall(_A("m1<float>(float)"), _A("m1<float>(float)"), ""));
REQUIRE_THAT(src,
HasCall(_A("main()"), _A("m1<unsigned long>(unsigned long)"),
""));
REQUIRE_THAT(src, HasCall(_A("m1<unsigned long>(unsigned long)"),
_A("m4<unsigned long>(unsigned long)"), ""));
REQUIRE_THAT(
src, HasCall(_A("main()"), _A("m1<std::string>(std::string)"),
"")); REQUIRE_THAT(src, HasCall(_A("m1<std::string>(std::string)"),
_A("m2<std::string>(std::string)"), ""));
REQUIRE_THAT(src, HasCall(_A("main()"), _A("m1<int>(int)"), ""));
REQUIRE_THAT(src, HasCall(_A("m1<int>(int)"), _A("m2<int>(int)"),
"")); REQUIRE_THAT(src, HasCall(_A("m2<int>(int)"), _A("m3<int>(int)"),
"")); REQUIRE_THAT(src, HasCall(_A("m3<int>(int)"), _A("m4<int>(int)"),
"")); REQUIRE_THAT(src, EndsWith("@enduml\n"));
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
{
auto j = generate_sequence_json(diagram, *model);
using namespace json;
std::vector<int> messages = {
FindMessage(j, "main()", "m1<float>(float)", ""),
FindMessage(j, "main()", "m1<unsigned long>(unsigned long)",
""), FindMessage(j, "m1<unsigned long>(unsigned long)", "m4<unsigned
long>(unsigned long)", ""), FindMessage(j, "main()",
"m1<std::string>(std::string)", ""), FindMessage(j,
"m1<std::string>(std::string)", "m2<std::string>(std::string)", ""),
FindMessage(j, "main()", "m1<int>(int)", ""),
FindMessage(j, "m1<int>(int)", "m2<int>(int)", ""),
FindMessage(j, "m2<int>(int)", "m3<int>(int)", ""),
FindMessage(j, "m3<int>(int)", "m4<int>(int)", "")};
REQUIRE(std::is_sorted(messages.begin(), messages.end()));
save_json(config.output_directory(), diagram->name + ".json", j);
}
{
auto src = generate_sequence_mermaid(diagram, *model);
mermaid::SequenceDiagramAliasMatcher _A(src);
using mermaid::HasCall;
REQUIRE_THAT(src, HasCall(_A("main()"), _A("m1<float>(float)"),
"")); REQUIRE_THAT( src, !HasCall(_A("m1<float>(float)"),
_A("m1<float>(float)"), "")); REQUIRE_THAT( src,
!HasCall(_A("m1<float>(float)"), _A("m1<float>(float)"), ""));
REQUIRE_THAT(src,
HasCall(_A("main()"), _A("m1<unsigned long>(unsigned long)"),
"")); REQUIRE_THAT(src, HasCall(_A("m1<unsigned long>(unsigned long)"),
_A("m4<unsigned long>(unsigned long)"), ""));
REQUIRE_THAT(
src, HasCall(_A("main()"), _A("m1<std::string>(std::string)"),
"")); REQUIRE_THAT(src, HasCall(_A("m1<std::string>(std::string)"),
_A("m2<std::string>(std::string)"), ""));
REQUIRE_THAT(src, HasCall(_A("main()"), _A("m1<int>(int)"), ""));
REQUIRE_THAT(src, HasCall(_A("m1<int>(int)"), _A("m2<int>(int)"),
"")); REQUIRE_THAT(src, HasCall(_A("m2<int>(int)"), _A("m3<int>(int)"),
"")); REQUIRE_THAT(src, HasCall(_A("m3<int>(int)"), _A("m4<int>(int)"),
""));
save_mermaid(config.output_directory(), diagram->name + ".mmd",
src);
}*/
}

46
tests/t20005/test_case.h
View File

@@ -33,50 +33,4 @@ TEST_CASE("t20005")
{Exitpoint{}, "C<T>"} //
}));
});
/*
{
auto src = generate_sequence_puml(diagram, *model);
AliasMatcher _A(src);
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
// 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 j = generate_sequence_json(diagram, *model);
using namespace json;
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()));
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::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);
}*/
}

123
tests/t20006/test_case.h
View File

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

58
tests/t20007/test_case.h
View File

@@ -33,62 +33,4 @@ TEST_CASE("t20007")
"add(std::string &&,std::string &&,std::string &&)"} //
}));
});
/*
{
auto src = generate_sequence_puml(diagram, *model);
AliasMatcher _A(src);
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
// 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",
src);
}
{
auto j = generate_sequence_json(diagram, *model);
using namespace json;
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()));
save_json(config.output_directory(), diagram->name + ".json",
j);
}
{
auto src = generate_sequence_mermaid(diagram, *model);
mermaid::SequenceDiagramAliasMatcher _A(src);
using mermaid::HasCall;
REQUIRE_THAT(src,
HasCall(_A("tmain()"), _A("Adder<int,int>"), "add(int &&,int
&&)")); REQUIRE_THAT(src, HasCall(_A("tmain()"),
_A("Adder<int,float,double>"), "add(int &&,float &&,double &&)"));
REQUIRE_THAT(src,
HasCall(_A("tmain()"),
_A("Adder<std::string,std::string,std::string>"),
"add(std::string &&,std::string &&,std::string &&)"));
save_mermaid(config.output_directory(), diagram->name + ".mmd",
src);
}*/
}

76
tests/t20008/test_case.h
View File

@@ -40,80 +40,4 @@ TEST_CASE("t20008")
REQUIRE(!HasMessage(src, {"B<int>", "A<int>", "a2(int)"}));
REQUIRE(!HasMessage(src, {"B<int>", "A<int>", "a3(int)"}));
});
/*
{
auto src = generate_sequence_puml(diagram, *model);
AliasMatcher _A(src);
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
// Check if all calls exist
REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B<int>"),
"b(int)")); REQUIRE_THAT(src, HasCall(_A("B<int>"), _A("A<int>"),
"a1(int)"));
// REQUIRE_THAT(puml, !HasCall(_A("B<int>"), _A("A<int>"),
// "a2(int)")); REQUIRE_THAT(puml, !HasCall(_A("B<int>"),
// _A("A<int>"), "a3(int)"));
REQUIRE_THAT(src,
HasCall(_A("tmain()"), _A("B<const char *>"), "b(const char
*)")); REQUIRE_THAT(src, HasCall(_A("B<const char *>"), _A("A<const
char *>"), "a2(const char *)"));
REQUIRE_THAT(src,
HasCall(_A("tmain()"), _A("B<std::string>"),
"b(std::string)")); REQUIRE_THAT(src, HasCall( _A("B<std::string>"),
_A("A<std::string>"), "a3(std::string)"));
save_puml(config.output_directory(), diagram->name + ".puml",
src);
}
{
auto j = generate_sequence_json(diagram, *model);
using namespace json;
std::vector<int> messages = {
FindMessage(j, "tmain()", "B<int>", "b(int)"),
FindMessage(j, "B<int>", "A<int>", "a1(int)"),
FindMessage(j, "tmain()", "B<const char *>", "b(const char
*)"), FindMessage( j, "B<const char *>", "A<const char *>", "a2(const
char *)"), FindMessage(j, "tmain()", "B<std::string>",
"b(std::string)"), FindMessage( j, "B<std::string>",
"A<std::string>", "a3(std::string)")};
REQUIRE(std::is_sorted(messages.begin(), messages.end()));
save_json(config.output_directory(), diagram->name + ".json",
j);
}
{
auto src = generate_sequence_mermaid(diagram, *model);
mermaid::SequenceDiagramAliasMatcher _A(src);
using mermaid::HasCall;
REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B<int>"),
"b(int)")); REQUIRE_THAT(src, HasCall(_A("B<int>"), _A("A<int>"),
"a1(int)"));
// REQUIRE_THAT(puml, !HasCall(_A("B<int>"), _A("A<int>"),
// "a2(int)")); REQUIRE_THAT(puml, !HasCall(_A("B<int>"),
// _A("A<int>"), "a3(int)"));
REQUIRE_THAT(src,
HasCall(_A("tmain()"), _A("B<const char *>"), "b(const char
*)")); REQUIRE_THAT(src, HasCall(_A("B<const char *>"), _A("A<const
char *>"), "a2(const char *)"));
REQUIRE_THAT(src,
HasCall(_A("tmain()"), _A("B<std::string>"),
"b(std::string)")); REQUIRE_THAT(src, HasCall( _A("B<std::string>"),
_A("A<std::string>"), "a3(std::string)"));
save_mermaid(config.output_directory(), diagram->name + ".mmd",
src);
}*/
}

68
tests/t20009/test_case.h
View File

@@ -37,72 +37,4 @@ TEST_CASE("t20009")
{"B<float>", "A<float>", "a(float)"} //
}));
});
/*
{
auto src = generate_sequence_puml(diagram, *model);
AliasMatcher _A(src);
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
// Check if all calls exist
REQUIRE_THAT(src,
HasCall(_A("tmain()"), _A("B<std::string>"), "b(std::string)"));
REQUIRE_THAT(src,
HasCall(
_A("B<std::string>"), _A("A<std::string>"),
"a(std::string)"));
REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B<int>"), "b(int)"));
REQUIRE_THAT(src, HasCall(_A("B<int>"), _A("A<int>"), "a(int)"));
REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B<float>"),
"b(float)")); REQUIRE_THAT(src, HasCall(_A("B<float>"), _A("A<float>"),
"a(float)"));
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
{
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)")};
REQUIRE(std::is_sorted(messages.begin(), messages.end()));
save_json(config.output_directory(), diagram->name + ".json", j);
}
{
auto src = generate_sequence_mermaid(diagram, *model);
mermaid::SequenceDiagramAliasMatcher _A(src);
using mermaid::HasCall;
REQUIRE_THAT(src,
HasCall(_A("tmain()"), _A("B<std::string>"), "b(std::string)"));
REQUIRE_THAT(src,
HasCall(
_A("B<std::string>"), _A("A<std::string>"),
"a(std::string)"));
REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B<int>"), "b(int)"));
REQUIRE_THAT(src, HasCall(_A("B<int>"), _A("A<int>"), "a(int)"));
REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B<float>"),
"b(float)")); REQUIRE_THAT(src, HasCall(_A("B<float>"), _A("A<float>"),
"a(float)"));
save_mermaid(config.output_directory(), diagram->name + ".mmd",
src);
}*/
}

65
tests/t20010/test_case.h
View File

@@ -39,69 +39,4 @@ TEST_CASE("t20010")
{"B<int>", "A", "a4()"} //
}));
});
/*
{
auto src = generate_sequence_puml(diagram, *model);
AliasMatcher _A(src);
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
// Check if all calls exist
REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B<int>"), "b1()"));
REQUIRE_THAT(src, HasCall(_A("B<int>"), _A("A"), "a1()"));
REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B<int>"), "b2()"));
REQUIRE_THAT(src, HasCall(_A("B<int>"), _A("A"), "a2()"));
REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B<int>"), "b3()"));
REQUIRE_THAT(src, HasCall(_A("B<int>"), _A("A"), "a3()"));
REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B<int>"), "b4()"));
REQUIRE_THAT(src, HasCall(_A("B<int>"), _A("A"), "a4()"));
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
{
auto j = generate_sequence_json(diagram, *model);
using namespace json;
std::vector<int> messages = {
FindMessage(j, "tmain()", "B<int>", "b1()"),
FindMessage(j, "B<int>", "A", "a1()"),
FindMessage(j, "tmain()", "B<int>", "b2()"),
FindMessage(j, "B<int>", "A", "a2()"),
FindMessage(j, "tmain()", "B<int>", "b3()"),
FindMessage(j, "B<int>", "A", "a3()"),
FindMessage(j, "tmain()", "B<int>", "b4()"),
FindMessage(j, "B<int>", "A", "a4()")};
REQUIRE(std::is_sorted(messages.begin(), messages.end()));
save_json(config.output_directory(), diagram->name + ".json", j);
}
{
auto src = generate_sequence_mermaid(diagram, *model);
mermaid::SequenceDiagramAliasMatcher _A(src);
using mermaid::HasCall;
REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B<int>"), "b1()"));
REQUIRE_THAT(src, HasCall(_A("B<int>"), _A("A"), "a1()"));
REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B<int>"), "b2()"));
REQUIRE_THAT(src, HasCall(_A("B<int>"), _A("A"), "a2()"));
REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B<int>"), "b3()"));
REQUIRE_THAT(src, HasCall(_A("B<int>"), _A("A"), "a3()"));
REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B<int>"), "b4()"));
REQUIRE_THAT(src, HasCall(_A("B<int>"), _A("A"), "a4()"));
save_mermaid(config.output_directory(), diagram->name + ".mmd",
src);
}*/
}

56
tests/t20011/test_case.h
View File

@@ -36,60 +36,4 @@ TEST_CASE("t20011")
{"A", "A", "b(int)"} //
}));
});
/*
{
auto src = generate_sequence_puml(diagram, *model);
AliasMatcher _A(src);
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
// Check if all calls exist
REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("A"), "a(int)"));
REQUIRE_THAT(src, HasCall(_A("A"), _A("A"), "a(int)"));
REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("A"), "b(int)"));
REQUIRE_THAT(src, HasCall(_A("A"), _A("A"), "c(int)"));
REQUIRE_THAT(src, HasCall(_A("A"), _A("A"), "d(int)"));
REQUIRE_THAT(src, HasCall(_A("A"), _A("A"), "b(int)"));
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
{
auto j = generate_sequence_json(diagram, *model);
using namespace json;
REQUIRE(IsFunctionParticipant(j, "tmain()"));
REQUIRE(IsClassParticipant(j, "A"));
std::vector<int> messages = {FindMessage(j, "tmain()", "A", "a(int)"),
FindMessage(j, "A", "A", "a(int)"),
FindMessage(j, "tmain()", "A", "b(int)"),
FindMessage(j, "A", "A", "c(int)")};
REQUIRE(std::is_sorted(messages.begin(), messages.end()));
save_json(config.output_directory(), diagram->name + ".json", j);
}
{
auto src = generate_sequence_mermaid(diagram, *model);
mermaid::SequenceDiagramAliasMatcher _A(src);
using mermaid::HasCall;
REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("A"), "a(int)"));
REQUIRE_THAT(src, HasCall(_A("A"), _A("A"), "a(int)"));
REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("A"), "b(int)"));
REQUIRE_THAT(src, HasCall(_A("A"), _A("A"), "c(int)"));
REQUIRE_THAT(src, HasCall(_A("A"), _A("A"), "d(int)"));
REQUIRE_THAT(src, HasCall(_A("A"), _A("A"), "b(int)"));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}
*/
}

131
tests/t20012/test_case.h
View File

@@ -68,135 +68,4 @@ TEST_CASE("t20012")
{"tmain()::(lambda t20012.cc:94:9)", "D", "add5(int) const"} //
}));
});
/*
{
auto src = generate_sequence_puml(diagram, *model);
AliasMatcher _A(src);
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
// Check if all calls exist
REQUIRE_THAT(src,
HasCall(_A("tmain()"), _A("tmain()::(lambda t20012.cc:67:20)"),
"operator()() const"));
REQUIRE_THAT(src,
HasCall(_A("tmain()::(lambda t20012.cc:67:20)"), _A("A"), "a()"));
REQUIRE_THAT(src, HasCall(_A("A"), _A("A"), "aa()"));
REQUIRE_THAT(src, HasCall(_A("A"), _A("A"), "aaa()"));
REQUIRE_THAT(src,
HasCall(_A("tmain()::(lambda t20012.cc:67:20)"), _A("B"), "b()"));
REQUIRE_THAT(src, HasCall(_A("B"), _A("B"), "bb()"));
REQUIRE_THAT(src, HasCall(_A("B"), _A("B"), "bbb()"));
REQUIRE_THAT(src,
HasCall(_A("tmain()::(lambda t20012.cc:80:20)"), _A("C"), "c()"));
REQUIRE_THAT(src, HasCall(_A("C"), _A("C"), "cc()"));
REQUIRE_THAT(src, HasCall(_A("C"), _A("C"), "ccc()"));
REQUIRE_THAT(src,
HasCall(_A("tmain()::(lambda t20012.cc:80:20)"),
_A("tmain()::(lambda t20012.cc:67:20)"), "operator()() const"));
REQUIRE_THAT(src, HasCall(_A("C"), _A("C"), "ccc()"));
REQUIRE_THAT(src,
HasCall(_A("tmain()"), _A("R<(lambda at t20012.cc:86:9)>"),
"R((lambda at t20012.cc:86:9) &&)"));
REQUIRE_THAT(src,
HasCall(_A("tmain()"), _A("R<(lambda at t20012.cc:86:9)>"), "r()"));
REQUIRE_THAT(src,
HasCall(_A("R<(lambda at t20012.cc:86:9)>"),
_A("tmain()::(lambda t20012.cc:86:9)"), "operator()() const"));
REQUIRE_THAT(src,
HasCall(_A("tmain()::(lambda t20012.cc:86:9)"), _A("C"), "c()"));
REQUIRE_THAT(src,
HasCall(_A("tmain()"), _A("tmain()::(lambda t20012.cc:94:9)"),
"operator()(auto) const"));
REQUIRE_THAT(src,
HasCall(_A("tmain()::(lambda t20012.cc:94:9)"), _A("D"),
"add5(int) const"));
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
{
auto j = generate_sequence_json(diagram, *model);
using namespace json;
std::vector<int> messages = {
FindMessage(j, "tmain()", "tmain()::(lambda t20012.cc:67:20)",
"operator()() const"),
FindMessage(j, "tmain()::(lambda t20012.cc:67:20)", "A", "a()"),
FindMessage(j, "A", "A", "aa()"),
FindMessage(j, "A", "A", "aaa()"),
FindMessage(j, "tmain()::(lambda t20012.cc:67:20)", "B", "b()"),
FindMessage(j, "B", "B", "bb()"),
FindMessage(j, "B", "B", "bbb()"),
FindMessage(j, "tmain()::(lambda t20012.cc:80:20)", "C", "c()"),
FindMessage(j, "C", "C", "cc()"),
FindMessage(j, "C", "C", "ccc()"),
FindMessage(j, "tmain()::(lambda t20012.cc:80:20)",
"tmain()::(lambda t20012.cc:67:20)", "operator()() const"),
FindMessage(j, "tmain()", "R<(lambda at t20012.cc:86:9)>", "r()"),
FindMessage(j, "R<(lambda at t20012.cc:86:9)>",
"tmain()::(lambda t20012.cc:86:9)", "operator()() const"),
FindMessage(j, "tmain()::(lambda t20012.cc:86:9)", "C", "c()"),
};
REQUIRE(std::is_sorted(messages.begin(), messages.end()));
save_json(config.output_directory(), diagram->name + ".json", j);
}
{
auto src = generate_sequence_mermaid(diagram, *model);
mermaid::SequenceDiagramAliasMatcher _A(src);
using mermaid::HasCall;
REQUIRE_THAT(src,
HasCall(_A("tmain()"), _A("tmain()::(lambda t20012.cc:67:20)"),
"operator()() const"));
REQUIRE_THAT(src,
HasCall(_A("tmain()::(lambda t20012.cc:67:20)"), _A("A"), "a()"));
REQUIRE_THAT(src, HasCall(_A("A"), _A("A"), "aa()"));
REQUIRE_THAT(src, HasCall(_A("A"), _A("A"), "aaa()"));
REQUIRE_THAT(src,
HasCall(_A("tmain()::(lambda t20012.cc:67:20)"), _A("B"), "b()"));
REQUIRE_THAT(src, HasCall(_A("B"), _A("B"), "bb()"));
REQUIRE_THAT(src, HasCall(_A("B"), _A("B"), "bbb()"));
REQUIRE_THAT(src,
HasCall(_A("tmain()::(lambda t20012.cc:80:20)"), _A("C"), "c()"));
REQUIRE_THAT(src, HasCall(_A("C"), _A("C"), "cc()"));
REQUIRE_THAT(src, HasCall(_A("C"), _A("C"), "ccc()"));
REQUIRE_THAT(src,
HasCall(_A("tmain()::(lambda t20012.cc:80:20)"),
_A("tmain()::(lambda t20012.cc:67:20)"), "operator()() const"));
REQUIRE_THAT(src, HasCall(_A("C"), _A("C"), "ccc()"));
REQUIRE_THAT(src,
HasCall(_A("tmain()"), _A("R<(lambda at t20012.cc:86:9)>"), "r()"));
REQUIRE_THAT(src,
HasCall(_A("R<(lambda at t20012.cc:86:9)>"),
_A("tmain()::(lambda t20012.cc:86:9)"), "operator()() const"));
REQUIRE_THAT(src,
HasCall(_A("tmain()::(lambda t20012.cc:86:9)"), _A("C"), "c()"));
REQUIRE_THAT(src,
HasCall(_A("tmain()"), _A("tmain()::(lambda t20012.cc:94:9)"),
"operator()(auto) const"));
REQUIRE_THAT(src,
HasCall(_A("tmain()::(lambda t20012.cc:94:9)"), _A("D"),
"add5(int) const"));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}
*/
}

60
tests/t20013/test_case.h
View File

@@ -37,64 +37,4 @@ TEST_CASE("t20013")
{"B", "A", "a3(const char *)"} //
}));
});
/*
{
auto src = generate_sequence_puml(diagram, *model);
AliasMatcher _A(src);
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
// Check if all calls exist
REQUIRE_THAT(src, HasCall(_A("tmain(int,char **)"), _A("B"), "b(int)"));
REQUIRE_THAT(src, HasCall(_A("B"), _A("A"), "a1(int)"));
REQUIRE_THAT(
src, HasCall(_A("tmain(int,char **)"), _A("B"), "b(double)"));
REQUIRE_THAT(src, HasCall(_A("B"), _A("A"), "a2(double)"));
REQUIRE_THAT(
src, HasCall(_A("tmain(int,char **)"), _A("B"), "b(const char *)"));
REQUIRE_THAT(src, HasCall(_A("B"), _A("A"), "a3(const char *)"));
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
{
auto j = generate_sequence_json(diagram, *model);
using namespace json;
std::vector<int> messages = {
FindMessage(j, "tmain(int,char **)", "B", "b(int)"),
FindMessage(j, "B", "A", "a1(int)"),
FindMessage(j, "tmain(int,char **)", "B", "b(double)"),
FindMessage(j, "B", "A", "a2(double)"),
FindMessage(j, "tmain(int,char **)", "B", "b(const char *)"),
FindMessage(j, "B", "A", "a3(const char *)")};
REQUIRE(std::is_sorted(messages.begin(), messages.end()));
save_json(config.output_directory(), diagram->name + ".json", j);
}
{
auto src = generate_sequence_mermaid(diagram, *model);
mermaid::SequenceDiagramAliasMatcher _A(src);
using mermaid::HasCall;
REQUIRE_THAT(src, HasCall(_A("tmain(int,char **)"), _A("B"), "b(int)"));
REQUIRE_THAT(src, HasCall(_A("B"), _A("A"), "a1(int)"));
REQUIRE_THAT(
src, HasCall(_A("tmain(int,char **)"), _A("B"), "b(double)"));
REQUIRE_THAT(src, HasCall(_A("B"), _A("A"), "a2(double)"));
REQUIRE_THAT(
src, HasCall(_A("tmain(int,char **)"), _A("B"), "b(const char *)"));
REQUIRE_THAT(src, HasCall(_A("B"), _A("A"), "a3(const char *)"));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}*/
}

59
tests/t20014/test_case.h
View File

@@ -37,63 +37,4 @@ TEST_CASE("t20014")
{"C<B,int>", "B", "b1(int,int)"}, //
}));
});
/*
{
auto src = generate_sequence_puml(diagram, *model);
AliasMatcher _A(src);
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
// Check if all calls exist
REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B"), "b1(int,int)"));
REQUIRE_THAT(src, HasCall(_A("B"), _A("A"), "a1(int,int)"));
REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B"), "b2(int,int)"));
REQUIRE_THAT(src, HasCall(_A("B"), _A("A"), "a2(int,int)"));
REQUIRE_THAT(
src, HasCall(_A("tmain()"), _A("C<B,int>"), "c1(int,int)"));
REQUIRE_THAT(src, HasCall(_A("C<B,int>"), _A("B"), "b1(int,int)"));
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
{
auto j = generate_sequence_json(diagram, *model);
using namespace json;
std::vector<int> messages = {
FindMessage(j, "tmain()", "B", "b1(int,int)"),
FindMessage(j, "B", "A", "a1(int,int)"),
FindMessage(j, "tmain()", "B", "b2(int,int)"),
FindMessage(j, "B", "A", "a2(int,int)"),
FindMessage(j, "tmain()", "C<B,int>", "c1(int,int)"),
FindMessage(j, "C<B,int>", "B", "b1(int,int)")};
REQUIRE(std::is_sorted(messages.begin(), messages.end()));
save_json(config.output_directory(), diagram->name + ".json", j);
}
{
auto src = generate_sequence_mermaid(diagram, *model);
mermaid::SequenceDiagramAliasMatcher _A(src);
using mermaid::HasCall;
REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B"), "b1(int,int)"));
REQUIRE_THAT(src, HasCall(_A("B"), _A("A"), "a1(int,int)"));
REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B"), "b2(int,int)"));
REQUIRE_THAT(src, HasCall(_A("B"), _A("A"), "a2(int,int)"));
REQUIRE_THAT(
src, HasCall(_A("tmain()"), _A("C<B,int>"), "c1(int,int)"));
REQUIRE_THAT(src, HasCall(_A("C<B,int>"), _A("B"), "b1(int,int)"));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}
*/
}

57
tests/t20015/test_case.h
View File

@@ -37,61 +37,4 @@ TEST_CASE("t20015")
REQUIRE(!HasMessage(src, {"B", "B", "set_y(int)"}));
REQUIRE(!HasMessage(src, {"B", "B", "set_z(int)"}));
});
/*
{
auto src = generate_sequence_puml(diagram, *model);
AliasMatcher _A(src);
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
// Check if all calls exist
REQUIRE_THAT(src,
HasCall(_A("tmain()"), _A("B"),
"setup_a(std::shared_ptr<detail::A> &)"));
REQUIRE_THAT(src, !HasCall(_A("B"), _A("detail::A"), "set_x(int)"));
REQUIRE_THAT(src, !HasCall(_A("B"), _A("detail::A"), "set_y(int)"));
REQUIRE_THAT(src, !HasCall(_A("B"), _A("detail::A"), "set_z(int)"));
REQUIRE_THAT(src, !HasCall(_A("B"), _A("B"), "set_x(int)"));
REQUIRE_THAT(src, !HasCall(_A("B"), _A("B"), "set_y(int)"));
REQUIRE_THAT(src, !HasCall(_A("B"), _A("B"), "set_z(int)"));
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
{
auto j = generate_sequence_json(diagram, *model);
using namespace json;
std::vector<int> messages = {FindMessage(
j, "tmain()", "B", "setup_a(std::shared_ptr<detail::A> &)")};
REQUIRE(std::is_sorted(messages.begin(), messages.end()));
save_json(config.output_directory(), diagram->name + ".json", j);
}
{
auto src = generate_sequence_mermaid(diagram, *model);
mermaid::SequenceDiagramAliasMatcher _A(src);
using mermaid::HasCall;
REQUIRE_THAT(src,
HasCall(_A("tmain()"), _A("B"),
"setup_a(std::shared_ptr<detail::A> &)"));
REQUIRE_THAT(src, !HasCall(_A("B"), _A("detail::A"), "set_x(int)"));
REQUIRE_THAT(src, !HasCall(_A("B"), _A("detail::A"), "set_y(int)"));
REQUIRE_THAT(src, !HasCall(_A("B"), _A("detail::A"), "set_z(int)"));
REQUIRE_THAT(src, !HasCall(_A("B"), _A("B"), "set_x(int)"));
REQUIRE_THAT(src, !HasCall(_A("B"), _A("B"), "set_y(int)"));
REQUIRE_THAT(src, !HasCall(_A("B"), _A("B"), "set_z(int)"));
save_mermaid(config.output_directory(), diagram->name + ".mmd",
src);
}
*/
}

56
tests/t20016/test_case.h
View File

@@ -33,60 +33,4 @@ TEST_CASE("t20016")
{"B<long>", "A", "a2(const long &)"} //
}));
});
/*
{
auto src = generate_sequence_puml(diagram, *model);
AliasMatcher _A(src);
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
// Check if all calls exist
REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B<long>"),
"b1(long)")); REQUIRE_THAT(src, HasCall(_A("B<long>"), _A("A"),
"a1(int)"));
REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B<long>"),
"b2(long)")); REQUIRE_THAT(src, HasCall(_A("B<long>"), _A("A"),
"a2(const long &)"));
save_puml(config.output_directory(), diagram->name + ".puml",
src);
}
{
auto j = generate_sequence_json(diagram, *model);
using namespace json;
std::vector<int> messages = {
FindMessage(j, "tmain()", "B<long>", "b1(long)"),
FindMessage(j, "B<long>", "A", "a1(int)"),
FindMessage(j, "tmain()", "B<long>", "b2(long)"),
FindMessage(j, "B<long>", "A", "a2(const long &)")};
REQUIRE(std::is_sorted(messages.begin(), messages.end()));
save_json(config.output_directory(), diagram->name + ".json",
j);
}
{
auto src = generate_sequence_mermaid(diagram, *model);
mermaid::SequenceDiagramAliasMatcher _A(src);
using mermaid::HasCall;
REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B<long>"),
"b1(long)")); REQUIRE_THAT(src, HasCall(_A("B<long>"), _A("A"),
"a1(int)"));
REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B<long>"),
"b2(long)")); REQUIRE_THAT(src, HasCall(_A("B<long>"), _A("A"),
"a2(const long &)"));
save_mermaid(config.output_directory(), diagram->name + ".mmd",
src);
}
*/
}

72
tests/t20018/test_case.h
View File

@@ -37,76 +37,4 @@ TEST_CASE("t20018")
{"Factorial<1>", "Factorial<0>", "print(int)", Static{}}, //
}));
});
/*
{
auto src = generate_sequence_puml(diagram, *model);
AliasMatcher _A(src);
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
// 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 j = generate_sequence_json(diagram, *model);
using namespace json;
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()));
save_json(config.output_directory(), diagram->name + ".json", j);
}
{
auto src = generate_sequence_mermaid(diagram, *model);
mermaid::SequenceDiagramAliasMatcher _A(src);
using mermaid::HasCall;
REQUIRE_THAT(src,
HasCall(_A("tmain()"), _A("Answer<Factorial<5>,120>"),
"print()")); REQUIRE_THAT(src, HasCall(_A("Answer<Factorial<5>,120>"),
_A("Factorial<5>"), "print(int)")); REQUIRE_THAT( src,
HasCall(_A("Factorial<5>"), _A("Factorial<4>"), "print(int)"));
REQUIRE_THAT(
src, HasCall(_A("Factorial<4>"), _A("Factorial<3>"),
"print(int)")); REQUIRE_THAT( src, HasCall(_A("Factorial<3>"),
_A("Factorial<2>"), "print(int)")); REQUIRE_THAT( src,
HasCall(_A("Factorial<2>"), _A("Factorial<1>"), "print(int)"));
REQUIRE_THAT(
src, HasCall(_A("Factorial<1>"), _A("Factorial<0>"),
"print(int)"));
save_mermaid(config.output_directory(), diagram->name + ".mmd",
src);
}
*/
}

47
tests/t20019/test_case.h
View File

@@ -33,51 +33,4 @@ TEST_CASE("t20019")
{"Base<D2>", "D2", "impl()"} //
}));
});
/*
{
auto src = generate_sequence_puml(diagram, *model);
AliasMatcher _A(src);
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
// Check if all calls exist
REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("Base<D1>"), "name()"));
REQUIRE_THAT(src, HasCall(_A("Base<D1>"), _A("D1"), "impl()"));
REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("Base<D2>"), "name()"));
REQUIRE_THAT(src, HasCall(_A("Base<D2>"), _A("D2"), "impl()"));
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
{
auto j = generate_sequence_json(diagram, *model);
using namespace json;
std::vector<int> messages = {
FindMessage(j, "tmain()", "Base<D1>", "name()"),
FindMessage(j, "Base<D1>", "D1", "impl()"),
FindMessage(j, "tmain()", "Base<D2>", "name()"),
FindMessage(j, "Base<D2>", "D2", "impl()")};
REQUIRE(std::is_sorted(messages.begin(), messages.end()));
save_json(config.output_directory(), diagram->name + ".json", j);
}
{
auto src = generate_sequence_mermaid(diagram, *model);
mermaid::SequenceDiagramAliasMatcher _A(src);
using mermaid::HasCall;
REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("Base<D1>"), "name()"));
REQUIRE_THAT(src, HasCall(_A("Base<D1>"), _A("D1"), "impl()"));
REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("Base<D2>"), "name()"));
REQUIRE_THAT(src, HasCall(_A("Base<D2>"), _A("D2"), "impl()"));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}
*/
}

85
tests/t20020/test_case.h
View File

@@ -42,89 +42,4 @@ TEST_CASE("t20020")
{"tmain()", "D<int>", "d1(int,int)"}, //
}));
});
/*
{
auto src = generate_sequence_puml(diagram, *model);
AliasMatcher _A(src);
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
// Check if all calls exist
REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("A"), "a1()"));
REQUIRE_THAT(
src, HasCallInControlCondition(_A("tmain()"), _A("A"), "a2()"));
REQUIRE_THAT(
src, HasCallInControlCondition(_A("tmain()"), _A("A"), "a3()"));
REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B"), "b1()"));
REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B"), "b2()"));
REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B"), "log()"));
REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("C"), "c1() const"));
REQUIRE_THAT(
src, HasCallInControlCondition(_A("C"), _A("C"), "c2() const"));
REQUIRE_THAT(src, HasCall(_A("C"), _A("C"), "log() const"));
REQUIRE_THAT(
src, HasCallInControlCondition(_A("tmain()"), _A("C"),
"c3(int)"));
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
{
auto j = generate_sequence_json(diagram, *model);
using namespace json;
std::vector<int> messages = {FindMessage(j, "tmain()", "A", "a1()"),
FindMessage(j, "tmain()", "A", "a5()"),
FindMessage(j, "tmain()", "A", "a2()"),
FindMessage(j, "tmain()", "C", "c3(int)"),
FindMessage(j, "tmain()", "B", "b1()"),
FindMessage(j, "tmain()", "A", "a3()"),
FindMessage(j, "tmain()", "B", "b2()"),
FindMessage(j, "tmain()", "A", "a4()"),
FindMessage(j, "tmain()", "B", "log()"),
FindMessage(j, "tmain()", "C", "c1() const"),
FindMessage(j, "C", "C", "c2() const"),
FindMessage(j, "C", "C", "log() const"),
FindMessage(j, "tmain()", "D<int>", "d1(int,int)")};
REQUIRE(std::is_sorted(messages.begin(), messages.end()));
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, HasCall(_A("tmain()"), _A("B"), "b1()"));
REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B"), "b2()"));
REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B"), "log()"));
REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("C"), "c1() const"));
REQUIRE_THAT(
src, HasCallInControlCondition(_A("C"), _A("C"), "c2() const"));
REQUIRE_THAT(src, HasCall(_A("C"), _A("C"), "log() const"));
REQUIRE_THAT(
src, HasCallInControlCondition(_A("tmain()"), _A("C"),
"c3(int)"));
save_mermaid(config.output_directory(), diagram->name + ".mmd",
src);
}
*/
}

88
tests/t20021/test_case.h
View File

@@ -40,92 +40,4 @@ TEST_CASE("t20021")
{"tmain()", "B", "b2() const"}, //
}));
});
/*
{
auto src = generate_sequence_puml(diagram, *model);
AliasMatcher _A(src);
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
// 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, HasCall(_A("tmain()"), _A("A"), "a3()"));
REQUIRE_THAT(src, !HasCall(_A("tmain()"), _A("B"), "b1()"));
REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B"), "b2()"));
REQUIRE_THAT(
src, HasCallInControlCondition(_A("tmain()"), _A("C"), "c1()"));
REQUIRE_THAT(
src, HasCallInControlCondition(_A("tmain()"), _A("C"), "c2()"));
// TODO: Why is this not working?
// REQUIRE_THAT(
// puml, HasCallInControlCondition(_A("tmain()"), _A("C"),
// "c3()"));
REQUIRE_THAT(
src, HasCallInControlCondition(_A("tmain()"), _A("C"), "c4()"));
REQUIRE_THAT(src, HasCall(_A("C"), _A("C"), "c5()"));
REQUIRE_THAT(src,
HasCallInControlCondition(_A("tmain()"), _A("C"), "contents()"));
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
{
auto j = generate_sequence_json(diagram, *model);
using namespace json;
std::vector<int> messages = {
FindMessage(j, "tmain()", "C", "c4()"),
FindMessage(j, "C", "C", "c5()"),
FindMessage(j, "tmain()", "A", "a3()"),
FindMessage(j, "tmain()", "A", "a2()"),
FindMessage(j, "tmain()", "C", "c1()"),
FindMessage(j, "tmain()", "C", "c2()"),
FindMessage(j, "tmain()", "A", "a1()"),
FindMessage(j, "tmain()", "C", "c3()"),
FindMessage(j, "tmain()", "B", "b2() const"),
FindMessage(j, "tmain()", "C", "contents()")
// TODO: Repeated messge gets wrong index
// FindMessage(j, "tmain()", "B", "b2()")
};
REQUIRE(std::is_sorted(messages.begin(), messages.end()));
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, HasCall(_A("tmain()"), _A("A"), "a3()"));
REQUIRE_THAT(src, !HasCall(_A("tmain()"), _A("B"), "b1()"));
REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B"), "b2()"));
REQUIRE_THAT(
src, HasCallInControlCondition(_A("tmain()"), _A("C"), "c1()"));
REQUIRE_THAT(
src, HasCallInControlCondition(_A("tmain()"), _A("C"), "c2()"));
REQUIRE_THAT(
src, HasCallInControlCondition(_A("tmain()"), _A("C"), "c4()"));
REQUIRE_THAT(src, HasCall(_A("C"), _A("C"), "c5()"));
REQUIRE_THAT(src,
HasCallInControlCondition(_A("tmain()"), _A("C"), "contents()"));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}*/
}

41
tests/t20022/test_case.h
View File

@@ -35,45 +35,4 @@ TEST_CASE("t20022")
{"A", "B", "b()"}, //
}));
});
/*
{
auto src = generate_sequence_puml(diagram, *model);
AliasMatcher _A(src);
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
// Check if all calls exist
REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("A"), "a()"));
REQUIRE_THAT(src, HasCall(_A("A"), _A("B"), "b()"));
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
{
auto j = generate_sequence_json(diagram, *model);
using namespace json;
std::vector<int> messages = {FindMessage(j, "tmain()", "A", "a()"),
FindMessage(j, "A", "B", "b()")};
REQUIRE(std::is_sorted(messages.begin(), messages.end()));
save_json(config.output_directory(), diagram->name + ".json", j);
}
{
auto src = generate_sequence_mermaid(diagram, *model);
mermaid::SequenceDiagramAliasMatcher _A(src);
using mermaid::HasCall;
REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("A"), "a()"));
REQUIRE_THAT(src, HasCall(_A("A"), _A("B"), "b()"));
save_mermaid(config.output_directory(), diagram->name + ".mmd",
src);
}*/
}

49
tests/t20023/test_case.h
View File

@@ -35,53 +35,4 @@ TEST_CASE("t20023")
}));
});
/*
{
auto src = generate_sequence_puml(diagram, *model);
AliasMatcher _A(src);
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
// Check if all calls exist
REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("A"), "a()"));
REQUIRE_THAT(src, HasCall(_A("A"), _A("A"), "a1()"));
REQUIRE_THAT(src, HasCall(_A("A"), _A("A"), "a2()"));
REQUIRE_THAT(src, HasCall(_A("A"), _A("A"), "a3()"));
REQUIRE_THAT(src, HasCall(_A("A"), _A("A"), "a4()"));
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
{
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()")};
REQUIRE(std::is_sorted(messages.begin(), messages.end()));
save_json(config.output_directory(), diagram->name + ".json", j);
}
{
auto src = generate_sequence_mermaid(diagram, *model);
mermaid::SequenceDiagramAliasMatcher _A(src);
using mermaid::HasCall;
REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("A"), "a()"));
REQUIRE_THAT(src, HasCall(_A("A"), _A("A"), "a1()"));
REQUIRE_THAT(src, HasCall(_A("A"), _A("A"), "a2()"));
REQUIRE_THAT(src, HasCall(_A("A"), _A("A"), "a3()"));
REQUIRE_THAT(src, HasCall(_A("A"), _A("A"), "a4()"));
save_mermaid(config.output_directory(), diagram->name + ".mmd",
src);
}
*/
}

57
tests/t20024/test_case.h
View File

@@ -40,61 +40,4 @@ TEST_CASE("t20024")
{"B", "B", "grey()"} //
}));
});
/*
{
auto src = generate_sequence_puml(diagram, *model);
AliasMatcher _A(src);
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
// Check if all calls exist
REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("A"), "select(enum_a)"));
REQUIRE_THAT(src, HasCall(_A("A"), _A("A"), "a0()"));
REQUIRE_THAT(src, HasCall(_A("A"), _A("A"), "a1()"));
REQUIRE_THAT(src, HasCall(_A("A"), _A("A"), "a2()"));
REQUIRE_THAT(src, HasCall(_A("A"), _A("A"), "a3()"));
REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B"), "select(colors)"));
REQUIRE_THAT(src, HasCall(_A("B"), _A("B"), "red()"));
REQUIRE_THAT(src, HasCall(_A("B"), _A("B"), "orange()"));
REQUIRE_THAT(src, HasCall(_A("B"), _A("B"), "green()"));
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
{
auto j = generate_sequence_json(diagram, *model);
using namespace json;
std::vector<int> messages = {
FindMessage(j, "tmain()", "A", "select(enum_a)"),
FindMessage(j, "A", "A", "a0()"), FindMessage(j, "A", "A", "a1()"),
FindMessage(j, "A", "A", "a2()"), FindMessage(j, "A", "A", "a3()")};
REQUIRE(std::is_sorted(messages.begin(), messages.end()));
save_json(config.output_directory(), diagram->name + ".json", j);
}
{
auto src = generate_sequence_mermaid(diagram, *model);
mermaid::SequenceDiagramAliasMatcher _A(src);
using mermaid::HasCall;
REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("A"), "select(enum_a)"));
REQUIRE_THAT(src, HasCall(_A("A"), _A("A"), "a0()"));
REQUIRE_THAT(src, HasCall(_A("A"), _A("A"), "a1()"));
REQUIRE_THAT(src, HasCall(_A("A"), _A("A"), "a2()"));
REQUIRE_THAT(src, HasCall(_A("A"), _A("A"), "a3()"));
REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B"), "select(colors)"));
REQUIRE_THAT(src, HasCall(_A("B"), _A("B"), "red()"));
REQUIRE_THAT(src, HasCall(_A("B"), _A("B"), "orange()"));
REQUIRE_THAT(src, HasCall(_A("B"), _A("B"), "green()"));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}*/
}

46
tests/t20025/test_case.h
View File

@@ -31,50 +31,4 @@ TEST_CASE("t20025")
{"tmain()", "add(int,int)", ""} //
}));
});
/*
{
auto src = generate_sequence_puml(diagram, *model);
AliasMatcher _A(src);
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
// Check if all calls exist
REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("A"), "a()"));
REQUIRE_THAT(src, !HasCall(_A("A"), _A("A"), "a1()"));
// REQUIRE_THAT(puml, !HasCall(_A("A"), _A("A"), "a2()"));
REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("add(int,int)"), ""));
REQUIRE_THAT(src, !HasCall(_A("tmain()"), _A("add2(int,int)"), ""));
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
{
auto j = generate_sequence_json(diagram, *model);
using namespace json;
std::vector<int> messages = {FindMessage(j, "tmain()", "A", "a()"),
// FindMessage(j, "tmain()", "A", "a2()"),
FindMessage(j, "tmain()", "add(int,int)", "")};
REQUIRE(std::is_sorted(messages.begin(), messages.end()));
save_json(config.output_directory(), diagram->name + ".json", j);
}
{
auto src = generate_sequence_mermaid(diagram, *model);
mermaid::SequenceDiagramAliasMatcher _A(src);
using mermaid::HasCall;
REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("A"), "a()"));
REQUIRE_THAT(src, !HasCall(_A("A"), _A("A"), "a1()"));
// REQUIRE_THAT(puml, !HasCall(_A("A"), _A("A"), "a2()"));
REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("add(int,int)"), ""));
REQUIRE_THAT(src, !HasCall(_A("tmain()"), _A("add2(int,int)"), ""));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}*/
}

36
tests/t20026/test_case.h
View File

@@ -30,40 +30,4 @@ TEST_CASE("t20026")
{"tmain()", "A", "a()"} //
}));
});
/*
{
auto src = generate_sequence_puml(diagram, *model);
AliasMatcher _A(src);
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
// Check if all calls exist
REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("A"), "a()"));
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
{
auto j = generate_sequence_json(diagram, *model);
using namespace json;
std::vector<int> messages = {FindMessage(j, "tmain()", "A", "a()")};
REQUIRE(std::is_sorted(messages.begin(), messages.end()));
save_json(config.output_directory(), diagram->name + ".json", j);
}
{
auto src = generate_sequence_mermaid(diagram, *model);
mermaid::SequenceDiagramAliasMatcher _A(src);
using mermaid::HasCall;
REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("A"), "a()"));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}*/
}

41
tests/t20027/test_case.h
View File

@@ -33,45 +33,4 @@ TEST_CASE("t20027")
REQUIRE(!HasMessage(src, {"A", "A", "aa()"}));
REQUIRE(!HasMessage(src, {"A", "A", "aaa()"}));
});
/*
{
auto src = generate_sequence_puml(diagram, *model);
AliasMatcher _A(src);
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
// Check if all calls exist
REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("A"), "a()"));
REQUIRE_THAT(src, !HasCall(_A("A"), _A("A"), "aa()"));
REQUIRE_THAT(src, !HasCall(_A("A"), _A("A"), "aaa()"));
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
{
auto j = generate_sequence_json(diagram, *model);
using namespace json;
std::vector<int> messages = {FindMessage(j, "tmain()", "A", "a()")};
REQUIRE(std::is_sorted(messages.begin(), messages.end()));
save_json(config.output_directory(), diagram->name + ".json", j);
}
{
auto src = generate_sequence_mermaid(diagram, *model);
mermaid::SequenceDiagramAliasMatcher _A(src);
using mermaid::HasCall;
REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("A"), "a()"));
REQUIRE_THAT(src, !HasCall(_A("A"), _A("A"), "aa()"));
REQUIRE_THAT(src, !HasCall(_A("A"), _A("A"), "aaa()"));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}*/
}

51
tests/t20028/test_case.h
View File

@@ -35,55 +35,4 @@ TEST_CASE("t20028")
REQUIRE(!HasMessage(src, {"tmain()", "B", "e()"}));
});
/*
{
auto src = generate_sequence_puml(diagram, *model);
AliasMatcher _A(src);
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
// Check if all calls exist
REQUIRE_THAT(
src, HasCallInControlCondition(_A("tmain()"), _A("A"), "a()"));
REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("A"), "b()"));
REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("A"), "c()"));
REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("A"), "d()"));
REQUIRE_THAT(src, !HasCall(_A("tmain()"), _A("B"), "e()"));
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
{
auto j = generate_sequence_json(diagram, *model);
using namespace json;
std::vector<int> messages = {FindMessage(j, "tmain()", "A", "a()"),
FindMessage(j, "tmain()", "A", "b()"),
FindMessage(j, "tmain()", "A", "c()"),
FindMessage(j, "tmain()", "A", "d()")};
REQUIRE(std::is_sorted(messages.begin(), messages.end()));
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, HasCallInControlCondition(_A("tmain()"), _A("A"), "a()"));
REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("A"), "b()"));
REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("A"), "c()"));
REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("A"), "d()"));
REQUIRE_THAT(src, !HasCall(_A("tmain()"), _A("B"), "e()"));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}*/
}

133
tests/t20029/test_case.h
View File

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

60
tests/t20041/test_case.h
View File

@@ -36,64 +36,4 @@ TEST_CASE("t20041")
{"A<std::string>", "A", "print()"}, //
}));
});
/*
{
auto src = generate_sequence_puml(diagram, *model);
AliasMatcher _A(src);
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
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 j = generate_sequence_json(diagram, *model);
using namespace json;
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()));
save_json(config.output_directory(), diagram->name + ".json", j);
}
{
auto src = generate_sequence_mermaid(diagram, *model);
mermaid::SequenceDiagramAliasMatcher _A(src);
using mermaid::HasCall;
REQUIRE_THAT(src,
HasCall(_A("tmain()"), _A("A<int,double,std::string>"),
"print(int,double,std::string)"));
REQUIRE_THAT(src,
HasCall(_A("A<int,double,std::string>"),
_A("A<double,std::string>"), "print(double,std::string)"));
REQUIRE_THAT(src,
HasCall(_A("A<double,std::string>"), _A("A<std::string>"),
"print(std::string)"));
save_mermaid(config.output_directory(), diagram->name + ".mmd",
src);
}*/
}

42
tests/t20042/test_case.h
View File

@@ -34,46 +34,4 @@ TEST_CASE("t20042")
{"BHandler", "BHandler", "handle(B &) const"}, //
}));
});
/*
{
auto src = generate_sequence_puml(diagram, *model);
AliasMatcher _A(src);
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
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_puml(config.output_directory(), diagram->name + ".puml", src);
}
{
auto j = generate_sequence_json(diagram, *model);
using namespace json;
save_json(config.output_directory(), diagram->name + ".json", j);
}
{
auto src = generate_sequence_mermaid(diagram, *model);
mermaid::SequenceDiagramAliasMatcher _A(src);
using mermaid::HasCall;
REQUIRE_THAT(src,
HasCall(_A("tmain()"), _A("AHandler"), "operator()(A &)
const")); REQUIRE_THAT( src, HasCall(_A("AHandler"), _A("AHandler"),
"handle(A &) const")); REQUIRE_THAT(src, HasCall(_A("tmain()"),
_A("BHandler"), "operator()(B &) const")); REQUIRE_THAT( src,
HasCall(_A("BHandler"), _A("BHandler"), "handle(B &) const"));
save_mermaid(config.output_directory(), diagram->name + ".mmd",
src);
}*/
}

43
tests/t20043/test_case.h
View File

@@ -37,47 +37,4 @@ TEST_CASE("t20043")
REQUIRE(!HasMessage(src, {"C", "B", "b()"}));
REQUIRE(!HasMessage(src, {"B", "A", "a()"}));
});
/*
{
auto src = generate_sequence_puml(diagram, *model);
AliasMatcher _A(src);
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
REQUIRE_THAT(src, !HasCall(_A("tmain()"), _A("F"), "f()"));
REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("D"), "d()"));
REQUIRE_THAT(src, HasCall(_A("D"), _A("C"), "c()"));
REQUIRE_THAT(src, !HasCall(_A("D"), _A("detail::E"), "e()"));
REQUIRE_THAT(src, !HasCall(_A("C"), _A("B"), "b()"));
REQUIRE_THAT(src, !HasCall(_A("B"), _A("A"), "a()"));
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
{
auto j = generate_sequence_json(diagram, *model);
using namespace json;
save_json(config.output_directory(), diagram->name + ".json", j);
}
{
auto src = generate_sequence_mermaid(diagram, *model);
mermaid::SequenceDiagramAliasMatcher _A(src);
using mermaid::HasCall;
REQUIRE_THAT(src, !HasCall(_A("tmain()"), _A("F"), "f()"));
REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("D"), "d()"));
REQUIRE_THAT(src, HasCall(_A("D"), _A("C"), "c()"));
REQUIRE_THAT(src, !HasCall(_A("D"), _A("detail::E"), "e()"));
REQUIRE_THAT(src, !HasCall(_A("C"), _A("B"), "b()"));
REQUIRE_THAT(src, !HasCall(_A("B"), _A("A"), "a()"));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}*/
}

2
tests/t20044/.clang-uml
View File

@@ -6,7 +6,7 @@ diagrams:
glob:
- t20044.cc
type_aliases:
"detail::expected<int,error>": result_t
"clanguml::t20044::detail::expected<int,clanguml::t20044::error>": result_t
generate_message_comments: true
include:
namespaces:

82
tests/t20044/test_case.h
View File

@@ -24,9 +24,11 @@ TEST_CASE("t20044")
CHECK_SEQUENCE_MODEL("t20044", "t20044_sequence");
CHECK_SEQUENCE_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(!IsClassParticipant(src, "detail::expected<int,error>"));
REQUIRE(IsClassParticipant(src, "result_t"));
REQUIRE(MessageOrder(src,
{
//
{"tmain()", "R", "R((lambda at t20044.cc:74:9) &&)"}, //
{"R", "tmain()::(lambda t20044.cc:74:9)",
"operator()() const"}, //
@@ -37,85 +39,21 @@ TEST_CASE("t20044")
{"tmain()::(lambda t20044.cc:84:18)", "A", "a5()"}, //
{"tmain()", "A", "a1() const"}, //
{"A", "detail::expected<int,error>", "expected(int)"}, //
{"A", "result_t", "expected(int)"}, //
{"tmain()", "detail::expected<int,error>",
{"tmain()", "result_t",
"and_then((lambda at t20044.cc:90:19) &&)"}, //
{"detail::expected<int,error>",
"tmain()::(lambda t20044.cc:90:19)",
{"result_t", "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)"}, //
{"A", "result_t", "expected(int)"}, //
{"tmain()", "detail::expected<int,error>",
{"tmain()", "result_t",
"and_then(result_t (&)(int))"}, // //
{"tmain()", "detail::expected<int,error>",
{"tmain()", "result_t",
"and_then(std::function<result_t (int)> &)"}, // //
{"tmain()", "detail::expected<int,error>",
{"tmain()", "result_t",
"value() const"}, // //
}));
});
/*
{
auto src = generate_sequence_puml(diagram, *model);
AliasMatcher _A(src);
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
// Check if all calls exist
REQUIRE_THAT(src,
HasCall(
_A("tmain()"), _A("R"), "R((lambda at t20044.cc:74:9) &&)"));
REQUIRE_THAT(src,
HasCall(_A("R"), _A("tmain()::(lambda t20044.cc:74:9)"),
"operator()()"));
REQUIRE_THAT(src,
HasCall(_A("tmain()::(lambda t20044.cc:74:9)"), _A("A"), "a()"));
REQUIRE_THAT(src,
HasCall(_A("tmain()"), _A("tmain()::(lambda t20044.cc:84:18)"),
"operator()()"));
REQUIRE_THAT(src,
HasCall(_A("tmain()::(lambda t20044.cc:84:18)"), _A("A"), "a5()"));
REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("A"), "a1()"));
REQUIRE_THAT(src,
HasCall(_A("tmain()"), _A("detail::expected<int,error>"),
"and_then((lambda at t20044.cc:90:19) &&)"));
REQUIRE_THAT(src,
HasCall(_A("detail::expected<int,error>"),
_A("tmain()::(lambda t20044.cc:90:19)"),
"operator()(auto &&) const"));
REQUIRE_THAT(src,
HasCall(
_A("tmain()::(lambda t20044.cc:90:19)"), _A("A"), "a2(int)"));
REQUIRE_THAT(src,
HasCall(
_A("A"), _A("detail::expected<int,error>"), "expected(int)"));
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
{
auto j = generate_sequence_json(diagram, *model);
using namespace json;
save_json(config.output_directory(), diagram->name + ".json", j);
}
{
auto src = generate_sequence_mermaid(diagram, *model);
mermaid::AliasMatcher _A(src);
using mermaid::IsClass;
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}*/
}

80
tests/t20045/test_case.h
View File

@@ -32,60 +32,32 @@ TEST_CASE("t20045")
"a1<(lambda at t20045.cc:35:18)>((lambda at "
"t20045.cc:35:18) &&)",
""}, //
{"a1<(lambda at t20045.cc:35:18)>((lambda at t20045.cc:35:18) "
"&&)",
"tmain()::(lambda t20045.cc:35:18)",
"operator()(auto &&) const"}, //
{"tmain()::(lambda t20045.cc:35:18)", "a3(int)", ""}, //
{"tmain()",
"a1<(lambda at t20045.cc:37:18)>((lambda at "
"t20045.cc:37:18) "
"&&)",
""}, //
{"a1<(lambda at t20045.cc:37:18)>((lambda at t20045.cc:37:18) "
"&&)",
"tmain()::(lambda t20045.cc:37:18)",
"operator()(auto &&) const"}, //
{"tmain()::(lambda t20045.cc:37:18)", "B", "b1(int)"}, //
{"tmain()",
"a1<(lambda at t20045.cc:39:18)>((lambda at "
"t20045.cc:39:18) &&)",
""}, //
{"a1<(lambda at t20045.cc:39:18)>((lambda at "
"t20045.cc:39:18) &&)",
"tmain()::(lambda t20045.cc:39:18)",
"operator()(auto &&) const"}, //
{"tmain()::(lambda t20045.cc:39:18)", "C", "get_x() const"} //
}));
});
/*
{
auto src = generate_sequence_puml(diagram, *model);
AliasMatcher _A(src);
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("a2(int)"), ""));
REQUIRE_THAT(src,
HasCall(_A("tmain()"),
_A("a1<(lambda at t20045.cc:35:18)>((lambda at "
"t20045.cc:35:18) &&)"),
""));
REQUIRE_THAT(src,
HasCall(_A("a1<(lambda at t20045.cc:35:18)>((lambda at "
"t20045.cc:35:18) &&)"),
_A("tmain()::(lambda t20045.cc:35:18)"),
"operator()(auto &&) const"));
REQUIRE_THAT(src,
HasCall(
_A("tmain()::(lambda t20045.cc:35:18)"), _A("a3(int)"), ""));
REQUIRE_THAT(src,
HasCall(
_A("tmain()::(lambda t20045.cc:37:18)"), _A("B"), "b1(int)"));
REQUIRE_THAT(src,
HasCall(
_A("tmain()::(lambda t20045.cc:39:18)"), _A("C"), "get_x()"));
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
{
auto j = generate_sequence_json(diagram, *model);
using namespace json;
save_json(config.output_directory(), diagram->name + ".json", j);
}
{
auto src = generate_sequence_mermaid(diagram, *model);
mermaid::AliasMatcher _A(src);
using mermaid::IsClass;
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}
*/
}

103
tests/t20046/test_case.h
View File

@@ -16,80 +16,41 @@
* limitations under the License.
*/
TEST_CASE("t20046", "[test-case][sequence]")
TEST_CASE("t20046")
{
auto [config, db] = load_config("t20046");
using namespace clanguml::test;
auto diagram = config.diagrams["t20046_sequence"];
auto [config, db, diagram, model] =
CHECK_SEQUENCE_MODEL("t20046", "t20046_sequence");
REQUIRE(diagram->name == "t20046_sequence");
CHECK_SEQUENCE_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(MessageOrder(src,
{//
{"tmain()", "tmain()::(lambda t20046.cc:13:15)",
"operator()(auto &&) const"}, //
{"tmain()::(lambda t20046.cc:13:15)",
"tmain()::(lambda t20046.cc:13:15)::(lambda "
"t20046.cc:14:16)",
"operator()(auto &&) const"}, //
{"tmain()::(lambda t20046.cc:13:15)::(lambda "
"t20046.cc:14:16)",
"a2(int)", ""}, //
auto model = generate_sequence_diagram(*db, diagram);
{"tmain()",
"a1<(lambda at t20046.cc:19:9)>((lambda at t20046.cc:19:9) "
"&&)",
""},
{"a1<(lambda at t20046.cc:19:9)>((lambda at t20046.cc:19:9) "
"&&)",
"tmain()::(lambda t20046.cc:19:9)",
"operator()(auto &&) const"}, //
{"tmain()::(lambda t20046.cc:19:9)",
"tmain()::(lambda t20046.cc:19:9)::(lambda "
"t20046.cc:19:34)",
"operator()(auto &&) const"}, //
{"tmain()::(lambda t20046.cc:19:9)::(lambda t20046.cc:19:34)",
"a3(int)", ""}
REQUIRE(model->name() == "t20046_sequence");
{
auto src = generate_sequence_puml(diagram, *model);
AliasMatcher _A(src);
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
REQUIRE_THAT(src,
HasCall(_A("tmain()"), _A("tmain()::(lambda t20046.cc:13:15)"),
"operator()(auto &&) const"));
REQUIRE_THAT(src,
HasCall(_A("tmain()::(lambda t20046.cc:13:15)"),
_A("tmain()::(lambda t20046.cc:13:15)::(lambda "
"t20046.cc:14:16)"),
"operator()(auto &&) const"));
REQUIRE_THAT(src,
HasCall(_A("tmain()::(lambda t20046.cc:13:15)::(lambda "
"t20046.cc:14:16)"),
_A("a2(int)"), ""));
REQUIRE_THAT(src,
HasCall(_A("tmain()"),
_A("a1<(lambda at t20046.cc:19:9)>((lambda at t20046.cc:19:9) "
"&&)"),
""));
REQUIRE_THAT(src,
HasCall(
_A("a1<(lambda at t20046.cc:19:9)>((lambda at t20046.cc:19:9) "
"&&)"),
_A("tmain()::(lambda t20046.cc:19:9)"),
"operator()(auto &&) const"));
REQUIRE_THAT(src,
HasCall(_A("tmain()::(lambda t20046.cc:19:9)"),
_A("tmain()::(lambda t20046.cc:19:9)::(lambda "
"t20046.cc:19:34)"),
"operator()(auto &&) const"));
REQUIRE_THAT(src,
HasCall(_A("tmain()::(lambda t20046.cc:19:9)::(lambda "
"t20046.cc:19:34)"),
_A("a3(int)"), ""));
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
{
auto j = generate_sequence_json(diagram, *model);
using namespace json;
save_json(config.output_directory(), diagram->name + ".json", j);
}
{
auto src = generate_sequence_mermaid(diagram, *model);
mermaid::AliasMatcher _A(src);
using mermaid::IsClass;
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}
}));
});
}

56
tests/t20047/test_case.h
View File

@@ -16,50 +16,24 @@
* limitations under the License.
*/
TEST_CASE("t20047", "[test-case][sequence]")
TEST_CASE("t20047")
{
auto [config, db] = load_config("t20047");
using namespace clanguml::test;
auto diagram = config.diagrams["t20047_sequence"];
REQUIRE(diagram->name == "t20047_sequence");
auto model = generate_sequence_diagram(*db, diagram);
REQUIRE(model->name() == "t20047_sequence");
auto [config, db, diagram, model] =
CHECK_SEQUENCE_MODEL("t20047", "t20047_sequence");
CHECK_SEQUENCE_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(MessageOrder(src,
{
auto src = generate_sequence_puml(diagram, *model);
AliasMatcher _A(src);
//
{"tmain()", "a1(int)", ""}, //
{"tmain()", "a2(int)", ""}, //
{"tmain()", "a3(int)", ""}, //
{"tmain()", "a4(int)", ""}, //
{"tmain()", "a5(int)", ""}, //
{"tmain()", "a6(int)", ""}, //
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
// Check if all calls exist
REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("a1(int)"), ""));
REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("a2(int)"), ""));
REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("a3(int)"), ""));
REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("a4(int)"), ""));
REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("a5(int)"), ""));
REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("a6(int)"), ""));
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
{
auto j = generate_sequence_json(diagram, *model);
using namespace json;
save_json(config.output_directory(), diagram->name + ".json", j);
}
{
auto src = generate_sequence_mermaid(diagram, *model);
mermaid::AliasMatcher _A(src);
using mermaid::IsClass;
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}
}));
});
}

96
tests/t20048/test_case.h
View File

@@ -16,76 +16,40 @@
* limitations under the License.
*/
TEST_CASE("t20048", "[test-case][sequence]")
TEST_CASE("t20048")
{
auto [config, db] = load_config("t20048");
using namespace clanguml::test;
auto diagram = config.diagrams["t20048_sequence"];
REQUIRE(diagram->name == "t20048_sequence");
auto model = generate_sequence_diagram(*db, diagram);
REQUIRE(model->name() == "t20048_sequence");
auto [config, db, diagram, model] =
CHECK_SEQUENCE_MODEL("t20048", "t20048_sequence");
CHECK_SEQUENCE_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(MessageOrder(src,
{
auto src = generate_sequence_puml(diagram, *model);
AliasMatcher _A(src);
//
{"tmain()", "a3(int)", ""}, //
{"tmain()", "a2(int)", ""}, //
{"tmain()", "a1(int)", ""}, //
{"tmain()", "tmain()::(lambda t20048.cc:26:11)",
"operator()(auto &&) const"}, //
{"tmain()::(lambda t20048.cc:26:11)", "a4(int)", ""}, //
{"tmain()", "a6(int)", ""}, //
{"tmain()", "a5(int)", ""}, //
{"tmain()", "a7(int)", ""}, //
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
// Check if all calls exist
REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("a3(int)"), ""));
REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("a2(int)"), ""));
REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("a1(int)"), ""));
REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("a5(int)"), ""));
REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("a6(int)"), ""));
REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("a7(int)"), ""));
REQUIRE_THAT(src,
HasCall(_A("tmain()"), _A("tmain()::(lambda t20048.cc:26:11)"),
"operator()(auto &&) const"));
REQUIRE_THAT(src,
HasCall(
_A("tmain()::(lambda t20048.cc:26:11)"), _A("a4(int)"), ""));
REQUIRE_THAT(src,
HasMessageComment(_A("tmain()"),
"a1\\(\\) adds `1` to the result\\n"
"of a2\\(\\)"));
REQUIRE_THAT(src,
HasMessageComment(_A("tmain()"),
"This lambda calls a4\\(\\) which\\n"
}));
REQUIRE(HasMessageComment(src, "tmain()",
"a1() adds `1` to the result\\n"
"of a2()"));
REQUIRE(HasMessageComment(src, "tmain()",
"This lambda calls a4() which\\n"
"adds `4` to it's argument"));
REQUIRE_THAT(src,
HasMessageComment(
_A("tmain()"), "a6\\(\\) adds `1` to its argument"));
REQUIRE_THAT(src,
HasMessageComment(_A("tmain()"),
"a5\\(\\) adds `1` to the result\\n"
"of a6\\(\\)"));
REQUIRE_THAT(src,
HasMessageComment(
_A("tmain()"), "a7\\(\\) is called via add std::async"));
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
{
auto j = generate_sequence_json(diagram, *model);
using namespace json;
save_json(config.output_directory(), diagram->name + ".json", j);
}
{
auto src = generate_sequence_mermaid(diagram, *model);
mermaid::AliasMatcher _A(src);
using mermaid::IsClass;
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}
REQUIRE(
HasMessageComment(src, "tmain()", "a6() adds `1` to its argument"));
REQUIRE(HasMessageComment(src, "tmain()",
"a5() adds `1` to the result\\n"
"of a6()"));
REQUIRE(HasMessageComment(
src, "tmain()", "a7() is called via add std::async"));
});
}

75
tests/t20049/test_case.h
View File

@@ -16,66 +16,25 @@
* limitations under the License.
*/
TEST_CASE("t20049", "[test-case][sequence]")
TEST_CASE("t20049")
{
auto [config, db] = load_config("t20049");
using namespace clanguml::test;
auto diagram = config.diagrams["t20049_sequence"];
REQUIRE(diagram->name == "t20049_sequence");
auto model = generate_sequence_diagram(*db, diagram);
REQUIRE(model->name() == "t20049_sequence");
auto [config, db, diagram, model] =
CHECK_SEQUENCE_MODEL("t20049", "t20049_sequence");
CHECK_SEQUENCE_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(MessageOrder(src,
{
auto src = generate_sequence_puml(diagram, *model);
AliasMatcher _A(src);
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
REQUIRE_THAT(src,
HasCall(_A("tmain()"),
_A("vector_square_add(float *,float *,float *,int)"), ""));
REQUIRE_THAT(src,
HasCall(_A("vector_square_add(float *,float *,float *,int)"),
_A("square(float)"), ""));
REQUIRE_THAT(src,
HasCall(_A("vector_square_add(float *,float *,float *,int)"),
_A("add<float>(float,float)"), ""));
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
{
auto j = generate_sequence_json(diagram, *model);
using namespace json;
save_json(config.output_directory(), diagram->name + ".json", j);
}
{
auto src = generate_sequence_mermaid(diagram, *model);
mermaid::SequenceDiagramAliasMatcher _A(src);
using mermaid::HasCall;
REQUIRE_THAT(src,
HasCall(_A("tmain()"),
_A("<< CUDA Kernel >><br>vector_square_add(float *,float "
"*,float *,int)"),
""));
REQUIRE_THAT(src,
HasCall(_A("<< CUDA Kernel >><br>vector_square_add(float *,float "
"*,float *,int)"),
_A("<< CUDA Device >><br>square(float)"), ""));
REQUIRE_THAT(src,
HasCall(_A("<< CUDA Kernel >><br>vector_square_add(float *,float "
"*,float *,int)"),
_A("<< CUDA Device >><br>add<float>(float,float)"), ""));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}
//
{"tmain()", "vector_square_add(float *,float *,float *,int)",
""}, //
{"vector_square_add(float *,float *,float *,int)",
"square(float)", ""}, //
{"vector_square_add(float *,float *,float *,int)",
"square(float)", ""}, //
{"vector_square_add(float *,float *,float *,int)",
"add<float>(float,float)", ""}, //
}));
});
}

74
tests/t20050/test_case.h
View File

@@ -16,65 +16,27 @@
* limitations under the License.
*/
TEST_CASE("t20050", "[test-case][sequence]")
TEST_CASE("t20050")
{
auto [config, db] = load_config("t20050");
using namespace clanguml::test;
auto diagram = config.diagrams["t20050_sequence"];
auto [config, db, diagram, model] =
CHECK_SEQUENCE_MODEL("t20050", "t20050_sequence");
REQUIRE(diagram->name == "t20050_sequence");
auto model = generate_sequence_diagram(*db, diagram);
REQUIRE(model->name() == "t20050_sequence");
CHECK_SEQUENCE_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(IsFileParticipant(src, "t20050.cu"));
REQUIRE(MessageOrder(src,
{
auto src = generate_sequence_puml(diagram, *model);
AliasMatcher _A(src);
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
// Check if all calls exist
REQUIRE_THAT(src,
HasCall(_A("t20050.cu"), _A("t20050.cu"),
"<< CUDA Kernel >>\\\\nvector_square_add(float *,float *,float "
"*,int)"));
REQUIRE_THAT(src,
HasCall(_A("t20050.cu"), _A("t20050.cu"),
"<< CUDA Device >>\\\\nsquare(float)"));
REQUIRE_THAT(src,
HasCall(_A("t20050.cu"), _A("t20050.cu"),
"<< CUDA Device >>\\\\nadd<float>(float,float)"));
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
{
auto j = generate_sequence_json(diagram, *model);
using namespace json;
save_json(config.output_directory(), diagram->name + ".json", j);
}
{
auto src = generate_sequence_mermaid(diagram, *model);
mermaid::SequenceDiagramAliasMatcher _A(src);
using mermaid::HasCall;
REQUIRE_THAT(src,
HasCall(_A("t20050.cu"), _A("t20050.cu"),
"<< CUDA Kernel >><br>vector_square_add(float *,float *,float "
"*,int)"));
REQUIRE_THAT(src,
HasCall(_A("t20050.cu"), _A("t20050.cu"),
"<< CUDA Device >><br>square(float)"));
REQUIRE_THAT(src,
HasCall(_A("t20050.cu"), _A("t20050.cu"),
"<< CUDA Device >><br>add<float>(float,float)"));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}
//
{Entrypoint{}, "t20050.cu", "tmain()"}, //
{"t20050.cu", "t20050.cu",
"vector_square_add(float *,float *,float *,int)",
CUDAKernel{}}, //
{"t20050.cu", "t20050.cu", "square(float)", CUDADevice{}}, //
{"t20050.cu", "t20050.cu", "square(float)", CUDADevice{}}, //
{"t20050.cu", "t20050.cu", "add<float>(float,float)",
CUDADevice{}}, //
}));
});
}

69
tests/t20051/test_case.h
View File

@@ -16,66 +16,21 @@
* limitations under the License.
*/
TEST_CASE("t20051", "[test-case][sequence]")
TEST_CASE("t20051")
{
auto [config, db] = load_config("t20051");
using namespace clanguml::test;
auto diagram = config.diagrams["t20051_sequence"];
auto [config, db, diagram, model] =
CHECK_SEQUENCE_MODEL("t20051", "t20051_sequence");
REQUIRE(diagram->name == "t20051_sequence");
auto model = generate_sequence_diagram(*db, diagram);
REQUIRE(model->name() == "t20051_sequence");
CHECK_SEQUENCE_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(!IsFileParticipant(src, "t20051.cu"));
REQUIRE(MessageOrder(src,
{
auto src = generate_sequence_puml(diagram, *model);
AliasMatcher _A(src);
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
REQUIRE_THAT(src,
HasCall(_A("tmain()"),
_A("vector_square_add(float *,float *,float *,int)"), ""));
REQUIRE_THAT(src,
!HasCall(_A("vector_square_add(float *,float *,float *,int)"),
_A("square(float)"), ""));
REQUIRE_THAT(src,
!HasCall(_A("vector_square_add(float *,float *,float *,int)"),
_A("add<float>(float,float)"), ""));
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
{
auto j = generate_sequence_json(diagram, *model);
using namespace json;
save_json(config.output_directory(), diagram->name + ".json", j);
}
{
auto src = generate_sequence_mermaid(diagram, *model);
mermaid::SequenceDiagramAliasMatcher _A(src);
using mermaid::HasCall;
REQUIRE_THAT(src,
HasCall(_A("tmain()"),
_A("<< CUDA Kernel >><br>vector_square_add(float *,float "
"*,float *,int)"),
""));
REQUIRE_THAT(src,
!HasCall(_A("<< CUDA Kernel >><br>vector_square_add(float *,float "
"*,float *,int)"),
_A("<< CUDA Device >><br>square(float)"), ""));
REQUIRE_THAT(src,
!HasCall(_A("<< CUDA Kernel >><br>vector_square_add(float *,float "
"*,float *,int)"),
_A("<< CUDA Device >><br>add<float>(float,float)"), ""));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}
//
{"tmain()", "vector_square_add(float *,float *,float *,int)",
""}, //
}));
});
}

177
tests/t20052/test_case.h
View File

@@ -16,161 +16,48 @@
* limitations under the License.
*/
TEST_CASE("t20052", "[test-case][sequence]")
TEST_CASE("t20052")
{
auto [config, db] = load_config("t20052");
using namespace clanguml::test;
auto diagram = config.diagrams["t20052_sequence"];
auto [config, db, diagram, model] =
CHECK_SEQUENCE_MODEL("t20052", "t20052_sequence");
REQUIRE(diagram->name == "t20052_sequence");
auto model = generate_sequence_diagram(*db, diagram);
REQUIRE(model->name() == "t20052_sequence");
CHECK_SEQUENCE_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(!IsFileParticipant(src, "t20052.cu"));
REQUIRE(MessageOrder(src,
{
auto src = generate_sequence_puml(diagram, *model);
AliasMatcher _A(src);
//
{"tmain()", "A", "a()"}, //
{"A", "A", "aa()"}, //
{"A", "A", "aaa()"}, //
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
{"tmain()", "B", "b()"}, //
{"B", "B", "bb()"}, //
{"B", "B", "bbb()"}, //
// Check if all calls exist
REQUIRE_THAT(src,
!HasCall(_A("tmain()"), _A("tmain()::(lambda t20052.cc:67:20)"),
"operator()() const"));
REQUIRE_THAT(src,
!HasCall(_A("tmain()::(lambda t20052.cc:67:20)"), _A("A"), "a()"));
{"tmain()", "C", "c()"}, //
{"C", "C", "cc()"}, //
{"C", "C", "ccc()"}, //
REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("A"), "a()"));
REQUIRE_THAT(src, HasCall(_A("A"), _A("A"), "aa()"));
REQUIRE_THAT(src, HasCall(_A("A"), _A("A"), "aaa()"));
{"tmain()", "A", "a()"}, //
{"A", "A", "aa()"}, //
{"A", "A", "aaa()"}, //
REQUIRE_THAT(src,
!HasCall(_A("tmain()::(lambda t20052.cc:67:20)"), _A("B"), "b()"));
{"tmain()", "B", "b()"}, //
{"B", "B", "bb()"}, //
{"B", "B", "bbb()"}, //
REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B"), "b()"));
REQUIRE_THAT(src, HasCall(_A("B"), _A("B"), "bb()"));
REQUIRE_THAT(src, HasCall(_A("B"), _A("B"), "bbb()"));
{"tmain()", "R<(lambda at t20052.cc:86:9)>",
"R((lambda at t20052.cc:86:9) &&)"}, //
REQUIRE_THAT(src,
!HasCall(_A("tmain()::(lambda t20052.cc:80:20)"), _A("C"), "c()"));
{"tmain()", "R<(lambda at t20052.cc:86:9)>", "r()"}, //
{"R<(lambda at t20052.cc:86:9)>", "C", "c()"}, //
{"C", "C", "cc()"}, //
{"C", "C", "ccc()"}, //
REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("C"), "c()"));
REQUIRE_THAT(src, HasCall(_A("C"), _A("C"), "cc()"));
REQUIRE_THAT(src, HasCall(_A("C"), _A("C"), "ccc()"));
REQUIRE_THAT(src,
!HasCall(_A("tmain()::(lambda t20052.cc:80:20)"),
_A("tmain()::(lambda t20052.cc:67:20)"), "operator()() const"));
REQUIRE_THAT(src, HasCall(_A("C"), _A("C"), "ccc()"));
REQUIRE_THAT(src,
HasCall(_A("tmain()"), _A("R<(lambda at t20052.cc:86:9)>"),
"R((lambda at t20052.cc:86:9) &&)"));
REQUIRE_THAT(src,
HasCall(_A("tmain()"), _A("R<(lambda at t20052.cc:86:9)>"), "r()"));
REQUIRE_THAT(src,
!HasCall(_A("R<(lambda at t20052.cc:86:9)>"),
_A("tmain()::(lambda t20052.cc:86:9)"), "operator()() const"));
REQUIRE_THAT(
src, HasCall(_A("R<(lambda at t20052.cc:86:9)>"), _A("C"), "c()"));
REQUIRE_THAT(src,
!HasCall(_A("tmain()"), _A("tmain()::(lambda t20052.cc:94:9)"),
"operator()(auto) const"));
REQUIRE_THAT(src,
!HasCall(_A("tmain()::(lambda t20052.cc:94:9)"), _A("D"),
"add5(int) const"));
REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("D"), "add5(int) const"));
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
{
auto j = generate_sequence_json(diagram, *model);
using namespace json;
std::vector<int> messages = {
FindMessage(j, "tmain()", "A", "a()"),
FindMessage(j, "A", "A", "aa()"),
FindMessage(j, "A", "A", "aaa()"),
FindMessage(j, "tmain()", "B", "b()"),
FindMessage(j, "B", "B", "bb()"),
FindMessage(j, "B", "B", "bbb()"),
FindMessage(j, "tmain()", "C", "c()"),
FindMessage(j, "C", "C", "cc()"),
FindMessage(j, "C", "C", "ccc()"),
FindMessage(j, "tmain()", "R<(lambda at t20052.cc:86:9)>", "r()"),
FindMessage(j, "R<(lambda at t20052.cc:86:9)>", "C", "c()"),
};
REQUIRE(std::is_sorted(messages.begin(), messages.end()));
save_json(config.output_directory(), diagram->name + ".json", j);
}
{
auto src = generate_sequence_mermaid(diagram, *model);
mermaid::SequenceDiagramAliasMatcher _A(src);
using mermaid::HasCall;
REQUIRE_THAT(src,
!HasCall(_A("tmain()"), _A("tmain()::(lambda t20052.cc:67:20)"),
"operator()() const"));
REQUIRE_THAT(src,
!HasCall(_A("tmain()::(lambda t20052.cc:67:20)"), _A("A"), "a()"));
REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("A"), "a()"));
REQUIRE_THAT(src, HasCall(_A("A"), _A("A"), "aa()"));
REQUIRE_THAT(src, HasCall(_A("A"), _A("A"), "aaa()"));
REQUIRE_THAT(src,
!HasCall(_A("tmain()::(lambda t20052.cc:67:20)"), _A("B"), "b()"));
REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B"), "b()"));
REQUIRE_THAT(src, HasCall(_A("B"), _A("B"), "bb()"));
REQUIRE_THAT(src, HasCall(_A("B"), _A("B"), "bbb()"));
REQUIRE_THAT(src,
!HasCall(_A("tmain()::(lambda t20052.cc:80:20)"), _A("C"), "c()"));
REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("C"), "c()"));
REQUIRE_THAT(src, HasCall(_A("C"), _A("C"), "cc()"));
REQUIRE_THAT(src, HasCall(_A("C"), _A("C"), "ccc()"));
REQUIRE_THAT(src,
!HasCall(_A("tmain()::(lambda t20052.cc:80:20)"),
_A("tmain()::(lambda t20052.cc:67:20)"), "operator()() const"));
REQUIRE_THAT(src, HasCall(_A("C"), _A("C"), "ccc()"));
REQUIRE_THAT(src,
HasCall(_A("tmain()"), _A("R<(lambda at t20052.cc:86:9)>"),
"R((lambda at t20052.cc:86:9) &&)"));
REQUIRE_THAT(src,
HasCall(_A("tmain()"), _A("R<(lambda at t20052.cc:86:9)>"), "r()"));
REQUIRE_THAT(src,
!HasCall(_A("R<(lambda at t20052.cc:86:9)>"),
_A("tmain()::(lambda t20052.cc:86:9)"), "operator()() const"));
REQUIRE_THAT(
src, HasCall(_A("R<(lambda at t20052.cc:86:9)>"), _A("C"), "c()"));
REQUIRE_THAT(src,
!HasCall(_A("tmain()"), _A("tmain()::(lambda t20052.cc:94:9)"),
"operator()(auto) const"));
REQUIRE_THAT(src,
!HasCall(_A("tmain()::(lambda t20052.cc:94:9)"), _A("D"),
"add5(int) const"));
REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("D"), "add5(int) const"));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}
{"tmain()", "D", "add5(int) const"} //
}));
});
}

63
tests/t20053/test_case.h
View File

@@ -16,55 +16,28 @@
* limitations under the License.
*/
TEST_CASE("t20053", "[test-case][sequence]")
TEST_CASE("t20053")
{
auto [config, db] = load_config("t20053");
using namespace clanguml::test;
auto diagram = config.diagrams["t20053_sequence"];
auto [config, db, diagram, model] =
CHECK_SEQUENCE_MODEL("t20053", "t20053_sequence");
REQUIRE(diagram->name == "t20053_sequence");
auto model = generate_sequence_diagram(*db, diagram);
REQUIRE(model->name() == "t20053_sequence");
CHECK_SEQUENCE_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(!IsFileParticipant(src, "t20053.cu"));
REQUIRE(MessageOrder(src,
{
auto src = generate_sequence_puml(diagram, *model);
AliasMatcher _A(src);
//
{"tmain()", "a2(int)", ""}, //
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("a2(int)"), ""));
REQUIRE_THAT(src,
HasCall(_A("tmain()"),
_A("a1<(lambda at t20053.cc:23:9)>((lambda at t20053.cc:23:9) "
"&&)"),
""));
REQUIRE_THAT(src,
HasCall(_A("a1<(lambda at t20053.cc:23:9)>((lambda at "
"t20053.cc:23:9) &&)"),
_A("a3(int)"), ""));
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
{
auto j = generate_sequence_json(diagram, *model);
using namespace json;
save_json(config.output_directory(), diagram->name + ".json", j);
}
{
auto src = generate_sequence_mermaid(diagram, *model);
mermaid::AliasMatcher _A(src);
using mermaid::IsClass;
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}
{"tmain()",
"a1<(lambda at t20053.cc:23:9)>((lambda at t20053.cc:23:9) "
"&&)",
""}, //
{"a1<(lambda at t20053.cc:23:9)>((lambda at t20053.cc:23:9) "
"&&)",
"a3(int)", ""}, //
}));
});
}

6
tests/test_cases.cc
View File

@@ -1221,25 +1221,25 @@ template <> bool IsClass(json_t d, std::string name)
#include "t20038/test_case.h"
#include "t20039/test_case.h"
#include "t20040/test_case.h"
#include "t20041/test_case.h"
#include "t20042/test_case.h"
#include "t20043/test_case.h"
#include "t20044/test_case.h"
#include "t20045/test_case.h"
/*
#include "t20046/test_case.h"
#include "t20047/test_case.h"
#include "t20048/test_case.h"
#if defined(ENABLE_CUDA_TEST_CASES)
#include "t20049/test_case.h"
#include "t20050/test_case.h"
#include "t20051/test_case.h"
#endif
#include "t20052/test_case.h"
#include "t20053/test_case.h"
*/
///
/// Package diagram tests
///

35
tests/test_cases.h
View File

@@ -88,6 +88,9 @@ struct Entrypoint { };
struct Exitpoint { };
struct CUDAKernel { };
struct CUDADevice { };
struct InControlCondition { };
struct Response { };
struct NamespacePackage { };
@@ -246,8 +249,12 @@ struct mermaid_t : public diagram_source_t<std::string> {
util::replace_all(name, "[", "\\[");
util::replace_all(name, "]", "\\]");
patterns.push_back(
std::regex{"participant\\s" + alias_regex + "\\sas\\s" + name+"\\n"});
patterns.push_back(std::regex{
"participant\\s" + alias_regex + "\\sas\\s" + name + "\\n"});
patterns.push_back(std::regex{"participant\\s" + alias_regex +
"\\sas\\s<< CUDA Kernel >><br>" + name + "\\n"});
patterns.push_back(std::regex{"participant\\s" + alias_regex +
"\\sas\\s<< CUDA Device >><br>" + name + "\\n"});
std::smatch base_match;
@@ -468,6 +475,8 @@ struct Message {
, is_static{has_type<Static, Attrs...>()}
, is_incontrolcondition{has_type<InControlCondition, Attrs...>()}
, is_response{has_type<Response, Attrs...>()}
, is_cuda_kernel{has_type<CUDAKernel, Attrs...>()}
, is_cuda_device{has_type<CUDADevice, Attrs...>()}
{
}
@@ -497,6 +506,8 @@ struct Message {
bool is_exitpoint{false};
bool is_incontrolcondition{false};
bool is_response{false};
bool is_cuda_kernel{false};
bool is_cuda_device{false};
};
///
@@ -1197,6 +1208,11 @@ int64_t FindMessage(
util::replace_all(msg_str, "]", "\\]");
util::replace_all(msg_str, "+", "\\+");
if (msg.is_cuda_kernel)
msg_str = fmt::format("<< CUDA Kernel >>\\\\n{}", msg_str);
if (msg.is_cuda_device)
msg_str = fmt::format("<< CUDA Device >>\\\\n{}", msg_str);
std::string style;
if (msg.is_static)
style = "__";
@@ -1750,6 +1766,11 @@ int64_t FindMessage(
util::replace_all(msg_str, "]", "\\]");
util::replace_all(msg_str, "+", "\\+");
if (msg.is_cuda_kernel)
msg_str = fmt::format("<< CUDA Kernel >><br>{}", msg_str);
if (msg.is_cuda_device)
msg_str = fmt::format("<< CUDA Device >><br>{}", msg_str);
std::string call_pattern{"__INVALID__"};
if (msg.is_entrypoint) {
@@ -2388,6 +2409,16 @@ int find_message_impl(const nlohmann::json &j, const std::string &from,
auto from_p = get_participant(j, from);
auto to_p = get_participant(j, to);
if (!from_p)
throw std::runtime_error(
fmt::format("Cannot find participant {}", from));
if (!to_p)
throw std::runtime_error(fmt::format("Cannot find participant {}", to));
assert(from_p->is_object());
assert(to_p->is_object());
// TODO: support diagrams with multiple sequences...
int count{0};