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

WIP

Browse Source
This commit is contained in:
Bartek Kryza
2024-05-13 15:51:45 +02:00
parent 235533d9fa
commit eeae5caef5
57 changed files with 2240 additions and 2480 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
tests/CMakeLists.txt
View File

@@ -102,7 +102,7 @@ foreach(TEST_NAME ${TEST_NAMES})
target_sources(${TEST_NAME} PUBLIC FILE_SET CXX_MODULES FILES
${TEST_CASE_MODULE_SOURCES})
endif(ENABLE_CXX_MODULES_TEST_CASES)
target_sources(${TEST_NAME} PUBLIC ${TEST_NAME}.cc test_cases_checks.h
target_sources(${TEST_NAME} PUBLIC ${TEST_NAME}.cc
${TEST_CASE_SOURCES} catch.h)
else()
target_sources(${TEST_NAME} PUBLIC ${TEST_NAME}.cc catch.h)

52
tests/t00028/test_case.h
View File

@@ -30,31 +30,39 @@ TEST_CASE("t00028")
REQUIRE(model->name() == "t00028_class");
CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(IsClass(src, "A"));
REQUIRE(IsClass(src, "B"));
REQUIRE(IsClass(src, "C"));
REQUIRE(IsClass(src, "D"));
REQUIRE(IsClassTemplate(src, "E<T>"));
REQUIRE(IsEnum(src, "F"));
REQUIRE(IsClass(src, "R"));
REQUIRE(HasNote(src, "A", "top", "A class note."));
REQUIRE(HasNote(src, "B", "left", "B class note."));
REQUIRE(HasNote(src, "C", "bottom", "C class note."));
const auto d_note = R"(
CHECK_CLASS_DIAGRAM(
config, diagram, *model,
[](const auto &src) {
REQUIRE(IsClass(src, "A"));
REQUIRE(IsClass(src, "B"));
REQUIRE(IsClass(src, "C"));
REQUIRE(IsClass(src, "D"));
REQUIRE(IsClassTemplate(src, "E<T>"));
REQUIRE(IsEnum(src, "F"));
REQUIRE(IsClass(src, "R"));
REQUIRE(HasNote(src, "A", "top", "A class note."));
REQUIRE(HasNote(src, "B", "left", "B class note."));
REQUIRE(HasNote(src, "C", "bottom", "C class note."));
const auto d_note = R"(
D
class
note.)";
REQUIRE(HasNote(src, "D", "left", d_note));
REQUIRE(HasNote(src, "E<T>", "left", "E template class note."));
REQUIRE(HasNote(src, "F", "bottom", "F enum note."));
REQUIRE(!HasNote(src, "G", "left", "G class note."));
REQUIRE(HasNote(src, "R", "right", "R class note."));
REQUIRE(HasMemberNote(
src, "R", "aaa", "left", "R contains an instance of A."));
REQUIRE(!HasMemberNote(src, "R", "bbb", "right", "R class note."));
REQUIRE(HasMemberNote(src, "R", "ccc", "left", "Reference to C."));
});
REQUIRE(HasNote(src, "D", "left", d_note));
REQUIRE(HasNote(src, "E<T>", "left", "E template class note."));
REQUIRE(HasNote(src, "F", "bottom", "F enum note."));
REQUIRE(HasNote(src, "R", "right", "R class note."));
},
[](const plantuml_t &src) {
REQUIRE(HasMemberNote(src, "R", "ccc", "left", "Reference to C."));
REQUIRE(!HasMemberNote(src, "R", "bbb", "right", "R class note."));
REQUIRE(HasMemberNote(
src, "R", "aaa", "left", "R contains an instance of A."));
REQUIRE(!HasNote(src, "G", "left", "G class note."));
},
[](const mermaid_t &src) {
REQUIRE(HasNote(src, "R", "left", "R contains an instance of A."));
REQUIRE(!HasNote(src, "G", "left", "G class note."));
});
/*
{
auto src = generate_class_puml(diagram, *model);

71
tests/t00031/test_case.h
View File

@@ -1,5 +1,5 @@
/**
* tests/t00031/test_case.cc
* tests/t00031/test_case.h
*
* Copyright (c) 2021-2024 Bartek Kryza <bkryza@gmail.com>
*
@@ -16,8 +16,10 @@
* limitations under the License.
*/
TEST_CASE("t00031", "[test-case][class]")
TEST_CASE("t00031")
{
using namespace clanguml::test;
auto [config, db] = load_config("t00031");
auto diagram = config.diagrams["t00031_class"];
@@ -28,55 +30,20 @@ TEST_CASE("t00031", "[test-case][class]")
REQUIRE(model->name() == "t00031_class");
{
auto src = generate_class_puml(diagram, *model);
AliasMatcher _A(src);
CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(IsClass(src, "A"));
REQUIRE(IsEnum(src, "B"));
REQUIRE(IsClass(src, "D"));
REQUIRE(IsClassTemplate(src, "C<T>"));
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
REQUIRE_THAT(src, IsClass(_A("A")));
REQUIRE_THAT(src, IsEnum(_A("B")));
REQUIRE_THAT(src, IsClassTemplate("C", "T"));
REQUIRE_THAT(src, IsClass(_A("D")));
REQUIRE_THAT(src,
IsAssociation(
_A("R"), _A("A"), "+aaa", "", "", "[#red,dashed,thickness=2]"));
REQUIRE_THAT(src,
IsComposition(_A("R"), _A("B"), "+bbb", "", "",
"[#green,dashed,thickness=4]"));
REQUIRE_THAT(src, IsDependency(_A("R"), _A("B")));
REQUIRE_THAT(src,
IsAggregation(_A("R"), _A("C<int>"), "+ccc", "", "",
"[#blue,dotted,thickness=8]"));
REQUIRE_THAT(src,
IsAssociation(_A("R"), _A("D"), "+ddd", "", "",
"[#blue,plain,thickness=16]"));
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
{
auto j = generate_class_json(diagram, *model);
using namespace json;
REQUIRE(IsClass(j, "A"));
REQUIRE(IsClassTemplate(j, "C<T>"));
save_json(config.output_directory(), diagram->name + ".json", j);
}
{
auto src = generate_class_mermaid(diagram, *model);
mermaid::AliasMatcher _A(src);
using mermaid::IsEnum;
REQUIRE_THAT(src, IsClass(_A("A")));
REQUIRE_THAT(src, IsEnum(_A("B")));
REQUIRE_THAT(src, IsClass(_A("C<T>")));
REQUIRE_THAT(src, IsClass(_A("D")));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}
REQUIRE(IsAssociation<Public>(
src, "R", "A", "aaa", "", "", "[#red,dashed,thickness=2]"));
REQUIRE(IsComposition<Public>(
src, "R", "B", "bbb", "", "", "[#green,dashed,thickness=4]"));
REQUIRE(IsDependency(src, "R", "B"));
REQUIRE(IsAggregation<Public>(
src, "R", "C<int>", "ccc", "", "", "[#blue,dotted,thickness=8]"));
REQUIRE(IsAssociation<Public>(
src, "R", "D", "ddd", "", "", "[#blue,plain,thickness=16]"));
});
}

101
tests/t00032/test_case.h
View File

@@ -1,5 +1,5 @@
/**
* tests/t00032/test_case.cc
* tests/t00032/test_case.h
*
* Copyright (c) 2021-2024 Bartek Kryza <bkryza@gmail.com>
*
@@ -16,8 +16,10 @@
* limitations under the License.
*/
TEST_CASE("t00032", "[test-case][class]")
TEST_CASE("t00032")
{
using namespace clanguml::test;
auto [config, db] = load_config("t00032");
auto diagram = config.diagrams["t00032_class"];
@@ -28,83 +30,24 @@ TEST_CASE("t00032", "[test-case][class]")
REQUIRE(model->name() == "t00032_class");
{
auto src = generate_class_puml(diagram, *model);
AliasMatcher _A(src);
CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(IsClass(src, "Base"));
REQUIRE(IsClass(src, "TBase"));
REQUIRE(IsClass(src, "A"));
REQUIRE(IsClass(src, "B"));
REQUIRE(IsClass(src, "C"));
REQUIRE(IsClass(src, "R"));
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
REQUIRE(IsClassTemplate(src, "Overload<T,L,Ts...>"));
REQUIRE_THAT(src, IsClass(_A("Base")));
REQUIRE_THAT(src, IsClass(_A("TBase")));
REQUIRE_THAT(src, IsClass(_A("A")));
REQUIRE_THAT(src, IsClass(_A("B")));
REQUIRE_THAT(src, IsClass(_A("C")));
REQUIRE_THAT(src, IsClass(_A("R")));
REQUIRE_THAT(src, IsClassTemplate("Overload", "T,L,Ts..."));
REQUIRE_THAT(src, IsBaseClass(_A("Base"), _A("Overload<T,L,Ts...>")));
REQUIRE_THAT(
src, IsBaseClass(_A("TBase"), _A("Overload<TBase,int,A,B,C>")));
REQUIRE_THAT(
src, IsBaseClass(_A("A"), _A("Overload<TBase,int,A,B,C>")));
REQUIRE_THAT(
src, IsBaseClass(_A("B"), _A("Overload<TBase,int,A,B,C>")));
REQUIRE_THAT(
src, IsBaseClass(_A("C"), _A("Overload<TBase,int,A,B,C>")));
REQUIRE_THAT(
src, !IsDependency(_A("Overload<TBase,int,A,B,C>"), _A("TBase")));
REQUIRE_THAT(
src, !IsDependency(_A("Overload<TBase,int,A,B,C>"), _A("A")));
REQUIRE_THAT(
src, !IsDependency(_A("Overload<TBase,int,A,B,C>"), _A("B")));
REQUIRE_THAT(
src, !IsDependency(_A("Overload<TBase,int,A,B,C>"), _A("C")));
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
{
auto j = generate_class_json(diagram, *model);
using namespace json;
REQUIRE(IsBaseClass(j, "A", "Overload<TBase,int,A,B,C>"));
save_json(config.output_directory(), diagram->name + ".json", j);
}
{
auto src = generate_class_mermaid(diagram, *model);
mermaid::AliasMatcher _A(src);
REQUIRE_THAT(src, IsClass(_A("Base")));
REQUIRE_THAT(src, IsClass(_A("TBase")));
REQUIRE_THAT(src, IsClass(_A("A")));
REQUIRE_THAT(src, IsClass(_A("B")));
REQUIRE_THAT(src, IsClass(_A("C")));
REQUIRE_THAT(src, IsClass(_A("R")));
REQUIRE_THAT(src, IsClass(_A("Overload<T,L,Ts...>")));
REQUIRE_THAT(src, IsBaseClass(_A("Base"), _A("Overload<T,L,Ts...>")));
REQUIRE_THAT(
src, IsBaseClass(_A("TBase"), _A("Overload<TBase,int,A,B,C>")));
REQUIRE_THAT(
src, IsBaseClass(_A("A"), _A("Overload<TBase,int,A,B,C>")));
REQUIRE_THAT(
src, IsBaseClass(_A("B"), _A("Overload<TBase,int,A,B,C>")));
REQUIRE_THAT(
src, IsBaseClass(_A("C"), _A("Overload<TBase,int,A,B,C>")));
REQUIRE_THAT(
src, !IsDependency(_A("Overload<TBase,int,A,B,C>"), _A("TBase")));
REQUIRE_THAT(
src, !IsDependency(_A("Overload<TBase,int,A,B,C>"), _A("A")));
REQUIRE_THAT(
src, !IsDependency(_A("Overload<TBase,int,A,B,C>"), _A("B")));
REQUIRE_THAT(
src, !IsDependency(_A("Overload<TBase,int,A,B,C>"), _A("C")));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}
REQUIRE(IsBaseClass(src, "Base", "Overload<T,L,Ts...>"));
REQUIRE(IsBaseClass(src, "TBase", "Overload<TBase,int,A,B,C>"));
REQUIRE(IsBaseClass(src, "A", "Overload<TBase,int,A,B,C>"));
REQUIRE(IsBaseClass(src, "B", "Overload<TBase,int,A,B,C>"));
REQUIRE(IsBaseClass(src, "C", "Overload<TBase,int,A,B,C>"));
REQUIRE(!IsDependency(src, "Overload<TBase,int,A,B,C>", "TBase"));
REQUIRE(!IsDependency(src, "Overload<TBase,int,A,B,C>", "A"));
REQUIRE(!IsDependency(src, "Overload<TBase,int,A,B,C>", "B"));
REQUIRE(!IsDependency(src, "Overload<TBase,int,A,B,C>", "C"));
});
}

83
tests/t00033/test_case.h
View File

@@ -1,5 +1,5 @@
/**
* tests/t00033/test_case.cc
* tests/t00033/test_case.h
*
* Copyright (c) 2021-2024 Bartek Kryza <bkryza@gmail.com>
*
@@ -16,8 +16,10 @@
* limitations under the License.
*/
TEST_CASE("t00033", "[test-case][class]")
TEST_CASE("t00033")
{
using namespace clanguml::test;
auto [config, db] = load_config("t00033");
auto diagram = config.diagrams["t00033_class"];
@@ -28,70 +30,21 @@ TEST_CASE("t00033", "[test-case][class]")
REQUIRE(model->name() == "t00033_class");
{
auto src = generate_class_puml(diagram, *model);
AliasMatcher _A(src);
CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(IsClassTemplate(src, "A<T>"));
REQUIRE(IsClassTemplate(src, "B<T>"));
REQUIRE(IsClassTemplate(src, "C<T>"));
REQUIRE(IsClass(src, "D"));
REQUIRE(IsClass(src, "R"));
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
REQUIRE_THAT(src, IsClassTemplate("A", "T"));
REQUIRE_THAT(src, IsClassTemplate("B", "T"));
REQUIRE_THAT(src, IsClassTemplate("C", "T"));
REQUIRE_THAT(src, IsClass(_A("D")));
REQUIRE_THAT(src, IsClass(_A("R")));
REQUIRE_THAT(src,
IsDependency(_A("A<B<std::unique_ptr<C<D>>>>"),
_A("B<std::unique_ptr<C<D>>>")));
REQUIRE_THAT(
src, IsDependency(_A("B<std::unique_ptr<C<D>>>"), _A("C<D>")));
REQUIRE_THAT(src, IsDependency(_A("C<D>"), _A("D")));
REQUIRE_THAT(src, IsInstantiation(_A("C<T>"), _A("C<D>"), "up"));
REQUIRE_THAT(src,
IsInstantiation(_A("B<T>"), _A("B<std::unique_ptr<C<D>>>"), "up"));
REQUIRE_THAT(src,
IsInstantiation(
_A("A<T>"), _A("A<B<std::unique_ptr<C<D>>>>"), "up"));
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
{
auto j = generate_class_json(diagram, *model);
using namespace json;
REQUIRE(IsClass(j, "A<B<std::unique_ptr<C<D>>>>"));
REQUIRE(IsDependency(
j, "A<B<std::unique_ptr<C<D>>>>", "B<std::unique_ptr<C<D>>>"));
src, "A<B<std::unique_ptr<C<D>>>>", "B<std::unique_ptr<C<D>>>"));
REQUIRE(IsDependency(src, "B<std::unique_ptr<C<D>>>", "C<D>"));
REQUIRE(IsDependency(src, "C<D>", "D"));
save_json(config.output_directory(), diagram->name + ".json", j);
}
{
auto src = generate_class_mermaid(diagram, *model);
mermaid::AliasMatcher _A(src);
REQUIRE_THAT(src, IsClass(_A("A<T>")));
REQUIRE_THAT(src, IsClass(_A("B<T>")));
REQUIRE_THAT(src, IsClass(_A("C<T>")));
REQUIRE_THAT(src, IsClass(_A("D")));
REQUIRE_THAT(src, IsClass(_A("R")));
REQUIRE_THAT(src,
IsDependency(_A("A<B<std::unique_ptr<C<D>>>>"),
_A("B<std::unique_ptr<C<D>>>")));
REQUIRE_THAT(
src, IsDependency(_A("B<std::unique_ptr<C<D>>>"), _A("C<D>")));
REQUIRE_THAT(src, IsDependency(_A("C<D>"), _A("D")));
REQUIRE_THAT(src, IsInstantiation(_A("C<T>"), _A("C<D>")));
REQUIRE_THAT(
src, IsInstantiation(_A("B<T>"), _A("B<std::unique_ptr<C<D>>>")));
REQUIRE_THAT(src,
IsInstantiation(_A("A<T>"), _A("A<B<std::unique_ptr<C<D>>>>")));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}
REQUIRE(IsInstantiation(src, "C<T>", "C<D>", "up"));
REQUIRE(IsInstantiation(src, "B<T>", "B<std::unique_ptr<C<D>>>", "up"));
REQUIRE(
IsInstantiation(src, "A<T>", "A<B<std::unique_ptr<C<D>>>>", "up"));
});
}

62
tests/t00034/test_case.h
View File

@@ -1,5 +1,5 @@
/**
* tests/t00034/test_case.cc
* tests/t00034/test_case.h
*
* Copyright (c) 2021-2024 Bartek Kryza <bkryza@gmail.com>
*
@@ -16,8 +16,10 @@
* limitations under the License.
*/
TEST_CASE("t00034", "[test-case][class]")
TEST_CASE("t00034")
{
using namespace clanguml::test;
auto [config, db] = load_config("t00034");
auto diagram = config.diagrams["t00034_class"];
@@ -28,52 +30,14 @@ TEST_CASE("t00034", "[test-case][class]")
REQUIRE(model->name() == "t00034_class");
{
auto src = generate_class_puml(diagram, *model);
AliasMatcher _A(src);
CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(IsClassTemplate(src, "lift_void<T>"));
REQUIRE(IsClassTemplate(src, "drop_void<T>"));
REQUIRE(IsClass(src, "Void"));
REQUIRE(IsClass(src, "A"));
REQUIRE(IsClass(src, "R"));
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
REQUIRE_THAT(src, IsClassTemplate("lift_void", "T"));
REQUIRE_THAT(src, IsClassTemplate("drop_void", "T"));
REQUIRE_THAT(src, IsClass(_A("Void")));
REQUIRE_THAT(src, IsClass(_A("A")));
REQUIRE_THAT(src, IsClass(_A("R")));
REQUIRE_THAT(
src, IsInstantiation(_A("lift_void<T>"), _A("lift_void<void>")));
REQUIRE_THAT(
src, IsInstantiation(_A("drop_void<T>"), _A("drop_void<Void>")));
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
{
auto j = generate_class_json(diagram, *model);
using namespace json;
REQUIRE(IsClass(j, "A"));
REQUIRE(IsClassTemplate(j, "lift_void<T>"));
save_json(config.output_directory(), diagram->name + ".json", j);
}
{
auto src = generate_class_mermaid(diagram, *model);
mermaid::AliasMatcher _A(src);
REQUIRE_THAT(src, IsClass(_A("lift_void<T>")));
REQUIRE_THAT(src, IsClass(_A("drop_void<T>")));
REQUIRE_THAT(src, IsClass(_A("Void")));
REQUIRE_THAT(src, IsClass(_A("A")));
REQUIRE_THAT(src, IsClass(_A("R")));
REQUIRE_THAT(
src, IsInstantiation(_A("lift_void<T>"), _A("lift_void<void>")));
REQUIRE_THAT(
src, IsInstantiation(_A("drop_void<T>"), _A("drop_void<Void>")));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}
REQUIRE(IsInstantiation(src, "lift_void<T>", "lift_void<void>"));
REQUIRE(IsInstantiation(src, "drop_void<T>", "drop_void<Void>"));
});
}

62
tests/t00035/test_case.h
View File

@@ -1,5 +1,5 @@
/**
* tests/t00035/test_case.cc
* tests/t00035/test_case.h
*
* Copyright (c) 2021-2024 Bartek Kryza <bkryza@gmail.com>
*
@@ -16,8 +16,10 @@
* limitations under the License.
*/
TEST_CASE("t00035", "[test-case][class]")
TEST_CASE("t00035")
{
using namespace clanguml::test;
auto [config, db] = load_config("t00035");
auto diagram = config.diagrams["t00035_class"];
@@ -28,50 +30,16 @@ TEST_CASE("t00035", "[test-case][class]")
REQUIRE(model->name() == "t00035_class");
{
auto src = generate_class_puml(diagram, *model);
AliasMatcher _A(src);
CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(IsClass(src, "Top"));
REQUIRE(IsClass(src, "Bottom"));
REQUIRE(IsClass(src, "Center"));
REQUIRE(IsClass(src, "Left"));
REQUIRE(IsClass(src, "Right"));
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
REQUIRE_THAT(src, IsClass(_A("Top")));
REQUIRE_THAT(src, IsClass(_A("Bottom")));
REQUIRE_THAT(src, IsClass(_A("Center")));
REQUIRE_THAT(src, IsClass(_A("Left")));
REQUIRE_THAT(src, IsClass(_A("Right")));
REQUIRE_THAT(src, IsLayoutHint(_A("Center"), "up", _A("Top")));
REQUIRE_THAT(src, IsLayoutHint(_A("Center"), "left", _A("Left")));
REQUIRE_THAT(src, IsLayoutHint(_A("Center"), "right", _A("Right")));
REQUIRE_THAT(src, IsLayoutHint(_A("Center"), "down", _A("Bottom")));
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
{
auto j = generate_class_json(diagram, *model);
using namespace json;
REQUIRE(IsClass(j, "Top"));
REQUIRE(IsClass(j, "Bottom"));
REQUIRE(IsClass(j, "Center"));
REQUIRE(IsClass(j, "Left"));
REQUIRE(IsClass(j, "Right"));
save_json(config.output_directory(), diagram->name + ".json", j);
}
{
auto src = generate_class_mermaid(diagram, *model);
mermaid::AliasMatcher _A(src);
REQUIRE_THAT(src, IsClass(_A("Top")));
REQUIRE_THAT(src, IsClass(_A("Bottom")));
REQUIRE_THAT(src, IsClass(_A("Center")));
REQUIRE_THAT(src, IsClass(_A("Left")));
REQUIRE_THAT(src, IsClass(_A("Right")));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}
REQUIRE(IsLayoutHint(src, "Center", "up", "Top"));
REQUIRE(IsLayoutHint(src, "Center", "left", "Left"));
REQUIRE(IsLayoutHint(src, "Center", "right", "Right"));
REQUIRE(IsLayoutHint(src, "Center", "down", "Bottom"));
});
}

80
tests/t00036/test_case.h
View File

@@ -16,8 +16,11 @@
* limitations under the License.
*/
TEST_CASE("t00036", "[test-case][class]")
TEST_CASE("t00036")
{
using namespace clanguml::test;
using namespace std::string_literals;
auto [config, db] = load_config("t00036");
auto diagram = config.diagrams["t00036_class"];
@@ -29,66 +32,23 @@ TEST_CASE("t00036", "[test-case][class]")
REQUIRE(model->name() == "t00036_class");
{
auto src = generate_class_puml(diagram, *model);
AliasMatcher _A(src);
CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(IsClassTemplate(src, {"ns1::ns11", "A<T>"}));
REQUIRE(IsClassTemplate(src, {"ns1::ns11", "A<int>"}));
REQUIRE(IsClass(src, {"ns1::ns11::ns111", "B"}));
REQUIRE(IsClass(src, {"ns2::ns22", "C"}));
REQUIRE(IsEnum(src, {"ns1", "E"}));
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
REQUIRE(!IsClass(src, "DImpl"));
REQUIRE_THAT(src, IsClassTemplate("A", "T"));
REQUIRE_THAT(src, IsClassTemplate("A", "int"));
REQUIRE_THAT(src, IsEnum(_A("E")));
REQUIRE_THAT(src, IsClass(_A("B")));
REQUIRE_THAT(src, IsClass(_A("C")));
REQUIRE_THAT(src, !IsClass(_A("DImpl")));
REQUIRE_THAT(src, IsPackage("ns111"));
REQUIRE_THAT(src, IsPackage("ns22"));
REQUIRE_THAT(src, !IsPackage("ns3"));
REQUIRE_THAT(src, !IsPackage("ns33"));
REQUIRE(IsNamespacePackage(src, "ns1"s));
REQUIRE(IsNamespacePackage(src, "ns1"s, "ns11"s));
REQUIRE(IsNamespacePackage(src, "ns1"s, "ns11"s, "ns111"s));
REQUIRE(IsNamespacePackage(src, "ns2"s));
REQUIRE(IsNamespacePackage(src, "ns2"s, "ns22"s));
REQUIRE_THAT(src, IsAggregation(_A("B"), _A("A<int>"), "+a_int"));
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
{
auto j = generate_class_json(diagram, *model);
using namespace json;
using namespace std::string_literals;
REQUIRE(IsClass(j, "ns1::ns11::A<T>"));
REQUIRE(IsClass(j, "ns1::ns11::A<int>"));
REQUIRE(IsClass(j, "ns1::ns11::ns111::B"));
REQUIRE(IsClass(j, "ns2::ns22::C"));
REQUIRE(IsEnum(j, "ns1::E"));
REQUIRE(IsNamespacePackage(j, "ns1"s));
REQUIRE(IsNamespacePackage(j, "ns1"s, "ns11"s));
REQUIRE(IsNamespacePackage(j, "ns1"s, "ns11"s, "ns111"s));
REQUIRE(IsNamespacePackage(j, "ns2"s));
REQUIRE(IsNamespacePackage(j, "ns2"s, "ns22"s));
REQUIRE(IsNamespacePackage(j, "ns3"s));
REQUIRE(IsNamespacePackage(j, "ns3"s, "ns33"s));
save_json(config.output_directory(), diagram->name + ".json", j);
}
{
auto src = generate_class_mermaid(diagram, *model);
mermaid::AliasMatcher _A(src);
using mermaid::IsEnum;
REQUIRE_THAT(src, IsClass(_A("ns1::ns11::A<T>")));
REQUIRE_THAT(src, IsClass(_A("ns1::ns11::A<int>")));
REQUIRE_THAT(src, IsEnum(_A("ns1::E")));
REQUIRE_THAT(src, IsClass(_A("ns1::ns11::ns111::B")));
REQUIRE_THAT(src, IsClass(_A("ns2::ns22::C")));
REQUIRE_THAT(src, !IsClass(_A("DImpl")));
REQUIRE_THAT(src,
IsAggregation(
_A("ns1::ns11::ns111::B"), _A("ns1::ns11::A<int>"), "+a_int"));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}
REQUIRE(!IsNamespacePackage(src, "ns3"s));
REQUIRE(!IsNamespacePackage(src, "ns33"s));
REQUIRE(!IsNamespacePackage(src, "ns3"s, "ns33"s));
});
}

59
tests/t00037/test_case.h
View File

@@ -1,5 +1,5 @@
/**
* tests/t00037/test_case.cc
* tests/t00037/test_case.h
*
* Copyright (c) 2021-2024 Bartek Kryza <bkryza@gmail.com>
*
@@ -16,8 +16,10 @@
* limitations under the License.
*/
TEST_CASE("t00037", "[test-case][class]")
TEST_CASE("t00037")
{
using namespace clanguml::test;
auto [config, db] = load_config("t00037");
auto diagram = config.diagrams["t00037_class"];
@@ -29,49 +31,14 @@ TEST_CASE("t00037", "[test-case][class]")
REQUIRE(model->name() == "t00037_class");
{
auto src = generate_class_puml(diagram, *model);
AliasMatcher _A(src);
CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(IsClass(src, "ST"));
REQUIRE(IsClass(src, "A"));
REQUIRE(IsClass(src, "ST::(units)"));
REQUIRE(IsClass(src, "ST::(dimensions)"));
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
REQUIRE_THAT(src, IsClass(_A("ST")));
REQUIRE_THAT(src, IsClass(_A("A")));
REQUIRE_THAT(src, IsClass(_A("ST::(units)")));
REQUIRE_THAT(src, IsClass(_A("ST::(dimensions)")));
REQUIRE_THAT(src,
IsAggregation(_A("ST"), _A("ST::(dimensions)"), "+dimensions"));
REQUIRE_THAT(src, IsAggregation(_A("ST"), _A("ST::(units)"), "-units"));
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
{
auto j = generate_class_json(diagram, *model);
using namespace json;
REQUIRE(IsClass(j, "ST"));
REQUIRE(IsClass(j, "A"));
REQUIRE(IsClass(j, "ST::(units)"));
REQUIRE(IsClass(j, "ST::(dimensions)"));
REQUIRE(IsAggregation(j, "ST", "ST::(dimensions)", "dimensions"));
save_json(config.output_directory(), diagram->name + ".json", j);
}
{
auto src = generate_class_mermaid(diagram, *model);
mermaid::AliasMatcher _A(src);
REQUIRE_THAT(src, IsClass(_A("ST")));
REQUIRE_THAT(src, IsClass(_A("A")));
REQUIRE_THAT(src, IsClass(_A("ST::(units)")));
REQUIRE_THAT(src, IsClass(_A("ST::(dimensions)")));
REQUIRE_THAT(src,
IsAggregation(_A("ST"), _A("ST::(dimensions)"), "+dimensions"));
REQUIRE_THAT(src, IsAggregation(_A("ST"), _A("ST::(units)"), "-units"));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}
REQUIRE(
IsAggregation<Public>(src, "ST", "ST::(dimensions)", "dimensions"));
REQUIRE(IsAggregation<Private>(src, "ST", "ST::(units)", "units"));
});
}

