googol/clang-uml
1
0
Fork 0
mirror of https://github.com/bkryza/clang-uml.git synced 2025-05-17 11:12:20 +08:00
Code Issues Packages Projects Releases Wiki Activity

Refactored sequence diagrams test cases (#266)

Browse Source
This commit is contained in:
Bartek Kryza 2024-05-20 21:56:54 +02:00
parent 4b5cfa7b48
commit 387b46f683
16 changed files with 40 additions and 3000 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

88
tests/t20017/test_case.h
View File

@ -27,93 +27,13 @@ TEST_CASE("t20017")
REQUIRE(MessageOrder(src,
{
//
// {Entrypoint{}, "t20017.cc", "tmain()"}, //
{"t20017.cc", "include/t20017_a.h", "a3(int,int)"}, //
{Entrypoint{}, "t20017.cc", "tmain()"}, //
{"t20017.cc", "include/t20017_a.h", "a3(int,int)"}, //
{"t20017.cc", "include/t20017_b.h", "b1(int,int)"}, //
/* {"t20017.cc", "include/t20017_a.h", "a2(int,int)"}, //
{"t20017.cc", "include/t20017_a.h", "a2(int,int)"}, //
{"t20017.cc", "include/t20017_a.h", "a1(int,int)"}, //
{"t20017.cc", "include/t20017_b.h", "b2<int>(int,int)"}, //
{Exitpoint{}, "t20017.cc"}, //*/
{Exitpoint{}, "t20017.cc"}, //
}));
});
/*
{
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("t20017.cc"), "tmain()"));
REQUIRE_THAT(src,
HasCall(_A("t20017.cc"), _A("include/t20017_a.h"), "a1(int,int)"));
REQUIRE_THAT(src,
HasCall(_A("t20017.cc"), _A("include/t20017_a.h"), "a2(int,int)"));
REQUIRE_THAT(src,
HasCall(_A("t20017.cc"), _A("include/t20017_a.h"), "a3(int,int)"));
REQUIRE_THAT(src,
HasCall(_A("t20017.cc"), _A("include/t20017_b.h"), "b1(int,int)"));
REQUIRE_THAT(src,
HasCall(
_A("t20017.cc"), _A("include/t20017_b.h"), "b2<int>(int,int)"));
REQUIRE_THAT(src, HasExitpoint(_A("t20017.cc")));
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
{
auto j = generate_sequence_json(diagram, *model);
using namespace json;
const auto &t20017_cc = get_participant(j, "t20017.cc");
CHECK(t20017_cc.has_value());
CHECK(t20017_cc.value()["type"] == "file");
CHECK(t20017_cc.value()["name"] == "t20017.cc");
CHECK(t20017_cc.value()["display_name"] == "t20017.cc");
std::vector<int> messages = {
FindMessage(j, File("t20017.cc"), File("include/t20017_a.h"),
"a3(int,int)"),
FindMessage(j, File("t20017.cc"), File("include/t20017_b.h"),
"b1(int,int)"),
FindMessage(j, File("t20017.cc"), File("include/t20017_a.h"),
"a2(int,int)"),
FindMessage(j, File("t20017.cc"), File("include/t20017_a.h"),
"a1(int,int)"),
FindMessage(j, File("t20017.cc"), File("include/t20017_b.h"),
"b2<int>(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::HasEntrypoint;
using mermaid::HasExitpoint;
REQUIRE_THAT(src, HasEntrypoint(_A("t20017.cc"), "tmain()"));
REQUIRE_THAT(src,
HasCall(_A("t20017.cc"), _A("include/t20017_a.h"), "a1(int,int)"));
REQUIRE_THAT(src,
HasCall(_A("t20017.cc"), _A("include/t20017_a.h"), "a2(int,int)"));
REQUIRE_THAT(src,
HasCall(_A("t20017.cc"), _A("include/t20017_a.h"), "a3(int,int)"));
REQUIRE_THAT(src,
HasCall(_A("t20017.cc"), _A("include/t20017_b.h"), "b1(int,int)"));
REQUIRE_THAT(src,
HasCall(
_A("t20017.cc"), _A("include/t20017_b.h"), "b2<int>(int,int)"));
REQUIRE_THAT(src, HasExitpoint(_A("t20017.cc")));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}*/
}

1
tests/t20023/test_case.h
View File

@ -32,7 +32,6 @@ TEST_CASE("t20023")
{"A", "A", "a2()"}, //
{"A", "A", "a3()"}, //
{"A", "A", "a4()"}, //
}));
});
}

88
tests/t20030/test_case.h
View File

@ -26,83 +26,27 @@ TEST_CASE("t20030")
CHECK_SEQUENCE_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(MessageOrder(src,
{
//
// "clanguml::t20030::tmain(int)"
//
{"tmain(int)", "magic()", ""}, //
{"tmain(int)", "A", "A(int)"}, //
{"tmain(int)", "A", "operator+=(int)"}, //
{"A", "A", "add(int)"}, //
{"tmain(bool,int)", "A", "A()"}, //
// {"A", "A", "create()"}, //
// {"tmain(bool,int)", "A", "A()"}, //
// {"A", "A", "create()"}, //
// {"tmain(bool,int)", "A", "operator+=(int)"},
// //
// {"A", "A", "add(int)"}, //
// {"tmain(bool,int)", "A", "operator=(const A
// &)"}, //
// {"A", "A", "set(int)"}, //
// {"tmain(bool,int)", "A", "value() const"} //
//
// "clanguml::t20030::tmain(bool,int)"
//
{"tmain(bool,int)", "A", "A()"}, //
{"A", "A", "create()"}, //
{"tmain(bool,int)", "A", "A()"}, //
{"A", "A", "create()"}, //
{"tmain(bool,int)", "A", "operator+=(int)"}, //
//
{"A", "A", "add(int)"}, //
{"tmain(bool,int)", "A", "operator=(const A &)"}, //
{"A", "A", "set(int)"}, //
{"tmain(bool,int)", "A", "value() const"} //
}));
});
/*
{
auto src = generate_sequence_puml(diagram, *model);
AliasMatcher _A(src);
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
// Check if all calls exist
REQUIRE_THAT(src, HasCall(_A("tmain(int)"), _A("magic()"), ""));
REQUIRE_THAT(src, HasCall(_A("A"), _A("A"), "create()"));
REQUIRE_THAT(
src, HasCall(_A("tmain(int)"), _A("A"), "operator+=(int)"));
REQUIRE_THAT(src, HasCall(_A("A"), _A("A"), "add(int)"));
REQUIRE_THAT(src, HasCall(_A("tmain(bool,int)"), _A("A"), "A()"));
REQUIRE_THAT(
src, HasCall(_A("tmain(bool,int)"), _A("A"),
"operator+=(int)")); REQUIRE_THAT(src, HasCall(_A("A"), _A("A"),
"add(int)")); REQUIRE_THAT(src, HasCall(_A("tmain(bool,int)"), _A("A"),
"operator=(const A &)")); REQUIRE_THAT(src, HasCall(_A("A"), _A("A"),
"set(int)")); REQUIRE_THAT(src, HasCall(_A("tmain(bool,int)"), _A("A"),
"value()"));
save_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(int)"), _A("magic()"), ""));
REQUIRE_THAT(src, HasCall(_A("A"), _A("A"), "create()"));
REQUIRE_THAT(
src, HasCall(_A("tmain(int)"), _A("A"), "operator+=(int)"));
REQUIRE_THAT(src, HasCall(_A("A"), _A("A"), "add(int)"));
REQUIRE_THAT(src, HasCall(_A("tmain(bool,int)"), _A("A"), "A()"));
REQUIRE_THAT(
src, HasCall(_A("tmain(bool,int)"), _A("A"),
"operator+=(int)")); REQUIRE_THAT(src, HasCall(_A("A"), _A("A"),
"add(int)")); REQUIRE_THAT(src, HasCall(_A("tmain(bool,int)"), _A("A"),
"operator=(const A &)")); REQUIRE_THAT(src, HasCall(_A("A"), _A("A"),
"set(int)")); REQUIRE_THAT(src, HasCall(_A("tmain(bool,int)"), _A("A"),
"value()"));
save_mermaid(config.output_directory(), diagram->name + ".mmd",
src);
}*/
}

81
tests/t20031/test_case.h
View File

@ -31,73 +31,16 @@ TEST_CASE("t20031")
{"tmain(bool,int)", "execute(std::function<int ()>)", ""}, //
{"tmain(bool,int)", "A", "value() const"} //
}));
REQUIRE(!HasMessage(src, {"A", "A", "create()"}));
REQUIRE(!HasMessage(src, {"tmain(int)", "A", "operator+=(int)"}));
REQUIRE(!HasMessage(src, {"tmain(bool,int)", "A", "A()"}));
REQUIRE(!HasMessage(src, {"tmain(bool,int)", "A", "operator+=(int)"}));
REQUIRE(!HasMessage(src, {"A", "A", "add(int)"}));
REQUIRE(
!HasMessage(src, {"tmain(bool,int)", "A", "operator=(const A &)"}));
REQUIRE(!HasMessage(src, {"A", "A", "set(int)"}));
REQUIRE(!HasMessage(src,
{"tmain(bool,int)::(lambda ../../tests/t20031/t20031.cc:47:26)",
"zero()", ""}));
});
/*
{
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(int)"), _A("magic()"), ""));
REQUIRE_THAT(src, !HasCall(_A("A"), _A("A"), "create()"));
REQUIRE_THAT(
src, !HasCall(_A("tmain(int)"), _A("A"), "operator+=(int)"));
REQUIRE_THAT(src, !HasCall(_A("A"), _A("A"), "add(int)"));
REQUIRE_THAT(src, !HasCall(_A("tmain(bool,int)"), _A("A"), "A()"));
REQUIRE_THAT(
src, !HasCall(_A("tmain(bool,int)"), _A("A"), "operator+=(int)"));
REQUIRE_THAT(src, !HasCall(_A("A"), _A("A"), "add(int)"));
REQUIRE_THAT(src,
!HasCall(_A("tmain(bool,int)"), _A("A"), "operator=(const A &)"));
REQUIRE_THAT(src, !HasCall(_A("A"), _A("A"), "set(int)"));
REQUIRE_THAT(src, HasCall(_A("tmain(bool,int)"), _A("A"), "value()"));
REQUIRE_THAT(src,
!HasCall(_A("tmain(bool,int)::(lambda "
"../../tests/t20031/t20031.cc:47:26)"),
_A("zero()"), ""));
save_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(int)"), _A("magic()"), ""));
REQUIRE_THAT(src, !HasCall(_A("A"), _A("A"), "create()"));
REQUIRE_THAT(
src, !HasCall(_A("tmain(int)"), _A("A"), "operator+=(int)"));
REQUIRE_THAT(src, !HasCall(_A("A"), _A("A"), "add(int)"));
REQUIRE_THAT(src, !HasCall(_A("tmain(bool,int)"), _A("A"), "A()"));
REQUIRE_THAT(
src, !HasCall(_A("tmain(bool,int)"), _A("A"), "operator+=(int)"));
REQUIRE_THAT(src, !HasCall(_A("A"), _A("A"), "add(int)"));
REQUIRE_THAT(src,
!HasCall(_A("tmain(bool,int)"), _A("A"), "operator=(const A &)"));
REQUIRE_THAT(src, !HasCall(_A("A"), _A("A"), "set(int)"));
REQUIRE_THAT(src, HasCall(_A("tmain(bool,int)"), _A("A"), "value()"));
REQUIRE_THAT(src,
!HasCall(_A("tmain(bool,int)::(lambda "
"../../tests/t20031/t20031.cc:47:26)"),
_A("zero()"), ""));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}
*/
}
}

79
tests/t20032/test_case.h
View File