188
tests/t00038/test_case.h
View File

@@ -1,5 +1,5 @@
/**
* tests/t00038/test_case.cc
* tests/t00038/test_case.h
*
* Copyright (c) 2021-2024 Bartek Kryza <bkryza@gmail.com>
*
@@ -16,8 +16,10 @@
* limitations under the License.
*/
TEST_CASE("t00038", "[test-case][class]")
TEST_CASE("t00038")
{
using namespace clanguml::test;
auto [config, db] = load_config("t00038");
auto diagram = config.diagrams["t00038_class"];
@@ -29,152 +31,56 @@ TEST_CASE("t00038", "[test-case][class]")
REQUIRE(model->name() == "t00038_class");
{
auto src = generate_class_puml(diagram, *model);
AliasMatcher _A(src);
CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(IsClass(src, "A"));
REQUIRE(IsClass(src, "B"));
REQUIRE(IsClass(src, "C"));
REQUIRE(IsClass(src, "thirdparty::ns1::E"));
REQUIRE(IsClass(src, "key_t"));
REQUIRE(IsClassTemplate(src, "map<T>"));
REQUIRE(IsClassTemplate(src,
"map<std::integral_constant<property_t,property_t::property_a>>"));
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
REQUIRE(IsClassTemplate(src,
"map<std::vector<std::integral_constant<property_t,property_t::"
"property_b>>>"));
REQUIRE(IsClassTemplate(src,
"map<std::map<key_t,std::vector<std::integral_constant<property_t,"
"property_t::property_c>>>>"));
REQUIRE_THAT(src, IsClass(_A("A")));
REQUIRE_THAT(src, IsClass(_A("B")));
REQUIRE_THAT(src, IsClass(_A("C")));
REQUIRE_THAT(src, IsClass(_A("thirdparty::ns1::E")));
REQUIRE_THAT(src, IsClass(_A("key_t")));
REQUIRE_THAT(src, IsClassTemplate("map", "T"));
REQUIRE_THAT(src,
IsClassTemplate("map",
"std::integral_constant<property_t,property_t::property_a>"));
REQUIRE_THAT(src,
IsClassTemplate("map",
"std::vector<std::integral_constant<property_t,property_t::"
"property_b>>"));
REQUIRE_THAT(src,
IsClassTemplate("map",
"std::map<key_t,std::vector<std::integral_constant<property_t,"
"property_t::property_c>>>"));
REQUIRE(IsEnum(src, "property_t"));
REQUIRE_THAT(src, IsEnum(_A("property_t")));
REQUIRE(IsInstantiation(src, "map<T>",
"map<std::map<key_t,std::vector<std::integral_constant<"
"property_t,property_t::property_c>>>>"));
REQUIRE_THAT(src,
IsInstantiation(_A("map<T>"),
_A("map<std::map<key_t,std::vector<std::integral_constant<"
"property_"
"t,property_t::property_c>>>>")));
REQUIRE(IsDependency(src,
"map<std::integral_constant<property_t,property_t::property_a>>",
"property_t"));
REQUIRE_THAT(src,
IsDependency(_A("map<std::integral_constant<property_t,property_t::"
"property_a>>"),
_A("property_t")));
REQUIRE(IsDependency(src,
"map<"
"std::vector<std::integral_constant<property_t,"
"property_t::property_b>>>",
"property_t"));
REQUIRE_THAT(src,
IsDependency(_A("map<"
"std::vector<std::integral_constant<property_t,"
"property_t::property_b>>>"),
_A("property_t")));
REQUIRE(IsDependency(src,
"map<std::map<key_t,std::vector<std::integral_constant<"
"property_t,property_t::property_c>>>>",
"property_t"));
REQUIRE_THAT(src,
IsDependency(
_A("map<std::map<key_t,std::vector<std::integral_constant<"
"property_t,property_t::property_c>>>>"),
_A("property_t")));
REQUIRE(IsDependency(src,
"map<std::map<key_t,std::vector<std::integral_constant<"
"property_t,property_t::property_c>>>>",
"key_t"));
REQUIRE_THAT(src,
IsDependency(
_A("map<std::map<key_t,std::vector<std::integral_constant<"
"property_t,property_t::property_c>>>>"),
_A("key_t")));
REQUIRE(IsDependency(src,
"map<std::integral_constant<thirdparty::ns1::color_t,"
"thirdparty::ns1::color_t::red>>",
"thirdparty::ns1::color_t"));
REQUIRE_THAT(src,
IsDependency(
_A("map<std::integral_constant<thirdparty::ns1::color_t,"
"thirdparty::ns1::color_t::red>>"),
_A("thirdparty::ns1::color_t")));
REQUIRE_THAT(src,
IsBaseClass(_A("thirdparty::ns1::E"),
_A("map<std::integral_constant<thirdparty::ns1::color_t,"
"thirdparty::ns1::color_t::red>>")));
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
{
auto j = generate_class_json(diagram, *model);
using namespace json;
REQUIRE(IsClass(j, "A"));
REQUIRE(IsClass(j, "B"));
REQUIRE(IsClass(j, "C"));
save_json(config.output_directory(), diagram->name + ".json", j);
}
{
auto src = generate_class_mermaid(diagram, *model);
mermaid::AliasMatcher _A(src);
using mermaid::IsEnum;
REQUIRE_THAT(src, IsClass(_A("A")));
REQUIRE_THAT(src, IsClass(_A("B")));
REQUIRE_THAT(src, IsClass(_A("C")));
REQUIRE_THAT(src, IsClass(_A("thirdparty::ns1::E")));
REQUIRE_THAT(src, IsClass(_A("key_t")));
REQUIRE_THAT(src, IsClass(_A("map<T>")));
REQUIRE_THAT(src,
IsClass(_A("map<std::integral_constant<property_t,property_t::"
"property_a>>")));
REQUIRE_THAT(src,
IsClass(_A(
"map<std::vector<std::integral_constant<property_t,property_t::"
"property_b>>>")));
REQUIRE_THAT(src,
IsClass(_A("map<std::map<key_t,std::vector<std::integral_constant<"
"property_t,"
"property_t::property_c>>>>")));
REQUIRE_THAT(src, IsEnum(_A("property_t")));
REQUIRE_THAT(src,
IsInstantiation(_A("map<T>"),
_A("map<std::map<key_t,std::vector<std::integral_constant<"
"property_"
"t,property_t::property_c>>>>")));
REQUIRE_THAT(src,
IsDependency(_A("map<std::integral_constant<property_t,property_t::"
"property_a>>"),
_A("property_t")));
REQUIRE_THAT(src,
IsDependency(_A("map<"
"std::vector<std::integral_constant<property_t,"
"property_t::property_b>>>"),
_A("property_t")));
REQUIRE_THAT(src,
IsDependency(
_A("map<std::map<key_t,std::vector<std::integral_constant<"
"property_t,property_t::property_c>>>>"),
_A("property_t")));
REQUIRE_THAT(src,
IsDependency(
_A("map<std::map<key_t,std::vector<std::integral_constant<"
"property_t,property_t::property_c>>>>"),
_A("key_t")));
REQUIRE_THAT(src,
IsDependency(
_A("map<std::integral_constant<thirdparty::ns1::color_t,"
"thirdparty::ns1::color_t::red>>"),
_A("thirdparty::ns1::color_t")));
REQUIRE_THAT(src,
IsBaseClass(_A("thirdparty::ns1::E"),
_A("map<std::integral_constant<thirdparty::ns1::color_t,"
"thirdparty::ns1::color_t::red>>")));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}
REQUIRE(IsBaseClass(src, "thirdparty::ns1::E",
"map<std::integral_constant<thirdparty::ns1::color_t,"
"thirdparty::ns1::color_t::red>>"));
});
}

121
tests/t00039/test_case.h
View File

@@ -1,5 +1,5 @@
/**
* tests/t00039/test_case.cc
* tests/t00039/test_case.h
*
* Copyright (c) 2021-2024 Bartek Kryza <bkryza@gmail.com>
*
@@ -16,8 +16,10 @@
* limitations under the License.
*/
TEST_CASE("t00039", "[test-case][class]")
TEST_CASE("t00039")
{
using namespace clanguml::test;
auto [config, db] = load_config("t00039");
auto diagram = config.diagrams["t00039_class"];
@@ -28,96 +30,33 @@ TEST_CASE("t00039", "[test-case][class]")
REQUIRE(model->name() == "t00039_class");
{
auto src = generate_class_puml(diagram, *model);
AliasMatcher _A(src);
CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(IsClass(src, "A"));
REQUIRE(IsClass(src, "AA"));
REQUIRE(IsClass(src, "AAA"));
REQUIRE(IsClass(src, "ns2::AAAA"));
REQUIRE(IsBaseClass(src, "A", "AA"));
REQUIRE(IsBaseClass(src, "AA", "AAA"));
REQUIRE(IsBaseClass(src, "AAA", "ns2::AAAA"));
REQUIRE(!IsClass(src, "detail::AA"));
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
REQUIRE(!IsClass(src, "B"));
REQUIRE(!IsClass(src, "ns1::BB"));
REQUIRE_THAT(src, IsClass(_A("A")));
REQUIRE_THAT(src, IsClass(_A("AA")));
REQUIRE_THAT(src, IsClass(_A("AAA")));
REQUIRE_THAT(src, IsClass(_A("ns2::AAAA")));
REQUIRE_THAT(src, IsBaseClass(_A("A"), _A("AA")));
REQUIRE_THAT(src, IsBaseClass(_A("AA"), _A("AAA")));
REQUIRE_THAT(src, IsBaseClass(_A("AAA"), _A("ns2::AAAA")));
REQUIRE_THAT(src, !IsClass(_A("detail::AA")));
REQUIRE(IsClass(src, "C"));
REQUIRE(IsClass(src, "D"));
REQUIRE(IsClass(src, "E"));
REQUIRE(IsBaseClass(src, "C", "CD"));
REQUIRE(IsBaseClass(src, "D", "CD"));
REQUIRE(IsBaseClass(src, "D", "DE"));
REQUIRE(IsBaseClass(src, "E", "DE"));
REQUIRE(IsBaseClass(src, "C", "CDE"));
REQUIRE(IsBaseClass(src, "D", "CDE"));
REQUIRE(IsBaseClass(src, "E", "CDE"));
REQUIRE_THAT(src, !IsClass(_A("B")));
REQUIRE_THAT(src, !IsClass(_A("ns1::BB")));
REQUIRE_THAT(src, IsClass(_A("C")));
REQUIRE_THAT(src, IsClass(_A("D")));
REQUIRE_THAT(src, IsClass(_A("E")));
REQUIRE_THAT(src, IsBaseClass(_A("C"), _A("CD")));
REQUIRE_THAT(src, IsBaseClass(_A("D"), _A("CD")));
REQUIRE_THAT(src, IsBaseClass(_A("D"), _A("DE")));
REQUIRE_THAT(src, IsBaseClass(_A("E"), _A("DE")));
REQUIRE_THAT(src, IsBaseClass(_A("C"), _A("CDE")));
REQUIRE_THAT(src, IsBaseClass(_A("D"), _A("CDE")));
REQUIRE_THAT(src, IsBaseClass(_A("E"), _A("CDE")));
REQUIRE_THAT(src, IsClassTemplate("ns3::F", "T"));
REQUIRE_THAT(src, IsClassTemplate("ns3::FF", "T,M"));
REQUIRE_THAT(src, IsClassTemplate("ns3::FE", "T,M"));
REQUIRE_THAT(src, IsClassTemplate("ns3::FFF", "T,M,N"));
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
{
auto j = generate_class_json(diagram, *model);
using namespace json;
REQUIRE(IsClass(j, "A"));
REQUIRE(IsClass(j, "AA"));
REQUIRE(IsClass(j, "AAA"));
REQUIRE(IsBaseClass(j, "C", "CD"));
REQUIRE(IsBaseClass(j, "D", "CD"));
REQUIRE(IsBaseClass(j, "E", "DE"));
REQUIRE(IsBaseClass(j, "D", "DE"));
REQUIRE(IsBaseClass(j, "C", "CDE"));
REQUIRE(IsBaseClass(j, "D", "CDE"));
REQUIRE(IsBaseClass(j, "E", "CDE"));
REQUIRE(IsClassTemplate(j, "ns3::F<T>"));
save_json(config.output_directory(), diagram->name + ".json", j);
}
{
auto src = generate_class_mermaid(diagram, *model);
mermaid::AliasMatcher _A(src);
REQUIRE_THAT(src, IsClass(_A("A")));
REQUIRE_THAT(src, IsClass(_A("AA")));
REQUIRE_THAT(src, IsClass(_A("AAA")));
REQUIRE_THAT(src, IsClass(_A("ns2::AAAA")));
REQUIRE_THAT(src, IsBaseClass(_A("A"), _A("AA")));
REQUIRE_THAT(src, IsBaseClass(_A("AA"), _A("AAA")));
REQUIRE_THAT(src, IsBaseClass(_A("AAA"), _A("ns2::AAAA")));
REQUIRE_THAT(src, !IsClass(_A("detail::AA")));
REQUIRE_THAT(src, !IsClass(_A("B")));
REQUIRE_THAT(src, !IsClass(_A("ns1::BB")));
REQUIRE_THAT(src, IsClass(_A("C")));
REQUIRE_THAT(src, IsClass(_A("D")));
REQUIRE_THAT(src, IsClass(_A("E")));
REQUIRE_THAT(src, IsBaseClass(_A("C"), _A("CD")));
REQUIRE_THAT(src, IsBaseClass(_A("D"), _A("CD")));
REQUIRE_THAT(src, IsBaseClass(_A("D"), _A("DE")));
REQUIRE_THAT(src, IsBaseClass(_A("E"), _A("DE")));
REQUIRE_THAT(src, IsBaseClass(_A("C"), _A("CDE")));
REQUIRE_THAT(src, IsBaseClass(_A("D"), _A("CDE")));
REQUIRE_THAT(src, IsBaseClass(_A("E"), _A("CDE")));
REQUIRE_THAT(src, IsClass(_A("ns3::F<T>")));
REQUIRE_THAT(src, IsClass(_A("ns3::FF<T,M>")));
REQUIRE_THAT(src, IsClass(_A("ns3::FE<T,M>")));
REQUIRE_THAT(src, IsClass(_A("ns3::FFF<T,M,N>")));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}
REQUIRE(IsClassTemplate(src, "ns3::F<T>"));
REQUIRE(IsClassTemplate(src, "ns3::FF<T,M>"));
REQUIRE(IsClassTemplate(src, "ns3::FE<T,M>"));
REQUIRE(IsClassTemplate(src, "ns3::FFF<T,M,N>"));
});
}

61
tests/t00040/test_case.h
View File

@@ -1,5 +1,5 @@
/**
* tests/t00040/test_case.cc
* tests/t00040/test_case.h
*
* Copyright (c) 2021-2024 Bartek Kryza <bkryza@gmail.com>
*
@@ -16,8 +16,10 @@
* limitations under the License.
*/
TEST_CASE("t00040", "[test-case][class]")
TEST_CASE("t00040")
{
using namespace clanguml::test;
auto [config, db] = load_config("t00040");
auto diagram = config.diagrams["t00040_class"];
@@ -28,51 +30,14 @@ TEST_CASE("t00040", "[test-case][class]")
auto model = generate_class_diagram(*db, diagram);
REQUIRE(model->name() == "t00040_class");
{
auto src = generate_class_puml(diagram, *model);
AliasMatcher _A(src);
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
REQUIRE_THAT(src, IsClass(_A("A")));
REQUIRE_THAT(src, IsClass(_A("AA")));
REQUIRE_THAT(src, IsClass(_A("AAA")));
REQUIRE_THAT(src, IsBaseClass(_A("A"), _A("AA")));
REQUIRE_THAT(src, IsBaseClass(_A("AA"), _A("AAA")));
REQUIRE_THAT(src, !IsClass(_A("B")));
REQUIRE_THAT(src, !IsDependency(_A("R"), _A("A")));
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
{
auto j = generate_class_json(diagram, *model);
using namespace json;
REQUIRE(IsClass(j, "A"));
REQUIRE(IsClass(j, "AA"));
REQUIRE(IsClass(j, "AAA"));
save_json(config.output_directory(), diagram->name + ".json", j);
}
{
auto src = generate_class_mermaid(diagram, *model);
mermaid::AliasMatcher _A(src);
REQUIRE_THAT(src, IsClass(_A("A")));
REQUIRE_THAT(src, IsClass(_A("AA")));
REQUIRE_THAT(src, IsClass(_A("AAA")));
REQUIRE_THAT(src, IsBaseClass(_A("A"), _A("AA")));
REQUIRE_THAT(src, IsBaseClass(_A("AA"), _A("AAA")));
REQUIRE_THAT(src, !IsClass(_A("B")));
REQUIRE_THAT(src, !IsDependency(_A("R"), _A("A")));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}
CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(IsClass(src, "A"));
REQUIRE(IsClass(src, "AA"));
REQUIRE(IsClass(src, "AAA"));
REQUIRE(IsBaseClass(src, "A", "AA"));
REQUIRE(IsBaseClass(src, "AA", "AAA"));
REQUIRE(!IsClass(src, "B"));
REQUIRE(!IsDependency(src, "R", "A"));
});
}

117
tests/t00041/test_case.h
View File

@@ -1,5 +1,5 @@
/**
* tests/t00041/test_case.cc
* tests/t00041/test_case.h
*
* Copyright (c) 2021-2024 Bartek Kryza <bkryza@gmail.com>
*
@@ -16,8 +16,10 @@
* limitations under the License.
*/
TEST_CASE("t00041", "[test-case][class]")
TEST_CASE("t00041")
{
using namespace clanguml::test;
auto [config, db] = load_config("t00041");
auto diagram = config.diagrams["t00041_class"];
@@ -29,95 +31,34 @@ TEST_CASE("t00041", "[test-case][class]")
REQUIRE(model->name() == "t00041_class");
{
auto src = generate_class_puml(diagram, *model);
AliasMatcher _A(src);
CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(!IsClass(src, "A"));
REQUIRE(!IsClass(src, "AA"));
REQUIRE(!IsClass(src, "AAA"));
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
REQUIRE(!IsClass(src, "B"));
REQUIRE_THAT(src, !IsClass(_A("A")));
REQUIRE_THAT(src, !IsClass(_A("AA")));
REQUIRE_THAT(src, !IsClass(_A("AAA")));
REQUIRE(IsClass(src, "D"));
REQUIRE(IsClass(src, "E"));
REQUIRE(IsClass(src, "F"));
REQUIRE(IsClass(src, "R"));
REQUIRE(IsClass(src, "RR"));
REQUIRE(IsClass(src, "RRR"));
REQUIRE(!IsClass(src, "detail::G"));
REQUIRE(!IsClass(src, "H"));
REQUIRE_THAT(src, !IsClass(_A("B")));
REQUIRE(IsBaseClass(src, "R", "RR"));
REQUIRE(IsBaseClass(src, "RR", "RRR"));
REQUIRE_THAT(src, IsClass(_A("D")));
REQUIRE_THAT(src, IsClass(_A("E")));
REQUIRE_THAT(src, IsClass(_A("F")));
REQUIRE_THAT(src, IsClass(_A("R")));
REQUIRE_THAT(src, IsClass(_A("RR")));
REQUIRE_THAT(src, IsClass(_A("RRR")));
REQUIRE_THAT(src, !IsClass(_A("detail::G")));
REQUIRE_THAT(src, !IsClass(_A("H")));
REQUIRE(IsAssociation<Public>(src, "D", "RR", "rr"));
REQUIRE(IsAssociation<Public>(src, "RR", "E", "e"));
REQUIRE(IsAssociation<Public>(src, "RR", "F", "f"));
REQUIRE(!IsDependency(src, "RR", "H"));
REQUIRE_THAT(src, IsBaseClass(_A("R"), _A("RR")));
REQUIRE_THAT(src, IsBaseClass(_A("RR"), _A("RRR")));
REQUIRE_THAT(src, IsAssociation(_A("D"), _A("RR"), "+rr"));
REQUIRE_THAT(src, IsAssociation(_A("RR"), _A("E"), "+e"));
REQUIRE_THAT(src, IsAssociation(_A("RR"), _A("F"), "+f"));
REQUIRE_THAT(src, !IsDependency(_A("RR"), _A("H")));
REQUIRE_THAT(src, IsClass(_A("ns1::N")));
REQUIRE_THAT(src, IsClass(_A("ns1::NN")));
REQUIRE_THAT(src, IsClass(_A("ns1::NM")));
REQUIRE_THAT(src, IsBaseClass(_A("ns1::N"), _A("ns1::NN")));
REQUIRE_THAT(src, IsBaseClass(_A("ns1::N"), _A("ns1::NM")));
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
{
auto j = generate_class_json(diagram, *model);
using namespace json;
REQUIRE(!IsClass(j, "A"));
REQUIRE(!IsClass(j, "AA"));
REQUIRE(!IsClass(j, "AAA"));
REQUIRE(IsClass(j, "D"));
REQUIRE(IsClass(j, "E"));
REQUIRE(IsClass(j, "F"));
REQUIRE(IsClass(j, "R"));
REQUIRE(IsAssociation(j, "D", "RR", "rr"));
save_json(config.output_directory(), diagram->name + ".json", j);
}
{
auto src = generate_class_mermaid(diagram, *model);
mermaid::AliasMatcher _A(src);
REQUIRE_THAT(src, !IsClass(_A("A")));
REQUIRE_THAT(src, !IsClass(_A("AA")));
REQUIRE_THAT(src, !IsClass(_A("AAA")));
REQUIRE_THAT(src, !IsClass(_A("B")));
REQUIRE_THAT(src, IsClass(_A("D")));
REQUIRE_THAT(src, IsClass(_A("E")));
REQUIRE_THAT(src, IsClass(_A("F")));
REQUIRE_THAT(src, IsClass(_A("R")));
REQUIRE_THAT(src, IsClass(_A("RR")));
REQUIRE_THAT(src, IsClass(_A("RRR")));
REQUIRE_THAT(src, !IsClass(_A("detail::G")));
REQUIRE_THAT(src, !IsClass(_A("H")));
REQUIRE_THAT(src, IsBaseClass(_A("R"), _A("RR")));
REQUIRE_THAT(src, IsBaseClass(_A("RR"), _A("RRR")));
REQUIRE_THAT(src, IsAssociation(_A("D"), _A("RR"), "+rr"));
REQUIRE_THAT(src, IsAssociation(_A("RR"), _A("E"), "+e"));
REQUIRE_THAT(src, IsAssociation(_A("RR"), _A("F"), "+f"));
REQUIRE_THAT(src, !IsDependency(_A("RR"), _A("H")));
REQUIRE_THAT(src, IsClass(_A("ns1::N")));
REQUIRE_THAT(src, IsClass(_A("ns1::NN")));
REQUIRE_THAT(src, IsClass(_A("ns1::NM")));
REQUIRE_THAT(src, IsBaseClass(_A("ns1::N"), _A("ns1::NN")));
REQUIRE_THAT(src, IsBaseClass(_A("ns1::N"), _A("ns1::NM")));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}
REQUIRE(IsClass(src, {"ns1", "N"}));
REQUIRE(IsClass(src, {"ns1", "NN"}));
REQUIRE(IsClass(src, {"ns1", "NM"}));
REQUIRE(IsBaseClass(src, "ns1::N", "ns1::NN"));
REQUIRE(IsBaseClass(src, "ns1::N", "ns1::NM"));
});
}

45
tests/t00042/test_case.h
View File

@@ -1,5 +1,5 @@
/**
* tests/t00042/test_case.cc
* tests/t00042/test_case.h
*
* Copyright (c) 2021-2024 Bartek Kryza <bkryza@gmail.com>
*
@@ -16,8 +16,10 @@
* limitations under the License.
*/
TEST_CASE("t00042", "[test-case][class]")
TEST_CASE("t00042")
{
using namespace clanguml::test;
auto [config, db] = load_config("t00042");
auto diagram = config.diagrams["t00042_class"];
@@ -29,38 +31,9 @@ TEST_CASE("t00042", "[test-case][class]")
REQUIRE(model->name() == "t00042_class");
{
auto src = generate_class_puml(diagram, *model);
AliasMatcher _A(src);
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
REQUIRE_THAT(src, IsClassTemplate("A", "T"));
REQUIRE_THAT(src, IsClassTemplate("B", "T,K"));
REQUIRE_THAT(src, !IsClassTemplate("C", "T"));
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
{
auto j = generate_class_json(diagram, *model);
using namespace json;
REQUIRE(IsClassTemplate(j, "A<T>"));
REQUIRE(IsClassTemplate(j, "B<T,K>"));
save_json(config.output_directory(), diagram->name + ".json", j);
}
{
auto src = generate_class_mermaid(diagram, *model);
mermaid::AliasMatcher _A(src);
REQUIRE_THAT(src, IsClass(_A("A<T>")));
REQUIRE_THAT(src, IsClass(_A("B<T,K>")));
REQUIRE_THAT(src, !IsClass(_A("C<T>")));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}
CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(IsClassTemplate(src, "A<T>"));
REQUIRE(IsClassTemplate(src, "B<T,K>"));
REQUIRE(!IsClassTemplate(src, "C<T>"));
});
}

129
tests/t00043/test_case.h
View File

@@ -1,5 +1,5 @@
/**
* tests/t00043/test_case.cc
* tests/t00043/test_case.h
*
* Copyright (c) 2021-2024 Bartek Kryza <bkryza@gmail.com>
*
@@ -16,8 +16,10 @@
* limitations under the License.
*/
TEST_CASE("t00043", "[test-case][class]")
TEST_CASE("t00043")
{
using namespace clanguml::test;
auto [config, db] = load_config("t00043");
auto diagram = config.diagrams["t00043_class"];
@@ -29,104 +31,31 @@ TEST_CASE("t00043", "[test-case][class]")
REQUIRE(model->name() == "t00043_class");
{
auto src = generate_class_puml(diagram, *model);
AliasMatcher _A(src);
CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(IsClass(src, {"dependants", "A"}));
REQUIRE(IsClass(src, {"dependants", "B"}));
REQUIRE(IsClass(src, {"dependants", "C"}));
REQUIRE(IsClass(src, {"dependants", "D"}));
REQUIRE(IsClass(src, {"dependants", "BB"}));
REQUIRE(IsClass(src, {"dependants", "E"}));
REQUIRE(IsDependency(src, {"dependants", "B"}, {"dependants", "A"}));
REQUIRE(IsDependency(src, {"dependants", "BB"}, {"dependants", "A"}));
REQUIRE(IsDependency(src, {"dependants", "C"}, {"dependants", "B"}));
REQUIRE(IsDependency(src, {"dependants", "D"}, {"dependants", "C"}));
REQUIRE(IsDependency(src, {"dependants", "E"}, {"dependants", "D"}));
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
REQUIRE(IsClass(src, {"dependencies", "G"}));
REQUIRE(IsClass(src, {"dependencies", "GG"}));
REQUIRE(IsClass(src, {"dependencies", "H"}));
REQUIRE(!IsClass(src, {"dependencies", "HH"}));
// Check dependants filter
REQUIRE_THAT(src, IsClass(_A("A")));
REQUIRE_THAT(src, IsClass(_A("B")));
REQUIRE_THAT(src, IsClass(_A("BB")));
REQUIRE_THAT(src, IsClass(_A("D")));
REQUIRE_THAT(src, IsClass(_A("E")));
REQUIRE_THAT(src, !IsClass(_A("F")));
REQUIRE_THAT(src, IsDependency(_A("B"), _A("A")));
REQUIRE_THAT(src, IsDependency(_A("BB"), _A("A")));
REQUIRE_THAT(src, IsDependency(_A("C"), _A("B")));
REQUIRE_THAT(src, IsDependency(_A("D"), _A("C")));
REQUIRE_THAT(src, IsDependency(_A("E"), _A("D")));
// Check dependencies filter
REQUIRE_THAT(src, IsClass(_A("G")));
REQUIRE_THAT(src, IsClass(_A("GG")));
REQUIRE_THAT(src, IsClass(_A("H")));
REQUIRE_THAT(src, !IsClass(_A("HH")));
REQUIRE_THAT(src, IsClass(_A("I")));
REQUIRE_THAT(src, IsClass(_A("J")));
REQUIRE_THAT(src, IsDependency(_A("H"), _A("G")));
REQUIRE_THAT(src, IsDependency(_A("H"), _A("GG")));
REQUIRE_THAT(src, IsDependency(_A("I"), _A("H")));
REQUIRE_THAT(src, IsDependency(_A("J"), _A("I")));
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
{
auto j = generate_class_json(diagram, *model);
using namespace json;
REQUIRE(IsClass(j, "dependants::A"));
REQUIRE(IsClass(j, "dependants::B"));
REQUIRE(IsClass(j, "dependants::C"));
REQUIRE(IsClass(j, "dependants::D"));
REQUIRE(IsClass(j, "dependants::BB"));
REQUIRE(IsClass(j, "dependants::E"));
REQUIRE(IsDependency(j, "dependants::B", "dependants::A"));
REQUIRE(IsClass(j, "dependencies::G"));
REQUIRE(IsClass(j, "dependencies::GG"));
REQUIRE(IsClass(j, "dependencies::H"));
REQUIRE(IsDependency(j, "dependencies::J", "dependencies::I"));
REQUIRE(IsDependency(j, "dependencies::H", "dependencies::G"));
save_json(config.output_directory(), diagram->name + ".json", j);
}
{
auto src = generate_class_mermaid(diagram, *model);
mermaid::AliasMatcher _A(src);
// Check dependants filter
REQUIRE_THAT(src, IsClass(_A("dependants::A")));
REQUIRE_THAT(src, IsClass(_A("dependants::B")));
REQUIRE_THAT(src, IsClass(_A("dependants::BB")));
REQUIRE_THAT(src, IsClass(_A("dependants::D")));
REQUIRE_THAT(src, IsClass(_A("dependants::E")));
REQUIRE_THAT(src, !IsClass(_A("dependants::F")));
REQUIRE_THAT(
src, IsDependency(_A("dependants::B"), _A("dependants::A")));
REQUIRE_THAT(
src, IsDependency(_A("dependants::BB"), _A("dependants::A")));
REQUIRE_THAT(
src, IsDependency(_A("dependants::C"), _A("dependants::B")));
REQUIRE_THAT(
src, IsDependency(_A("dependants::D"), _A("dependants::C")));
REQUIRE_THAT(
src, IsDependency(_A("dependants::E"), _A("dependants::D")));
// Check dependencies filter
REQUIRE_THAT(src, IsClass(_A("dependencies::G")));
REQUIRE_THAT(src, IsClass(_A("dependencies::GG")));
REQUIRE_THAT(src, IsClass(_A("dependencies::H")));
REQUIRE_THAT(src, !IsClass(_A("dependencies::HH")));
REQUIRE_THAT(src, IsClass(_A("dependencies::I")));
REQUIRE_THAT(src, IsClass(_A("dependencies::J")));
REQUIRE_THAT(
src, IsDependency(_A("dependencies::H"), _A("dependencies::G")));
REQUIRE_THAT(
src, IsDependency(_A("dependencies::H"), _A("dependencies::GG")));
REQUIRE_THAT(
src, IsDependency(_A("dependencies::I"), _A("dependencies::H")));
REQUIRE_THAT(
src, IsDependency(_A("dependencies::J"), _A("dependencies::I")));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}
REQUIRE(
IsDependency(src, {"dependencies", "J"}, {"dependencies", "I"}));
REQUIRE(
IsDependency(src, {"dependencies", "H"}, {"dependencies", "G"}));
REQUIRE(
IsDependency(src, {"dependencies", "I"}, {"dependencies", "H"}));
REQUIRE(
IsDependency(src, {"dependencies", "H"}, {"dependencies", "GG"}));
});
}

102
tests/t00044/test_case.h
View File

@@ -1,5 +1,5 @@
/**
* tests/t00044/test_case.cc
* tests/t00044/test_case.h
*
* Copyright (c) 2021-2024 Bartek Kryza <bkryza@gmail.com>
*
@@ -16,8 +16,10 @@
* limitations under the License.
*/
TEST_CASE("t00044", "[test-case][class]")
TEST_CASE("t00044")
{
using namespace clanguml::test;
auto [config, db] = load_config("t00044");
auto diagram = config.diagrams["t00044_class"];
@@ -29,90 +31,28 @@ TEST_CASE("t00044", "[test-case][class]")
REQUIRE(model->name() == "t00044_class");
{
auto src = generate_class_puml(diagram, *model);
AliasMatcher _A(src);
CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(!src.contains("type-parameter-"));
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
REQUIRE(IsClassTemplate(src, "sink<T>"));
REQUIRE(IsClassTemplate(src, "signal_handler<T,A>"));
REQUIRE_THAT(src, !Contains("type-parameter-"));
REQUIRE(IsClassTemplate(src, "signal_handler<Ret(Args...),A>"));
REQUIRE(IsClassTemplate(src, "signal_handler<void(int),bool>"));
REQUIRE_THAT(src, IsClassTemplate("sink", "T"));
REQUIRE_THAT(src, IsClassTemplate("signal_handler", "T,A"));
REQUIRE(IsClassTemplate(src, "sink<signal_handler<Ret(Args...),A>>"));
REQUIRE_THAT(src, IsClassTemplate("signal_handler", "Ret(Args...),A"));
REQUIRE_THAT(src, IsClassTemplate("signal_handler", "void(int),bool"));
REQUIRE(IsInstantiation(
src, "sink<T>", "sink<signal_handler<Ret(Args...),A>>"));
REQUIRE_THAT(
src, IsClassTemplate("sink", "signal_handler<Ret(Args...),A>"));
REQUIRE(IsInstantiation(src, "sink<signal_handler<Ret(Args...),A>>",
"sink<signal_handler<void(int),bool>>"));
REQUIRE_THAT(src,
IsInstantiation(
_A("sink<T>"), _A("sink<signal_handler<Ret(Args...),A>>")));
REQUIRE(IsClassTemplate(src, "signal_handler<T,A>"));
REQUIRE(IsInstantiation(
src, "signal_handler<T,A>", "signal_handler<Ret(Args...),A>"));
REQUIRE_THAT(src,
IsInstantiation(_A("sink<signal_handler<Ret(Args...),A>>"),
_A("sink<signal_handler<void(int),bool>>")));
REQUIRE_THAT(src, IsClassTemplate("signal_handler", "T,A"));
REQUIRE_THAT(src,
IsInstantiation(_A("signal_handler<T,A>"),
_A("signal_handler<Ret(Args...),A>")));
REQUIRE_THAT(src,
IsInstantiation(_A("signal_handler<Ret(Args...),A>"),
_A("signal_handler<void(int),bool>")));
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
{
auto j = generate_class_json(diagram, *model);
using namespace json;
REQUIRE(IsClassTemplate(j, "sink<T>"));
REQUIRE(IsClassTemplate(j, "signal_handler<T,A>"));
REQUIRE(IsClassTemplate(j, "signal_handler<Ret(Args...),A>"));
REQUIRE(IsStruct(j, "signal_handler<Ret(Args...),A>"));
REQUIRE(IsClassTemplate(j, "signal_handler<void(int),bool>"));
REQUIRE(IsClassTemplate(j, "sink<signal_handler<Ret(Args...),A>>"));
REQUIRE(IsStruct(j, "R"));
save_json(config.output_directory(), diagram->name + ".json", j);
}
{
auto src = generate_class_mermaid(diagram, *model);
mermaid::AliasMatcher _A(src);
REQUIRE_THAT(src, !Contains("type-parameter-"));
REQUIRE_THAT(src, IsClass(_A("sink<T>")));
REQUIRE_THAT(src, IsClass(_A("signal_handler<T,A>")));
REQUIRE_THAT(src, IsClass(_A("signal_handler<Ret(Args...),A>")));
REQUIRE_THAT(src, IsClass(_A("signal_handler<void(int),bool>")));
REQUIRE_THAT(src, IsClass(_A("sink<signal_handler<Ret(Args...),A>>")));
REQUIRE_THAT(src,
IsInstantiation(
_A("sink<T>"), _A("sink<signal_handler<Ret(Args...),A>>")));
REQUIRE_THAT(src,
IsInstantiation(_A("sink<signal_handler<Ret(Args...),A>>"),
_A("sink<signal_handler<void(int),bool>>")));
REQUIRE_THAT(src, IsClass(_A("signal_handler<T,A>")));
REQUIRE_THAT(src,
IsInstantiation(_A("signal_handler<T,A>"),
_A("signal_handler<Ret(Args...),A>")));
REQUIRE_THAT(src,
IsInstantiation(_A("signal_handler<Ret(Args...),A>"),
_A("signal_handler<void(int),bool>")));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}
REQUIRE(IsInstantiation(src, "signal_handler<Ret(Args...),A>",
"signal_handler<void(int),bool>"));
});
}

114
tests/t00045/test_case.h
View File

@@ -16,8 +16,10 @@
* limitations under the License.
*/
TEST_CASE("t00045", "[test-case][class]")
TEST_CASE("t00045")
{
using namespace clanguml::test;
auto [config, db] = load_config("t00045");
auto diagram = config.diagrams["t00045_class"];
@@ -28,97 +30,33 @@ TEST_CASE("t00045", "[test-case][class]")
REQUIRE(model->name() == "t00045_class");
{
auto src = generate_class_puml(diagram, *model);
AliasMatcher _A(src);
CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(IsClass(src, "A"));
REQUIRE(IsClass(src, {"ns1", "A"}));
REQUIRE(IsClass(src, {"ns1::ns2", "A"}));
REQUIRE(IsClass(src, {"ns1::ns2", "B"}));
REQUIRE(IsClass(src, {"ns1::ns2", "C"}));
REQUIRE(IsClass(src, {"ns1::ns2", "D"}));
REQUIRE(IsClass(src, {"ns1::ns2", "E"}));
REQUIRE(IsClass(src, {"ns1::ns2", "R"}));
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
REQUIRE_THAT(src, IsClass(_A("A")));
REQUIRE_THAT(src, IsClass(_A("ns1::A")));
REQUIRE_THAT(src, IsClass(_A("ns1::ns2::A")));
REQUIRE_THAT(src, IsClass(_A("ns1::ns2::B")));
REQUIRE_THAT(src, IsClass(_A("ns1::ns2::C")));
REQUIRE_THAT(src, IsClass(_A("ns1::ns2::D")));
REQUIRE_THAT(src, IsClass(_A("ns1::ns2::E")));
REQUIRE_THAT(src, IsClass(_A("ns1::ns2::R")));
REQUIRE(IsBaseClass(src, {"ns1::ns2", "A"}, {"ns1::ns2", "B"}));
REQUIRE(IsBaseClass(src, {"ns1", "A"}, {"ns1::ns2", "C"}));
REQUIRE(IsBaseClass(src, {"ns1::ns2", "A"}, {"ns1::ns2", "D"}));
REQUIRE(IsBaseClass(src, "A", {"ns1::ns2", "E"}));
REQUIRE_THAT(src, IsBaseClass(_A("ns1::ns2::A"), _A("ns1::ns2::B")));
REQUIRE_THAT(src, IsBaseClass(_A("ns1::A"), _A("ns1::ns2::C")));
REQUIRE_THAT(src, IsBaseClass(_A("ns1::ns2::A"), _A("ns1::ns2::D")));
REQUIRE_THAT(src, IsBaseClass(_A("A"), _A("ns1::ns2::E")));
REQUIRE(IsAssociation<Public>(src, "ns1::ns2::R", "ns1::ns2::A", "a"));
REQUIRE(IsAssociation<Public>(src, "ns1::ns2::R", "ns1::A", "ns1_a"));
REQUIRE(IsAssociation<Public>(
src, "ns1::ns2::R", "ns1::ns2::A", "ns1_ns2_a"));
REQUIRE(IsAssociation<Public>(src, "ns1::ns2::R", "A", "root_a"));
REQUIRE_THAT(
src, IsAssociation(_A("ns1::ns2::R"), _A("ns1::ns2::A"), "+a"));
REQUIRE_THAT(
src, IsAssociation(_A("ns1::ns2::R"), _A("ns1::A"), "+ns1_a"));
REQUIRE_THAT(src,
IsAssociation(_A("ns1::ns2::R"), _A("ns1::ns2::A"), "+ns1_ns2_a"));
REQUIRE_THAT(src, IsAssociation(_A("ns1::ns2::R"), _A("A"), "+root_a"));
REQUIRE(IsDependency(src, "ns1::ns2::R", "AA"));
REQUIRE_THAT(src, IsDependency(_A("ns1::ns2::R"), _A("AA")));
REQUIRE_THAT(src, IsFriend<Public>(_A("ns1::ns2::R"), _A("AAA")));
REQUIRE_THAT(
src, !IsFriend<Public>(_A("ns1::ns2::R"), _A("ns1::ns2::AAA")));
REQUIRE(IsFriend<Public>(src, "ns1::ns2::R", "AAA"));
REQUIRE(!IsFriend<Public>(src, "ns1::ns2::R", "ns1::ns2::AAA"));
// TODO:
// REQUIRE_THAT(puml, IsFriend<Public>(_A("ns1::ns2::R"),
// REQUIRE(puml, IsFriend<Public>(src, "ns1::ns2::R"),
// _A("AAAA<T>")));
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
{
auto j = generate_class_json(diagram, *model);
using namespace json;
REQUIRE(IsClass(j, "A"));
REQUIRE(IsClass(j, "ns1::A"));
REQUIRE(IsClass(j, "ns1::ns2::A"));
REQUIRE(IsClass(j, "ns1::ns2::B"));
REQUIRE(IsClass(j, "ns1::ns2::C"));
REQUIRE(IsClass(j, "ns1::ns2::D"));
REQUIRE(IsClass(j, "ns1::ns2::E"));
REQUIRE(IsClass(j, "ns1::ns2::R"));
REQUIRE(IsBaseClass(j, "ns1::ns2::A", "ns1::ns2::B"));
save_json(config.output_directory(), diagram->name + ".json", j);
}
{
auto src = generate_class_mermaid(diagram, *model);
mermaid::AliasMatcher _A(src);
using mermaid::IsFriend;
REQUIRE_THAT(src, IsClass(_A("A")));
REQUIRE_THAT(src, IsClass(_A("ns1::A")));
REQUIRE_THAT(src, IsClass(_A("ns1::ns2::A")));
REQUIRE_THAT(src, IsClass(_A("ns1::ns2::B")));
REQUIRE_THAT(src, IsClass(_A("ns1::ns2::C")));
REQUIRE_THAT(src, IsClass(_A("ns1::ns2::D")));
REQUIRE_THAT(src, IsClass(_A("ns1::ns2::E")));
REQUIRE_THAT(src, IsClass(_A("ns1::ns2::R")));
REQUIRE_THAT(src, IsBaseClass(_A("ns1::ns2::A"), _A("ns1::ns2::B")));
REQUIRE_THAT(src, IsBaseClass(_A("ns1::A"), _A("ns1::ns2::C")));
REQUIRE_THAT(src, IsBaseClass(_A("ns1::ns2::A"), _A("ns1::ns2::D")));
REQUIRE_THAT(src, IsBaseClass(_A("A"), _A("ns1::ns2::E")));
REQUIRE_THAT(
src, IsAssociation(_A("ns1::ns2::R"), _A("ns1::ns2::A"), "+a"));
REQUIRE_THAT(
src, IsAssociation(_A("ns1::ns2::R"), _A("ns1::A"), "+ns1_a"));
REQUIRE_THAT(src,
IsAssociation(_A("ns1::ns2::R"), _A("ns1::ns2::A"), "+ns1_ns2_a"));
REQUIRE_THAT(src, IsAssociation(_A("ns1::ns2::R"), _A("A"), "+root_a"));
REQUIRE_THAT(src, IsDependency(_A("ns1::ns2::R"), _A("AA")));
REQUIRE_THAT(src, IsFriend<Public>(_A("ns1::ns2::R"), _A("AAA")));
REQUIRE_THAT(
src, !IsFriend<Public>(_A("ns1::ns2::R"), _A("ns1::ns2::AAA")));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}
});
}

63
tests/t00046/test_case.h
View File

@@ -1,5 +1,5 @@
/**
* tests/t00046/test_case.cc
* tests/t00046/test_case.h
*
* Copyright (c) 2021-2024 Bartek Kryza <bkryza@gmail.com>
*
@@ -16,8 +16,10 @@
* limitations under the License.
*/
TEST_CASE("t00046", "[test-case][class]")
TEST_CASE("t00046")
{
using namespace clanguml::test;
auto [config, db] = load_config("t00046");
auto diagram = config.diagrams["t00046_class"];
@@ -28,51 +30,16 @@ TEST_CASE("t00046", "[test-case][class]")
REQUIRE(model->name() == "t00046_class");
{
auto src = generate_class_puml(diagram, *model);
AliasMatcher _A(src);
CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(IsClass(src, "A"));
REQUIRE(IsClass(src, "AA"));
REQUIRE(IsClass(src, {"ns1::ns2", "B"}));
REQUIRE(IsClass(src, {"ns1::ns2", "C"}));
REQUIRE(IsClass(src, {"ns1::ns2", "D"}));
REQUIRE(IsClass(src, {"ns1::ns2", "E"}));
REQUIRE(IsClass(src, {"ns1::ns2", "R"}));
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
REQUIRE_THAT(src, IsClass(_A("A")));
REQUIRE_THAT(src, IsClass(_A("B")));
REQUIRE_THAT(src, IsClass(_A("C")));
REQUIRE_THAT(src, IsClass(_A("D")));
REQUIRE_THAT(src, IsClass(_A("E")));
REQUIRE_THAT(src, IsClass(_A("R")));
REQUIRE_THAT(src, IsField<Public>("i", "std::vector<std::uint8_t>"));
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
{
auto j = generate_class_json(diagram, *model);
using namespace json;
REQUIRE(get_element(j, "A").value()["type"] == "class");
REQUIRE(get_element(j, "AA").value()["type"] == "class");
REQUIRE(get_element(j, "ns1::A").value()["type"] == "class");
REQUIRE(get_element(j, "ns1::ns2::D").value()["type"] == "class");
save_json(config.output_directory(), diagram->name + ".json", j);
}
{
auto src = generate_class_mermaid(diagram, *model);
mermaid::AliasMatcher _A(src);
using mermaid::IsField;
REQUIRE_THAT(src, IsClass(_A("A")));
REQUIRE_THAT(src, IsClass(_A("AA")));
REQUIRE_THAT(src, IsClass(_A("ns1::ns2::B")));
REQUIRE_THAT(src, IsClass(_A("ns1::ns2::C")));
REQUIRE_THAT(src, IsClass(_A("ns1::ns2::D")));
REQUIRE_THAT(src, IsClass(_A("ns1::ns2::E")));
REQUIRE_THAT(src, IsClass(_A("ns1::ns2::R")));
REQUIRE_THAT(src, IsField<Public>("i", "std::vector<std::uint8_t>"));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}
REQUIRE(IsField<Public>(
src, "ns1::ns2::R", "i", "std::vector<std::uint8_t>"));
});
}

54
tests/t00047/test_case.h
View File

@@ -16,8 +16,10 @@
* limitations under the License.
*/
TEST_CASE("t00047", "[test-case][class]")
TEST_CASE("t00047")
{
using namespace clanguml::test;
auto [config, db] = load_config("t00047");
auto diagram = config.diagrams["t00047_class"];
@@ -28,48 +30,10 @@ TEST_CASE("t00047", "[test-case][class]")
REQUIRE(model->name() == "t00047_class");
{
auto src = generate_class_puml(diagram, *model);
AliasMatcher _A(src);
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
// Check if class templates exist
REQUIRE_THAT(src, IsClassTemplate("conditional_t", "Ts..."));
REQUIRE_THAT(src, IsClassTemplate("conditional_t", "Else"));
REQUIRE_THAT(src,
IsClassTemplate("conditional_t", "std::true_type,Result,Tail..."));
REQUIRE_THAT(src,
IsClassTemplate("conditional_t", "std::false_type,Result,Tail..."));
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
{
auto j = generate_class_json(diagram, *model);
using namespace json;
REQUIRE(IsClassTemplate(j, "conditional_t<Ts...>"));
REQUIRE(IsClass(j, "conditional_t<Else>"));
REQUIRE(IsClass(j, "conditional_t<std::true_type,Result,Tail...>"));
REQUIRE(IsClass(j, "conditional_t<std::false_type,Result,Tail...>"));
save_json(config.output_directory(), diagram->name + ".json", j);
}
{
auto src = generate_class_mermaid(diagram, *model);
mermaid::AliasMatcher _A(src);
// Check if class templates exist
REQUIRE_THAT(src, IsClass(_A("conditional_t<Ts...>")));
REQUIRE_THAT(src, IsClass(_A("conditional_t<Else>")));
REQUIRE_THAT(
src, IsClass(_A("conditional_t<std::true_type,Result,Tail...>")));
REQUIRE_THAT(
src, IsClass(_A("conditional_t<std::false_type,Result,Tail...>")));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}
CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(IsClassTemplate(src, "conditional_t<Ts...>"));
REQUIRE(IsClass(src, "conditional_t<Else>"));
REQUIRE(IsClass(src, "conditional_t<std::true_type,Result,Tail...>"));
REQUIRE(IsClass(src, "conditional_t<std::false_type,Result,Tail...>"));
});
}

68
tests/t00048/test_case.h
View File

@@ -16,8 +16,10 @@
* limitations under the License.
*/
TEST_CASE("t00048", "[test-case][class]")
TEST_CASE("t00048")
{
using namespace clanguml::test;
auto [config, db] = load_config("t00048");
auto diagram = config.diagrams["t00048_class"];
@@ -28,63 +30,19 @@ TEST_CASE("t00048", "[test-case][class]")
REQUIRE(model->name() == "t00048_class");
{
auto src = generate_class_puml(diagram, *model);
AliasMatcher _A(src);
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
// Check if all classes exist
REQUIRE_THAT(src, IsAbstractClass(_A("Base")));
REQUIRE_THAT(src, IsClass(_A("A")));
REQUIRE_THAT(src, IsClass(_A("B")));
REQUIRE(IsAbstractClass(src, "Base"));
REQUIRE(IsClass(src, "A"));
REQUIRE(IsClass(src, "B"));
// Check if class templates exist
REQUIRE_THAT(src, IsAbstractClassTemplate("BaseTemplate", "T"));
REQUIRE_THAT(src, IsClassTemplate("ATemplate", "T"));
REQUIRE_THAT(src, IsClassTemplate("BTemplate", "T"));
REQUIRE(IsAbstractClassTemplate(src, "BaseTemplate<T>"));
REQUIRE(IsClassTemplate(src, "ATemplate<T>"));
REQUIRE(IsClassTemplate(src, "BTemplate<T>"));
// Check if all inheritance relationships exist
REQUIRE_THAT(src, IsBaseClass(_A("Base"), _A("A")));
REQUIRE_THAT(src, IsBaseClass(_A("Base"), _A("B")));
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
{
auto j = generate_class_json(diagram, *model);
using namespace json;
REQUIRE(IsClass(j, "A"));
REQUIRE(IsClass(j, "B"));
REQUIRE(IsClass(j, "ATemplate<T>"));
REQUIRE(IsClass(j, "BTemplate<T>"));
REQUIRE(IsBaseClass(j, "Base", "A"));
REQUIRE(IsBaseClass(j, "Base", "B"));
save_json(config.output_directory(), diagram->name + ".json", j);
}
{
auto src = generate_class_mermaid(diagram, *model);
mermaid::AliasMatcher _A(src);
using mermaid::IsAbstractClass;
// Check if all classes exist
REQUIRE_THAT(src, IsAbstractClass(_A("Base")));
REQUIRE_THAT(src, IsClass(_A("A")));
REQUIRE_THAT(src, IsClass(_A("B")));
// Check if class templates exist
REQUIRE_THAT(src, IsAbstractClass(_A("BaseTemplate<T>")));
REQUIRE_THAT(src, IsClass(_A("ATemplate<T>")));
REQUIRE_THAT(src, IsClass(_A("BTemplate<T>")));
// Check if all inheritance relationships exist
REQUIRE_THAT(src, IsBaseClass(_A("Base"), _A("A")));
REQUIRE_THAT(src, IsBaseClass(_A("Base"), _A("B")));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}
REQUIRE(IsBaseClass(src, "Base", "A"));
REQUIRE(IsBaseClass(src, "Base", "B"));
});
}

88
tests/t00049/test_case.h
View File

@@ -16,8 +16,10 @@
* limitations under the License.
*/
TEST_CASE("t00049", "[test-case][class]")
TEST_CASE("t00049")
{
using namespace clanguml::test;
auto [config, db] = load_config("t00049");
auto diagram = config.diagrams["t00049_class"];
@@ -27,78 +29,22 @@ TEST_CASE("t00049", "[test-case][class]")
auto model = generate_class_diagram(*db, diagram);
REQUIRE(model->name() == "t00049_class");
CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(IsClass(src, "R"));
{
auto src = generate_class_puml(diagram, *model);
AliasMatcher _A(src);
REQUIRE(IsClassTemplate(src, "A<T>"));
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
REQUIRE(IsMethod<Public>(src, "R", "get_int_map", "A<intmap>"));
REQUIRE(IsMethod<Public>(
src, "R", "set_int_map", "void", "A<intmap> && int_map"));
// Check if all classes exist
REQUIRE_THAT(src, IsClass(_A("R")));
REQUIRE(IsField<Public>(src, "R", "a_string", "A<thestring>"));
REQUIRE(
IsField<Public>(src, "R", "a_vector_string", "A<string_vector>"));
REQUIRE(IsField<Public>(src, "R", "a_int_map", "A<intmap>"));
// Check if class templates exist
REQUIRE_THAT(src, IsClassTemplate("A", "T"));
// Check if all methods exist
REQUIRE_THAT(src, (IsMethod<Public>("get_int_map", "A<intmap>")));
REQUIRE_THAT(src,
(IsMethod<Public>("set_int_map", "void", "A<intmap> && int_map")));
// Check if all fields exist
REQUIRE_THAT(src, (IsField<Public>("a_string", "A<thestring>")));
REQUIRE_THAT(
src, (IsField<Public>("a_vector_string", "A<string_vector>")));
REQUIRE_THAT(src, (IsField<Public>("a_int_map", "A<intmap>")));
// Check if all relationships exist
REQUIRE_THAT(src, IsInstantiation(_A("A<T>"), _A("A<string_vector>")));
REQUIRE_THAT(src, IsInstantiation(_A("A<T>"), _A("A<thestring>")));
REQUIRE_THAT(src, IsInstantiation(_A("A<T>"), _A("A<intmap>")));
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
{
auto j = generate_class_json(diagram, *model);
using namespace json;
REQUIRE(IsClass(j, "R"));
REQUIRE(IsClassTemplate(j, "A<T>"));
REQUIRE(IsInstantiation(j, "A<T>", "A<string_vector>"));
save_json(config.output_directory(), diagram->name + ".json", j);
}
{
auto src = generate_class_mermaid(diagram, *model);
mermaid::AliasMatcher _A(src);
using mermaid::IsField;
using mermaid::IsMethod;
// Check if all classes exist
REQUIRE_THAT(src, IsClass(_A("R")));
// Check if class templates exist
REQUIRE_THAT(src, IsClass(_A("A<T>")));
// Check if all methods exist
REQUIRE_THAT(src, (IsMethod<Public>("get_int_map", "A<intmap>")));
REQUIRE_THAT(src,
(IsMethod<Public>("set_int_map", "void", "A<intmap> && int_map")));
// Check if all fields exist
REQUIRE_THAT(src, (IsField<Public>("a_string", "A<thestring>")));
REQUIRE_THAT(
src, (IsField<Public>("a_vector_string", "A<string_vector>")));
REQUIRE_THAT(src, (IsField<Public>("a_int_map", "A<intmap>")));
// Check if all relationships exist
REQUIRE_THAT(src, IsInstantiation(_A("A<T>"), _A("A<string_vector>")));
REQUIRE_THAT(src, IsInstantiation(_A("A<T>"), _A("A<thestring>")));
REQUIRE_THAT(src, IsInstantiation(_A("A<T>"), _A("A<intmap>")));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}
REQUIRE(IsInstantiation(src, "A<T>", "A<string_vector>"));
REQUIRE(IsInstantiation(src, "A<T>", "A<thestring>"));
REQUIRE(IsInstantiation(src, "A<T>", "A<intmap>"));
});
}

98
tests/t00050/test_case.h
View File