@ -37,83 +37,10 @@ TEST_CASE("t20032")
{"A", "B", "double", Response{}}, //
{"B", "tmain(int,char **)", "double", Response{}}, //
{"tmain(int,char **)", "B", "b(const char *)"}, //
{"B", "A", "a3(const char *)"}, //
{"A", "B", "const char *", Response{}}, //
{"tmain(int,char **)", "B", "b(const char *)"}, //
{"B", "A", "a3(const char *)"}, //
{"A", "B", "const char *", Response{}}, //
{"B", "tmain(int,char **)", "const char *", Response{}} //
}));
});
/*
{
auto src = generate_sequence_puml(diagram, *model);
AliasMatcher _A(src);
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, HasResponse(_A("tmain(int,char **)"), _A("B"), "int"));
REQUIRE_THAT(src, HasCall(_A("B"), _A("A"), "a1(int)"));
REQUIRE_THAT(src, HasResponse(_A("B"), _A("A"), "int"));
REQUIRE_THAT(
src, HasCall(_A("tmain(int,char **)"), _A("B"), "b(double)"));
REQUIRE_THAT(src, HasCall(_A("B"), _A("A"), "a2(double)"));
REQUIRE_THAT(src, HasResponse(_A("B"), _A("A"), "double"));
REQUIRE_THAT(
src, HasCall(_A("tmain(int,char **)"), _A("B"), "b(const char *)"));
REQUIRE_THAT(src, HasCall(_A("B"), _A("A"), "a3(const char *)"));
REQUIRE_THAT(src, HasResponse(_A("B"), _A("A"), "const char *"));
save_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)", "int"),
FindMessage(j, "B", "A", "a1(int)", "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;
using mermaid::HasResponse;
REQUIRE_THAT(src, HasCall(_A("tmain(int,char **)"), _A("B"), "b(int)"));
REQUIRE_THAT(
src, HasResponse(_A("tmain(int,char **)"), _A("B"), "int"));
REQUIRE_THAT(src, HasCall(_A("B"), _A("A"), "a1(int)"));
REQUIRE_THAT(src, HasResponse(_A("B"), _A("A"), "int"));
REQUIRE_THAT(
src, HasCall(_A("tmain(int,char **)"), _A("B"), "b(double)"));
REQUIRE_THAT(src, HasCall(_A("B"), _A("A"), "a2(double)"));
REQUIRE_THAT(src, HasResponse(_A("B"), _A("A"), "double"));
REQUIRE_THAT(
src, HasCall(_A("tmain(int,char **)"), _A("B"), "b(const char *)"));
REQUIRE_THAT(src, HasCall(_A("B"), _A("A"), "a3(const char *)"));
REQUIRE_THAT(src, HasResponse(_A("B"), _A("A"), "const char *"));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}*/
}

46
tests/t20033/test_case.h
View File

@ -52,50 +52,4 @@ TEST_CASE("t20033")
{"tmain()", "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("A"), "a1()"));
REQUIRE_THAT(
src, HasCallInControlCondition(_A("tmain()"), _A("A"), "a2()"));
REQUIRE_THAT(
src, HasCallInControlCondition(_A("tmain()"), _A("A"), "a3()"));
REQUIRE_THAT(
src, HasCallInControlCondition(_A("tmain()"), _A("A"), "a4()"));
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
{
auto 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;
using mermaid::HasCallInControlCondition;
REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("A"), "a1()"));
REQUIRE_THAT(
src, HasCallInControlCondition(_A("tmain()"), _A("A"), "a2()"));
REQUIRE_THAT(
src, HasCallInControlCondition(_A("tmain()"), _A("A"), "a3()"));
REQUIRE_THAT(
src, HasCallInControlCondition(_A("tmain()"), _A("A"), "a4()"));
save_mermaid(config.output_directory(), diagram->name + ".mmd",
src);
}*/
}

70
tests/t20034/test_case.h
View File

@ -68,75 +68,7 @@ TEST_CASE("t20034")
{"C", "C", "c2()"}, //
{"C", "B", "b2()"}, //
{"B", "A", "a2()"} //
} //
} //
}));
});
/*
{
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("D"), _A("A"), "a2()"));
REQUIRE_THAT(src, HasCall(_A("D"), _A("C"), "c3()"));
REQUIRE_THAT(src, HasCall(_A("C"), _A("C"), "c2()"));
REQUIRE_THAT(src, HasCall(_A("C"), _A("B"), "b2()"));
REQUIRE_THAT(src, HasCall(_A("B"), _A("A"), "a2()"));
REQUIRE_THAT(src, HasCall(_A("D"), _A("C"), "c4()"));
REQUIRE_THAT(src, !HasCall(_A("C"), _A("B"), "b3()"));
save_puml(config.output_directory(), diagram->name +
".puml", src);
}
{
auto j = generate_sequence_json(diagram, *model);
using namespace json;
REQUIRE(HasMessageChain(j,
{{"d2()", "c3()", "void"}, {"c3()", "c2()", "void"},
{"c2()", "b2()", "void"}, {"b2()", "a2()",
"void"}})); REQUIRE(HasMessageChain(j,
{{"d2()", "c4()", "void"}, {"c4()", "b4()", "void"},
{"b4()", "b2()", "void"}, {"b2()", "a2()",
"void"}})); REQUIRE(HasMessageChain(j, {{"d2()", "a2()",
"void"}})); REQUIRE(HasMessageChain(j,
{{"d2()", "c1()", "void"}, {"c1()", "b1()", "void"},
{"b1()", "a2()", "void"}}));
REQUIRE(HasMessageChain(j,
{{"d2()", "c2()", "void"}, {"c2()", "b2()", "void"},
{"b2()", "a2()", "void"}}));
save_json(config.output_directory(), diagram->name +
".json", j);
}
{
auto src = generate_sequence_mermaid(diagram, *model);
mermaid::SequenceDiagramAliasMatcher _A(src);
using mermaid::HasCall;
REQUIRE_THAT(src, HasCall(_A("D"), _A("A"), "a2()"));
REQUIRE_THAT(src, HasCall(_A("D"), _A("C"), "c3()"));
REQUIRE_THAT(src, HasCall(_A("C"), _A("C"), "c2()"));
REQUIRE_THAT(src, HasCall(_A("C"), _A("B"), "b2()"));
REQUIRE_THAT(src, HasCall(_A("B"), _A("A"), "a2()"));
REQUIRE_THAT(src, HasCall(_A("D"), _A("C"), "c4()"));
REQUIRE_THAT(src, !HasCall(_A("C"), _A("B"), "b3()"));
save_mermaid(config.output_directory(), diagram->name +
".mmd", src);
}
*/
}