@@ -16,8 +16,10 @@
* limitations under the License.
*/
TEST_CASE("t00050", "[test-case][class]")
TEST_CASE("t00050")
{
using namespace clanguml::test;
auto [config, db] = load_config("t00050");
auto diagram = config.diagrams["t00050_class"];
@@ -28,73 +30,31 @@ TEST_CASE("t00050", "[test-case][class]")
REQUIRE(model->name() == "t00050_class");
{
auto src = generate_class_puml(diagram, *model);
AliasMatcher _A(src);
CHECK_CLASS_DIAGRAM(
config, diagram, *model,
[](const auto &src) {
REQUIRE(IsClass(src, "A"));
REQUIRE(IsClass(src, "B"));
REQUIRE(IsClass(src, "C"));
REQUIRE(IsClass(src, {"utils", "D"}));
REQUIRE(IsEnum(src, "E"));
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
// Check if all classes exist
REQUIRE_THAT(src, IsClass(_A("A")));
REQUIRE_THAT(src, IsClass(_A("B")));
REQUIRE_THAT(src, IsClass(_A("C")));
REQUIRE_THAT(src, IsClass(_A("utils::D")));
REQUIRE_THAT(src, IsEnum(_A("E")));
REQUIRE_THAT(src, HasNote(_A("A"), "left"));
REQUIRE_THAT(src, HasNote(_A("A"), "right"));
REQUIRE_THAT(src, HasNote(_A("B"), "top"));
REQUIRE_THAT(src, HasNote(_A("C"), "top"));
REQUIRE_THAT(src, HasNote(_A("utils::D"), "top"));
REQUIRE_THAT(src, !HasNote(_A("E"), "bottom"));
REQUIRE_THAT(src, !HasNote(_A("NoComment"), "top"));
REQUIRE_THAT(src, HasNote(_A("F<T,V,int N>"), "top"));
REQUIRE_THAT(src, HasNote(_A("G"), "top"));
REQUIRE_THAT(src, HasNote(_A("G"), "bottom"));
REQUIRE_THAT(src, HasNote(_A("G"), "right"));
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
{
auto j = generate_class_json(diagram, *model);
using namespace json;
REQUIRE(IsClass(j, "A"));
REQUIRE(IsClass(j, "B"));
REQUIRE(IsClass(j, "C"));
REQUIRE(IsClass(j, "utils::D"));
REQUIRE(IsEnum(j, "E"));
save_json(config.output_directory(), diagram->name + ".json", j);
}
{
auto src = generate_class_mermaid(diagram, *model);
mermaid::AliasMatcher _A(src);
using mermaid::HasNote;
using mermaid::IsEnum;
// Check if all classes exist
REQUIRE_THAT(src, IsClass(_A("A")));
REQUIRE_THAT(src, IsClass(_A("B")));
REQUIRE_THAT(src, IsClass(_A("C")));
REQUIRE_THAT(src, IsClass(_A("utils::D")));
REQUIRE_THAT(src, IsEnum(_A("E")));
REQUIRE_THAT(src, HasNote(_A("A"), "left"));
REQUIRE_THAT(src, HasNote(_A("A"), "right"));
REQUIRE_THAT(src, HasNote(_A("B"), "top"));
REQUIRE_THAT(src, HasNote(_A("C"), "top"));
REQUIRE_THAT(src, HasNote(_A("utils::D"), "top"));
REQUIRE_THAT(src, !HasNote(_A("E"), "bottom"));
REQUIRE_THAT(src, !HasNote(_A("NoComment"), "top"));
REQUIRE_THAT(src, HasNote(_A("F<T,V,int N>"), "top"));
REQUIRE_THAT(src, HasNote(_A("G"), "top"));
REQUIRE_THAT(src, HasNote(_A("G"), "bottom"));
REQUIRE_THAT(src, HasNote(_A("G"), "right"));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}
REQUIRE(HasNote(src, "A", "left"));
REQUIRE(HasNote(src, "A", "right"));
REQUIRE(HasNote(src, "B", "top"));
REQUIRE(HasNote(src, "C", "top"));
REQUIRE(HasNote(src, "utils::D", "top"));
REQUIRE(HasNote(src, "F<T,V,int N>", "top"));
REQUIRE(HasNote(src, "G", "top"));
REQUIRE(HasNote(src, "G", "bottom"));
REQUIRE(HasNote(src, "G", "right"));
},
[](const plantuml_t &src) {
REQUIRE(!HasNote(src, "E", "bottom"));
REQUIRE(!HasNote(src, "NoComment", "top"));
},
[](const mermaid_t &src) {
REQUIRE(!HasNote(src, "E", "bottom"));
REQUIRE(!HasNote(src, "NoComment", "top"));
});
}

35
tests/t00051/test_case.h
View File

@@ -16,8 +16,10 @@
* limitations under the License.
*/
TEST_CASE("t00051", "[test-case][class]")
TEST_CASE("t00051")
{
using namespace clanguml::test;
auto [config, db] = load_config("t00051");
auto diagram = config.diagrams["t00051_class"];
@@ -28,6 +30,36 @@ TEST_CASE("t00051", "[test-case][class]")
REQUIRE(model->name() == "t00051_class");
CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(IsClass(src, "A"));
REQUIRE(IsInnerClass(src, "A", "A::custom_thread1"));
REQUIRE(IsInnerClass(src, "A", "A::custom_thread2"));
REQUIRE(IsMethod<Public>(src, "A::custom_thread1",
"custom_thread1<Function,Args...>", "void",
"Function && f, Args &&... args"));
REQUIRE(IsMethod<Public>(src, "A::custom_thread2", "thread", "void",
"(lambda at t00051.cc:59:27) &&"));
REQUIRE(IsMethod<Private>(src, "A", "start_thread3",
"B<(lambda at t00051.cc:43:18),(lambda at "
"t00051.cc:43:27)>"));
REQUIRE(IsMethod<Private>(
src, "A", "get_function", "(lambda at t00051.cc:48:16)"));
REQUIRE(IsClassTemplate(src, "B<F,FF=F>"));
REQUIRE(IsMethod<Public>(src, "B<F,FF=F>", "f", "void"));
REQUIRE(IsMethod<Public>(src, "B<F,FF=F>", "ff", "void"));
REQUIRE(IsClassTemplate(
src, "B<(lambda at t00051.cc:43:18),(lambda at t00051.cc:43:27)>"));
REQUIRE(IsInstantiation(src, "B<F,FF=F>",
"B<(lambda at t00051.cc:43:18),(lambda at t00051.cc:43:27)>"));
REQUIRE(IsDependency(src, "A",
"B<(lambda at t00051.cc:43:18),(lambda at t00051.cc:43:27)>"));
});
/*
{
auto src = generate_class_puml(diagram, *model);
AliasMatcher _A(src);
@@ -128,4 +160,5 @@ TEST_CASE("t00051", "[test-case][class]")
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}
*/
}

16
tests/t00052/test_case.h
View File

@@ -16,8 +16,10 @@
* limitations under the License.
*/
TEST_CASE("t00052", "[test-case][class]")
TEST_CASE("t00052")
{
using namespace clanguml::test;
auto [config, db] = load_config("t00052");
auto diagram = config.diagrams["t00052_class"];
@@ -28,6 +30,17 @@ TEST_CASE("t00052", "[test-case][class]")
REQUIRE(model->name() == "t00052_class");
CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(IsClass(src, "A"));
REQUIRE(IsClassTemplate(src, "B<T>"));
REQUIRE(IsMethod<Public>(src, "A", "a<T>", "T", "T p"));
REQUIRE(IsMethod<Public>(src, "A", "aa<F,Q>", "void", "F && f, Q q"));
REQUIRE(IsMethod<Public>(src, "B<T>", "b", "T", "T t"));
REQUIRE(IsMethod<Public>(src, "B<T>", "bb<F>", "T", "F && f, T t"));
});
/*
{
auto src = generate_class_puml(diagram, *model);
AliasMatcher _A(src);
@@ -79,4 +92,5 @@ TEST_CASE("t00052", "[test-case][class]")
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}
*/
}

146
tests/t00053/test_case.h
View File

@@ -16,8 +16,10 @@
* limitations under the License.
*/
TEST_CASE("t00053", "[test-case][class]")
TEST_CASE("t00053")
{
using namespace clanguml::test;
auto [config, db] = load_config("t00053");
auto diagram = config.diagrams["t00053_class"];
@@ -28,78 +30,98 @@ TEST_CASE("t00053", "[test-case][class]")
REQUIRE(model->name() == "t00053_class");
{
auto src = generate_class_puml(diagram, *model);
AliasMatcher _A(src);
CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(IsClass(src, "a"));
REQUIRE(IsClass(src, "b"));
REQUIRE(IsClass(src, "c"));
REQUIRE(IsClass(src, "d"));
REQUIRE(IsClass(src, "e"));
REQUIRE(IsClass(src, "f"));
REQUIRE(IsClass(src, "g"));
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
REQUIRE(IsClass(src, "A"));
REQUIRE(IsClass(src, "B"));
REQUIRE(IsClass(src, "C"));
REQUIRE(IsClass(src, "D"));
REQUIRE(IsClass(src, "E"));
REQUIRE(IsClass(src, "F"));
REQUIRE(IsClass(src, "G"));
});
/*
{
auto src = generate_class_puml(diagram, *model);
AliasMatcher _A(src);
// Check if all classes exist
REQUIRE_THAT(src, IsClass(_A("a")));
REQUIRE_THAT(src, IsClass(_A("b")));
REQUIRE_THAT(src, IsClass(_A("c")));
REQUIRE_THAT(src, IsClass(_A("d")));
REQUIRE_THAT(src, IsClass(_A("e")));
REQUIRE_THAT(src, IsClass(_A("f")));
REQUIRE_THAT(src, IsClass(_A("g")));
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
REQUIRE_THAT(src, IsClass(_A("A")));
REQUIRE_THAT(src, IsClass(_A("B")));
REQUIRE_THAT(src, IsClass(_A("C")));
REQUIRE_THAT(src, IsClass(_A("D")));
REQUIRE_THAT(src, IsClass(_A("E")));
REQUIRE_THAT(src, IsClass(_A("F")));
REQUIRE_THAT(src, IsClass(_A("G")));
// Check if all classes exist
REQUIRE_THAT(src, IsClass(_A("a")));
REQUIRE_THAT(src, IsClass(_A("b")));
REQUIRE_THAT(src, IsClass(_A("c")));
REQUIRE_THAT(src, IsClass(_A("d")));
REQUIRE_THAT(src, IsClass(_A("e")));
REQUIRE_THAT(src, IsClass(_A("f")));
REQUIRE_THAT(src, IsClass(_A("g")));
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
REQUIRE_THAT(src, IsClass(_A("A")));
REQUIRE_THAT(src, IsClass(_A("B")));
REQUIRE_THAT(src, IsClass(_A("C")));
REQUIRE_THAT(src, IsClass(_A("D")));
REQUIRE_THAT(src, IsClass(_A("E")));
REQUIRE_THAT(src, IsClass(_A("F")));
REQUIRE_THAT(src, IsClass(_A("G")));
{
auto j = generate_class_json(diagram, *model);
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
using namespace json;
{
auto j = generate_class_json(diagram, *model);
REQUIRE(IsClass(j, "a"));
REQUIRE(IsClass(j, "b"));
REQUIRE(IsClass(j, "c"));
REQUIRE(IsClass(j, "d"));
REQUIRE(IsClass(j, "e"));
REQUIRE(IsClass(j, "f"));
REQUIRE(IsClass(j, "g"));
using namespace json;
REQUIRE(IsClass(j, "A"));
REQUIRE(IsClass(j, "B"));
REQUIRE(IsClass(j, "C"));
REQUIRE(IsClass(j, "D"));
REQUIRE(IsClass(j, "E"));
REQUIRE(IsClass(j, "F"));
REQUIRE(IsClass(j, "G"));
REQUIRE(IsClass(j, "a"));
REQUIRE(IsClass(j, "b"));
REQUIRE(IsClass(j, "c"));
REQUIRE(IsClass(j, "d"));
REQUIRE(IsClass(j, "e"));
REQUIRE(IsClass(j, "f"));
REQUIRE(IsClass(j, "g"));
save_json(config.output_directory(), diagram->name + ".json", j);
}
{
auto src = generate_class_mermaid(diagram, *model);
REQUIRE(IsClass(j, "A"));
REQUIRE(IsClass(j, "B"));
REQUIRE(IsClass(j, "C"));
REQUIRE(IsClass(j, "D"));
REQUIRE(IsClass(j, "E"));
REQUIRE(IsClass(j, "F"));
REQUIRE(IsClass(j, "G"));
mermaid::AliasMatcher _A(src);
save_json(config.output_directory(), diagram->name + ".json", j);
}
{
auto src = generate_class_mermaid(diagram, *model);
// Check if all classes exist
REQUIRE_THAT(src, IsClass(_A("a")));
REQUIRE_THAT(src, IsClass(_A("b")));
REQUIRE_THAT(src, IsClass(_A("c")));
REQUIRE_THAT(src, IsClass(_A("d")));
REQUIRE_THAT(src, IsClass(_A("e")));
REQUIRE_THAT(src, IsClass(_A("f")));
REQUIRE_THAT(src, IsClass(_A("g")));
mermaid::AliasMatcher _A(src);
REQUIRE_THAT(src, IsClass(_A("A")));
REQUIRE_THAT(src, IsClass(_A("B")));
REQUIRE_THAT(src, IsClass(_A("C")));
REQUIRE_THAT(src, IsClass(_A("D")));
REQUIRE_THAT(src, IsClass(_A("E")));
REQUIRE_THAT(src, IsClass(_A("F")));
REQUIRE_THAT(src, IsClass(_A("G")));
// Check if all classes exist
REQUIRE_THAT(src, IsClass(_A("a")));
REQUIRE_THAT(src, IsClass(_A("b")));
REQUIRE_THAT(src, IsClass(_A("c")));
REQUIRE_THAT(src, IsClass(_A("d")));
REQUIRE_THAT(src, IsClass(_A("e")));
REQUIRE_THAT(src, IsClass(_A("f")));
REQUIRE_THAT(src, IsClass(_A("g")));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}
REQUIRE_THAT(src, IsClass(_A("A")));
REQUIRE_THAT(src, IsClass(_A("B")));
REQUIRE_THAT(src, IsClass(_A("C")));
REQUIRE_THAT(src, IsClass(_A("D")));
REQUIRE_THAT(src, IsClass(_A("E")));
REQUIRE_THAT(src, IsClass(_A("F")));
REQUIRE_THAT(src, IsClass(_A("G")));
save_mermaid(config.output_directory(), diagram->name + ".mmd",
src);
}
*/
}

28
tests/t00054/test_case.h
View File

@@ -16,8 +16,10 @@
* limitations under the License.
*/
TEST_CASE("t00054", "[test-case][class]")
TEST_CASE("t00054")
{
using namespace clanguml::test;
auto [config, db] = load_config("t00054");
auto diagram = config.diagrams["t00054_class"];
@@ -28,6 +30,28 @@ TEST_CASE("t00054", "[test-case][class]")
REQUIRE(model->name() == "t00054_class");
CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(IsClass(src, "a"));
REQUIRE(IsClass(src, "b"));
REQUIRE(IsClass(src, {"detail", "c"}));
REQUIRE(IsClass(src, {"detail", "d"}));
REQUIRE(IsClass(src, {"detail", "e"}));
REQUIRE(IsClass(src, "f"));
REQUIRE(IsClass(src, "g"));
REQUIRE(IsClass(src, "A"));
REQUIRE(IsClass(src, "B"));
REQUIRE(IsClass(src, {"detail2", "C"}));
REQUIRE(IsClass(src, {"detail2::detail3", "D"}));
REQUIRE(IsClass(src, {"detail2::detail3", "E"}));
REQUIRE(IsClass(src, {"detail2", "F"}));
REQUIRE(IsClass(src, "G"));
REQUIRE(IsEnum(src, {"detail4", "i"}));
REQUIRE(IsEnum(src, {"detail4", "h"}));
REQUIRE(IsEnum(src, {"detail4", "j"}));
});
/*
{
auto src = generate_class_puml(diagram, *model);
AliasMatcher _A(src);
@@ -114,5 +138,5 @@ TEST_CASE("t00054", "[test-case][class]")
REQUIRE_THAT(src, IsEnum(_A("detail4::j")));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}
}*/
}

29
tests/t00055/test_case.h
View File

@@ -16,8 +16,10 @@
* limitations under the License.
*/
TEST_CASE("t00055", "[test-case][class]")
TEST_CASE("t00055")
{
using namespace clanguml::test;
auto [config, db] = load_config("t00055");
auto diagram = config.diagrams["t00055_class"];
@@ -28,6 +30,29 @@ TEST_CASE("t00055", "[test-case][class]")
REQUIRE(model->name() == "t00055_class");
CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(IsClass(src, "A"));
REQUIRE(IsClass(src, "B"));
REQUIRE(IsClass(src, "C"));
REQUIRE(IsClass(src, "D"));
REQUIRE(IsClass(src, "E"));
REQUIRE(IsClass(src, "F"));
REQUIRE(IsClass(src, "G"));
REQUIRE(IsClass(src, "H"));
REQUIRE(IsClass(src, "I"));
REQUIRE(IsClass(src, "J"));
REQUIRE(IsLayoutHint(src, "A", "right", "C"));
REQUIRE(IsLayoutHint(src, "C", "right", "E"));
REQUIRE(IsLayoutHint(src, "E", "right", "G"));
REQUIRE(IsLayoutHint(src, "G", "right", "I"));
REQUIRE(IsLayoutHint(src, "B", "down", "D"));
REQUIRE(IsLayoutHint(src, "D", "down", "F"));
REQUIRE(IsLayoutHint(src, "F", "down", "H"));
REQUIRE(IsLayoutHint(src, "H", "down", "J"));
});
/*
{
auto src = generate_class_puml(diagram, *model);
AliasMatcher _A(src);
@@ -96,5 +121,5 @@ TEST_CASE("t00055", "[test-case][class]")
REQUIRE_THAT(src, IsClass(_A("J")));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}
}*/
}

401
tests/t00056/test_case.h
View File

@@ -16,8 +16,10 @@
* limitations under the License.
*/
TEST_CASE("t00056", "[test-case][class]")
TEST_CASE("t00056")
{
using namespace clanguml::test;
auto [config, db] = load_config("t00056");
auto diagram = config.diagrams["t00056_class"];
@@ -28,200 +30,267 @@ TEST_CASE("t00056", "[test-case][class]")
REQUIRE(model->name() == "t00056_class");
{
auto src = generate_class_puml(diagram, *model);
AliasMatcher _A(src);
CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(IsConcept(src, "greater_than_simple<T,L>"));
REQUIRE(IsConcept(src, "greater_than_with_requires<T,P>"));
REQUIRE(IsConcept(src, "max_four_bytes<T>"));
REQUIRE(IsConcept(src, "iterable<T>"));
REQUIRE(IsConcept(src, "has_value_type<T>"));
REQUIRE(IsConcept(src, "convertible_to_string<T>"));
REQUIRE(IsConcept(src, "iterable_with_value_type<T>"));
REQUIRE(IsConcept(src, "iterable_or_small_value_type<T>"));
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
REQUIRE(IsConceptRequirement(
src, "greater_than_with_requires<T,P>", "sizeof (l) > sizeof (r)"));
// Check if all classes exist
REQUIRE_THAT(src, IsConcept(_A("greater_than_simple<T,L>")));
REQUIRE_THAT(src, IsConcept(_A("greater_than_with_requires<T,P>")));
REQUIRE_THAT(src, IsConcept(_A("max_four_bytes<T>")));
REQUIRE_THAT(src, IsConcept(_A("iterable<T>")));
REQUIRE_THAT(src, IsConcept(_A("has_value_type<T>")));
REQUIRE_THAT(src, IsConcept(_A("convertible_to_string<T>")));
REQUIRE_THAT(src, IsConcept(_A("iterable_with_value_type<T>")));
REQUIRE_THAT(src, IsConcept(_A("iterable_or_small_value_type<T>")));
REQUIRE_THAT(src,
IsConceptRequirement(_A("greater_than_with_requires<T,P>"),
"sizeof (l) > sizeof (r)"));
REQUIRE_THAT(
src, IsConceptRequirement(_A("iterable<T>"), "container.begin()"));
REQUIRE_THAT(
src, IsConceptRequirement(_A("iterable<T>"), "container.end()"));
REQUIRE(IsConceptRequirement(src, "iterable<T>", "container.begin()"));
REQUIRE(IsConceptRequirement(src, "iterable<T>", "container.end()"));
#if (LLVM_VERSION_MAJOR == 13) || (LLVM_VERSION_MAJOR == 14)
REQUIRE_THAT(src,
IsConceptRequirement(
_A("convertible_to_string<T>"), "std::string({s})"));
REQUIRE(IsConceptRequirement(
src, "convertible_to_string<T>", "std::string({s})"));
#else
REQUIRE_THAT(src,
REQUIRE(
IsConceptRequirement(
_A("convertible_to_string<T>"), "std::string{s}"));
src,"convertible_to_string<T>", "std::string{s}"));
#endif
REQUIRE_THAT(src,
IsConceptRequirement(_A("convertible_to_string<T>"),
"{std::to_string(s)} noexcept"));
REQUIRE_THAT(src,
IsConceptRequirement(_A("convertible_to_string<T>"),
"{std::to_string(s)} -> std::same_as<std::string>"));
REQUIRE(IsConceptRequirement(
src, "convertible_to_string<T>", "{std::to_string(s)} noexcept"));
REQUIRE(IsConceptRequirement(src, "convertible_to_string<T>",
"{std::to_string(s)} -> std::same_as<std::string>"));
// Check if class templates exist
REQUIRE_THAT(src, IsClassTemplate("A", "max_four_bytes T"));
REQUIRE_THAT(src, IsClassTemplate("B", "T"));
REQUIRE_THAT(src, IsClassTemplate("C", "convertible_to_string T"));
REQUIRE_THAT(
src, IsClassTemplate("D", "iterable T1,T2,iterable T3,T4,T5"));
REQUIRE_THAT(src, IsClassTemplate("E", "T1,T2,T3"));
REQUIRE_THAT(src, IsClassTemplate("F", "T1,T2,T3"));
REQUIRE(IsClassTemplate(src, "A<max_four_bytes T>"));
// Check if all relationships exist
REQUIRE_THAT(src,
IsConstraint(
_A("A<max_four_bytes T>"), _A("max_four_bytes<T>"), "T"));
REQUIRE(IsClassTemplate(src, "B<T>"));
REQUIRE(IsClassTemplate(src, "C<convertible_to_string T>"));
REQUIRE(IsClassTemplate(src, "D<iterable T1,T2,iterable T3,T4,T5>"));
REQUIRE(IsClassTemplate(src, "E<T1,T2,T3>"));
REQUIRE(IsClassTemplate(src, "F<T1,T2,T3>"));
REQUIRE_THAT(src,
IsConstraint(_A("D<iterable T1,T2,iterable T3,T4,T5>"),
_A("max_four_bytes<T>"), "T2"));
REQUIRE_THAT(src,
IsConstraint(_A("D<iterable T1,T2,iterable T3,T4,T5>"),
_A("max_four_bytes<T>"), "T5"));
REQUIRE_THAT(src,
IsConstraint(_A("D<iterable T1,T2,iterable T3,T4,T5>"),
_A("iterable<T>"), "T1"));
REQUIRE_THAT(src,
IsConstraint(_A("D<iterable T1,T2,iterable T3,T4,T5>"),
_A("iterable<T>"), "T3"));
REQUIRE(
IsConstraint(src, "A<max_four_bytes T>", "max_four_bytes<T>", "T"));
REQUIRE_THAT(src,
IsConstraint(_A("iterable_with_value_type<T>"),
_A("has_value_type<T>"), "T"));
REQUIRE(IsConstraint(src, "D<iterable T1,T2,iterable T3,T4,T5>",
"max_four_bytes<T>", "T2"));
REQUIRE(IsConstraint(src, "D<iterable T1,T2,iterable T3,T4,T5>",
"max_four_bytes<T>", "T5"));
REQUIRE(IsConstraint(
src, "D<iterable T1,T2,iterable T3,T4,T5>", "iterable<T>", "T1"));
REQUIRE(IsConstraint(
src, "D<iterable T1,T2,iterable T3,T4,T5>", "iterable<T>", "T3"));
REQUIRE_THAT(src,
IsConstraint(_A("iterable_or_small_value_type<T>"),
_A("max_four_bytes<T>"), "T"));
REQUIRE_THAT(src,
IsConstraint(_A("iterable_or_small_value_type<T>"),
_A("iterable_with_value_type<T>"), "T"));
REQUIRE(IsConstraint(
src, "iterable_with_value_type<T>", "has_value_type<T>", "T"));
REQUIRE_THAT(src,
IsConstraint(_A("E<T1,T2,T3>"),
_A("greater_than_with_requires<T,P>"), "T1,T3"));
REQUIRE(IsConstraint(
src, "iterable_or_small_value_type<T>", "max_four_bytes<T>", "T"));
REQUIRE(IsConstraint(src, "iterable_or_small_value_type<T>",
"iterable_with_value_type<T>", "T"));
REQUIRE_THAT(src,
IsConstraint(
_A("F<T1,T2,T3>"), _A("greater_than_simple<T,L>"), "T1,T3"));
REQUIRE(IsConstraint(
src, "E<T1,T2,T3>", "greater_than_with_requires<T,P>", "T1,T3"));
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
{
auto j = generate_class_json(diagram, *model);
REQUIRE(IsConstraint(
src, "F<T1,T2,T3>", "greater_than_simple<T,L>", "T1,T3"));
});
/*
{
auto src = generate_class_puml(diagram, *model);
AliasMatcher _A(src);
using namespace json;
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
REQUIRE(IsConcept(j, "greater_than_simple<T,L>"));
REQUIRE(IsConcept(j, "greater_than_with_requires<T,P>"));
REQUIRE(IsConcept(j, "max_four_bytes<T>"));
REQUIRE(IsConcept(j, "iterable<T>"));
REQUIRE(IsConcept(j, "has_value_type<T>"));
REQUIRE(IsConcept(j, "convertible_to_string<T>"));
REQUIRE(IsConcept(j, "iterable_with_value_type<T>"));
REQUIRE(IsConcept(j, "iterable_or_small_value_type<T>"));
// Check if all classes exist
REQUIRE_THAT(src, IsConcept(_A("greater_than_simple<T,L>")));
REQUIRE_THAT(src, IsConcept(_A("greater_than_with_requires<T,P>")));
REQUIRE_THAT(src, IsConcept(_A("max_four_bytes<T>")));
REQUIRE_THAT(src, IsConcept(_A("iterable<T>")));
REQUIRE_THAT(src, IsConcept(_A("has_value_type<T>")));
REQUIRE_THAT(src, IsConcept(_A("convertible_to_string<T>")));
REQUIRE_THAT(src, IsConcept(_A("iterable_with_value_type<T>")));
REQUIRE_THAT(src, IsConcept(_A("iterable_or_small_value_type<T>")));
save_json(config.output_directory(), diagram->name + ".json", j);
}
{
auto src = generate_class_mermaid(diagram, *model);
REQUIRE_THAT(src,
IsConceptRequirement(_A("greater_than_with_requires<T,P>"),
"sizeof (l) > sizeof (r)"));
mermaid::AliasMatcher _A(src);
using mermaid::IsConcept;
using mermaid::IsConceptRequirement;
using mermaid::IsConstraint;
REQUIRE_THAT(
src, IsConceptRequirement(_A("iterable<T>"),
"container.begin()")); REQUIRE_THAT( src,
IsConceptRequirement(_A("iterable<T>"), "container.end()"));
// Check if all classes exist
REQUIRE_THAT(src, IsConcept(_A("greater_than_simple<T,L>")));
REQUIRE_THAT(src, IsConcept(_A("greater_than_with_requires<T,P>")));
REQUIRE_THAT(src, IsConcept(_A("max_four_bytes<T>")));
REQUIRE_THAT(src, IsConcept(_A("iterable<T>")));
REQUIRE_THAT(src, IsConcept(_A("has_value_type<T>")));
REQUIRE_THAT(src, IsConcept(_A("convertible_to_string<T>")));
REQUIRE_THAT(src, IsConcept(_A("iterable_with_value_type<T>")));
REQUIRE_THAT(src, IsConcept(_A("iterable_or_small_value_type<T>")));
#if (LLVM_VERSION_MAJOR == 13) || (LLVM_VERSION_MAJOR == 14)
REQUIRE_THAT(src,
IsConceptRequirement(
_A("convertible_to_string<T>"), "std::string({s})"));
#else
REQUIRE_THAT(src,
IsConceptRequirement(
_A("convertible_to_string<T>"), "std::string{s}"));
#endif
REQUIRE_THAT(src,
IsConceptRequirement(_A("convertible_to_string<T>"),
"{std::to_string(s)} noexcept"));
REQUIRE_THAT(src,
IsConceptRequirement(_A("convertible_to_string<T>"),
"{std::to_string(s)} -> std::same_as<std::string>"));
REQUIRE_THAT(src,
IsConceptRequirement(_A("greater_than_with_requires<T,P>"),
"sizeof (l) > sizeof (r)"));
// Check if class templates exist
REQUIRE_THAT(src, IsClassTemplate("A", "max_four_bytes T"));
REQUIRE_THAT(src, IsClassTemplate("B", "T"));
REQUIRE_THAT(src, IsClassTemplate("C", "convertible_to_string T"));
REQUIRE_THAT(
src, IsClassTemplate("D", "iterable T1,T2,iterable T3,T4,T5"));
REQUIRE_THAT(src, IsClassTemplate("E", "T1,T2,T3"));
REQUIRE_THAT(src, IsClassTemplate("F", "T1,T2,T3"));
REQUIRE_THAT(
src, IsConceptRequirement(_A("iterable<T>"), "container.begin()"));
REQUIRE_THAT(
src, IsConceptRequirement(_A("iterable<T>"), "container.end()"));
// Check if all relationships exist
REQUIRE_THAT(src,
IsConstraint(
_A("A<max_four_bytes T>"), _A("max_four_bytes<T>"), "T"));
#if (LLVM_VERSION_MAJOR == 13) || (LLVM_VERSION_MAJOR == 14)
REQUIRE_THAT(src,
IsConceptRequirement(
_A("convertible_to_string<T>"), "std::string({s})"));
#else
REQUIRE_THAT(src,
IsConceptRequirement(
_A("convertible_to_string<T>"), "std::string{s}"));
#endif
REQUIRE_THAT(src,
IsConceptRequirement(_A("convertible_to_string<T>"),
"{std::to_string(s)} noexcept"));
REQUIRE_THAT(src,
IsConceptRequirement(_A("convertible_to_string<T>"),
"{std::to_string(s)} -> std::same_as<std::string>"));
REQUIRE_THAT(src,
IsConstraint(_A("D<iterable T1,T2,iterable T3,T4,T5>"),
_A("max_four_bytes<T>"), "T2"));
REQUIRE_THAT(src,
IsConstraint(_A("D<iterable T1,T2,iterable T3,T4,T5>"),
_A("max_four_bytes<T>"), "T5"));
REQUIRE_THAT(src,
IsConstraint(_A("D<iterable T1,T2,iterable T3,T4,T5>"),
_A("iterable<T>"), "T1"));
REQUIRE_THAT(src,
IsConstraint(_A("D<iterable T1,T2,iterable T3,T4,T5>"),
_A("iterable<T>"), "T3"));
// Check if class templates exist
REQUIRE_THAT(src, IsClass(_A("A<max_four_bytes T>")));
REQUIRE_THAT(src, IsClass(_A("B<T>")));
REQUIRE_THAT(src, IsClass(_A("C<convertible_to_string T>")));
REQUIRE_THAT(src, IsClass(_A("D<iterable T1,T2,iterable T3,T4,T5>")));
REQUIRE_THAT(src, IsClass(_A("E<T1,T2,T3>")));
REQUIRE_THAT(src, IsClass(_A("F<T1,T2,T3>")));
REQUIRE_THAT(src,
IsConstraint(_A("iterable_with_value_type<T>"),
_A("has_value_type<T>"), "T"));
// Check if all relationships exist
REQUIRE_THAT(src,
IsConstraint(
_A("A<max_four_bytes T>"), _A("max_four_bytes<T>"), "T"));
REQUIRE_THAT(src,
IsConstraint(_A("iterable_or_small_value_type<T>"),
_A("max_four_bytes<T>"), "T"));
REQUIRE_THAT(src,
IsConstraint(_A("iterable_or_small_value_type<T>"),
_A("iterable_with_value_type<T>"), "T"));
REQUIRE_THAT(src,
IsConstraint(_A("D<iterable T1,T2,iterable T3,T4,T5>"),
_A("max_four_bytes<T>"), "T2"));
REQUIRE_THAT(src,
IsConstraint(_A("D<iterable T1,T2,iterable T3,T4,T5>"),
_A("max_four_bytes<T>"), "T5"));
REQUIRE_THAT(src,
IsConstraint(_A("D<iterable T1,T2,iterable T3,T4,T5>"),
_A("iterable<T>"), "T1"));
REQUIRE_THAT(src,
IsConstraint(_A("D<iterable T1,T2,iterable T3,T4,T5>"),
_A("iterable<T>"), "T3"));
REQUIRE_THAT(src,
IsConstraint(_A("E<T1,T2,T3>"),
_A("greater_than_with_requires<T,P>"), "T1,T3"));
REQUIRE_THAT(src,
IsConstraint(_A("iterable_with_value_type<T>"),
_A("has_value_type<T>"), "T"));
REQUIRE_THAT(src,
IsConstraint(
_A("F<T1,T2,T3>"), _A("greater_than_simple<T,L>"),
"T1,T3"));
REQUIRE_THAT(src,
IsConstraint(_A("iterable_or_small_value_type<T>"),
_A("max_four_bytes<T>"), "T"));
REQUIRE_THAT(src,
IsConstraint(_A("iterable_or_small_value_type<T>"),
_A("iterable_with_value_type<T>"), "T"));
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
{
auto j = generate_class_json(diagram, *model);
REQUIRE_THAT(src,
IsConstraint(_A("E<T1,T2,T3>"),
_A("greater_than_with_requires<T,P>"), "T1,T3"));
using namespace json;
REQUIRE_THAT(src,
IsConstraint(
_A("F<T1,T2,T3>"), _A("greater_than_simple<T,L>"), "T1,T3"));
REQUIRE(IsConcept(j, "greater_than_simple<T,L>"));
REQUIRE(IsConcept(j, "greater_than_with_requires<T,P>"));
REQUIRE(IsConcept(j, "max_four_bytes<T>"));
REQUIRE(IsConcept(j, "iterable<T>"));
REQUIRE(IsConcept(j, "has_value_type<T>"));
REQUIRE(IsConcept(j, "convertible_to_string<T>"));
REQUIRE(IsConcept(j, "iterable_with_value_type<T>"));
REQUIRE(IsConcept(j, "iterable_or_small_value_type<T>"));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}
save_json(config.output_directory(), diagram->name + ".json", j);
}
{
auto src = generate_class_mermaid(diagram, *model);
mermaid::AliasMatcher _A(src);
using mermaid::IsConcept;
using mermaid::IsConceptRequirement;
using mermaid::IsConstraint;
// Check if all classes exist
REQUIRE_THAT(src, IsConcept(_A("greater_than_simple<T,L>")));
REQUIRE_THAT(src, IsConcept(_A("greater_than_with_requires<T,P>")));
REQUIRE_THAT(src, IsConcept(_A("max_four_bytes<T>")));
REQUIRE_THAT(src, IsConcept(_A("iterable<T>")));
REQUIRE_THAT(src, IsConcept(_A("has_value_type<T>")));
REQUIRE_THAT(src, IsConcept(_A("convertible_to_string<T>")));
REQUIRE_THAT(src, IsConcept(_A("iterable_with_value_type<T>")));
REQUIRE_THAT(src, IsConcept(_A("iterable_or_small_value_type<T>")));
REQUIRE_THAT(src,
IsConceptRequirement(_A("greater_than_with_requires<T,P>"),
"sizeof (l) > sizeof (r)"));
REQUIRE_THAT(
src, IsConceptRequirement(_A("iterable<T>"),
"container.begin()")); REQUIRE_THAT( src,
IsConceptRequirement(_A("iterable<T>"), "container.end()"));
#if (LLVM_VERSION_MAJOR == 13) || (LLVM_VERSION_MAJOR == 14)
REQUIRE_THAT(src,
IsConceptRequirement(
_A("convertible_to_string<T>"), "std::string({s})"));
#else
REQUIRE_THAT(src,
IsConceptRequirement(
_A("convertible_to_string<T>"), "std::string{s}"));
#endif
REQUIRE_THAT(src,
IsConceptRequirement(_A("convertible_to_string<T>"),
"{std::to_string(s)} noexcept"));
REQUIRE_THAT(src,
IsConceptRequirement(_A("convertible_to_string<T>"),
"{std::to_string(s)} -> std::same_as<std::string>"));
// Check if class templates exist
REQUIRE_THAT(src, IsClass(_A("A<max_four_bytes T>")));
REQUIRE_THAT(src, IsClass(_A("B<T>")));
REQUIRE_THAT(src, IsClass(_A("C<convertible_to_string T>")));
REQUIRE_THAT(src, IsClass(_A("D<iterable T1,T2,iterable
T3,T4,T5>"))); REQUIRE_THAT(src, IsClass(_A("E<T1,T2,T3>")));
REQUIRE_THAT(src, IsClass(_A("F<T1,T2,T3>")));
// Check if all relationships exist
REQUIRE_THAT(src,
IsConstraint(
_A("A<max_four_bytes T>"), _A("max_four_bytes<T>"), "T"));
REQUIRE_THAT(src,
IsConstraint(_A("D<iterable T1,T2,iterable T3,T4,T5>"),
_A("max_four_bytes<T>"), "T2"));
REQUIRE_THAT(src,
IsConstraint(_A("D<iterable T1,T2,iterable T3,T4,T5>"),
_A("max_four_bytes<T>"), "T5"));
REQUIRE_THAT(src,
IsConstraint(_A("D<iterable T1,T2,iterable T3,T4,T5>"),
_A("iterable<T>"), "T1"));
REQUIRE_THAT(src,
IsConstraint(_A("D<iterable T1,T2,iterable T3,T4,T5>"),
_A("iterable<T>"), "T3"));
REQUIRE_THAT(src,
IsConstraint(_A("iterable_with_value_type<T>"),
_A("has_value_type<T>"), "T"));
REQUIRE_THAT(src,
IsConstraint(_A("iterable_or_small_value_type<T>"),
_A("max_four_bytes<T>"), "T"));
REQUIRE_THAT(src,
IsConstraint(_A("iterable_or_small_value_type<T>"),
_A("iterable_with_value_type<T>"), "T"));
REQUIRE_THAT(src,
IsConstraint(_A("E<T1,T2,T3>"),
_A("greater_than_with_requires<T,P>"), "T1,T3"));
REQUIRE_THAT(src,
IsConstraint(
_A("F<T1,T2,T3>"), _A("greater_than_simple<T,L>"),
"T1,T3"));
save_mermaid(config.output_directory(), diagram->name + ".mmd",
src);
}*/
}