42
tests/t20035/test_case.h
View File

@ -32,46 +32,4 @@ TEST_CASE("t20035")
{"b1(int)", "c(int)", ""} //
}}));
});
/*
{
auto src = generate_sequence_puml(diagram, *model);
AliasMatcher _A(src);
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
REQUIRE_THAT(src, HasCall(_A("tmain(int,char **)"), _A("a(int)"),
"")); REQUIRE_THAT(src, HasCall(_A("a(int)"), _A("b1(int)"), ""));
REQUIRE_THAT(src, HasCall(_A("b1(int)"), _A("c(int)"), ""));
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
{
auto j = generate_sequence_json(diagram, *model);
using namespace json;
REQUIRE(HasMessageChain(j,
{{"tmain(int,char **)", "a(int)", "int"},
{"a(int)", "b1(int)", "int"}, {"b1(int)", "c(int)",
"int"}}));
save_json(config.output_directory(), diagram->name + ".json", j);
}
{
auto src = generate_sequence_mermaid(diagram, *model);
mermaid::SequenceDiagramAliasMatcher _A(src);
using mermaid::HasCall;
REQUIRE_THAT(src, HasCall(_A("tmain(int,char **)"), _A("a(int)"),
"")); REQUIRE_THAT(src, HasCall(_A("a(int)"), _A("b1(int)"), ""));
REQUIRE_THAT(src, HasCall(_A("b1(int)"), _A("c(int)"), ""));
save_mermaid(config.output_directory(), diagram->name + ".mmd",
src);
}
*/
}

64
tests/t20036/test_case.h
View File

@ -67,68 +67,4 @@ TEST_CASE("t20036")
}, //
}));
});
/*
{
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("C"), _A("C"), "c2()"));
REQUIRE_THAT(src, HasCall(_A("C"), _A("B"), "b2()"));
REQUIRE_THAT(src, HasCall(_A("B"), _A("A"), "a2()"));
REQUIRE_THAT(src, HasCall(_A("C"), _A("B"), "b2()"));
REQUIRE_THAT(src, HasCall(_A("B"), _A("A"), "a2()"));
REQUIRE_THAT(src, HasCall(_A("D"), _A("A"), "a2()"));
REQUIRE_THAT(src, HasCall(_A("C"), _A("B"), "b1()"));
REQUIRE_THAT(src, HasCall(_A("B"), _A("A"), "a2()"));
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
{
auto j = generate_sequence_json(diagram, *model);
using namespace json;
REQUIRE(HasMessageChain(j,
{{"c3()", "c2()", "void"}, {"c2()", "b2()", "void"},
{"b2()", "a2()", "void"}}));
REQUIRE(HasMessageChain(
j, {{"c4()", "b2()", "void"}, {"b2()", "a2()", "void"}}));
REQUIRE(HasMessageChain(j, {{"d3()", "a2()", "void"}}));
REQUIRE(HasMessageChain(j,
{{"d1()", "c2()", "void"}, {"c2()", "b2()", "void"},
{"b2()", "a2()", "void"}}));
REQUIRE(HasMessageChain(
j, {{"c1()", "b1()", "void"}, {"b1()", "a2()", "void"}}));
save_json(config.output_directory(), diagram->name + ".json", j);
}
{
auto src = generate_sequence_mermaid(diagram, *model);
mermaid::SequenceDiagramAliasMatcher _A(src);
using mermaid::HasCall;
REQUIRE_THAT(src, HasCall(_A("C"), _A("C"), "c2()"));
REQUIRE_THAT(src, HasCall(_A("C"), _A("B"), "b2()"));
REQUIRE_THAT(src, HasCall(_A("B"), _A("A"), "a2()"));
REQUIRE_THAT(src, HasCall(_A("C"), _A("B"), "b2()"));
REQUIRE_THAT(src, HasCall(_A("B"), _A("A"), "a2()"));
REQUIRE_THAT(src, HasCall(_A("D"), _A("A"), "a2()"));
REQUIRE_THAT(src, HasCall(_A("C"), _A("B"), "b1()"));
REQUIRE_THAT(src, HasCall(_A("B"), _A("A"), "a2()"));
save_mermaid(config.output_directory(), diagram->name + ".mmd",
src);
}*/
}

103
tests/t20038/test_case.h
View File

@ -53,107 +53,4 @@ TEST_CASE("t20038")
{"B", "A", "aaa()"}, //
}));
});
/*
{
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("B"), "b()"));
REQUIRE_THAT(src, !HasCall(_A("tmain()"), _A("B"), "bb()"));
REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B"), "bbb()"));
REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B"), "bbbb()"));
REQUIRE_THAT(src,
HasMessageComment(_A("tmain()"),
"This comment should be rendered only\\n"
"once"));
REQUIRE_THAT(src,
HasCall(_A("tmain()"), _A("add_impl<double>(double,double)"),
""));
REQUIRE_THAT(
src, HasMessageComment(_A("tmain()"), "What is 2 \\+ 2\\?"));
REQUIRE_THAT(src,
!HasMessageComment(
_A("tmain()"), "This is specific for some_other_diagram"));
REQUIRE_THAT(
src, HasMessageComment(_A("tmain()"), "Calling
B::bbbbb\\(\\)"));
REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B"), "bbbbb()"));
REQUIRE_THAT(src,
HasMessageComment(_A("tmain()"), "This is a conditional
operator"));
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;
using mermaid::HasCallInControlCondition;
using mermaid::HasMessageComment;
REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B"), "b()"));
REQUIRE_THAT(src, !HasCall(_A("tmain()"), _A("B"), "bb()"));
REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B"), "bbb()"));
REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B"), "bbbb()"));
REQUIRE_THAT(src,
HasMessageComment(_A("tmain()"),
"This comment should be rendered only<br/>"
"once"));
REQUIRE_THAT(src,
HasCall(_A("tmain()"), _A("add_impl<double>(double,double)"),
""));
REQUIRE_THAT(
src, HasMessageComment(_A("tmain()"), "What is 2 \\+ 2\\?"));
REQUIRE_THAT(src,
!HasMessageComment(
_A("tmain()"), "This is specific for some_other_diagram"));
REQUIRE_THAT(
src, HasMessageComment(_A("tmain()"), "Calling
B::bbbbb\\(\\)"));
REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B"), "bbbbb()"));
REQUIRE_THAT(src,
!HasMessageComment(
_A("tmain()"), "This is specific for some_other_diagram"));
REQUIRE_THAT(
src, HasMessageComment(_A("tmain()"), "Calling
B::bbbbb\\(\\)"));
save_mermaid(config.output_directory(), diagram->name + ".mmd",
src);
}
*/
}

48
tests/t20039/test_case.h
View File

@ -31,54 +31,8 @@ TEST_CASE("t20039")
{"R", "A<int>", "a(int)"}, //
{"R", "A<int_vec_t>", "a(int_vec_t)"}, //
{"R", "A<string_vec_t>", "a(string_vec_t)"}, //
{"R", "A<int_map_t>", "a(int_map_t)"}, //
{"R", "A<int_map_t>", "a(int_map_t)"}, //
{"R", "A<string_map_t>", "a(string_map_t)"} //
}));
});
/*
{
auto src = generate_sequence_puml(diagram, *model);
AliasMatcher _A(src);
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
// Check if all calls exist
REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("R"), "run()"));
REQUIRE_THAT(src, HasCall(_A("R"), _A("A<int>"), "a(int)"));
REQUIRE_THAT(src, HasCall(_A("R"), _A("A<int_vec_t>"), "a(int_vec_t)"));
REQUIRE_THAT(
src, HasCall(_A("R"), _A("A<string_vec_t>"), "a(string_vec_t)"));
REQUIRE_THAT(src, HasCall(_A("R"), _A("A<int_map_t>"), "a(int_map_t)"));
REQUIRE_THAT(
src, HasCall(_A("R"), _A("A<string_map_t>"), "a(string_map_t)"));
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("R"), "run()"));
REQUIRE_THAT(src, HasCall(_A("R"), _A("A<int>"), "a(int)"));
REQUIRE_THAT(src, HasCall(_A("R"), _A("A<int_vec_t>"), "a(int_vec_t)"));
REQUIRE_THAT(
src, HasCall(_A("R"), _A("A<string_vec_t>"), "a(string_vec_t)"));
REQUIRE_THAT(src, HasCall(_A("R"), _A("A<int_map_t>"), "a(int_map_t)"));
REQUIRE_THAT(
src, HasCall(_A("R"), _A("A<string_map_t>"), "a(string_map_t)"));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}*/
}

62
tests/t20040/test_case.h
View File

@ -45,66 +45,4 @@ TEST_CASE("t20040")
{"print<int>(int)", "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("print<int,double,std::string>(int,double,std::string)"),
""));
REQUIRE_THAT(src,
HasCall(_A("print<int,double,std::string>(int,double,std::string)"),
_A("print<double,std::string>(double,std::string)"), ""));
REQUIRE_THAT(src,
HasCall(_A("print<double,std::string>(double,std::string)"),
_A("print<std::string>(std::string)"), ""));
REQUIRE_THAT(src,
HasCall(_A("print<std::string>(std::string)"), _A("print()"),
""));
save_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("print<int,double,std::string>(int,double,std::string)"),
""));
REQUIRE_THAT(src,
HasCall(_A("print<int,double,std::string>(int,double,std::string)"),
_A("print<double,std::string>(double,std::string)"), ""));
REQUIRE_THAT(src,
HasCall(_A("print<double,std::string>(double,std::string)"),
_A("print<std::string>(std::string)"), ""));
REQUIRE_THAT(src,
HasCall(_A("print<std::string>(std::string)"), _A("print()"),
""));
save_mermaid(config.output_directory(), diagram->name + ".mmd",
src);
}*/
}

3
tests/t20046/test_case.h
View File

@ -49,8 +49,7 @@ TEST_CASE("t20046")
"t20046.cc:19:34)",
"operator()(auto &&) const"}, //
{"tmain()::(lambda t20046.cc:19:9)::(lambda t20046.cc:19:34)",
"a3(int)", ""}
"a3(int)", ""} //
}));
});
}

1
tests/t20047/test_case.h
View File

@ -33,7 +33,6 @@ TEST_CASE("t20047")
{"tmain()", "a4(int)", ""}, //
{"tmain()", "a5(int)", ""}, //
{"tmain()", "a6(int)", ""}, //
}));
});
}

629
tests/test_cases.cc
View File