168
tests/t00057/test_case.h
View File

@@ -16,8 +16,10 @@
* limitations under the License.
*/
TEST_CASE("t00057", "[test-case][class]")
TEST_CASE("t00057")
{
using namespace clanguml::test;
auto [config, db] = load_config("t00057");
auto diagram = config.diagrams["t00057_class"];
@@ -28,86 +30,110 @@ TEST_CASE("t00057", "[test-case][class]")
REQUIRE(model->name() == "t00057_class");
{
auto src = generate_class_puml(diagram, *model);
AliasMatcher _A(src);
CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(IsClass(src, "t00057_A"));
REQUIRE(IsClass(src, "t00057_B"));
REQUIRE(IsClass(src, "t00057_C"));
REQUIRE(IsUnion(src, "t00057_D"));
REQUIRE(IsClass(src, "t00057_E"));
REQUIRE(IsClass(src, "t00057_F"));
REQUIRE(IsClass(src, "t00057_G"));
REQUIRE(!IsClass(src, "(anonymous)"));
REQUIRE(IsClass(src, "t00057_R"));
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
REQUIRE(IsAggregation<Public>(src, "t00057_R", "t00057_A", "a"));
REQUIRE(IsAggregation<Public>(src, "t00057_R", "t00057_B", "b"));
REQUIRE(IsAssociation<Public>(src, "t00057_R", "t00057_C", "c"));
REQUIRE(IsAggregation<Public>(src, "t00057_R", "t00057_D", "d"));
REQUIRE(IsAssociation<Public>(src, "t00057_R", "t00057_E", "e"));
REQUIRE(IsAssociation<Public>(src, "t00057_R", "t00057_F", "f"));
REQUIRE(IsAggregation<Public>(
src, "t00057_E", "t00057_E::(coordinates)", "coordinates"));
REQUIRE(IsAggregation<Public>(
src, "t00057_E", "t00057_E::(height)", "height"));
});
// Check if all classes exist
REQUIRE_THAT(src, IsClass(_A("t00057_A")));
REQUIRE_THAT(src, IsClass(_A("t00057_B")));
REQUIRE_THAT(src, IsClass(_A("t00057_C")));
REQUIRE_THAT(src, IsUnion(_A("t00057_D")));
REQUIRE_THAT(src, IsClass(_A("t00057_E")));
REQUIRE_THAT(src, IsClass(_A("t00057_F")));
REQUIRE_THAT(src, IsClass(_A("t00057_G")));
REQUIRE_THAT(src, !IsClass(_A("(anonymous)")));
REQUIRE_THAT(src, IsClass(_A("t00057_R")));
/*
{
auto src = generate_class_puml(diagram, *model);
AliasMatcher _A(src);
// Check if all relationships exist
REQUIRE_THAT(src, IsAggregation(_A("t00057_R"), _A("t00057_A"), "+a"));
REQUIRE_THAT(src, IsAggregation(_A("t00057_R"), _A("t00057_B"), "+b"));
REQUIRE_THAT(src, IsAssociation(_A("t00057_R"), _A("t00057_C"), "+c"));
REQUIRE_THAT(src, IsAggregation(_A("t00057_R"), _A("t00057_D"), "+d"));
REQUIRE_THAT(src, IsAssociation(_A("t00057_R"), _A("t00057_E"), "+e"));
REQUIRE_THAT(src, IsAssociation(_A("t00057_R"), _A("t00057_F"), "+f"));
REQUIRE_THAT(src,
IsAggregation(
_A("t00057_E"), _A("t00057_E::(coordinates)"), "+coordinates"));
REQUIRE_THAT(src,
IsAggregation(_A("t00057_E"), _A("t00057_E::(height)"), "+height"));
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
// Check if all classes exist
REQUIRE_THAT(src, IsClass(_A("t00057_A")));
REQUIRE_THAT(src, IsClass(_A("t00057_B")));
REQUIRE_THAT(src, IsClass(_A("t00057_C")));
REQUIRE_THAT(src, IsUnion(_A("t00057_D")));
REQUIRE_THAT(src, IsClass(_A("t00057_E")));
REQUIRE_THAT(src, IsClass(_A("t00057_F")));
REQUIRE_THAT(src, IsClass(_A("t00057_G")));
REQUIRE_THAT(src, !IsClass(_A("(anonymous)")));
REQUIRE_THAT(src, IsClass(_A("t00057_R")));
{
auto j = generate_class_json(diagram, *model);
// Check if all relationships exist
REQUIRE_THAT(src, IsAggregation(_A("t00057_R"), _A("t00057_A"),
"+a")); REQUIRE_THAT(src, IsAggregation(_A("t00057_R"), _A("t00057_B"),
"+b")); REQUIRE_THAT(src, IsAssociation(_A("t00057_R"), _A("t00057_C"),
"+c")); REQUIRE_THAT(src, IsAggregation(_A("t00057_R"), _A("t00057_D"),
"+d")); REQUIRE_THAT(src, IsAssociation(_A("t00057_R"), _A("t00057_E"),
"+e")); REQUIRE_THAT(src, IsAssociation(_A("t00057_R"), _A("t00057_F"),
"+f")); REQUIRE_THAT(src, IsAggregation( _A("t00057_E"),
_A("t00057_E::(coordinates)"), "+coordinates")); REQUIRE_THAT(src,
IsAggregation(_A("t00057_E"), _A("t00057_E::(height)"),
"+height"));
using namespace json;
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
REQUIRE(get_element(j, "t00057_A").value()["type"] == "class");
REQUIRE(get_element(j, "t00057_B").value()["type"] == "class");
REQUIRE(get_element(j, "t00057_C").value()["type"] == "class");
REQUIRE(get_element(j, "t00057_D").value()["type"] == "class");
REQUIRE(get_element(j, "t00057_E").value()["type"] == "class");
REQUIRE(get_element(j, "t00057_F").value()["type"] == "class");
REQUIRE(get_element(j, "t00057_G").value()["type"] == "class");
REQUIRE(get_element(j, "t00057_R").value()["type"] == "class");
{
auto j = generate_class_json(diagram, *model);
save_json(config.output_directory(), diagram->name + ".json", j);
}
{
auto src = generate_class_mermaid(diagram, *model);
using namespace json;
mermaid::AliasMatcher _A(src);
using mermaid::IsUnion;
REQUIRE(get_element(j, "t00057_A").value()["type"] == "class");
REQUIRE(get_element(j, "t00057_B").value()["type"] == "class");
REQUIRE(get_element(j, "t00057_C").value()["type"] == "class");
REQUIRE(get_element(j, "t00057_D").value()["type"] == "class");
REQUIRE(get_element(j, "t00057_E").value()["type"] == "class");
REQUIRE(get_element(j, "t00057_F").value()["type"] == "class");
REQUIRE(get_element(j, "t00057_G").value()["type"] == "class");
REQUIRE(get_element(j, "t00057_R").value()["type"] == "class");
// Check if all classes exist
REQUIRE_THAT(src, IsClass(_A("t00057_A")));
REQUIRE_THAT(src, IsClass(_A("t00057_B")));
REQUIRE_THAT(src, IsClass(_A("t00057_C")));
REQUIRE_THAT(src, IsUnion(_A("t00057_D")));
REQUIRE_THAT(src, IsClass(_A("t00057_E")));
REQUIRE_THAT(src, IsClass(_A("t00057_F")));
REQUIRE_THAT(src, IsClass(_A("t00057_G")));
REQUIRE_THAT(src, !IsClass(_A("(anonymous)")));
REQUIRE_THAT(src, IsClass(_A("t00057_R")));
save_json(config.output_directory(), diagram->name + ".json", j);
}
{
auto src = generate_class_mermaid(diagram, *model);
// Check if all relationships exist
REQUIRE_THAT(src, IsAggregation(_A("t00057_R"), _A("t00057_A"), "+a"));
REQUIRE_THAT(src, IsAggregation(_A("t00057_R"), _A("t00057_B"), "+b"));
REQUIRE_THAT(src, IsAssociation(_A("t00057_R"), _A("t00057_C"), "+c"));
REQUIRE_THAT(src, IsAggregation(_A("t00057_R"), _A("t00057_D"), "+d"));
REQUIRE_THAT(src, IsAssociation(_A("t00057_R"), _A("t00057_E"), "+e"));
REQUIRE_THAT(src, IsAssociation(_A("t00057_R"), _A("t00057_F"), "+f"));
REQUIRE_THAT(src,
IsAggregation(
_A("t00057_E"), _A("t00057_E::(coordinates)"), "+coordinates"));
REQUIRE_THAT(src,
IsAggregation(_A("t00057_E"), _A("t00057_E::(height)"), "+height"));
mermaid::AliasMatcher _A(src);
using mermaid::IsUnion;
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}
// Check if all classes exist
REQUIRE_THAT(src, IsClass(_A("t00057_A")));
REQUIRE_THAT(src, IsClass(_A("t00057_B")));
REQUIRE_THAT(src, IsClass(_A("t00057_C")));
REQUIRE_THAT(src, IsUnion(_A("t00057_D")));
REQUIRE_THAT(src, IsClass(_A("t00057_E")));
REQUIRE_THAT(src, IsClass(_A("t00057_F")));
REQUIRE_THAT(src, IsClass(_A("t00057_G")));
REQUIRE_THAT(src, !IsClass(_A("(anonymous)")));
REQUIRE_THAT(src, IsClass(_A("t00057_R")));
// Check if all relationships exist
REQUIRE_THAT(src, IsAggregation(_A("t00057_R"), _A("t00057_A"),
"+a")); REQUIRE_THAT(src, IsAggregation(_A("t00057_R"), _A("t00057_B"),
"+b")); REQUIRE_THAT(src, IsAssociation(_A("t00057_R"), _A("t00057_C"),
"+c")); REQUIRE_THAT(src, IsAggregation(_A("t00057_R"), _A("t00057_D"),
"+d")); REQUIRE_THAT(src, IsAssociation(_A("t00057_R"), _A("t00057_E"),
"+e")); REQUIRE_THAT(src, IsAssociation(_A("t00057_R"), _A("t00057_F"),
"+f")); REQUIRE_THAT(src, IsAggregation( _A("t00057_E"),
_A("t00057_E::(coordinates)"), "+coordinates")); REQUIRE_THAT(src,
IsAggregation(_A("t00057_E"), _A("t00057_E::(height)"),
"+height"));
save_mermaid(config.output_directory(), diagram->name + ".mmd",
src);
}
*/
}

3
tests/t00058/.clang-uml
View File

@@ -8,5 +8,8 @@ diagrams:
- clanguml::t00058
using_namespace: clanguml::t00058
plantuml:
after:
- '{{ alias("same_as_first_type<T,Args...>") }} ..> {{ alias("first_type<T,Args...>") }}'
mermaid:
after:
- '{{ alias("same_as_first_type<T,Args...>") }} ..> {{ alias("first_type<T,Args...>") }}'

182
tests/t00058/test_case.h
View File