@ -121,42 +121,6 @@ auto render_diagram(
return ss.str();
}
}
//
// template <typename DiagramConfig, typename DiagramModel>
// auto generate_diagram_json(
// std::shared_ptr<clanguml::config::diagram> config, DiagramModel &model)
//{
// using diagram_config = DiagramConfig;
// using diagram_model = DiagramModel;
// using diagram_generator =
// typename clanguml::common::generators::diagram_generator_t<
// DiagramConfig,
// clanguml::common::generators::json_generator_tag>::type;
//
// std::stringstream ss;
//
// ss << diagram_generator(dynamic_cast<diagram_config &>(*config), model);
//
// return nlohmann::json::parse(ss.str());
//}
//
// template <typename DiagramConfig, typename DiagramModel>
// auto generate_diagram_mermaid(
// std::shared_ptr<clanguml::config::diagram> config, DiagramModel &model)
//{
// using diagram_config = DiagramConfig;
// using diagram_model = DiagramModel;
// using diagram_generator =
// typename clanguml::common::generators::diagram_generator_t<
// DiagramConfig,
// clanguml::common::generators::mermaid_generator_tag>::type;
//
// std::stringstream ss;
//
// ss << diagram_generator(dynamic_cast<diagram_config &>(*config), model);
//
// return ss.str();
//}
} // namespace detail
///
@ -198,109 +162,6 @@ generate_include_diagram(clanguml::common::compilation_database &db,
/// }@
///
/// @defgroup Diagram renderers
/// @{
///
/*
template <typename GeneratorType>
std::string render_class_diagram(
std::shared_ptr<clanguml::config::diagram> config,
clanguml::class_diagram::model::diagram &model)
{
return detail::generate_diagram<GeneratorType,
clanguml::config::class_diagram>(config, model);
}
std::string render_sequence_diagram(
std::shared_ptr<clanguml::config::diagram> config,
clanguml::sequence_diagram::model::diagram &model)
{
return detail::generate_diagram_puml<clanguml::config::sequence_diagram>(
config, model);
}
std::string generate_package_puml(
std::shared_ptr<clanguml::config::diagram> config,
clanguml::package_diagram::model::diagram &model)
{
return detail::generate_diagram_puml<clanguml::config::package_diagram>(
config, model);
}
std::string generate_include_puml(
std::shared_ptr<clanguml::config::diagram> config,
clanguml::include_diagram::model::diagram &model)
{
return detail::generate_diagram_puml<clanguml::config::include_diagram>(
config, model);
}
nlohmann::json generate_class_json(
std::shared_ptr<clanguml::config::diagram> config,
clanguml::class_diagram::model::diagram &model)
{
return detail::generate_diagram_json<clanguml::config::class_diagram>(
config, model);
}
nlohmann::json generate_sequence_json(
std::shared_ptr<clanguml::config::diagram> config,
clanguml::sequence_diagram::model::diagram &model)
{
return detail::generate_diagram_json<clanguml::config::sequence_diagram>(
config, model);
}
nlohmann::json generate_package_json(
std::shared_ptr<clanguml::config::diagram> config,
clanguml::package_diagram::model::diagram &model)
{
return detail::generate_diagram_json<clanguml::config::package_diagram>(
config, model);
}
nlohmann::json generate_include_json(
std::shared_ptr<clanguml::config::diagram> config,
clanguml::include_diagram::model::diagram &model)
{
return detail::generate_diagram_json<clanguml::config::include_diagram>(
config, model);
}
std::string generate_class_mermaid(
std::shared_ptr<clanguml::config::diagram> config,
clanguml::class_diagram::model::diagram &model)
{
return detail::generate_diagram_mermaid<clanguml::config::class_diagram>(
config, model);
}
std::string generate_sequence_mermaid(
std::shared_ptr<clanguml::config::diagram> config,
clanguml::sequence_diagram::model::diagram &model)
{
return detail::generate_diagram_mermaid<clanguml::config::sequence_diagram>(
config, model);
}
std::string generate_package_mermaid(
std::shared_ptr<clanguml::config::diagram> config,
clanguml::package_diagram::model::diagram &model)
{
return detail::generate_diagram_mermaid<clanguml::config::package_diagram>(
config, model);
}
std::string generate_include_mermaid(
std::shared_ptr<clanguml::config::diagram> config,
clanguml::include_diagram::model::diagram &model)
{
return detail::generate_diagram_mermaid<clanguml::config::include_diagram>(
config, model);
}
*/
template <typename T>
void save_diagram(const std::filesystem::path &path, const T &diagram)
{
@ -592,495 +453,6 @@ void CHECK_INCLUDE_DIAGRAM(const clanguml::config::config &config,
}
} // namespace clanguml::test
/*
template <>
plantuml_t render_class_diagram<plantuml_t>(
std::shared_ptr<clanguml::config::diagram> c,
clanguml::class_diagram::model::diagram &d)
{
return detail::generate_diagram_puml<clanguml::config::class_diagram>(c, d);
}
template <>
mermaid_t render_class_diagram<mermaid_t>(
std::shared_ptr<clanguml::config::diagram> c,
clanguml::class_diagram::model::diagram &d)
{
return generate_class_mermaid(c, d);
}
template <>
json_t render_class_diagram<json_t>(
std::shared_ptr<clanguml::config::diagram> c,
clanguml::class_diagram::model::diagram &d)
{
return generate_class_json(c, d);
}
template <>
DiagramType render_sequence_diagram(
std::shared_ptr<clanguml::config::diagram> c,
clanguml::sequence_diagram::model::diagram &model);
template <typename DiagramType>
DiagramType render_package_diagram(std::shared_ptr<clanguml::config::diagram> c,
clanguml::package_diagram::model::diagram &model);
template <typename DiagramType>
DiagramType render_include_diagram(std::shared_ptr<clanguml::config::diagram> c,
clanguml::include_diagram::model::diagram &model);
}
*/
// using namespace clanguml::test::matchers;
/*
namespace detail {
template <typename DiagramConfig>
auto generate_diagram_impl(clanguml::common::compilation_database &db,
std::shared_ptr<clanguml::config::diagram> diagram)
{
LOG_INFO("All paths will be evaluated relative to {}",
diagram->root_directory().string());
using diagram_config = DiagramConfig;
using diagram_model =
typename clanguml::common::generators::diagram_model_t<
diagram_config>::type;
using diagram_visitor =
typename clanguml::common::generators::diagram_visitor_t<
diagram_config>::type;
inject_diagram_options(diagram);
auto model = clanguml::common::generators::generate<diagram_model,
diagram_config, diagram_visitor>(db, diagram->name,
dynamic_cast<diagram_config &>(*diagram),
diagram->get_translation_units());
return model;
}
template <typename DiagramConfig, typename DiagramModel>
auto generate_diagram_puml(
std::shared_ptr<clanguml::config::diagram> config, DiagramModel &model)
{
using diagram_config = DiagramConfig;
using diagram_model = DiagramModel;
using diagram_generator =
typename clanguml::common::generators::diagram_generator_t<
DiagramConfig,
clanguml::common::generators::plantuml_generator_tag>::type;
std::stringstream ss;
ss << diagram_generator(dynamic_cast<diagram_config &>(*config), model);
return ss.str();
}
template <typename DiagramConfig, typename DiagramModel>
auto generate_diagram_json(
std::shared_ptr<clanguml::config::diagram> config, DiagramModel &model)
{
using diagram_config = DiagramConfig;
using diagram_model = DiagramModel;
using diagram_generator =
typename clanguml::common::generators::diagram_generator_t<
DiagramConfig,
clanguml::common::generators::json_generator_tag>::type;
std::stringstream ss;
ss << diagram_generator(dynamic_cast<diagram_config &>(*config), model);
return nlohmann::json::parse(ss.str());
}
template <typename DiagramConfig, typename DiagramModel>
auto generate_diagram_mermaid(
std::shared_ptr<clanguml::config::diagram> config, DiagramModel &model)
{
using diagram_config = DiagramConfig;
using diagram_model = DiagramModel;
using diagram_generator =
typename clanguml::common::generators::diagram_generator_t<
DiagramConfig,
clanguml::common::generators::mermaid_generator_tag>::type;
std::stringstream ss;
ss << diagram_generator(dynamic_cast<diagram_config &>(*config), model);
return ss.str();
}
}
std::unique_ptr<clanguml::class_diagram::model::diagram> generate_class_diagram(
clanguml::common::compilation_database &db,
std::shared_ptr<clanguml::config::diagram> diagram)
{
return detail::generate_diagram_impl<clanguml::config::class_diagram>(
db, diagram);
}
std::unique_ptr<clanguml::sequence_diagram::model::diagram>
generate_sequence_diagram(clanguml::common::compilation_database &db,
std::shared_ptr<clanguml::config::diagram> diagram)
{
return detail::generate_diagram_impl<clanguml::config::sequence_diagram>(
db, diagram);
}
std::unique_ptr<clanguml::package_diagram::model::diagram>
generate_package_diagram(clanguml::common::compilation_database &db,
std::shared_ptr<clanguml::config::diagram> diagram)
{
return detail::generate_diagram_impl<clanguml::config::package_diagram>(
db, diagram);
}
std::unique_ptr<clanguml::include_diagram::model::diagram>
generate_include_diagram(clanguml::common::compilation_database &db,
std::shared_ptr<clanguml::config::diagram> diagram)
{
return detail::generate_diagram_impl<clanguml::config::include_diagram>(
db, diagram);
}
std::string generate_class_puml(
std::shared_ptr<clanguml::config::diagram> config,
clanguml::class_diagram::model::diagram &model)
{
return detail::generate_diagram_puml<clanguml::config::class_diagram>(
config, model);
}
std::string generate_sequence_puml(
std::shared_ptr<clanguml::config::diagram> config,
clanguml::sequence_diagram::model::diagram &model)
{
return detail::generate_diagram_puml<clanguml::config::sequence_diagram>(
config, model);
}
std::string generate_package_puml(
std::shared_ptr<clanguml::config::diagram> config,
clanguml::package_diagram::model::diagram &model)
{
return detail::generate_diagram_puml<clanguml::config::package_diagram>(
config, model);
}
std::string generate_include_puml(
std::shared_ptr<clanguml::config::diagram> config,
clanguml::include_diagram::model::diagram &model)
{
return detail::generate_diagram_puml<clanguml::config::include_diagram>(
config, model);
}
nlohmann::json generate_class_json(
std::shared_ptr<clanguml::config::diagram> config,
clanguml::class_diagram::model::diagram &model)
{
return detail::generate_diagram_json<clanguml::config::class_diagram>(
config, model);
}
nlohmann::json generate_sequence_json(
std::shared_ptr<clanguml::config::diagram> config,
clanguml::sequence_diagram::model::diagram &model)
{
return detail::generate_diagram_json<clanguml::config::sequence_diagram>(
config, model);
}
nlohmann::json generate_package_json(
std::shared_ptr<clanguml::config::diagram> config,
clanguml::package_diagram::model::diagram &model)
{
return detail::generate_diagram_json<clanguml::config::package_diagram>(
config, model);
}
nlohmann::json generate_include_json(
std::shared_ptr<clanguml::config::diagram> config,
clanguml::include_diagram::model::diagram &model)
{
return detail::generate_diagram_json<clanguml::config::include_diagram>(
config, model);
}
std::string generate_class_mermaid(
std::shared_ptr<clanguml::config::diagram> config,
clanguml::class_diagram::model::diagram &model)
{
return detail::generate_diagram_mermaid<clanguml::config::class_diagram>(
config, model);
}
std::string generate_sequence_mermaid(
std::shared_ptr<clanguml::config::diagram> config,
clanguml::sequence_diagram::model::diagram &model)
{
return detail::generate_diagram_mermaid<clanguml::config::sequence_diagram>(
config, model);
}
std::string generate_package_mermaid(
std::shared_ptr<clanguml::config::diagram> config,
clanguml::package_diagram::model::diagram &model)
{
return detail::generate_diagram_mermaid<clanguml::config::package_diagram>(
config, model);
}
std::string generate_include_mermaid(
std::shared_ptr<clanguml::config::diagram> config,
clanguml::include_diagram::model::diagram &model)
{
return detail::generate_diagram_mermaid<clanguml::config::include_diagram>(
config, model);
}
template <typename T>
void save_diagram(const std::filesystem::path &path, const T &diagram)
{
static_assert(
std::is_same_v<T, std::string> || std::is_same_v<T, nlohmann::json>);
std::filesystem::create_directories(path.parent_path());
std::ofstream ofs;
ofs.open(path, std::ofstream::out | std::ofstream::trunc);
if constexpr (std::is_same_v<T, nlohmann::json>) {
ofs << std::setw(2) << diagram;
}
else {
ofs << diagram;
}
ofs.close();
}
void save_puml(const std::string &path, const std::string &filename,
const std::string &puml)
{
std::filesystem::path p{path};
p /= filename;
save_diagram(p, puml);
}
void save_json(const std::string &path, const std::string &filename,
const nlohmann::json &j)
{
std::filesystem::path p{path};
p /= filename;
save_diagram(p, j);
}
void save_mermaid(const std::string &path, const std::string &filename,
const std::string &mmd)
{
std::filesystem::path p{path};
p /= filename;
save_diagram(p, mmd);
}
namespace clanguml::test {
template <class F> struct test_traits;
// function pointer
template <class R, class... Args>
struct test_traits<R (*)(Args...)> : public test_traits<R(Args...)> { };
template <class R, class... Args> struct test_traits<R(Args...)> {
using return_type = R;
static constexpr std::size_t arity = sizeof...(Args);
template <std::size_t N> struct argument {
static_assert(N < arity, "error: invalid parameter index.");
using type = typename std::tuple_element<N, std::tuple<Args...>>::type;
};
};
struct diagram_source_storage {
diagram_source_storage(plantuml_t &&p, json_t &&j, mermaid_t &&m)
: plantuml{std::move(p)}
, json{std::move(j)}
, mermaid{std::move(m)}
{
}
template <typename T> const T &get() const;
plantuml_t plantuml;
json_t json;
mermaid_t mermaid;
};
template <> const plantuml_t &diagram_source_storage::get<plantuml_t>() const
{
return plantuml;
}
template <> const json_t &diagram_source_storage::get<json_t>() const
{
return json;
}
template <> const mermaid_t &diagram_source_storage::get<mermaid_t>() const
{
return mermaid;
}
template <typename TC, typename... TCs>
void CHECK_CLASS_DIAGRAM_IMPL(
const diagram_source_storage &diagrams, TC &&tc, TCs &&...tcs)
{
if constexpr (std::is_invocable_v<TC, plantuml_t>) {
tc(diagrams.get<plantuml_t>());
}
if constexpr (std::is_invocable_v<TC, json_t>) {
tc(diagrams.get<json_t>());
}
if constexpr (std::is_invocable_v<TC, mermaid_t>) {
tc(diagrams.get<mermaid_t>());
}
if constexpr (sizeof...(tcs) > 0) {
CHECK_CLASS_DIAGRAM_IMPL(diagrams, std::forward<TCs>(tcs)...);
}
}
template <typename DiagramConfig, typename DiagramModel, typename... TCs>
void CHECK_CLASS_DIAGRAM(
DiagramConfig diagram, DiagramModel &model, TCs &&...tcs)
{
diagram_source_storage diagram_sources{
render_class_diagram<plantuml_t>(diagram, model),
render_class_diagram<json_t>(diagram, model),
render_class_diagram<mermaid_t>(diagram, model)};
CHECK_CLASS_DIAGRAM_IMPL(diagram_sources, std::forward<TCs>(tcs)...);
}
//
// PlantUML test helpers
//
template <>
plantuml_t render_class_diagram<plantuml_t>(
std::shared_ptr<clanguml::config::diagram> c,
clanguml::class_diagram::model::diagram &d)
{
return generate_class_puml(c, d);
}
template <> bool IsClass(plantuml_t d, std::string name)
{
return util::contains(d.src, fmt::format("class {}", name));
}
//
// MermaidJS test helpers
//
template <>
mermaid_t render_class_diagram<mermaid_t>(
std::shared_ptr<clanguml::config::diagram> c,
clanguml::class_diagram::model::diagram &d)
{
return generate_class_mermaid(c, d);
}
template <> bool IsClass(mermaid_t d, std::string name)
{
return util::contains(d.src, fmt::format("class {}", name));
}
//
// JSON test helpers
//
struct File {
explicit File(const std::string &f)
: file{f}
{
}
const std::string file;
};
std::optional<nlohmann::json> get_element_by_id(
const nlohmann::json &j, const std::string &id)
{
if (!j.contains("elements"))
return {};
for (const nlohmann::json &e : j["elements"]) {
if (e["id"] == id)
return {e};
if (e["type"] == "namespace" || e["type"] == "folder") {
auto maybe_e = get_element_by_id(e, id);
if (maybe_e)
return maybe_e;
}
}
return {};
}
std::optional<nlohmann::json> get_element(
const nlohmann::json &j, const std::string &name)
{
if (!j.contains("elements"))
return {};
for (const nlohmann::json &e : j["elements"]) {
if (e["display_name"] == name)
return {e};
if (e["type"] == "namespace" || e["type"] == "folder" ||
e["type"] == "directory" || e["type"] == "module") {
auto maybe_e = get_element(e, name);
if (maybe_e)
return maybe_e;
}
}
return {};
}
std::optional<nlohmann::json> get_element(
const json_t &src, const std::string &name)
{
return get_element(src.src, name);
}
std::string expand_name(const nlohmann::json &j, const std::string &name)
{
return name;
}
template <>
json_t render_class_diagram<json_t>(
std::shared_ptr<clanguml::config::diagram> c,
clanguml::class_diagram::model::diagram &d)
{
return generate_class_json(c, d);
}
template <> bool IsClass(json_t d, std::string name)
{
auto e = get_element(d.src, expand_name(d.src, name));
return e && e->at("type") == "class";
}
}
}
*/
///
/// Class diagram tests
///
@ -1186,7 +558,6 @@ template <> bool IsClass(json_t d, std::string name)
#include "t20005/test_case.h"
#endif
#include "t20006/test_case.h"
#include "t20007/test_case.h"
#include "t20008/test_case.h"
#include "t20009/test_case.h"

1635
tests/test_cases.h
View File

File diff suppressed because it is too large Load Diff