@@ -16,8 +16,10 @@
* limitations under the License.
*/
TEST_CASE("t00058", "[test-case][class]")
TEST_CASE("t00058")
{
using namespace clanguml::test;
auto [config, db] = load_config("t00058");
auto diagram = config.diagrams["t00058_class"];
@@ -28,96 +30,134 @@ TEST_CASE("t00058", "[test-case][class]")
REQUIRE(model->name() == "t00058_class");
{
auto src = generate_class_puml(diagram, *model);
AliasMatcher _A(src);
CHECK_CLASS_DIAGRAM(
config, diagram, *model,
[](const auto &src) {
REQUIRE(IsClassTemplate(src, "A<int,int,double,std::string>"));
REQUIRE(IsClassTemplate(
src, "B<int,std::string,int,double,A<int,int>>"));
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
REQUIRE(IsConcept(src, "same_as_first_type<T,Args...>"));
REQUIRE_THAT(src, IsClassTemplate("A", "int,int,double,std::string"));
REQUIRE_THAT(
src, IsClassTemplate("B", "int,std::string,int,double,A<int,int>"));
REQUIRE(IsConstraint(src, "A<T,Args...>",
"same_as_first_type<T,Args...>", "T,Args..."));
REQUIRE_THAT(src, IsConcept(_A("same_as_first_type<T,Args...>")));
REQUIRE(IsConstraint(src, "B<T,P,Args...>",
"same_as_first_type<T,Args...>", "T,Args..."));
REQUIRE_THAT(src,
IsConstraint(_A("A<T,Args...>"),
_A("same_as_first_type<T,Args...>"), "T,Args..."));
REQUIRE(IsAggregation<Public>(
src, "R", "A<int,int,double,std::string>", "aa"));
REQUIRE(IsAggregation<Public>(
src, "R", "B<int,std::string,int,double,A<int,int>>", "bb"));
REQUIRE_THAT(src,
IsConstraint(_A("B<T,P,Args...>"),
_A("same_as_first_type<T,Args...>"), "T,Args..."));
REQUIRE(IsInstantiation(
src, "A<T,Args...>", "A<int,int,double,std::string>"));
REQUIRE(IsInstantiation(src, "B<T,P,Args...>",
"B<int,std::string,int,double,A<int,int>>"));
},
[](const plantuml_t &src) {
// TODO: This dependency has to be added manually in config file
// so it doesn't work in JSON
REQUIRE(IsDependency(
src, "same_as_first_type<T,Args...>", "first_type<T,Args...>"));
},
[](const mermaid_t &src) {
// TODO: This dependency has to be added manually in config file
// so it doesn't work in JSON
REQUIRE(IsDependency(
src, "same_as_first_type<T,Args...>", "first_type<T,Args...>"));
});
REQUIRE_THAT(src,
IsAggregation(_A("R"), _A("A<int,int,double,std::string>"), "+aa"));
REQUIRE_THAT(src,
IsAggregation(_A("R"),
_A("B<int,std::string,int,double,A<int,int>>"), "+bb"));
/*
{
auto src = generate_class_puml(diagram, *model);
AliasMatcher _A(src);
REQUIRE_THAT(src,
IsInstantiation(
_A("A<T,Args...>"), _A("A<int,int,double,std::string>")));
REQUIRE_THAT(src,
IsInstantiation(_A("B<T,P,Args...>"),
_A("B<int,std::string,int,double,A<int,int>>")));
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
REQUIRE_THAT(src,
IsDependency(_A("same_as_first_type<T,Args...>"),
_A("first_type<T,Args...>")));
REQUIRE_THAT(src, IsClassTemplate("A",
"int,int,double,std::string")); REQUIRE_THAT( src, IsClassTemplate("B",
"int,std::string,int,double,A<int,int>"));
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
REQUIRE_THAT(src, IsConcept(_A("same_as_first_type<T,Args...>")));
{
auto j = generate_class_json(diagram, *model);
REQUIRE_THAT(src,
IsConstraint(_A("A<T,Args...>"),
_A("same_as_first_type<T,Args...>"), "T,Args..."));
using namespace json;
REQUIRE_THAT(src,
IsConstraint(_A("B<T,P,Args...>"),
_A("same_as_first_type<T,Args...>"), "T,Args..."));
REQUIRE(IsClass(j, "A<int,int,double,std::string>"));
REQUIRE(IsClass(j, "B<int,std::string,int,double,A<int,int>>"));
REQUIRE_THAT(src,
IsAggregation(_A("R"), _A("A<int,int,double,std::string>"),
"+aa")); REQUIRE_THAT(src, IsAggregation(_A("R"),
_A("B<int,std::string,int,double,A<int,int>>"), "+bb"));
save_json(config.output_directory(), diagram->name + ".json", j);
}
{
auto src = generate_class_mermaid(diagram, *model);
REQUIRE_THAT(src,
IsInstantiation(
_A("A<T,Args...>"), _A("A<int,int,double,std::string>")));
REQUIRE_THAT(src,
IsInstantiation(_A("B<T,P,Args...>"),
_A("B<int,std::string,int,double,A<int,int>>")));
mermaid::AliasMatcher _A(src);
using mermaid::IsConcept;
using mermaid::IsConstraint;
REQUIRE_THAT(src,
IsDependency(_A("same_as_first_type<T,Args...>"),
_A("first_type<T,Args...>")));
REQUIRE_THAT(src, IsClass(_A("A<int,int,double,std::string>")));
REQUIRE_THAT(
src, IsClass(_A("B<int,std::string,int,double,A<int,int>>")));
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
REQUIRE_THAT(src, IsConcept(_A("same_as_first_type<T,Args...>")));
{
auto j = generate_class_json(diagram, *model);
REQUIRE_THAT(src,
IsConstraint(_A("A<T,Args...>"),
_A("same_as_first_type<T,Args...>"), "T,Args..."));
using namespace json;
REQUIRE_THAT(src,
IsConstraint(_A("B<T,P,Args...>"),
_A("same_as_first_type<T,Args...>"), "T,Args..."));
REQUIRE(IsClass(j, "A<int,int,double,std::string>"));
REQUIRE(IsClass(j, "B<int,std::string,int,double,A<int,int>>"));
REQUIRE_THAT(src,
IsAggregation(_A("R"), _A("A<int,int,double,std::string>"), "+aa"));
REQUIRE_THAT(src,
IsAggregation(_A("R"),
_A("B<int,std::string,int,double,A<int,int>>"), "+bb"));
save_json(config.output_directory(), diagram->name + ".json", j);
}
{
auto src = generate_class_mermaid(diagram, *model);
REQUIRE_THAT(src,
IsInstantiation(
_A("A<T,Args...>"), _A("A<int,int,double,std::string>")));
REQUIRE_THAT(src,
IsInstantiation(_A("B<T,P,Args...>"),
_A("B<int,std::string,int,double,A<int,int>>")));
mermaid::AliasMatcher _A(src);
using mermaid::IsConcept;
using mermaid::IsConstraint;
// TODO
// REQUIRE_THAT(src,
// IsDependency(_A("same_as_first_type<T,Args...>"),
// _A("first_type<T,Args...>")));
REQUIRE_THAT(src, IsClass(_A("A<int,int,double,std::string>")));
REQUIRE_THAT(
src, IsClass(_A("B<int,std::string,int,double,A<int,int>>")));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}
REQUIRE_THAT(src, IsConcept(_A("same_as_first_type<T,Args...>")));
REQUIRE_THAT(src,
IsConstraint(_A("A<T,Args...>"),
_A("same_as_first_type<T,Args...>"), "T,Args..."));
REQUIRE_THAT(src,
IsConstraint(_A("B<T,P,Args...>"),
_A("same_as_first_type<T,Args...>"), "T,Args..."));
REQUIRE_THAT(src,
IsAggregation(_A("R"), _A("A<int,int,double,std::string>"),
"+aa")); REQUIRE_THAT(src, IsAggregation(_A("R"),
_A("B<int,std::string,int,double,A<int,int>>"), "+bb"));
REQUIRE_THAT(src,
IsInstantiation(
_A("A<T,Args...>"), _A("A<int,int,double,std::string>")));
REQUIRE_THAT(src,
IsInstantiation(_A("B<T,P,Args...>"),
_A("B<int,std::string,int,double,A<int,int>>")));
// TODO
// REQUIRE_THAT(src,
// IsDependency(_A("same_as_first_type<T,Args...>"),
// _A("first_type<T,Args...>")));
save_mermaid(config.output_directory(), diagram->name + ".mmd",
src);
}*/
}

268
tests/t00059/test_case.h
View File

@@ -16,8 +16,10 @@
* limitations under the License.
*/
TEST_CASE("t00059", "[test-case][class]")
TEST_CASE("t00059")
{
using namespace clanguml::test;
auto [config, db] = load_config("t00059");
auto diagram = config.diagrams["t00059_class"];
@@ -28,138 +30,186 @@ TEST_CASE("t00059", "[test-case][class]")
REQUIRE(model->name() == "t00059_class");
{
auto src = generate_class_puml(diagram, *model);
AliasMatcher _A(src);
CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(IsConcept(src, "fruit_c<T>"));
REQUIRE(IsConcept(src, "apple_c<T>"));
REQUIRE(IsConcept(src, "orange_c<T>"));
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
REQUIRE(IsConstraint(src, "apple_c<T>", "fruit_c<T>", "T", "up"));
REQUIRE(IsConstraint(src, "orange_c<T>", "fruit_c<T>", "T", "up"));
REQUIRE_THAT(src, IsConcept(_A("fruit_c<T>")));
REQUIRE_THAT(src, IsConcept(_A("apple_c<T>")));
REQUIRE_THAT(src, IsConcept(_A("orange_c<T>")));
REQUIRE(IsConceptRequirement(src, "apple_c<T>", "t.get_sweetness()"));
REQUIRE(IsConceptRequirement(src, "apple_c<T>", "t.get_bitterness()"));
REQUIRE_THAT(
src, IsConstraint(_A("apple_c<T>"), _A("fruit_c<T>"), "T", "up"));
REQUIRE_THAT(
src, IsConstraint(_A("orange_c<T>"), _A("fruit_c<T>"), "T", "up"));
REQUIRE(IsClass(src, "gala_apple"));
REQUIRE(IsClass(src, "empire_apple"));
REQUIRE(IsClass(src, "valencia_orange"));
REQUIRE(IsClass(src, "lima_orange"));
REQUIRE(IsClass(src, "R"));
REQUIRE_THAT(
src, IsConceptRequirement(_A("apple_c<T>"), "t.get_sweetness()"));
REQUIRE_THAT(
src, IsConceptRequirement(_A("apple_c<T>"), "t.get_bitterness()"));
REQUIRE(IsClassTemplate(src, "fruit_factory<apple_c TA,orange_c TO>"));
REQUIRE_THAT(src, IsClass(_A("gala_apple")));
REQUIRE_THAT(src, IsClass(_A("empire_apple")));
REQUIRE_THAT(src, IsClass(_A("valencia_orange")));
REQUIRE_THAT(src, IsClass(_A("lima_orange")));
REQUIRE_THAT(src, IsClass(_A("R")));
REQUIRE(IsDependency(src, "fruit_factory<gala_apple,valencia_orange>",
"gala_apple", "up"));
REQUIRE(IsDependency(src, "fruit_factory<gala_apple,valencia_orange>",
"valencia_orange", "up"));
REQUIRE_THAT(
src, IsClassTemplate("fruit_factory", "apple_c TA,orange_c TO"));
REQUIRE(IsDependency(src, "fruit_factory<empire_apple,lima_orange>",
"empire_apple", "up"));
REQUIRE(IsDependency(src, "fruit_factory<empire_apple,lima_orange>",
"lima_orange", "up"));
REQUIRE_THAT(src,
IsDependency(_A("fruit_factory<gala_apple,valencia_orange>"),
_A("gala_apple"), "up"));
REQUIRE_THAT(src,
IsDependency(_A("fruit_factory<gala_apple,valencia_orange>"),
_A("valencia_orange"), "up"));
REQUIRE(IsAggregation<Public>(src, "R",
"fruit_factory<gala_apple,valencia_orange>", "factory_1", "", "",
"up"));
REQUIRE(IsAggregation<Public>(src, "R",
"fruit_factory<empire_apple,lima_orange>", "factory_2", "", "",
"up"));
REQUIRE_THAT(src,
IsDependency(_A("fruit_factory<empire_apple,lima_orange>"),
_A("empire_apple"), "up"));
REQUIRE_THAT(src,
IsDependency(_A("fruit_factory<empire_apple,lima_orange>"),
_A("lima_orange"), "up"));
REQUIRE(IsInstantiation(src, "fruit_factory<apple_c TA,orange_c TO>",
"fruit_factory<gala_apple,valencia_orange>", "up"));
REQUIRE(IsInstantiation(src, "fruit_factory<apple_c TA,orange_c TO>",
"fruit_factory<empire_apple,lima_orange>", "up"));
});
/*
REQUIRE_THAT(src,
IsAggregation(_A("R"),
_A("fruit_factory<gala_apple,valencia_orange>"), "+factory_1",
"", "", "up"));
REQUIRE_THAT(src,
IsAggregation(_A("R"),
_A("fruit_factory<empire_apple,lima_orange>"), "+factory_2", "",
"", "up"));
{
auto src = generate_class_puml(diagram, *model);
AliasMatcher _A(src);
REQUIRE_THAT(src,
IsInstantiation(_A("fruit_factory<apple_c TA,orange_c TO>"),
_A("fruit_factory<gala_apple,valencia_orange>"), "up"));
REQUIRE_THAT(src,
IsInstantiation(_A("fruit_factory<apple_c TA,orange_c TO>"),
_A("fruit_factory<empire_apple,lima_orange>"), "up"));
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
REQUIRE_THAT(src, IsConcept(_A("fruit_c<T>")));
REQUIRE_THAT(src, IsConcept(_A("apple_c<T>")));
REQUIRE_THAT(src, IsConcept(_A("orange_c<T>")));
{
auto j = generate_class_json(diagram, *model);
REQUIRE_THAT(
src, IsConstraint(_A("apple_c<T>"), _A("fruit_c<T>"), "T",
"up")); REQUIRE_THAT( src, IsConstraint(_A("orange_c<T>"),
_A("fruit_c<T>"), "T", "up"));
using namespace json;
REQUIRE_THAT(
src, IsConceptRequirement(_A("apple_c<T>"),
"t.get_sweetness()")); REQUIRE_THAT( src,
IsConceptRequirement(_A("apple_c<T>"), "t.get_bitterness()"));
REQUIRE(IsConcept(j, "fruit_c<T>"));
REQUIRE(IsConcept(j, "apple_c<T>"));
REQUIRE(IsConcept(j, "orange_c<T>"));
REQUIRE_THAT(src, IsClass(_A("gala_apple")));
REQUIRE_THAT(src, IsClass(_A("empire_apple")));
REQUIRE_THAT(src, IsClass(_A("valencia_orange")));
REQUIRE_THAT(src, IsClass(_A("lima_orange")));
REQUIRE_THAT(src, IsClass(_A("R")));
save_json(config.output_directory(), diagram->name + ".json", j);
}
{
auto src = generate_class_mermaid(diagram, *model);
REQUIRE_THAT(
src, IsClassTemplate("fruit_factory", "apple_c TA,orange_c
TO"));
mermaid::AliasMatcher _A(src);
using mermaid::IsConcept;
using mermaid::IsConceptRequirement;
using mermaid::IsConstraint;
REQUIRE_THAT(src,
IsDependency(_A("fruit_factory<gala_apple,valencia_orange>"),
_A("gala_apple"), "up"));
REQUIRE_THAT(src,
IsDependency(_A("fruit_factory<gala_apple,valencia_orange>"),
_A("valencia_orange"), "up"));
REQUIRE_THAT(src, IsConcept(_A("fruit_c<T>")));
REQUIRE_THAT(src, IsConcept(_A("apple_c<T>")));
REQUIRE_THAT(src, IsConcept(_A("orange_c<T>")));
REQUIRE_THAT(src,
IsDependency(_A("fruit_factory<empire_apple,lima_orange>"),
_A("empire_apple"), "up"));
REQUIRE_THAT(src,
IsDependency(_A("fruit_factory<empire_apple,lima_orange>"),
_A("lima_orange"), "up"));
REQUIRE_THAT(
src, IsConstraint(_A("apple_c<T>"), _A("fruit_c<T>"), "T"));
REQUIRE_THAT(
src, IsConstraint(_A("orange_c<T>"), _A("fruit_c<T>"), "T"));
REQUIRE_THAT(src,
IsAggregation(_A("R"),
_A("fruit_factory<gala_apple,valencia_orange>"),
"+factory_1",
"", "", "up"));
REQUIRE_THAT(src,
IsAggregation(_A("R"),
_A("fruit_factory<empire_apple,lima_orange>"), "+factory_2",
"",
"", "up"));
REQUIRE_THAT(
src, IsConceptRequirement(_A("apple_c<T>"), "t.get_sweetness()"));
REQUIRE_THAT(
src, IsConceptRequirement(_A("apple_c<T>"), "t.get_bitterness()"));
REQUIRE_THAT(src,
IsInstantiation(_A("fruit_factory<apple_c TA,orange_c TO>"),
_A("fruit_factory<gala_apple,valencia_orange>"), "up"));
REQUIRE_THAT(src,
IsInstantiation(_A("fruit_factory<apple_c TA,orange_c TO>"),
_A("fruit_factory<empire_apple,lima_orange>"), "up"));
REQUIRE_THAT(src, IsClass(_A("gala_apple")));
REQUIRE_THAT(src, IsClass(_A("empire_apple")));
REQUIRE_THAT(src, IsClass(_A("valencia_orange")));
REQUIRE_THAT(src, IsClass(_A("lima_orange")));
REQUIRE_THAT(src, IsClass(_A("R")));
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
REQUIRE_THAT(src, IsClass(_A("fruit_factory<apple_c TA,orange_c TO>")));
{
auto j = generate_class_json(diagram, *model);
REQUIRE_THAT(src,
IsDependency(_A("fruit_factory<gala_apple,valencia_orange>"),
_A("gala_apple")));
REQUIRE_THAT(src,
IsDependency(_A("fruit_factory<gala_apple,valencia_orange>"),
_A("valencia_orange")));
using namespace json;
REQUIRE_THAT(src,
IsDependency(_A("fruit_factory<empire_apple,lima_orange>"),
_A("empire_apple")));
REQUIRE_THAT(src,
IsDependency(_A("fruit_factory<empire_apple,lima_orange>"),
_A("lima_orange")));
REQUIRE(IsConcept(j, "fruit_c<T>"));
REQUIRE(IsConcept(j, "apple_c<T>"));
REQUIRE(IsConcept(j, "orange_c<T>"));
REQUIRE_THAT(src,
IsAggregation(_A("R"),
_A("fruit_factory<gala_apple,valencia_orange>"), "+factory_1"));
REQUIRE_THAT(src,
IsAggregation(_A("R"),
_A("fruit_factory<empire_apple,lima_orange>"), "+factory_2"));
save_json(config.output_directory(), diagram->name + ".json", j);
}
{
auto src = generate_class_mermaid(diagram, *model);
REQUIRE_THAT(src,
IsInstantiation(_A("fruit_factory<apple_c TA,orange_c TO>"),
_A("fruit_factory<gala_apple,valencia_orange>")));
REQUIRE_THAT(src,
IsInstantiation(_A("fruit_factory<apple_c TA,orange_c TO>"),
_A("fruit_factory<empire_apple,lima_orange>")));
mermaid::AliasMatcher _A(src);
using mermaid::IsConcept;
using mermaid::IsConceptRequirement;
using mermaid::IsConstraint;
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}
REQUIRE_THAT(src, IsConcept(_A("fruit_c<T>")));
REQUIRE_THAT(src, IsConcept(_A("apple_c<T>")));
REQUIRE_THAT(src, IsConcept(_A("orange_c<T>")));
REQUIRE_THAT(
src, IsConstraint(_A("apple_c<T>"), _A("fruit_c<T>"), "T"));
REQUIRE_THAT(
src, IsConstraint(_A("orange_c<T>"), _A("fruit_c<T>"), "T"));
REQUIRE_THAT(
src, IsConceptRequirement(_A("apple_c<T>"),
"t.get_sweetness()")); REQUIRE_THAT( src,
IsConceptRequirement(_A("apple_c<T>"), "t.get_bitterness()"));
REQUIRE_THAT(src, IsClass(_A("gala_apple")));
REQUIRE_THAT(src, IsClass(_A("empire_apple")));
REQUIRE_THAT(src, IsClass(_A("valencia_orange")));
REQUIRE_THAT(src, IsClass(_A("lima_orange")));
REQUIRE_THAT(src, IsClass(_A("R")));
REQUIRE_THAT(src, IsClass(_A("fruit_factory<apple_c TA,orange_c
TO>")));
REQUIRE_THAT(src,
IsDependency(_A("fruit_factory<gala_apple,valencia_orange>"),
_A("gala_apple")));
REQUIRE_THAT(src,
IsDependency(_A("fruit_factory<gala_apple,valencia_orange>"),
_A("valencia_orange")));
REQUIRE_THAT(src,
IsDependency(_A("fruit_factory<empire_apple,lima_orange>"),
_A("empire_apple")));
REQUIRE_THAT(src,
IsDependency(_A("fruit_factory<empire_apple,lima_orange>"),
_A("lima_orange")));
REQUIRE_THAT(src,
IsAggregation(_A("R"),
_A("fruit_factory<gala_apple,valencia_orange>"),
"+factory_1")); REQUIRE_THAT(src, IsAggregation(_A("R"),
_A("fruit_factory<empire_apple,lima_orange>"),
"+factory_2"));
REQUIRE_THAT(src,
IsInstantiation(_A("fruit_factory<apple_c TA,orange_c TO>"),
_A("fruit_factory<gala_apple,valencia_orange>")));
REQUIRE_THAT(src,
IsInstantiation(_A("fruit_factory<apple_c TA,orange_c TO>"),
_A("fruit_factory<empire_apple,lima_orange>")));
save_mermaid(config.output_directory(), diagram->name + ".mmd",
src);
}*/
}

103
tests/t00060/test_case.h
View File

@@ -16,8 +16,10 @@
* limitations under the License.
*/
TEST_CASE("t00060", "[test-case][class]")
TEST_CASE("t00060")
{
using namespace clanguml::test;
auto [config, db] = load_config("t00060");
auto diagram = config.diagrams["t00060_class"];
@@ -28,59 +30,72 @@ TEST_CASE("t00060", "[test-case][class]")
REQUIRE(model->name() == "t00060_class");
{
auto src = generate_class_puml(diagram, *model);
AliasMatcher _A(src);
CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(IsClass(src, "A"));
REQUIRE(IsClass(src, "B"));
REQUIRE(IsClass(src, "C"));
REQUIRE(IsClass(src, "D"));
REQUIRE(!IsClass(src, "E"));
REQUIRE(!IsClass(src, "F"));
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
REQUIRE(IsClassTemplate(src, "G<T>"));
REQUIRE(IsClassTemplate(src, "H<T,P>"));
});
/*
{
auto src = generate_class_puml(diagram, *model);
AliasMatcher _A(src);
// Check if all classes exist
REQUIRE_THAT(src, IsClass(_A("A")));
REQUIRE_THAT(src, IsClass(_A("B")));
REQUIRE_THAT(src, IsClass(_A("C")));
REQUIRE_THAT(src, IsClass(_A("D")));
REQUIRE_THAT(src, !IsClass(_A("E")));
REQUIRE_THAT(src, !IsClass(_A("F")));
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
// Check if class templates exist
REQUIRE_THAT(src, IsClassTemplate("G", "T"));
REQUIRE_THAT(src, IsClassTemplate("H", "T,P"));
// Check if all classes exist
REQUIRE_THAT(src, IsClass(_A("A")));
REQUIRE_THAT(src, IsClass(_A("B")));
REQUIRE_THAT(src, IsClass(_A("C")));
REQUIRE_THAT(src, IsClass(_A("D")));
REQUIRE_THAT(src, !IsClass(_A("E")));
REQUIRE_THAT(src, !IsClass(_A("F")));
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
// Check if class templates exist
REQUIRE_THAT(src, IsClassTemplate("G", "T"));
REQUIRE_THAT(src, IsClassTemplate("H", "T,P"));
{
auto j = generate_class_json(diagram, *model);
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
using namespace json;
{
auto j = generate_class_json(diagram, *model);
REQUIRE(IsClass(j, "A"));
REQUIRE(IsClass(j, "B"));
REQUIRE(IsClass(j, "C"));
REQUIRE(IsClass(j, "D"));
REQUIRE(!IsClass(j, "E"));
REQUIRE(!IsClass(j, "F"));
using namespace json;
save_json(config.output_directory(), diagram->name + ".json", j);
}
{
auto src = generate_class_mermaid(diagram, *model);
REQUIRE(IsClass(j, "A"));
REQUIRE(IsClass(j, "B"));
REQUIRE(IsClass(j, "C"));
REQUIRE(IsClass(j, "D"));
REQUIRE(!IsClass(j, "E"));
REQUIRE(!IsClass(j, "F"));
mermaid::AliasMatcher _A(src);
save_json(config.output_directory(), diagram->name + ".json", j);
}
{
auto src = generate_class_mermaid(diagram, *model);
// Check if all classes exist
REQUIRE_THAT(src, IsClass(_A("A")));
REQUIRE_THAT(src, IsClass(_A("B")));
REQUIRE_THAT(src, IsClass(_A("C")));
REQUIRE_THAT(src, IsClass(_A("D")));
REQUIRE_THAT(src, !IsClass(_A("E")));
REQUIRE_THAT(src, !IsClass(_A("F")));
mermaid::AliasMatcher _A(src);
// Check if class templates exist
REQUIRE_THAT(src, IsClass(_A("G<T>")));
REQUIRE_THAT(src, IsClass(_A("H<T,P>")));
// Check if all classes exist
REQUIRE_THAT(src, IsClass(_A("A")));
REQUIRE_THAT(src, IsClass(_A("B")));
REQUIRE_THAT(src, IsClass(_A("C")));
REQUIRE_THAT(src, IsClass(_A("D")));
REQUIRE_THAT(src, !IsClass(_A("E")));
REQUIRE_THAT(src, !IsClass(_A("F")));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}
// Check if class templates exist
REQUIRE_THAT(src, IsClass(_A("G<T>")));
REQUIRE_THAT(src, IsClass(_A("H<T,P>")));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}
*/
}

67
tests/t00061/test_case.h
View File

@@ -16,8 +16,10 @@
* limitations under the License.
*/
TEST_CASE("t00061", "[test-case][class]")
TEST_CASE("t00061")
{
using namespace clanguml::test;
auto [config, db] = load_config("t00061");
auto diagram = config.diagrams["t00061_class"];
@@ -28,42 +30,49 @@ TEST_CASE("t00061", "[test-case][class]")
REQUIRE(model->name() == "t00061_class");
{
auto src = generate_class_puml(diagram, *model);
AliasMatcher _A(src);
CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(IsClass(src, "A"));
REQUIRE(!IsClass(src, "B"));
REQUIRE(!IsClass(src, "C"));
});
/*
{
auto src = generate_class_puml(diagram, *model);
AliasMatcher _A(src);
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
// Check if all classes exist
REQUIRE_THAT(src, IsClass(_A("A")));
REQUIRE_THAT(src, !IsClass(_A("B")));
REQUIRE_THAT(src, !IsClass(_A("C")));
// Check if all classes exist
REQUIRE_THAT(src, IsClass(_A("A")));
REQUIRE_THAT(src, !IsClass(_A("B")));
REQUIRE_THAT(src, !IsClass(_A("C")));
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
{
auto j = generate_class_json(diagram, *model);
{
auto j = generate_class_json(diagram, *model);
using namespace json;
using namespace json;
REQUIRE(IsClass(j, "A"));
REQUIRE(!IsClass(j, "B"));
REQUIRE(!IsClass(j, "C"));
REQUIRE(IsClass(j, "A"));
REQUIRE(!IsClass(j, "B"));
REQUIRE(!IsClass(j, "C"));
save_json(config.output_directory(), diagram->name + ".json", j);
}
{
auto src = generate_class_mermaid(diagram, *model);
save_json(config.output_directory(), diagram->name + ".json", j);
}
{
auto src = generate_class_mermaid(diagram, *model);
mermaid::AliasMatcher _A(src);
mermaid::AliasMatcher _A(src);
// Check if all classes exist
REQUIRE_THAT(src, IsClass(_A("A")));
REQUIRE_THAT(src, !IsClass(_A("B")));
REQUIRE_THAT(src, !IsClass(_A("C")));
// Check if all classes exist
REQUIRE_THAT(src, IsClass(_A("A")));
REQUIRE_THAT(src, !IsClass(_A("B")));
REQUIRE_THAT(src, !IsClass(_A("C")));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}
*/
}

55
tests/t00062/test_case.h
View File

@@ -16,8 +16,10 @@
* limitations under the License.
*/
TEST_CASE("t00062", "[test-case][class]")
TEST_CASE("t00062")
{
using namespace clanguml::test;
auto [config, db] = load_config("t00062");
auto diagram = config.diagrams["t00062_class"];
@@ -28,6 +30,55 @@ TEST_CASE("t00062", "[test-case][class]")
REQUIRE(model->name() == "t00062_class");
CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(!src.contains("type-parameter-"));
REQUIRE(IsClassTemplate(src, "A<T>"));
REQUIRE(IsClassTemplate(src, "A<U &>"));
REQUIRE(IsClassTemplate(src, "A<U &&>"));
REQUIRE(IsClassTemplate(src, "A<U const&>"));
REQUIRE(IsClassTemplate(src, "A<M C::*>"));
REQUIRE(IsClassTemplate(src, "A<M C::* &&>"));
REQUIRE(IsClassTemplate(src, "A<M (C::*)(Arg)>"));
REQUIRE(IsClassTemplate(src, "A<int (C::*)(bool)>"));
REQUIRE(IsClassTemplate(src, "A<M (C::*)(Arg) &&>"));
REQUIRE(IsClassTemplate(src, "A<M (C::*)(Arg1,Arg2,Arg3)>"));
REQUIRE(IsClassTemplate(src, "A<float (C::*)(int) &&>"));
REQUIRE(IsClassTemplate(src, "A<char[N]>"));
REQUIRE(IsClassTemplate(src, "A<char[1000]>"));
REQUIRE(IsClassTemplate(src, "A<U(...)>"));
REQUIRE(IsClassTemplate(src, "A<C<T>>"));
REQUIRE(IsClassTemplate(src, "A<C<T,Args...>>"));
REQUIRE(IsField<Public>(src, "A<U &>", "u", "U &"));
REQUIRE(IsField<Public>(src, "A<U **>", "u", "U **"));
REQUIRE(IsField<Public>(src, "A<U ***>", "u", "U ***"));
REQUIRE(IsField<Public>(src, "A<U &&>", "u", "U &&"));
REQUIRE(IsField<Public>(src, "A<const U &>", "u", "const U &"));
REQUIRE(IsField<Public>(src, "A<C &>", "c", "C &"));
REQUIRE(IsField<Public>(src, "A<M C::*>", "m", "M C::*"));
REQUIRE(IsInstantiation(src, "A<T>", "A<U &>"));
REQUIRE(IsInstantiation(src, "A<T>", "A<U &&>"));
REQUIRE(IsInstantiation(src, "A<T>", "A<M C::*>"));
REQUIRE(IsInstantiation(src, "A<U &&>", "A<M C::* &&>"));
REQUIRE(IsInstantiation(src, "A<T>", "A<M (C::*)(Arg)>"));
REQUIRE(
IsInstantiation(src, "A<M (C::*)(Arg)>", "A<int (C::*)(bool)>"));
REQUIRE(IsInstantiation(src, "A<T>", "A<char[N]>"));
REQUIRE(IsInstantiation(src, "A<char[N]>", "A<char[1000]>"));
REQUIRE(IsInstantiation(src, "A<T>", "A<U(...)>"));
REQUIRE(IsInstantiation(src, "A<T>", "A<U(...)>"));
REQUIRE(IsInstantiation(src, "A<T>", "A<C<T>>"));
REQUIRE(IsInstantiation(src, "A<T>", "A<C<T,Args...>>"));
});
/*
{
auto src = generate_class_puml(diagram, *model);
AliasMatcher _A(src);
@@ -148,5 +199,5 @@ TEST_CASE("t00062", "[test-case][class]")
REQUIRE_THAT(src, IsInstantiation(_A("A<T>"), _A("A<C<T,Args...>>")));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}
}*/
}

66
tests/t00063/test_case.h
View File

@@ -16,8 +16,10 @@
* limitations under the License.
*/
TEST_CASE("t00063", "[test-case][class]")
TEST_CASE("t00063")
{
using namespace clanguml::test;
auto [config, db] = load_config("t00063");
auto diagram = config.diagrams["t00063_class"];
@@ -28,41 +30,49 @@ TEST_CASE("t00063", "[test-case][class]")
REQUIRE(model->name() == "t00063_class");
{
auto src = generate_class_puml(diagram, *model);
AliasMatcher _A(src);
CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(IsClass(src, "A"));
REQUIRE(!IsEnum(src, "B"));
REQUIRE(!IsEnum(src, "C"));
});
/*
{
auto src = generate_class_puml(diagram, *model);
AliasMatcher _A(src);
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
REQUIRE_THAT(src, IsClass(_A("A")));
REQUIRE_THAT(src, !IsEnum(_A("B")));
REQUIRE_THAT(src, !IsEnum(_A("C")));
REQUIRE_THAT(src, IsClass(_A("A")));
REQUIRE_THAT(src, !IsEnum(_A("B")));
REQUIRE_THAT(src, !IsEnum(_A("C")));
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
{
auto j = generate_class_json(diagram, *model);
{
auto j = generate_class_json(diagram, *model);
using namespace json;
using namespace json;
REQUIRE(IsClass(j, "A"));
REQUIRE(!IsEnum(j, "B"));
REQUIRE(!IsEnum(j, "C"));
REQUIRE(IsClass(j, "A"));
REQUIRE(!IsEnum(j, "B"));
REQUIRE(!IsEnum(j, "C"));
save_json(config.output_directory(), diagram->name + ".json", j);
}
{
auto src = generate_class_mermaid(diagram, *model);
save_json(config.output_directory(), diagram->name + ".json", j);
}
{
auto src = generate_class_mermaid(diagram, *model);
mermaid::AliasMatcher _A(src);
using mermaid::IsEnum;
mermaid::AliasMatcher _A(src);
using mermaid::IsEnum;
REQUIRE_THAT(src, IsClass(_A("A")));
REQUIRE_THAT(src, !IsEnum(_A("B")));
REQUIRE_THAT(src, !IsEnum(_A("C")));
REQUIRE_THAT(src, IsClass(_A("A")));
REQUIRE_THAT(src, !IsEnum(_A("B")));
REQUIRE_THAT(src, !IsEnum(_A("C")));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}
save_mermaid(config.output_directory(), diagram->name + ".mmd",
src);
}
*/
}

44
tests/t00064/test_case.h
View File

@@ -16,8 +16,10 @@
* limitations under the License.
*/
TEST_CASE("t00064", "[test-case][class]")
TEST_CASE("t00064")
{
using namespace clanguml::test;
auto [config, db] = load_config("t00064");
auto diagram = config.diagrams["t00064_class"];
@@ -28,6 +30,45 @@ TEST_CASE("t00064", "[test-case][class]")
REQUIRE(model->name() == "t00064_class");
CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(!src.contains("type-parameter-"));
REQUIRE(IsClass(src, "A"));
REQUIRE(IsClass(src, "B"));
REQUIRE(IsClass(src, "C"));
REQUIRE(IsClass(src, "R"));
REQUIRE(IsClassTemplate(src, "type_list<Ts...>"));
REQUIRE(IsClassTemplate(src, "type_list<Ret(Arg &&),Ts...>"));
REQUIRE(IsClassTemplate(src, "type_list<T const,Ts...>"));
REQUIRE(IsClassTemplate(src, "head<typename>"));
REQUIRE(IsClassTemplate(src, "head<type_list<Head,Tail...>>"));
REQUIRE(IsClassTemplate(src, "type_group_pair<typename,typename>"));
REQUIRE(IsClassTemplate(
src, "type_group_pair<type_list<First...>,type_list<Second...>>"));
REQUIRE(IsClassTemplate(
src, "type_group_pair<type_list<float,double>,type_list<A,B,C>>"));
REQUIRE(IsClassTemplate(src, "optional_ref<T>"));
REQUIRE(IsClassTemplate(src,
"type_group_pair_it<It,type_list<First...>,type_list<Second...>>"));
REQUIRE(IsMethod<Public>(src, "get", "ref_t", "unsigned int i"));
#if LLVM_VERSION_MAJOR < 16
REQUIRE(IsMethod<Public>(
src, "getp", "value_type const*", "unsigned int i"));
REQUIRE(IsMethod<Public, Constexpr>(
src, "find", "unsigned int", "value_type const& v"));
#else
REQUIRE(
IsMethod<Public>(src, "getp", "const value_type *", "unsigned int i"));
REQUIRE(
IsMethod<Public, Constexpr>(src,
"find", "unsigned int", "const value_type & v"));
#endif
});
/*
{
auto src = generate_class_puml(diagram, *model);
AliasMatcher _A(src);
@@ -137,4 +178,5 @@ TEST_CASE("t00064", "[test-case][class]")
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}
*/
}

86
tests/t00065/test_case.h
View File

@@ -16,8 +16,10 @@
* limitations under the License.
*/
TEST_CASE("t00065", "[test-case][class]")
TEST_CASE("t00065")
{
using namespace clanguml::test;
auto [config, db] = load_config("t00065");
auto diagram = config.diagrams["t00065_class"];
@@ -28,48 +30,62 @@ TEST_CASE("t00065", "[test-case][class]")
REQUIRE(model->name() == "t00065_class");
{
auto src = generate_class_puml(diagram, *model);
AliasMatcher _A(src);
CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(IsClass(src, "R"));
REQUIRE(IsClass(src, "A"));
REQUIRE(IsClass(src, {"detail", "AImpl"}));
REQUIRE(IsEnum(src, "XYZ"));
REQUIRE(IsEnum(src, "ABC"));
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
REQUIRE(IsPackage("module1"));
REQUIRE(IsPackage("module2"));
REQUIRE(IsPackage("submodule1a"));
REQUIRE(IsPackage("concepts"));
});
/*
{
auto src = generate_class_puml(diagram, *model);
AliasMatcher _A(src);
// Check if all classes exist
REQUIRE_THAT(src, IsClass(_A("R")));
REQUIRE_THAT(src, IsClass(_A("A")));
REQUIRE_THAT(src, IsClass(_A("detail::AImpl")));
REQUIRE_THAT(src, IsEnum(_A("XYZ")));
REQUIRE_THAT(src, IsEnum(_A("ABC")));
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
REQUIRE_THAT(src, IsPackage("module1"));
REQUIRE_THAT(src, IsPackage("module2"));
REQUIRE_THAT(src, IsPackage("submodule1a"));
REQUIRE_THAT(src, IsPackage("concepts"));
// Check if all classes exist
REQUIRE_THAT(src, IsClass(_A("R")));
REQUIRE_THAT(src, IsClass(_A("A")));
REQUIRE_THAT(src, IsClass(_A("detail::AImpl")));
REQUIRE_THAT(src, IsEnum(_A("XYZ")));
REQUIRE_THAT(src, IsEnum(_A("ABC")));
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
REQUIRE_THAT(src, IsPackage("module1"));
REQUIRE_THAT(src, IsPackage("module2"));
REQUIRE_THAT(src, IsPackage("submodule1a"));
REQUIRE_THAT(src, IsPackage("concepts"));
{
auto j = generate_class_json(diagram, *model);
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
using namespace json;
{
auto j = generate_class_json(diagram, *model);
save_json(config.output_directory(), diagram->name + ".json", j);
}
{
auto src = generate_class_mermaid(diagram, *model);
using namespace json;
mermaid::AliasMatcher _A(src);
using mermaid::IsEnum;
save_json(config.output_directory(), diagram->name + ".json", j);
}
{
auto src = generate_class_mermaid(diagram, *model);
// Check if all classes exist
REQUIRE_THAT(src, IsClass(_A("R")));
REQUIRE_THAT(src, IsClass(_A("A")));
REQUIRE_THAT(src, IsClass(_A("detail::AImpl")));
REQUIRE_THAT(src, IsEnum(_A("XYZ")));
REQUIRE_THAT(src, IsEnum(_A("ABC")));
mermaid::AliasMatcher _A(src);
using mermaid::IsEnum;
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}
// Check if all classes exist
REQUIRE_THAT(src, IsClass(_A("R")));
REQUIRE_THAT(src, IsClass(_A("A")));
REQUIRE_THAT(src, IsClass(_A("detail::AImpl")));
REQUIRE_THAT(src, IsEnum(_A("XYZ")));
REQUIRE_THAT(src, IsEnum(_A("ABC")));
save_mermaid(config.output_directory(), diagram->name + ".mmd",
src);
}*/
}

180
tests/t00066/test_case.h
View File

@@ -16,8 +16,10 @@
* limitations under the License.
*/
TEST_CASE("t00066", "[test-case][class]")
TEST_CASE("t00066")
{
using namespace clanguml::test;
auto [config, db] = load_config("t00066");
auto diagram = config.diagrams["t00066_class"];
@@ -28,98 +30,132 @@ TEST_CASE("t00066", "[test-case][class]")
REQUIRE(model->name() == "t00066_class");
{
auto src = generate_class_puml(diagram, *model);
AliasMatcher _A(src);
CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(IsClass(src, "A"));
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
REQUIRE(!IsDependency(src, "A", "A"));
REQUIRE_THAT(src, IsClass(_A("A")));
REQUIRE(IsMethod<Public, Default>(src,"A")));
REQUIRE(IsMethod<Public, Default>(src, "A", "void", "A &&"));
REQUIRE(IsMethod<Public, Deleted>(src, "A", "void", "const A &"));
REQUIRE_THAT(src, !IsDependency(_A("A"), _A("A")));
REQUIRE(IsMethod<Public, Default>(src, "~A"));
REQUIRE_THAT(src, (IsMethod<Public, Default>("A")));
REQUIRE_THAT(src, (IsMethod<Public, Default>("A", "void", "A &&")));
REQUIRE_THAT(
src, (IsMethod<Public, Deleted>("A", "void", "const A &")));
REQUIRE(IsMethod<Public>(src,"basic_method")));
REQUIRE(IsMethod<Public, Static>(src,"static_method", "int")));
REQUIRE(IsMethod<Public, Const>(src,"const_method")));
REQUIRE(IsMethod<Public>(src,"default_int", "int", "int i = 12")));
REQUIRE(IsMethod<Public>(src, "default_string", "std::string",
"int i, std::string s = \"abc\""));
REQUIRE_THAT(src, (IsMethod<Public, Default>("~A")));
REQUIRE(IsMethod<Public, Const>(src, "size", "std::size_t"));
REQUIRE_THAT(src, (IsMethod<Public>("basic_method")));
REQUIRE_THAT(src, (IsMethod<Public, Static>("static_method", "int")));
REQUIRE_THAT(src, (IsMethod<Public, Const>("const_method")));
REQUIRE_THAT(
src, (IsMethod<Public>("default_int", "int", "int i = 12")));
REQUIRE_THAT(src,
(IsMethod<Public>("default_string", "std::string",
"int i, std::string s = \"abc\"")));
REQUIRE(IsMethod<Protected>(src, "protected_method"));
REQUIRE(IsMethod<Private>(src, "private_method"));
REQUIRE(IsField<Public>(src, "public_member", "int"));
REQUIRE(IsField<Protected>(src, "protected_member", "int"));
REQUIRE(IsField<Private>(src, "private_member", "int"));
REQUIRE(
(IsField<Public, Static>(src,"auto_member", "const unsigned long"));
REQUIRE_THAT(src, (IsMethod<Public, Const>("size", "std::size_t")));
REQUIRE(IsField<Private>(src,"a_", "int"));
REQUIRE(IsField<Private>(src,"b_", "int"));
REQUIRE(IsField<Private>(src,"c_", "int"));
});
REQUIRE_THAT(src, (IsMethod<Protected>("protected_method")));
REQUIRE_THAT(src, (IsMethod<Private>("private_method")));
REQUIRE_THAT(src, (IsField<Public>("public_member", "int")));
REQUIRE_THAT(src, (IsField<Protected>("protected_member", "int")));
REQUIRE_THAT(src, (IsField<Private>("private_member", "int")));
REQUIRE_THAT(src,
(IsField<Public, Static>("auto_member", "const unsigned long")));
/*
{
auto src = generate_class_puml(diagram, *model);
AliasMatcher _A(src);
REQUIRE_THAT(src, (IsField<Private>("a_", "int")));
REQUIRE_THAT(src, (IsField<Private>("b_", "int")));
REQUIRE_THAT(src, (IsField<Private>("c_", "int")));
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
REQUIRE_THAT(src, IsClass(_A("A")));
{
auto j = generate_class_json(diagram, *model);
REQUIRE_THAT(src, !IsDependency(_A("A"), _A("A")));
using namespace json;
REQUIRE_THAT(src, (IsMethod<Public, Default>("A")));
REQUIRE_THAT(src, (IsMethod<Public, Default>("A", "void", "A &&")));
REQUIRE_THAT(
src, (IsMethod<Public, Deleted>("A", "void", "const A &")));
save_json(config.output_directory(), diagram->name + ".json", j);
}
{
auto src = generate_class_mermaid(diagram, *model);
REQUIRE_THAT(src, (IsMethod<Public, Default>("~A")));
mermaid::AliasMatcher _A(src);
using mermaid::IsField;
using mermaid::IsMethod;
REQUIRE_THAT(src, (IsMethod<Public>("basic_method")));
REQUIRE_THAT(src, (IsMethod<Public, Static>("static_method", "int")));
REQUIRE_THAT(src, (IsMethod<Public, Const>("const_method")));
REQUIRE_THAT(
src, (IsMethod<Public>("default_int", "int", "int i = 12")));
REQUIRE_THAT(src,
(IsMethod<Public>("default_string", "std::string",
"int i, std::string s = \"abc\"")));
REQUIRE_THAT(src, IsClass(_A("A")));
REQUIRE_THAT(src, (IsMethod<Public, Const>("size", "std::size_t")));
REQUIRE_THAT(src, !IsDependency(_A("A"), _A("A")));
REQUIRE_THAT(src, (IsMethod<Protected>("protected_method")));
REQUIRE_THAT(src, (IsMethod<Private>("private_method")));
REQUIRE_THAT(src, (IsField<Public>("public_member", "int")));
REQUIRE_THAT(src, (IsField<Protected>("protected_member", "int")));
REQUIRE_THAT(src, (IsField<Private>("private_member", "int")));
REQUIRE_THAT(src,
(IsField<Public, Static>("auto_member", "const unsigned long")));
REQUIRE_THAT(src, (IsMethod<Public, Default>("A")));
REQUIRE_THAT(src, (IsMethod<Public, Default>("A", "void", "A &&")));
REQUIRE_THAT(
src, (IsMethod<Public, Deleted>("A", "void", "const A &")));
REQUIRE_THAT(src, (IsField<Private>("a_", "int")));
REQUIRE_THAT(src, (IsField<Private>("b_", "int")));
REQUIRE_THAT(src, (IsField<Private>("c_", "int")));
REQUIRE_THAT(src, (IsMethod<Public, Default>("~A")));
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
REQUIRE_THAT(src, (IsMethod<Public>("basic_method")));
REQUIRE_THAT(src, (IsMethod<Public, Static>("static_method", "int")));
REQUIRE_THAT(src, (IsMethod<Public, Const>("const_method")));
REQUIRE_THAT(
src, (IsMethod<Public>("default_int", "int", "int i = 12")));
REQUIRE_THAT(src,
(IsMethod<Public>("default_string", "std::string",
"int i, std::string s = \"abc\"")));
{
auto j = generate_class_json(diagram, *model);
REQUIRE_THAT(src, (IsMethod<Public, Const>("size", "std::size_t")));
using namespace json;
REQUIRE_THAT(src, (IsMethod<Protected>("protected_method")));
REQUIRE_THAT(src, (IsMethod<Private>("private_method")));
REQUIRE_THAT(src, (IsField<Public>("public_member", "int")));
REQUIRE_THAT(src, (IsField<Protected>("protected_member", "int")));
REQUIRE_THAT(src, (IsField<Private>("private_member", "int")));
REQUIRE_THAT(src,
(IsField<Public, Static>("auto_member", "const unsigned long")));
save_json(config.output_directory(), diagram->name + ".json", j);
}
{
auto src = generate_class_mermaid(diagram, *model);
REQUIRE_THAT(src, (IsField<Private>("a_", "int")));
REQUIRE_THAT(src, (IsField<Private>("b_", "int")));
REQUIRE_THAT(src, (IsField<Private>("c_", "int")));
mermaid::AliasMatcher _A(src);
using mermaid::IsField;
using mermaid::IsMethod;
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}
REQUIRE_THAT(src, IsClass(_A("A")));
REQUIRE_THAT(src, !IsDependency(_A("A"), _A("A")));
REQUIRE_THAT(src, (IsMethod<Public, Default>("A")));
REQUIRE_THAT(src, (IsMethod<Public, Default>("A", "void", "A &&")));
REQUIRE_THAT(
src, (IsMethod<Public, Deleted>("A", "void", "const A &")));
REQUIRE_THAT(src, (IsMethod<Public, Default>("~A")));
REQUIRE_THAT(src, (IsMethod<Public>("basic_method")));
REQUIRE_THAT(src, (IsMethod<Public, Static>("static_method", "int")));
REQUIRE_THAT(src, (IsMethod<Public, Const>("const_method")));
REQUIRE_THAT(
src, (IsMethod<Public>("default_int", "int", "int i = 12")));
REQUIRE_THAT(src,
(IsMethod<Public>("default_string", "std::string",
"int i, std::string s = \"abc\"")));
REQUIRE_THAT(src, (IsMethod<Public, Const>("size", "std::size_t")));
REQUIRE_THAT(src, (IsMethod<Protected>("protected_method")));
REQUIRE_THAT(src, (IsMethod<Private>("private_method")));
REQUIRE_THAT(src, (IsField<Public>("public_member", "int")));
REQUIRE_THAT(src, (IsField<Protected>("protected_member", "int")));
REQUIRE_THAT(src, (IsField<Private>("private_member", "int")));
REQUIRE_THAT(src,
(IsField<Public, Static>("auto_member", "const unsigned long")));
REQUIRE_THAT(src, (IsField<Private>("a_", "int")));
REQUIRE_THAT(src, (IsField<Private>("b_", "int")));
REQUIRE_THAT(src, (IsField<Private>("c_", "int")));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}*/
}

16
tests/t00067/test_case.h
View File

@@ -16,8 +16,10 @@
* limitations under the License.
*/
TEST_CASE("t00067", "[test-case][class]")
TEST_CASE("t00067")
{
using namespace clanguml::test;
auto [config, db] = load_config("t00067");
auto diagram = config.diagrams["t00067_class"];
@@ -28,6 +30,16 @@ TEST_CASE("t00067", "[test-case][class]")
REQUIRE(model->name() == "t00067_class");
CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(!(IsMethod<Public, Default>(src, "A")));
REQUIRE(!(IsMethod<Public, Default>(src, "A", "void", "A &&")));
REQUIRE(!(IsMethod<Public, Deleted>(src, "A", "void", "const A &")));
REQUIRE(!(IsMethod<Public, Default>(src, "~A")));
REQUIRE(!(IsMethod<Public, Default>(src, "~A")));
});
/*
{
auto src = generate_class_puml(diagram, *model);
AliasMatcher _A(src);
@@ -71,5 +83,5 @@ TEST_CASE("t00067", "[test-case][class]")
REQUIRE_THAT(src, !(IsMethod<Public, Default>("~A")));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}
}*/
}

176
tests/t00068/test_case.h
View File

@@ -16,8 +16,10 @@
* limitations under the License.
*/
TEST_CASE("t00068_r0", "[test-case][class][t00068]")
TEST_CASE("t00068_r0")
{
using namespace clanguml::test;
auto [config, db] = load_config("t00068");
auto diagram = config.diagrams["t00068_r0_class"];
@@ -26,61 +28,25 @@ TEST_CASE("t00068_r0", "[test-case][class][t00068]")
REQUIRE(model->name() == "t00068_r0_class");
{
auto src = generate_class_puml(diagram, *model);
AliasMatcher _A(src);
CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(!IsClass(src, "A"));
REQUIRE(!IsClass(src, "AA"));
REQUIRE(IsClass(src, "AAA"));
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
REQUIRE(!IsClass(src, "B"));
REQUIRE(!IsClass(src, "BB"));
REQUIRE_THAT(src, !IsClass(_A("A")));
REQUIRE_THAT(src, !IsClass(_A("AA")));
REQUIRE_THAT(src, IsClass(_A("AAA")));
REQUIRE(!IsClass(src, "R"));
REQUIRE(!IsClass(src, "RR"));
REQUIRE_THAT(src, !IsClass(_A("B")));
REQUIRE_THAT(src, !IsClass(_A("BB")));
REQUIRE_THAT(src, !IsClass(_A("R")));
REQUIRE_THAT(src, !IsClass(_A("RR")));
REQUIRE_THAT(src, !IsEnum(_A("AKind")));
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
{
auto j = generate_class_json(diagram, *model);
using namespace json;
save_json(config.output_directory(), diagram->name + ".json", j);
}
{
auto src = generate_class_mermaid(diagram, *model);
mermaid::AliasMatcher _A(src);
using mermaid::IsClass;
using mermaid::IsEnum;
REQUIRE_THAT(src, !IsClass(_A("A")));
REQUIRE_THAT(src, !IsClass(_A("AA")));
REQUIRE_THAT(src, IsClass(_A("AAA")));
REQUIRE_THAT(src, !IsClass(_A("B")));
REQUIRE_THAT(src, !IsClass(_A("BB")));
REQUIRE_THAT(src, !IsClass(_A("R")));
REQUIRE_THAT(src, !IsClass(_A("RR")));
REQUIRE_THAT(src, !IsEnum(_A("AKind")));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}
REQUIRE(!IsEnum(src, "AKind"));
});
}
TEST_CASE("t00068_r1", "[test-case][class][t00068]")
TEST_CASE("t00068_r1")
{
using namespace clanguml::test;
auto [config, db] = load_config("t00068");
auto diagram = config.diagrams["t00068_r1_class"];
@@ -88,53 +54,25 @@ TEST_CASE("t00068_r1", "[test-case][class][t00068]")
auto model = generate_class_diagram(*db, diagram);
REQUIRE(model->name() == "t00068_r1_class");
CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(!IsClass(src, "A"));
REQUIRE(IsClass(src, "AA"));
REQUIRE(IsClass(src, "AAA"));
{
auto src = generate_class_puml(diagram, *model);
AliasMatcher _A(src);
REQUIRE(!IsClass(src, "B"));
REQUIRE(IsClass(src, "BB"));
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
REQUIRE(IsClass(src, "R"));
REQUIRE(!IsClass(src, "RR"));
REQUIRE_THAT(src, !IsClass(_A("A")));
REQUIRE_THAT(src, IsClass(_A("AA")));
REQUIRE_THAT(src, IsClass(_A("AAA")));
REQUIRE_THAT(src, !IsClass(_A("B")));
REQUIRE_THAT(src, IsClass(_A("BB")));
REQUIRE_THAT(src, IsClass(_A("R")));
REQUIRE_THAT(src, !IsClass(_A("RR")));
REQUIRE_THAT(src, IsEnum(_A("AKind")));
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
{
auto j = generate_class_json(diagram, *model);
using namespace json;
save_json(config.output_directory(), diagram->name + ".json", j);
}
{
auto src = generate_class_mermaid(diagram, *model);
mermaid::AliasMatcher _A(src);
using mermaid::IsClass;
REQUIRE_THAT(src, !IsClass(_A("A")));
REQUIRE_THAT(src, IsClass(_A("AA")));
REQUIRE_THAT(src, IsClass(_A("AAA")));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}
REQUIRE(IsEnum(src, "AKind"));
});
}
TEST_CASE("t00068_r2", "[test-case][class][t00068]")
TEST_CASE("t00068_r2")
{
using namespace clanguml::test;
auto [config, db] = load_config("t00068");
auto diagram = config.diagrams["t00068_r2_class"];
@@ -143,53 +81,17 @@ TEST_CASE("t00068_r2", "[test-case][class][t00068]")
REQUIRE(model->name() == "t00068_r2_class");
{
auto src = generate_class_puml(diagram, *model);
AliasMatcher _A(src);
CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(IsClass(src, "A"));
REQUIRE(IsClass(src, "AA"));
REQUIRE(IsClass(src, "AAA"));
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
REQUIRE(IsClass(src, "B"));
REQUIRE(IsClass(src, "BB"));
REQUIRE_THAT(src, IsClass(_A("A")));
REQUIRE_THAT(src, IsClass(_A("AA")));
REQUIRE_THAT(src, IsClass(_A("AAA")));
REQUIRE(IsClass(src, "R"));
REQUIRE(IsClass(src, "RR"));
REQUIRE_THAT(src, IsClass(_A("B")));
REQUIRE_THAT(src, IsClass(_A("BB")));
REQUIRE_THAT(src, IsClass(_A("R")));
REQUIRE_THAT(src, IsClass(_A("RR")));
REQUIRE_THAT(src, IsEnum(_A("AKind")));
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
{
auto j = generate_class_json(diagram, *model);
using namespace json;
save_json(config.output_directory(), diagram->name + ".json", j);
}
{
auto src = generate_class_mermaid(diagram, *model);
mermaid::AliasMatcher _A(src);
using mermaid::IsClass;
using mermaid::IsEnum;
REQUIRE_THAT(src, IsClass(_A("A")));
REQUIRE_THAT(src, IsClass(_A("AA")));
REQUIRE_THAT(src, IsClass(_A("AAA")));
REQUIRE_THAT(src, IsClass(_A("B")));
REQUIRE_THAT(src, IsClass(_A("BB")));
REQUIRE_THAT(src, IsClass(_A("R")));
REQUIRE_THAT(src, IsClass(_A("RR")));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}
REQUIRE(IsEnum(src, "AKind"));
});
}

112
tests/t00069/test_case.h
View File

@@ -16,8 +16,10 @@
* limitations under the License.
*/
TEST_CASE("t00069", "[test-case][class]")
TEST_CASE("t00069")
{
using namespace clanguml::test;
auto [config, db] = load_config("t00069");
auto diagram = config.diagrams["t00069_class"];
@@ -28,60 +30,82 @@ TEST_CASE("t00069", "[test-case][class]")
REQUIRE(model->name() == "t00069_class");
{
auto src = generate_class_puml(diagram, *model);
AliasMatcher _A(src);
CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(IsClass(src, "A"));
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
REQUIRE(IsClassTemplate(src, "generator", "T"));
// Check if all classes exist
REQUIRE_THAT(src, IsClass(_A("A")));
REQUIRE(
IsInnerClass(src,("generator<T>", "generator::promise_type"));
// Check if class templates exist
REQUIRE_THAT(src, IsClassTemplate("generator", "T"));
REQUIRE(
IsMethod<Public, Coroutine>(src,"iota", "generator<unsigned long>"));
REQUIRE(
IsMethod<Public, Coroutine>(src,"seed", "generator<unsigned long>"));
// Check if all inner classes exist
REQUIRE_THAT(src,
IsInnerClass(_A("generator<T>"), _A("generator::promise_type")));
// Check if all methods exist
REQUIRE_THAT(src,
(IsMethod<Public, Coroutine>("iota", "generator<unsigned long>")));
REQUIRE_THAT(src,
(IsMethod<Public, Coroutine>("seed", "generator<unsigned long>")));
// Check if all relationships exist
REQUIRE_THAT(
src, IsDependency(_A("A"), _A("generator<unsigned long>")));
REQUIRE_THAT(src,
REQUIRE(
IsDependency(src,"A", "generator<unsigned long>"));
REQUIRE(
IsInstantiation(
_A("generator<T>"), _A("generator<unsigned long>")));
src,"generator<T>", "generator<unsigned long>"));
});
/*
{
auto src = generate_class_puml(diagram, *model);
AliasMatcher _A(src);
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
{
auto j = generate_class_json(diagram, *model);
// Check if all classes exist
REQUIRE_THAT(src, IsClass(_A("A")));
using namespace json;
// Check if class templates exist
REQUIRE_THAT(src, IsClassTemplate("generator", "T"));
save_json(config.output_directory(), diagram->name + ".json", j);
}
// Check if all inner classes exist
REQUIRE_THAT(src,
IsInnerClass(_A("generator<T>"),
_A("generator::promise_type")));
{
auto src = generate_class_mermaid(diagram, *model);
// Check if all methods exist
REQUIRE_THAT(src,
(IsMethod<Public, Coroutine>("iota", "generator<unsigned
long>"))); REQUIRE_THAT(src, (IsMethod<Public, Coroutine>("seed",
"generator<unsigned long>")));
mermaid::AliasMatcher _A(src);
using mermaid::IsClass;
using mermaid::IsMethod;
// Check if all relationships exist
REQUIRE_THAT(
src, IsDependency(_A("A"), _A("generator<unsigned long>")));
REQUIRE_THAT(src,
IsInstantiation(
_A("generator<T>"), _A("generator<unsigned long>")));
REQUIRE_THAT(src, IsClass(_A("A")));
REQUIRE_THAT(src,
(IsMethod<Public, Coroutine>("iota", "generator<unsigned long>")));
REQUIRE_THAT(src,
(IsMethod<Public, Coroutine>("seed", "generator<unsigned long>")));
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}
{
auto j = generate_class_json(diagram, *model);
using namespace json;
save_json(config.output_directory(), diagram->name + ".json", j);
}
{
auto src = generate_class_mermaid(diagram, *model);
mermaid::AliasMatcher _A(src);
using mermaid::IsClass;
using mermaid::IsMethod;
REQUIRE_THAT(src, IsClass(_A("A")));
REQUIRE_THAT(src,
(IsMethod<Public, Coroutine>("iota", "generator<unsigned
long>"))); REQUIRE_THAT(src, (IsMethod<Public, Coroutine>("seed",
"generator<unsigned long>")));
save_mermaid(config.output_directory(), diagram->name + ".mmd",
src);
}*/
}

91
tests/t00070/test_case.h
View File

@@ -16,8 +16,10 @@
* limitations under the License.
*/
TEST_CASE("t00070", "[test-case][class]")
TEST_CASE("t00070")
{
using namespace clanguml::test;
auto [config, db] = load_config("t00070");
auto diagram = config.diagrams["t00070_class"];
@@ -28,62 +30,67 @@ TEST_CASE("t00070", "[test-case][class]")
REQUIRE(model->name() == "t00070_class");
{
auto src = generate_class_puml(diagram, *model);
AliasMatcher _A(src);
CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(IsClass(src, "A"));
REQUIRE(IsClass(src, "B"));
REQUIRE(!IsClass(src, "C"));
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
REQUIRE(IsClassTemplate(src, "BB<T>"));
REQUIRE(!IsClassTemplate(src, "CC<T>"));
REQUIRE_THAT(src, IsClass(_A("A")));
REQUIRE_THAT(src, IsClass(_A("B")));
REQUIRE_THAT(src, !IsClass(_A("C")));
REQUIRE(IsEnum(src, "BBB"));
REQUIRE(!IsClass(src, "BBBB"));
REQUIRE(!IsEnum(src, "CCC"));
});
REQUIRE_THAT(src, IsClassTemplate("BB", "T"));
REQUIRE_THAT(src, !IsClassTemplate("CC", "T"));
/*
{
auto src = generate_class_puml(diagram, *model);
AliasMatcher _A(src);
REQUIRE_THAT(src, IsEnum(_A("BBB")));
REQUIRE_THAT(src, !IsClass(_A("BBBB")));
REQUIRE_THAT(src, !IsEnum(_A("CCC")));
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
{
auto j = generate_class_json(diagram, *model);
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
using namespace json;
{
auto j = generate_class_json(diagram, *model);
REQUIRE(IsClass(j, "A"));
REQUIRE(IsClass(j, "B"));
REQUIRE(!IsClass(j, "C"));
using namespace json;
REQUIRE(InPublicModule(j, "A", "t00070"));
REQUIRE(InPublicModule(j, "B", "t00070.lib1"));
REQUIRE(IsClass(j, "A"));
REQUIRE(IsClass(j, "B"));
REQUIRE(!IsClass(j, "C"));
REQUIRE(!IsClass(j, "BBBB"));
REQUIRE(InPublicModule(j, "A", "t00070"));
REQUIRE(InPublicModule(j, "B", "t00070.lib1"));
save_json(config.output_directory(), diagram->name + ".json", j);
}
REQUIRE(!IsClass(j, "BBBB"));
{
auto src = generate_class_mermaid(diagram, *model);
save_json(config.output_directory(), diagram->name + ".json", j);
}
mermaid::AliasMatcher _A(src);
using mermaid::IsClass;
using mermaid::IsEnum;
{
auto src = generate_class_mermaid(diagram, *model);
REQUIRE_THAT(src, IsClass(_A("A")));
REQUIRE_THAT(src, IsClass(_A("B")));
REQUIRE_THAT(src, !IsClass(_A("C")));
mermaid::AliasMatcher _A(src);
using mermaid::IsClass;
using mermaid::IsEnum;
REQUIRE_THAT(src, IsClass(_A("BB<T>")));
REQUIRE_THAT(src, !IsClass(_A("CC<T>")));
REQUIRE_THAT(src, IsClass(_A("A")));
REQUIRE_THAT(src, IsClass(_A("B")));
REQUIRE_THAT(src, !IsClass(_A("C")));
REQUIRE_THAT(src, IsEnum(_A("BBB")));
REQUIRE_THAT(src, !IsClass(_A("BBBB")));
REQUIRE_THAT(src, !IsEnum(_A("CCC")));
REQUIRE_THAT(src, IsClass(_A("BB<T>")));
REQUIRE_THAT(src, !IsClass(_A("CC<T>")));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}
REQUIRE_THAT(src, IsEnum(_A("BBB")));
REQUIRE_THAT(src, !IsClass(_A("BBBB")));
REQUIRE_THAT(src, !IsEnum(_A("CCC")));
save_mermaid(config.output_directory(), diagram->name + ".mmd",
src);
}*/
}

82
tests/t00071/test_case.h
View File

@@ -16,8 +16,10 @@
* limitations under the License.
*/
TEST_CASE("t00071", "[test-case][class]")
TEST_CASE("t00071")
{
using namespace clanguml::test;
auto [config, db] = load_config("t00071");
auto diagram = config.diagrams["t00071_class"];
@@ -28,49 +30,63 @@ TEST_CASE("t00071", "[test-case][class]")
REQUIRE(model->name() == "t00071_class");
{
auto src = generate_class_puml(diagram, *model);
AliasMatcher _A(src);
CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(IsClass(src, "A"));
REQUIRE(IsClass(src, "R"));
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
REQUIRE(IsEnum(src, {"detail", "BBB"}));
REQUIRE(IsEnum(src, {"detail", "CCC"}));
REQUIRE_THAT(src, IsClass(_A("A")));
REQUIRE_THAT(src, IsClass(_A("R")));
REQUIRE(IsModulePackage(src, "app"s));
REQUIRE(IsModulePackage(src, "app"s, "lib1"s));
REQUIRE(IsModulePackage(src, "app"s, "lib1"s, "mod1"s));
REQUIRE(IsModulePackage(src, "app"s, "lib1"s, "mod2"s));
});
/*
{
auto src = generate_class_puml(diagram, *model);
AliasMatcher _A(src);
REQUIRE_THAT(src, IsEnum(_A("detail::BBB")));
REQUIRE_THAT(src, IsEnum(_A("detail::CCC")));
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
REQUIRE_THAT(src, IsClass(_A("A")));
REQUIRE_THAT(src, IsClass(_A("R")));
{
auto j = generate_class_json(diagram, *model);
REQUIRE_THAT(src, IsEnum(_A("detail::BBB")));
REQUIRE_THAT(src, IsEnum(_A("detail::CCC")));
using namespace json;
using namespace std::string_literals;
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
REQUIRE(IsModulePackage(j, "app"s));
REQUIRE(IsModulePackage(j, "app"s, "lib1"s));
REQUIRE(IsModulePackage(j, "app"s, "lib1"s, "mod1"s));
REQUIRE(IsModulePackage(j, "app"s, "lib1"s, "mod2"s));
{
auto j = generate_class_json(diagram, *model);
save_json(config.output_directory(), diagram->name + ".json", j);
}
using namespace json;
using namespace std::string_literals;
{
auto src = generate_class_mermaid(diagram, *model);
REQUIRE(IsModulePackage(j, "app"s));
REQUIRE(IsModulePackage(j, "app"s, "lib1"s));
REQUIRE(IsModulePackage(j, "app"s, "lib1"s, "mod1"s));
REQUIRE(IsModulePackage(j, "app"s, "lib1"s, "mod2"s));
mermaid::AliasMatcher _A(src);
using mermaid::IsClass;
using mermaid::IsEnum;
save_json(config.output_directory(), diagram->name + ".json", j);
}
REQUIRE_THAT(src, IsClass(_A("A")));
REQUIRE_THAT(src, IsClass(_A("R")));
{
auto src = generate_class_mermaid(diagram, *model);
REQUIRE_THAT(src, IsEnum(_A("detail::BBB")));
REQUIRE_THAT(src, IsEnum(_A("detail::CCC")));
mermaid::AliasMatcher _A(src);
using mermaid::IsClass;
using mermaid::IsEnum;
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}
REQUIRE_THAT(src, IsClass(_A("A")));
REQUIRE_THAT(src, IsClass(_A("R")));
REQUIRE_THAT(src, IsEnum(_A("detail::BBB")));
REQUIRE_THAT(src, IsEnum(_A("detail::CCC")));
save_mermaid(config.output_directory(), diagram->name + ".mmd",
src);
}*/
}

26
tests/t00072/test_case.h
View File

@@ -16,8 +16,10 @@
* limitations under the License.
*/
TEST_CASE("t00072", "[test-case][class]")
TEST_CASE("t00072")
{
using namespace clanguml::test;
auto [config, db] = load_config("t00072");
auto diagram = config.diagrams["t00072_class"];
@@ -28,6 +30,27 @@ TEST_CASE("t00072", "[test-case][class]")
REQUIRE(model->name() == "t00072_class");
CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(IsPackage(src, "app"));
REQUIRE(IsPackage(src, ":lib1"));
REQUIRE(IsPackage(src, ":lib2"));
REQUIRE(IsPackage(src, "mod1"));
REQUIRE(IsPackage(src, "mod2"));
REQUIRE(IsClass(src, "A"));
REQUIRE(IsClass(src, "C"));
REQUIRE(IsClassTemplate(src, "CC<T>"));
REQUIRE(IsEnum(src, {"detail", "CCC"}));
REQUIRE(IsClass(src, "B"));
REQUIRE(IsClassTemplate(src, "BB<T>"));
REQUIRE(IsEnum(src, {"detail", "BBB"}));
REQUIRE(IsClass(src, "D"));
REQUIRE(IsClass(src, "E"));
});
/*
{
auto src = generate_class_puml(diagram, *model);
AliasMatcher _A(src);
@@ -100,4 +123,5 @@ TEST_CASE("t00072", "[test-case][class]")
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}
*/
}

123
tests/t00073/test_case.h
View File

@@ -16,8 +16,10 @@
* limitations under the License.
*/
TEST_CASE("t00073", "[test-case][class]")
TEST_CASE("t00073")
{
using namespace clanguml::test;
auto [config, db] = load_config("t00073");
auto diagram = config.diagrams["t00073_class"];
@@ -28,69 +30,84 @@ TEST_CASE("t00073", "[test-case][class]")
REQUIRE(model->name() == "t00073_class");
{
auto src = generate_class_puml(diagram, *model);
AliasMatcher _A(src);
CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(IsClass(src, "A"));
REQUIRE(IsClass(src, "B"));
REQUIRE(IsClass(src, "AHandler"));
REQUIRE(IsClass(src, "BHandler"));
REQUIRE(IsClassTemplate(src, "Overload<Bases...>"));
REQUIRE(IsClassTemplate(src, "Overload<AHandler,BHandler>"));
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
REQUIRE(IsDependency(src, "AHandler", "A"));
REQUIRE(IsDependency(src, "BHandler", "B"));
REQUIRE(IsInstantiation(
src, "Overload<Bases...>", "Overload<AHandler,BHandler>"));
REQUIRE(IsAggregation<Public>(
src, "R", "Overload<AHandler,BHandler>", "dispatch"));
});
/*
{
auto src = generate_class_puml(diagram, *model);
AliasMatcher _A(src);
REQUIRE_THAT(src, IsClass(_A("A")));
REQUIRE_THAT(src, IsClass(_A("B")));
REQUIRE_THAT(src, IsClass(_A("AHandler")));
REQUIRE_THAT(src, IsClass(_A("BHandler")));
REQUIRE_THAT(src, IsClassTemplate("Overload", "Bases..."));
REQUIRE_THAT(src, IsClassTemplate("Overload", "AHandler,BHandler"));
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
REQUIRE_THAT(src, IsDependency(_A("AHandler"), _A("A")));
REQUIRE_THAT(src, IsDependency(_A("BHandler"), _A("B")));
REQUIRE_THAT(src,
IsInstantiation(
_A("Overload<Bases...>"), _A("Overload<AHandler,BHandler>")));
REQUIRE_THAT(src,
IsAggregation(
_A("R"), _A("Overload<AHandler,BHandler>"), "+dispatch"));
REQUIRE_THAT(src, IsClass(_A("A")));
REQUIRE_THAT(src, IsClass(_A("B")));
REQUIRE_THAT(src, IsClass(_A("AHandler")));
REQUIRE_THAT(src, IsClass(_A("BHandler")));
REQUIRE_THAT(src, IsClassTemplate("Overload", "Bases..."));
REQUIRE_THAT(src, IsClassTemplate("Overload", "AHandler,BHandler"));
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
REQUIRE_THAT(src, IsDependency(_A("AHandler"), _A("A")));
REQUIRE_THAT(src, IsDependency(_A("BHandler"), _A("B")));
REQUIRE_THAT(src,
IsInstantiation(
_A("Overload<Bases...>"),
_A("Overload<AHandler,BHandler>"))); REQUIRE_THAT(src, IsAggregation(
_A("R"), _A("Overload<AHandler,BHandler>"), "+dispatch"));
{
auto j = generate_class_json(diagram, *model);
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
using namespace json;
{
auto j = generate_class_json(diagram, *model);
REQUIRE(IsClassTemplate(j, "Overload<Bases...>"));
REQUIRE(IsClass(j, "A"));
REQUIRE(IsClass(j, "B"));
REQUIRE(IsClass(j, "AHandler"));
REQUIRE(IsClass(j, "BHandler"));
REQUIRE(IsClass(j, "Overload<AHandler,BHandler>"));
using namespace json;
save_json(config.output_directory(), diagram->name + ".json", j);
}
REQUIRE(IsClassTemplate(j, "Overload<Bases...>"));
REQUIRE(IsClass(j, "A"));
REQUIRE(IsClass(j, "B"));
REQUIRE(IsClass(j, "AHandler"));
REQUIRE(IsClass(j, "BHandler"));
REQUIRE(IsClass(j, "Overload<AHandler,BHandler>"));
{
auto src = generate_class_mermaid(diagram, *model);
save_json(config.output_directory(), diagram->name + ".json", j);
}
mermaid::AliasMatcher _A(src);
using mermaid::IsClass;
{
auto src = generate_class_mermaid(diagram, *model);
REQUIRE_THAT(src, IsClass(_A("A")));
REQUIRE_THAT(src, IsClass(_A("B")));
REQUIRE_THAT(src, IsClass(_A("AHandler")));
REQUIRE_THAT(src, IsClass(_A("BHandler")));
REQUIRE_THAT(src, IsClass(_A("Overload<Bases...>")));
REQUIRE_THAT(src, IsClass(_A("Overload<AHandler,BHandler>")));
mermaid::AliasMatcher _A(src);
using mermaid::IsClass;
REQUIRE_THAT(src, IsDependency(_A("AHandler"), _A("A")));
REQUIRE_THAT(src, IsDependency(_A("BHandler"), _A("B")));
REQUIRE_THAT(src,
IsInstantiation(
_A("Overload<Bases...>"), _A("Overload<AHandler,BHandler>")));
REQUIRE_THAT(src,
IsAggregation(
_A("R"), _A("Overload<AHandler,BHandler>"), "+dispatch"));
REQUIRE_THAT(src, IsClass(_A("A")));
REQUIRE_THAT(src, IsClass(_A("B")));
REQUIRE_THAT(src, IsClass(_A("AHandler")));
REQUIRE_THAT(src, IsClass(_A("BHandler")));
REQUIRE_THAT(src, IsClass(_A("Overload<Bases...>")));
REQUIRE_THAT(src, IsClass(_A("Overload<AHandler,BHandler>")));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}
REQUIRE_THAT(src, IsDependency(_A("AHandler"), _A("A")));
REQUIRE_THAT(src, IsDependency(_A("BHandler"), _A("B")));
REQUIRE_THAT(src,
IsInstantiation(
_A("Overload<Bases...>"),
_A("Overload<AHandler,BHandler>"))); REQUIRE_THAT(src, IsAggregation(
_A("R"), _A("Overload<AHandler,BHandler>"), "+dispatch"));
save_mermaid(config.output_directory(), diagram->name + ".mmd",
src);
}*/
}

19
tests/t00074/test_case.h
View File

@@ -16,8 +16,10 @@
* limitations under the License.
*/
TEST_CASE("t00074", "[test-case][class]")
TEST_CASE("t00074")
{
using namespace clanguml::test;
auto [config, db] = load_config("t00074");
auto diagram = config.diagrams["t00074_class"];
@@ -28,6 +30,19 @@ TEST_CASE("t00074", "[test-case][class]")
REQUIRE(model->name() == "t00074_class");
CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(IsConcept(src, "fruit_c<T>"));
REQUIRE(IsConcept(src, "apple_c<T>"));
REQUIRE(IsConcept(src, "orange_c<T>"));
REQUIRE(IsConstraint(src, "apple_c<T>", "fruit_c<T>", "T"));
REQUIRE(IsConstraint(src, "orange_c<T>", "fruit_c<T>", "T"));
REQUIRE(!IsConceptRequirement(src, "apple_c<T>", "t.get_sweetness()"));
REQUIRE(
!IsConceptRequirement(src, "orange_c<T>", "t.get_bitterness()"));
});
/*
{
auto src = generate_class_puml(diagram, *model);
AliasMatcher _A(src);
@@ -87,5 +102,5 @@ TEST_CASE("t00074", "[test-case][class]")
src, !IsConceptRequirement(_A("apple_c<T>"), "t.get_bitterness()"));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}
}*/
}

23
tests/t00075/test_case.h
View File

@@ -16,8 +16,10 @@
* limitations under the License.
*/
TEST_CASE("t00075", "[test-case][class]")
TEST_CASE("t00075")
{
using namespace clanguml::test;
auto [config, db] = load_config("t00075");
auto diagram = config.diagrams["t00075_class"];
@@ -28,6 +30,25 @@ TEST_CASE("t00075", "[test-case][class]")
REQUIRE(model->name() == "t00075_class");
CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(IsClass(src, "A"));
REQUIRE(IsClass(src, "B"));
REQUIRE(IsClassTemplate(src, "ABE<ns1::ns2::C T>"));
REQUIRE(IsClass(src, "R"));
REQUIRE(IsEnum(src, "E"));
REQUIRE(IsConcept(src, "C<T>"));
REQUIRE(IsConceptRequirement(src, "C<T>", "T{}"));
REQUIRE(IsConceptRequirement(src, "C<T>", "t.e()"));
REQUIRE(IsConceptRequirement(src, "C<T>", "(T t)"));
REQUIRE(!IsConceptRequirement(src, "C<T>", "(T ns1::ns2::t)"));
REQUIRE(IsConstraint(src, "ABE<ns1::ns2::C T>", "C<T>", "T",
"up[#green,dashed,thickness=2]"));
});
{
auto src = generate_class_puml(diagram, *model);
AliasMatcher _A(src);

8
tests/t30011/test_case.h
View File

@@ -38,10 +38,10 @@ TEST_CASE("t30011")
REQUIRE(IsDirectoryPackage(src, "libraries"s, "lib3"s));
REQUIRE(IsDirectoryPackage(src, "libraries"s, "lib4"s));
REQUIRE(IsDependency(src, "app"s, "lib1"s));
REQUIRE(IsDependency(src, "app"s, "lib2"s));
REQUIRE(IsDependency(src, "app"s, "lib3"s));
REQUIRE(IsDependency(src, "app"s, "lib4"s));
REQUIRE(IsDependency(src, "app", "lib1"));
REQUIRE(IsDependency(src, "app", "lib2"));
REQUIRE(IsDependency(src, "app", "lib3"));
REQUIRE(IsDependency(src, "app", "lib4"));
});
/*
{

38
tests/test_cases.cc
View File

@@ -387,7 +387,7 @@ void try_run_test_case(const diagram_source_storage &diagrams, TC &&tc)
std::cout << "-----------------------------------------------------"
"--------------------------\n";
std::cout << "Test case failed for diagram type "
<< T::diagram_type_name << ": " << "\n";
<< T::diagram_type_name << ": " << "\n\n";
std::cout << diagrams.get<T>().to_string() << "\n";
throw e;
@@ -1044,9 +1044,6 @@ template <> bool IsClass(json_t d, std::string name)
#include "t00028/test_case.h"
#include "t00029/test_case.h"
#include "t00030/test_case.h"
/*
#include "t00031/test_case.h"
#include "t00032/test_case.h"
#include "t00033/test_case.h"
@@ -1085,6 +1082,10 @@ template <> bool IsClass(json_t d, std::string name)
#include "t00062/test_case.h"
#include "t00063/test_case.h"
#include "t00064/test_case.h"
/*
#if defined(ENABLE_CXX_STD_20_TEST_CASES)
#include "t00065/test_case.h"
#endif
@@ -1215,43 +1216,24 @@ int main(int argc, char *argv[])
{
doctest::Context context;
// defaults
// context.addFilter("test-case-exclude",
// "*math*"); // exclude test cases with "math" in their name
context.setOption(
"abort-after", 5); // stop test execution after 5 failed assertions
context.setOption("order-by", "name"); // sort the test cases by their name
context.applyCommandLine(argc, argv);
// overrides
context.setOption(
"no-breaks", false); // don't break in the debugger when assertions fail
clanguml::cli::cli_handler clih;
std::vector<const char *> argvv = {
"clang-uml", "--config", "./test_config_data/simple.yml"};
// if (debug_log)
// argvv.push_back("-vvv");
// else
argvv.push_back("-q");
argvv.push_back("-vvv");
clih.handle_options(argvv.size(), argvv.data());
int res = context.run(); // run
int res = context.run();
if (context.shouldExit()) // important - query flags (and --exit) rely on
// the user doing this
return res; // propagate the result of the tests
if (context.shouldExit())
return res;
int client_stuff_return_code = 0;
// your program - if the testing framework is integrated in your production
// code
return res;
return res + client_stuff_return_code; // the result from doctest is
// propagated here as well
/*
Catch::Session session;
using namespace Catch::clara;

234
tests/test_cases.h
View File

@@ -124,6 +124,11 @@ template <typename T> struct diagram_source_t {
return "__INVALID_ALIAS__";
}
virtual std::string get_alias(std::string ns, std::string name) const
{
return get_alias(fmt::format("{}::{}", ns, name));
}
bool search(const std::string &pattern) const;
std::string to_string() const;
@@ -364,6 +369,43 @@ template <> std::string diagram_source_t<nlohmann::json>::to_string() const
return src.dump(2);
}
struct QualifiedName {
QualifiedName(const char *n)
: name{n}
{
}
QualifiedName(std::string_view n)
: name{n}
{
}
QualifiedName(std::string_view ns_, std::string_view n)
: ns{ns_}
, name{n}
{
}
QualifiedName(const char *ns_, const char *n)
: ns{ns_}
, name{n}
{
}
operator std::string() const { return str(); }
std::string str() const
{
if (ns)
return fmt::format("{}::{}", ns.value(), name);
return name;
}
std::optional<std::string> ns;
std::string name;
};
///
/// The following functions declarations define various checks on generated
/// diagrams.
@@ -386,23 +428,31 @@ bool HasTitle(const DiagramType &d, std::string const &str);
// Check if generated diagram contains a specified enum
template <typename DiagramType>
bool IsEnum(const DiagramType &d, std::string name);
bool IsEnum(const DiagramType &d, QualifiedName name);
// Check if generated diagram contains a specified union
template <typename DiagramType>
bool IsUnion(const DiagramType &d, QualifiedName name);
// Check if generated diagram contains a specified class
template <typename DiagramType>
bool IsClass(const DiagramType &d, std::string name);
bool IsClass(const DiagramType &d, QualifiedName name);
// Check if generated diagram contains a specified class template
template <typename DiagramType>
bool IsClassTemplate(const DiagramType &d, std::string name);
bool IsClassTemplate(const DiagramType &d, QualifiedName name);
template <typename DiagramType>
bool IsAbstractClassTemplate(const DiagramType &d, QualifiedName name);
// Check if generated diagram contains a specified abstract class
template <typename DiagramType>
bool IsAbstractClass(const DiagramType &d, std::string name);
bool IsAbstractClass(const DiagramType &d, QualifiedName name);
// Check if generated diagram contains a specified class
template <typename DiagramType>
bool IsBaseClass(const DiagramType &d, std::string base, std::string subclass);
bool IsBaseClass(
const DiagramType &d, QualifiedName base, QualifiedName subclass);
template <typename DiagramType>
bool IsInnerClass(
@@ -440,8 +490,8 @@ bool IsInstantiation(const DiagramType &d, std::string const &from,
std::string const &to, std::string style = "");
template <typename DiagramType>
bool IsDependency(const DiagramType &d, std::string const &from,
std::string const &to, std::string style = "");
bool IsDependency(const DiagramType &d, QualifiedName from, QualifiedName to,
std::string style = "");
template <typename DiagramType, typename... Ts>
bool IsFriend(
@@ -459,6 +509,9 @@ template <typename DiagramType>
bool IsConstraint(const DiagramType &d, std::string const &from,
std::string const &to, std::string label = {}, std::string style = "");
template <typename DiagramType>
bool IsConcept(const DiagramType &d, std::string const &cpt);
template <typename DiagramType>
bool IsConceptRequirement(
const DiagramType &d, std::string const &cpt, std::string requirement);
@@ -543,28 +596,40 @@ template <> bool HasTitle(const plantuml_t &d, std::string const &str)
return d.contains("title " + str);
}
template <> bool IsEnum(const plantuml_t &d, std::string name)
template <> bool IsEnum(const plantuml_t &d, QualifiedName enm)
{
return d.contains(fmt::format("enum {}", d.get_alias(name)));
return d.contains(fmt::format("enum {}", d.get_alias(enm.name)));
}
template <> bool IsClass(const plantuml_t &d, std::string name)
template <> bool IsUnion(const plantuml_t &d, QualifiedName cls)
{
return d.contains(fmt::format("class {}", d.get_alias(name)));
return d.contains(fmt::format("class {} <<union>>", d.get_alias(cls)));
}
template <> bool IsClassTemplate(const plantuml_t &d, std::string name)
template <> bool IsClass(const plantuml_t &d, QualifiedName cls)
{
return d.contains(fmt::format("class \"{}\"", name));
return d.contains(fmt::format("class {}", d.get_alias(cls.name))) ||
d.contains(fmt::format("class {}", d.get_alias(cls.str())));
}
template <> bool IsAbstractClass(const plantuml_t &d, std::string name)
template <> bool IsClassTemplate(const plantuml_t &d, QualifiedName cls)
{
return d.contains(fmt::format("abstract {}", d.get_alias(name)));
return d.contains(fmt::format("class \"{}\"", cls.name));
}
template <> bool IsAbstractClassTemplate(const plantuml_t &d, QualifiedName cls)
{
return d.contains(fmt::format("abstract \"{}\"", cls.name));
}
template <> bool IsAbstractClass(const plantuml_t &d, QualifiedName cls)
{
return d.contains(fmt::format("abstract {}", d.get_alias(cls.name)));
}
template <>
bool IsBaseClass(const plantuml_t &d, std::string base, std::string subclass)
bool IsBaseClass(
const plantuml_t &d, QualifiedName base, QualifiedName subclass)
{
return d.contains(
fmt::format("{} <|-- {}", d.get_alias(base), d.get_alias(subclass)));
@@ -750,11 +815,13 @@ bool IsInstantiation(const plantuml_t &d, std::string const &from,
}
template <>
bool IsDependency(const plantuml_t &d, std::string const &from,
std::string const &to, std::string style)
bool IsDependency(const plantuml_t &d, QualifiedName from, QualifiedName to,
std::string style)
{
return d.contains(
fmt::format("{} .{}.> {}", d.get_alias(from), style, d.get_alias(to)));
return d.contains(fmt::format(
"{} .{}.> {}", d.get_alias(from), style, d.get_alias(to))) ||
d.contains(fmt::format("{} .{}.> {}", d.get_alias(from.name), style,
d.get_alias(to.name)));
}
template <typename... Ts>
@@ -802,6 +869,11 @@ bool IsConstraint(const plantuml_t &d, std::string const &from,
"{} .{}.> {} : {}", d.get_alias(from), style, d.get_alias(to), label));
}
template <> bool IsConcept(const plantuml_t &d, std::string const &cpt)
{
return d.contains("class " + d.get_alias(cpt) + " <<concept>>");
}
template <>
bool IsConceptRequirement(
const plantuml_t &d, std::string const &cpt, std::string requirement)
@@ -945,30 +1017,43 @@ template <> bool HasTitle(const mermaid_t &d, std::string const &str)
return d.contains("title: " + str);
}
template <> bool IsEnum(const mermaid_t &d, std::string name)
template <> bool IsEnum(const mermaid_t &d, QualifiedName enm)
{
return d.search(std::string("class ") + d.get_alias(name) +
return d.search(std::string("class ") + d.get_alias(enm) +
" \\{\\n\\s+<<enumeration>>");
}
template <> bool IsClass(const mermaid_t &d, std::string name)
template <> bool IsUnion(const mermaid_t &d, QualifiedName cls)
{
return d.contains(fmt::format("class {}[\"{}\"]", d.get_alias(name), name));
return d.search(
std::string("class ") + d.get_alias(cls) + " \\{\\n\\s+<<union>>");
}
template <> bool IsClassTemplate(const mermaid_t &d, std::string name)
template <> bool IsClass(const mermaid_t &d, QualifiedName cls)
{
return d.contains(fmt::format("class {}", d.get_alias(name)));
return d.contains(fmt::format("class {}", d.get_alias(cls)));
}
template <> bool IsAbstractClass(const mermaid_t &d, std::string name)
template <> bool IsClassTemplate(const mermaid_t &d, QualifiedName cls)
{
return d.contains(fmt::format("class {}", d.get_alias(cls)));
}
template <> bool IsAbstractClassTemplate(const mermaid_t &d, QualifiedName cls)
{
// return d.contains(fmt::format("class {}", d.get_alias(cls)));
return d.search(
std::string("class ") + d.get_alias(cls) + " \\{\\n\\s+<<abstract>>");
}
template <> bool IsAbstractClass(const mermaid_t &d, QualifiedName name)
{
return d.search(
std::string("class ") + d.get_alias(name) + " \\{\\n\\s+<<abstract>>");
}
template <>
bool IsBaseClass(const mermaid_t &d, std::string base, std::string subclass)
bool IsBaseClass(const mermaid_t &d, QualifiedName base, QualifiedName subclass)
{
return d.contains(
fmt::format("{} <|-- {}", d.get_alias(base), d.get_alias(subclass)));
@@ -1119,7 +1204,7 @@ bool IsComposition(const mermaid_t &d, std::string const &from,
if (!multiplicity_source.empty())
format_string += " \"" + multiplicity_source + "\"";
format_string += fmt::format(" *-{}-", style);
format_string += fmt::format(" *--", style);
if (!multiplicity_dest.empty())
format_string += " \"" + multiplicity_dest + "\"";
@@ -1168,8 +1253,8 @@ bool IsInstantiation(const mermaid_t &d, std::string const &from,
}
template <>
bool IsDependency(const mermaid_t &d, std::string const &from,
std::string const &to, std::string style)
bool IsDependency(
const mermaid_t &d, QualifiedName from, QualifiedName to, std::string style)
{
if (d.diagram_type == common::model::diagram_t::kClass) {
return d.contains(
@@ -1259,6 +1344,12 @@ bool IsConstraint(const mermaid_t &d, std::string const &from,
return d.contains(fmt::format("{} ..> {} : {}", from_id, to_id, label));
}
template <> bool IsConcept(const mermaid_t &d, std::string const &cpt)
{
return d.search(
std::string("class ") + d.get_alias(cpt) + " \\{\\n\\s+<<concept>>");
}
template <>
bool IsConceptRequirement(
const mermaid_t &d, std::string const &cpt, std::string requirement)
@@ -1354,8 +1445,13 @@ template <> bool IsSystemHeader(const mermaid_t &d, std::string const &path)
template <typename... Args>
bool IsNamespacePackage(const mermaid_t &d, Args... args)
{
if (d.diagram_type == class_diagram::model::diagram_t::kClass) {
std::vector<std::string> toks{{args...}};
return d.contains(fmt::format("[\"{}", fmt::join(toks, "::")));
}
const auto &name = get_last(args...);
return d.contains("subgraph " + d.get_alias(name));
return d.contains(fmt::format("subgraph {}", d.get_alias(name)));
}
template <typename... Args>
@@ -1394,32 +1490,44 @@ template <> bool HasTitle(const json_t &d, std::string const &str)
return d.src.contains("title") && d.src["title"] == str;
}
template <> bool IsAbstractClass(const json_t &d, std::string name)
template <> bool IsAbstractClass(const json_t &d, QualifiedName cls)
{
auto e = get_element(d.src, expand_name(d.src, name));
auto e = get_element(d.src, expand_name(d.src, cls));
return e && e->at("type") == "class" && e->at("is_abstract");
}
template <> bool IsEnum(const json_t &d, std::string name)
template <> bool IsEnum(const json_t &d, QualifiedName enm)
{
auto e = get_element(d.src, expand_name(d.src, name));
auto e = get_element(d.src, expand_name(d.src, enm));
return e && e->at("type") == "enum";
}
template <> bool IsClass(const json_t &d, std::string name)
template <> bool IsUnion(const json_t &d, QualifiedName enm)
{
auto e = get_element(d.src, expand_name(d.src, name));
auto e = get_element(d.src, expand_name(d.src, enm));
return e && e->at("type") == "class" && e->at("is_union");
}
template <> bool IsClass(const json_t &d, QualifiedName cls)
{
auto e = get_element(d.src, expand_name(d.src, cls));
return e && e->at("type") == "class" && !e->at("is_abstract");
}
template <> bool IsClassTemplate(const json_t &d, std::string name)
template <> bool IsClassTemplate(const json_t &d, QualifiedName cls)
{
auto e = get_element(d.src, expand_name(d.src, name));
auto e = get_element(d.src, expand_name(d.src, cls));
return e && e->at("type") == "class";
}
template <> bool IsAbstractClassTemplate(const json_t &d, QualifiedName cls)
{
auto e = get_element(d.src, expand_name(d.src, cls));
return e && e->at("type") == "class" && e->at("is_abstract");
}
template <>
bool IsBaseClass(const json_t &d, std::string base, std::string subclass)
bool IsBaseClass(const json_t &d, QualifiedName base, QualifiedName subclass)
{
const auto &j = d.src;
auto base_el = get_element(j, expand_name(j, base));
@@ -1459,8 +1567,8 @@ bool IsMethod(const json_t &d, const std::string &cls, std::string const &name,
const nlohmann::json &methods = (*sc)["methods"];
return std::find_if(methods.begin(), methods.end(), [&](const auto &it) {
return it["name"] == name;
return std::find_if(methods.begin(), methods.end(), [name](const auto &it) {
return it["display_name"] == name;
}) != methods.end();
}
@@ -1522,7 +1630,7 @@ bool IsComposition(const json_t &d, std::string const &from,
const auto &j = d.src;
auto rel = get_relationship(
j, expand_name(j, to), expand_name(j, from), "composition", label);
j, expand_name(j, from), expand_name(j, to), "composition", label);
if (rel == j["relationships"].end())
return false;
@@ -1591,8 +1699,8 @@ bool IsInstantiation(const json_t &d, std::string const &from,
}
template <>
bool IsDependency(const json_t &d, std::string const &from,
std::string const &to, std::string style)
bool IsDependency(
const json_t &d, QualifiedName from, QualifiedName to, std::string style)
{
const auto &j = d.src;
@@ -1655,18 +1763,48 @@ bool IsIncludeDependency(
return true;
}
template <> bool IsConcept(const json_t &d, std::string const &cpt)
{
const auto &j = d.src;
auto e = get_element(j, expand_name(j, cpt));
return e && e->at("type") == "concept";
}
template <>
bool IsConstraint(const json_t &d, std::string const &from,
std::string const &to, std::string label, std::string style)
{
return false;
const auto &j = d.src;
auto rel = get_relationship(
j, expand_name(j, from), expand_name(j, to), "constraint", label);
if (rel == j["relationships"].end())
return false;
if ((*rel)["label"] != label)
return false;
return true;
}
template <>
bool IsConceptRequirement(
const json_t &d, std::string const &cpt, std::string requirement)
{
return false;
const auto &j = d.src;
auto e = get_element(j, expand_name(j, cpt));
if (!e)
return false;
const nlohmann::json &statements = (*e)["statements"];
return std::find_if(statements.begin(), statements.end(),
[requirement](const auto &it) { return it == requirement; }) !=
statements.end();
}
template <>