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-12 00:45:45 +02:00
parent baeda78c7e
commit 235533d9fa
52 changed files with 4641 additions and 3156 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
target_sources(${TEST_NAME} PUBLIC ${TEST_NAME}.cc test_cases_checks.h
${TEST_CASE_SOURCES} catch.h)
else()
target_sources(${TEST_NAME} PUBLIC ${TEST_NAME}.cc catch.h)

204
tests/t00002/test_case.h
View File

@@ -1,5 +1,5 @@
/**
* tests/t00002/test_case.cc
* tests/t00002/test_case.h
*
* Copyright (c) 2021-2024 Bartek Kryza <bkryza@gmail.com>
*
@@ -16,11 +16,10 @@
* limitations under the License.
*/
#include "../test_cases.h"
TEST_CASE("t00002")
{
using namespace clanguml::test;
using namespace std::string_literals;
auto [config, db] = load_config("t00002");
@@ -40,158 +39,69 @@ TEST_CASE("t00002")
REQUIRE(!model->should_include({"std"}, "vector"));
CHECK_CLASS_DIAGRAM(
diagram, *model,
config, diagram, *model,
// Common test case for all diagram types
[](const auto &src) {
REQUIRE(HasTitle(src, "Basic class diagram example"));
REQUIRE(!IsClass(src, "NOSUCHCLASS"));
REQUIRE(IsClass(src, "A"));
REQUIRE(IsAbstractClass(src, "A"));
REQUIRE(IsClass(src, "B"));
REQUIRE(IsClass(src, "C"));
REQUIRE(IsClass(src, "D"));
REQUIRE(IsBaseClass(src, "A", "B"));
REQUIRE(IsBaseClass(src, "A", "C"));
REQUIRE(IsBaseClass(src, "B", "D"));
REQUIRE(IsBaseClass(src, "C", "D"));
REQUIRE(IsMethod<Public, Abstract>(src, "A", "foo_a"));
REQUIRE(IsMethod<Public, Abstract>(src, "C", "foo_c"));
REQUIRE(IsAssociation<Private>(src, "D", "A", "as"));
REQUIRE(HasNote(src, "A", "left", "This is class A"));
REQUIRE(HasNote(src, "B", "top", "This is class B"));
REQUIRE(HasLink(src, "A",
fmt::format("https://github.com/bkryza/clang-uml/blob/{}/tests/"
"t00002/t00002.cc#L7",
clanguml::util::get_git_commit()),
"This is class A"));
REQUIRE(HasLink(src, "B",
fmt::format("https://github.com/bkryza/clang-uml/blob/{}/tests/"
"t00002/t00002.cc#L16",
clanguml::util::get_git_commit()),
"This is class B"));
REQUIRE(HasMemberLink(src, "+foo_a() : void",
fmt::format("https://github.com/bkryza/clang-uml/blob/{}/tests/"
"t00002/t00002.cc#L18",
clanguml::util::get_git_commit()),
"foo_a"));
REQUIRE(HasMemberLink(src, "-as : std::vector<A *>",
fmt::format("https://github.com/bkryza/clang-uml/blob/{}/tests/"
"t00002/t00002.cc#L83",
clanguml::util::get_git_commit()),
"as"));
},
// Specific test case only for PlantUML diagram
[](const plantuml_t &src) {
REQUIRE(StartsWith(src, "@startuml"s));
REQUIRE(EndsWith(src, "@enduml\n"s));
},
// Specific test case only for JSON diagram
[](const json_t &src) {
const auto &A = get_element(src, "A");
CHECK(A.has_value());
REQUIRE(A.has_value());
CHECK(A.value()["type"] == "class");
CHECK(A.value()["name"] == "A");
CHECK(A.value()["display_name"] == "A");
CHECK(A.value()["namespace"] == "clanguml::t00002");
CHECK(A.value()["source_location"]["file"] == "t00002.cc");
CHECK(A.value()["source_location"]["line"] == 7);
REQUIRE(A.value()["type"] == "class");
REQUIRE(A.value()["name"] == "A");
REQUIRE(A.value()["display_name"] == "A");
REQUIRE(A.value()["namespace"] == "clanguml::t00002");
REQUIRE(A.value()["source_location"]["file"] == "t00002.cc");
REQUIRE(A.value()["source_location"]["line"] == 7);
});
// auto src = render_class_diagram<plantuml_t>(diagram, *model);
/*
{
auto puml = generate_class_puml(diagram, *model);
AliasMatcher _A(puml);
REQUIRE_THAT(puml, StartsWith("@startuml"));
REQUIRE_THAT(puml, EndsWith("@enduml\n"));
REQUIRE_THAT(puml, HasTitle("Basic class diagram example"));
REQUIRE_THAT(puml, IsAbstractClass(_A("A")));
REQUIRE_THAT(puml, IsClass(_A("B")));
REQUIRE_THAT(puml, IsClass(_A("C")));
REQUIRE_THAT(puml, IsClass(_A("D")));
REQUIRE_THAT(puml, IsBaseClass(_A("A"), _A("B")));
REQUIRE_THAT(puml, IsBaseClass(_A("A"), _A("C")));
REQUIRE_THAT(puml, IsBaseClass(_A("B"), _A("D")));
REQUIRE_THAT(puml, IsBaseClass(_A("C"), _A("D")));
REQUIRE_THAT(puml, (IsMethod<Public, Abstract>("foo_a")));
REQUIRE_THAT(puml, (IsMethod<Public, Abstract>("foo_c")));
REQUIRE_THAT(puml, IsAssociation(_A("D"), _A("A"), "-as"));
REQUIRE_THAT(puml, HasNote(_A("A"), "left", "This is class A"));
REQUIRE_THAT(puml, HasNote(_A("B"), "top", "This is class B"));
REQUIRE_THAT(puml,
HasLink(_A("A"),
fmt::format("https://github.com/bkryza/clang-uml/blob/{}/tests/"
"t00002/t00002.cc#L7",
clanguml::util::get_git_commit()),
"This is class A"));
REQUIRE_THAT(puml,
HasLink(_A("B"),
fmt::format("https://github.com/bkryza/clang-uml/blob/{}/tests/"
"t00002/t00002.cc#L16",
clanguml::util::get_git_commit()),
"This is class B"));
REQUIRE_THAT(puml,
HasMemberLink("+foo_a() : void",
fmt::format("https://github.com/bkryza/clang-uml/blob/{}/tests/"
"t00002/t00002.cc#L18",
clanguml::util::get_git_commit()),
"foo_a"));
REQUIRE_THAT(puml,
HasMemberLink("-as : std::vector<A *>",
fmt::format("https://github.com/bkryza/clang-uml/blob/{}/tests/"
"t00002/t00002.cc#L83",
clanguml::util::get_git_commit()),
"as"));
save_puml(config.output_directory(), diagram->name + ".puml", puml);
}
{
auto j = generate_class_json(diagram, *model);
using namespace json;
const auto &A = get_element(j, "A");
CHECK(A.has_value());
CHECK(A.value()["type"] == "class");
CHECK(A.value()["name"] == "A");
CHECK(A.value()["display_name"] == "A");
CHECK(A.value()["namespace"] == "clanguml::t00002");
CHECK(A.value()["source_location"]["file"] == "t00002.cc");
CHECK(A.value()["source_location"]["line"] == 7);
REQUIRE(HasTitle(j, "Basic class diagram example"));
REQUIRE(IsClass(j, "A"));
REQUIRE(IsClass(j, "B"));
REQUIRE(IsClass(j, "C"));
REQUIRE(IsBaseClass(j, "A", "B"));
REQUIRE(IsBaseClass(j, "A", "C"));
REQUIRE(IsBaseClass(j, "B", "D"));
REQUIRE(IsBaseClass(j, "C", "D"));
REQUIRE(IsMethod(j, "A", "foo_a"));
REQUIRE(IsMethod(j, "C", "foo_c"));
REQUIRE(IsField(j, "E", "as", "std::vector<A *>"));
REQUIRE(IsAssociation(j, "D", "A", "as"));
save_json(config.output_directory(), diagram->name + ".json", j);
}
{
auto mmd = generate_class_mermaid(diagram, *model);
mermaid::AliasMatcher _A(mmd);
using mermaid::HasNote;
using mermaid::HasTitle;
using mermaid::IsAbstractClass;
REQUIRE_THAT(mmd, HasTitle("Basic class diagram example"));
REQUIRE_THAT(mmd, Contains("classDiagram"));
REQUIRE_THAT(mmd, IsAbstractClass(_A("A")));
REQUIRE_THAT(mmd, IsClass(_A("B")));
REQUIRE_THAT(mmd, IsClass(_A("C")));
REQUIRE_THAT(mmd, IsClass(_A("D")));
REQUIRE_THAT(mmd, IsBaseClass(_A("A"), _A("B")));
REQUIRE_THAT(mmd, IsBaseClass(_A("A"), _A("C")));
REQUIRE_THAT(mmd, IsBaseClass(_A("B"), _A("D")));
REQUIRE_THAT(mmd, IsBaseClass(_A("C"), _A("D")));
REQUIRE_THAT(mmd, IsAssociation(_A("D"), _A("A"), "-as"));
REQUIRE_THAT(mmd, (mermaid::IsMethod<Public, Abstract>("foo_a")));
REQUIRE_THAT(mmd, (mermaid::IsMethod<Public, Abstract>("foo_c")));
REQUIRE_THAT(mmd, HasNote(_A("A"), "left", "This is class A"));
REQUIRE_THAT(mmd, HasNote(_A("B"), "top", "This is class B"));
REQUIRE_THAT(mmd,
mermaid::HasLink(_A("A"),
fmt::format("https://github.com/bkryza/clang-uml/blob/{}/tests/"
"t00002/t00002.cc#L7",
clanguml::util::get_git_commit()),
"This is class A"));
REQUIRE_THAT(mmd,
mermaid::HasLink(_A("B"),
fmt::format("https://github.com/bkryza/clang-uml/blob/{}/tests/"
"t00002/t00002.cc#L16",
clanguml::util::get_git_commit()),
"This is class B"));
save_mermaid(config.output_directory(), diagram->name + ".mmd",
mmd);
}
*/
}

138
tests/t00003/test_case.h
View File

@@ -1,5 +1,5 @@
/**
* tests/t00003/test_case.cc
* tests/t00003/test_case.h
*
* Copyright (c) 2021-2024 Bartek Kryza <bkryza@gmail.com>
*
@@ -16,8 +16,13 @@
* limitations under the License.
*/
TEST_CASE("t00003", "[test-case][class]")
// #include "../test_cases.h"
TEST_CASE("t00003")
{
using namespace clanguml::test;
using namespace std::string_literals;
auto [config, db] = load_config("t00003");
auto diagram = config.diagrams["t00003_class"];
@@ -32,111 +37,40 @@ TEST_CASE("t00003", "[test-case][class]")
REQUIRE(model->name() == "t00003_class");
{
auto puml = generate_class_puml(diagram, *model);
AliasMatcher _A(puml);
CHECK_CLASS_DIAGRAM(config, diagram, *model,
[](const auto &src) {
REQUIRE(IsClass(src, "A"));
REQUIRE_THAT(puml, StartsWith("@startuml"));
REQUIRE_THAT(puml, EndsWith("@enduml\n"));
REQUIRE_THAT(puml, IsClass(_A("A")));
REQUIRE(!IsDependency(src, "A", "A"));
REQUIRE_THAT(puml, !IsDependency(_A("A"), _A("A")));
REQUIRE(IsMethod<Public, Default>(src, "A", "A"));
REQUIRE(IsMethod<Public, Default>(src, "A", "A", "void", "A &&"));
REQUIRE(
IsMethod<Public, Deleted>(src, "A", "A", "void", "const A &"));
REQUIRE_THAT(puml, (IsMethod<Public, Default>("A")));
REQUIRE_THAT(puml, (IsMethod<Public, Default>("A", "void", "A &&")));
REQUIRE_THAT(
puml, (IsMethod<Public, Deleted>("A", "void", "const A &")));
REQUIRE(IsMethod<Public, Default>(src, "A", "~A"));
REQUIRE_THAT(puml, (IsMethod<Public, Default>("~A")));
REQUIRE(IsMethod<Public>(src, "A", "basic_method"));
REQUIRE(IsMethod<Public, Static>(src, "A", "static_method", "int"));
REQUIRE(IsMethod<Public, Const>(src, "A", "const_method"));
REQUIRE(
IsMethod<Public>(src, "A", "default_int", "int", "int i = 12"));
REQUIRE(IsMethod<Public>(src, "A", "default_string", "std::string",
"int i, std::string s = \"abc\""));
REQUIRE_THAT(puml, (IsMethod<Public>("basic_method")));
REQUIRE_THAT(puml, (IsMethod<Public, Static>("static_method", "int")));
REQUIRE_THAT(puml, (IsMethod<Public, Const>("const_method")));
REQUIRE_THAT(
puml, (IsMethod<Public>("default_int", "int", "int i = 12")));
REQUIRE_THAT(puml,
(IsMethod<Public>("default_string", "std::string",
"int i, std::string s = \"abc\"")));
REQUIRE(IsMethod<Public, Const, Constexpr>(
src, "A", "size", "std::size_t"));
REQUIRE_THAT(
puml, (IsMethod<Public, Const, Constexpr>("size", "std::size_t")));
REQUIRE(IsMethod<Protected>(src, "A", "protected_method"));
REQUIRE(IsMethod<Private>(src, "A", "private_method"));
REQUIRE(IsField<Public>(src, "A", "public_member", "int"));
REQUIRE(IsField<Protected>(src, "A", "protected_member", "int"));
REQUIRE(IsField<Private>(src, "A", "private_member", "int"));
REQUIRE(IsField<Public, Static>(
src, "A", "auto_member", "const unsigned long"));
REQUIRE_THAT(puml, (IsMethod<Protected>("protected_method")));
REQUIRE_THAT(puml, (IsMethod<Private>("private_method")));
REQUIRE_THAT(puml, (IsField<Public>("public_member", "int")));
REQUIRE_THAT(puml, (IsField<Protected>("protected_member", "int")));
REQUIRE_THAT(puml, (IsField<Private>("private_member", "int")));
REQUIRE_THAT(puml,
(IsField<Public, Static>("auto_member", "const unsigned long")));
REQUIRE_THAT(puml, (IsField<Private>("a_", "int")));
REQUIRE_THAT(puml, (IsField<Private>("b_", "int")));
REQUIRE_THAT(puml, (IsField<Private>("c_", "int")));
save_puml(config.output_directory(), diagram->name + ".puml", puml);
}
{
auto j = generate_class_json(diagram, *model);
using namespace json;
REQUIRE(IsClass(j, "A"));
REQUIRE(IsMethod(j, "A", "A"));
REQUIRE(IsMethod(j, "A", "~A"));
REQUIRE(IsMethod(j, "A", "basic_method"));
REQUIRE(IsMethod(j, "A", "static_method"));
REQUIRE(IsMethod(j, "A", "const_method"));
REQUIRE(IsMethod(j, "A", "default_int"));
REQUIRE(IsMethod(j, "A", "default_string"));
REQUIRE(!IsDependency(j, "A", "A"));
save_json(config.output_directory(), diagram->name + ".json", j);
}
{
auto mmd = generate_class_mermaid(diagram, *model);
mermaid::AliasMatcher _A(mmd);
REQUIRE_THAT(mmd, IsClass(_A("A")));
REQUIRE_THAT(mmd, !IsDependency(_A("A"), _A("A")));
REQUIRE_THAT(mmd, (mermaid::IsMethod<Public, Default>("A")));
REQUIRE_THAT(
mmd, (mermaid::IsMethod<Public, Default>("A", "void", "A &&")));
REQUIRE_THAT(mmd,
(mermaid::IsMethod<Public, Deleted>("A", "void", "const A &")));
REQUIRE_THAT(mmd, (mermaid::IsMethod<Public, Default>("~A")));
REQUIRE_THAT(mmd, (mermaid::IsMethod<Public>("basic_method")));
REQUIRE_THAT(
mmd, (mermaid::IsMethod<Public, Static>("static_method", "int")));
REQUIRE_THAT(mmd, (mermaid::IsMethod<Public, Const>("const_method")));
REQUIRE_THAT(mmd,
(mermaid::IsMethod<Public>("default_int", "int", "int i = 12")));
REQUIRE_THAT(mmd,
(mermaid::IsMethod<Public>("default_string", "std::string",
"int i, std::string s = \"abc\"")));
REQUIRE_THAT(mmd,
(mermaid::IsMethod<Public, Const, Constexpr>(
"size", "std::size_t")));
REQUIRE_THAT(mmd, (mermaid::IsMethod<Protected>("protected_method")));
REQUIRE_THAT(mmd, (mermaid::IsMethod<Private>("private_method")));
REQUIRE_THAT(mmd, (IsField<Public>("public_member", "int")));
REQUIRE_THAT(mmd, (IsField<Protected>("protected_member", "int")));
REQUIRE_THAT(mmd, (IsField<Private>("private_member", "int")));
REQUIRE_THAT(mmd,
(IsField<Public, Static>("auto_member", "const unsigned long")));
REQUIRE_THAT(mmd, (IsField<Private>("a_", "int")));
REQUIRE_THAT(mmd, (IsField<Private>("b_", "int")));
REQUIRE_THAT(mmd, (IsField<Private>("c_", "int")));
save_mermaid(config.output_directory(), diagram->name + ".mmd", mmd);
}
REQUIRE(IsField<Private>(src, "A", "a_", "int"));
REQUIRE(IsField<Private>(src, "A", "b_", "int"));
REQUIRE(IsField<Private>(src, "A", "c_", "int"));
});
}

117
tests/t00004/test_case.h
View File

@@ -1,5 +1,5 @@
/**
* tests/t00004/test_case.cc
* tests/t00004/test_case.h
*
* Copyright (c) 2021-2024 Bartek Kryza <bkryza@gmail.com>
*
@@ -16,8 +16,10 @@
* limitations under the License.
*/
TEST_CASE("t00004", "[test-case][class]")
TEST_CASE("t00004")
{
using namespace clanguml::test;
auto [config, db] = load_config("t00004");
auto diagram = config.diagrams["t00004_class"];
@@ -31,94 +33,33 @@ TEST_CASE("t00004", "[test-case][class]")
REQUIRE(model->name() == "t00004_class");
{
auto puml = generate_class_puml(diagram, *model);
AliasMatcher _A(puml);
CHECK_CLASS_DIAGRAM(config, diagram, *model,
[](const auto &src) {
REQUIRE(IsClass(src, "A"));
REQUIRE(IsClass(src, "A::AA"));
REQUIRE(IsClass(src, "A::AA::AAA"));
REQUIRE(IsEnum(src, "B::AA"));
REQUIRE(IsEnum(src, "A::AA::Lights"));
REQUIRE(IsInnerClass(src, "A", "A::AA"));
REQUIRE(IsInnerClass(src, "A::AA", "A::AA::AAA"));
REQUIRE(IsInnerClass(src, "A::AA", "A::AA::Lights"));
REQUIRE_THAT(puml, StartsWith("@startuml"));
REQUIRE_THAT(puml, EndsWith("@enduml\n"));
REQUIRE_THAT(puml, IsClass(_A("A")));
REQUIRE_THAT(puml, IsClass(_A("A::AA")));
REQUIRE_THAT(puml, IsClass(_A("A::AA::AAA")));
REQUIRE_THAT(puml, IsEnum(_A("B::AA")));
REQUIRE_THAT(puml, IsEnum(_A("A::AA::Lights")));
REQUIRE_THAT(puml, IsInnerClass(_A("A"), _A("A::AA")));
REQUIRE_THAT(puml, IsInnerClass(_A("A::AA"), _A("A::AA::AAA")));
REQUIRE_THAT(puml, IsInnerClass(_A("A::AA"), _A("A::AA::Lights")));
REQUIRE(IsMethod<Public, Const>(src, "A", "foo"));
REQUIRE(IsMethod<Public, Const>(src, "A", "foo2"));
REQUIRE_THAT(puml, (IsMethod<Public, Const>("foo")));
REQUIRE_THAT(puml, (IsMethod<Public, Const>("foo2")));
REQUIRE(IsClassTemplate(src, "C<T>"));
REQUIRE(IsInnerClass(src, "C<T>", "C::AA"));
REQUIRE(IsInnerClass(src, "C::AA", "C::AA::AAA"));
REQUIRE(IsInnerClass(src, "C<T>", "C::CC"));
REQUIRE(IsInnerClass(src, "C::AA", "C::AA::CCC"));
REQUIRE_THAT(puml, IsClassTemplate("C", "T"));
REQUIRE_THAT(puml, IsInnerClass(_A("C<T>"), _A("C::AA")));
REQUIRE_THAT(puml, IsInnerClass(_A("C::AA"), _A("C::AA::AAA")));
REQUIRE_THAT(puml, IsInnerClass(_A("C<T>"), _A("C::CC")));
REQUIRE_THAT(puml, IsInnerClass(_A("C::AA"), _A("C::AA::CCC")));
REQUIRE(IsInnerClass(src, "C<T>", "C::B<V>"));
REQUIRE(IsAggregation<Public>(src, "C<T>", "C::B<int>", "b_int"));
REQUIRE(!IsInnerClass(src, "C<T>", "C::B"));
REQUIRE(IsInstantiation(src, "C::B<V>", "C::B<int>"));
REQUIRE_THAT(puml, IsInnerClass(_A("C<T>"), _A("C::B<V>")));
REQUIRE_THAT(
puml, IsAggregation(_A("C<T>"), _A("C::B<int>"), "+b_int"));
REQUIRE_THAT(puml, !IsInnerClass(_A("C<T>"), _A("C::B")));
REQUIRE_THAT(puml, IsInstantiation(_A("C::B<V>"), _A("C::B<int>")));
REQUIRE_THAT(puml, IsClass(_A("detail::D")));
REQUIRE_THAT(puml, IsClass(_A("detail::D::DD")));
REQUIRE_THAT(puml, IsEnum(_A("detail::D::AA")));
save_puml(config.output_directory(), diagram->name + ".puml", puml);
}
{
auto j = generate_class_json(diagram, *model);
using namespace json;
REQUIRE(IsClass(j, "A"));
REQUIRE(IsClass(j, "A::AA"));
REQUIRE(IsClass(j, "A::AA::AAA"));
REQUIRE(IsEnum(j, "B::AA"));
REQUIRE(IsEnum(j, "A::AA::Lights"));
REQUIRE(IsInnerClass(j, "A", "A::AA"));
REQUIRE(IsInnerClass(j, "A::AA", "A::AA::AAA"));
REQUIRE(IsInnerClass(j, "A::AA", "A::AA::Lights"));
REQUIRE(IsClassTemplate(j, "C<T>"));
REQUIRE(IsClass(j, "detail::D"));
REQUIRE(IsClass(j, "detail::D::DD"));
REQUIRE(IsEnum(j, "detail::D::AA"));
save_json(config.output_directory(), diagram->name + ".json", j);
}
{
auto mmd = generate_class_mermaid(diagram, *model);
mermaid::AliasMatcher _A(mmd);
REQUIRE_THAT(mmd, IsClass(_A("A")));
REQUIRE_THAT(mmd, IsClass(_A("A::AA")));
REQUIRE_THAT(mmd, IsClass(_A("A::AA::AAA")));
REQUIRE_THAT(mmd, mermaid::IsEnum(_A("B::AA")));
REQUIRE_THAT(mmd, mermaid::IsEnum(_A("A::AA::Lights")));
REQUIRE_THAT(mmd, mermaid::IsInnerClass(_A("A"), _A("A::AA")));
REQUIRE_THAT(mmd, mermaid::IsInnerClass(_A("A::AA"), _A("A::AA::AAA")));
REQUIRE_THAT(
mmd, mermaid::IsInnerClass(_A("A::AA"), _A("A::AA::Lights")));
REQUIRE_THAT(mmd, IsClass(_A("C<T>")));
REQUIRE_THAT(mmd, mermaid::IsInnerClass(_A("C<T>"), _A("C::AA")));
REQUIRE_THAT(mmd, mermaid::IsInnerClass(_A("C::AA"), _A("C::AA::AAA")));
REQUIRE_THAT(mmd, mermaid::IsInnerClass(_A("C<T>"), _A("C::CC")));
REQUIRE_THAT(mmd, mermaid::IsInnerClass(_A("C::AA"), _A("C::AA::CCC")));
REQUIRE_THAT(mmd, mermaid::IsInnerClass(_A("C<T>"), _A("C::B<V>")));
REQUIRE_THAT(mmd, IsAggregation(_A("C<T>"), _A("C::B<int>"), "+b_int"));
REQUIRE_THAT(mmd, !mermaid::IsInnerClass(_A("C<T>"), _A("C::B")));
REQUIRE_THAT(mmd, IsInstantiation(_A("C::B<V>"), _A("C::B<int>")));
REQUIRE_THAT(mmd, IsClass(_A("detail::D")));
REQUIRE_THAT(mmd, IsClass(_A("detail::D::DD")));
REQUIRE_THAT(mmd, mermaid::IsEnum(_A("detail::D::AA")));
save_mermaid(config.output_directory(), diagram->name + ".mmd", mmd);
}
REQUIRE(IsClass(src, "detail::D"));
REQUIRE(IsClass(src, "detail::D::DD"));
REQUIRE(IsEnum(src, "detail::D::AA"));
});
}

142
tests/t00005/test_case.h
View File

@@ -1,5 +1,5 @@
/**
* tests/t00005/test_case.cc
* tests/t00005/test_case.h
*
* Copyright (c) 2021-2024 Bartek Kryza <bkryza@gmail.com>
*
@@ -16,8 +16,10 @@
* limitations under the License.
*/
TEST_CASE("t00005", "[test-case][class]")
TEST_CASE("t00005")
{
using namespace clanguml::test;
auto [config, db] = load_config("t00005");
auto diagram = config.diagrams["t00005_class"];
@@ -28,112 +30,36 @@ TEST_CASE("t00005", "[test-case][class]")
REQUIRE(model->name() == "t00005_class");
{
auto puml = generate_class_puml(diagram, *model);
AliasMatcher _A(puml);
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(IsClass(src, "K"));
REQUIRE(IsClass(src, "R"));
REQUIRE_THAT(puml, StartsWith("@startuml"));
REQUIRE_THAT(puml, EndsWith("@enduml\n"));
REQUIRE_THAT(puml, IsClass(_A("A")));
REQUIRE_THAT(puml, IsClass(_A("B")));
REQUIRE_THAT(puml, IsClass(_A("C")));
REQUIRE_THAT(puml, IsClass(_A("D")));
REQUIRE_THAT(puml, IsClass(_A("E")));
REQUIRE_THAT(puml, IsClass(_A("F")));
REQUIRE_THAT(puml, IsClass(_A("G")));
REQUIRE_THAT(puml, IsClass(_A("H")));
REQUIRE_THAT(puml, IsClass(_A("I")));
REQUIRE_THAT(puml, IsClass(_A("J")));
REQUIRE_THAT(puml, IsClass(_A("K")));
REQUIRE_THAT(puml, IsClass(_A("R")));
REQUIRE((IsField<Public>(src, "R", "some_int", "int")));
REQUIRE((IsField<Public>(src, "R", "some_int_pointer", "int *")));
REQUIRE((IsField<Public>(
src, "R", "some_int_pointer_pointer", "int **")));
REQUIRE_THAT(puml, (IsField<Public>("some_int", "int")));
REQUIRE_THAT(puml, (IsField<Public>("some_int_pointer", "int *")));
REQUIRE_THAT(
puml, (IsField<Public>("some_int_pointer_pointer", "int **")));
REQUIRE_THAT(puml, IsAggregation(_A("R"), _A("A"), "+a"));
REQUIRE_THAT(puml, IsAssociation(_A("R"), _A("B"), "+b"));
REQUIRE_THAT(puml, IsAssociation(_A("R"), _A("C"), "+c"));
REQUIRE_THAT(puml, IsAssociation(_A("R"), _A("D"), "+d"));
REQUIRE_THAT(puml, IsAssociation(_A("R"), _A("E"), "+e"));
REQUIRE_THAT(puml, IsAggregation(_A("R"), _A("F"), "+f"));
REQUIRE_THAT(puml, IsAssociation(_A("R"), _A("G"), "+g"));
REQUIRE_THAT(puml, IsAssociation(_A("R"), _A("H"), "+h"));
REQUIRE_THAT(puml, IsAssociation(_A("R"), _A("I"), "+i"));
REQUIRE_THAT(puml, IsAssociation(_A("R"), _A("J"), "+j"));
REQUIRE_THAT(puml, IsAssociation(_A("R"), _A("K"), "+k"));
save_puml(config.output_directory(), diagram->name + ".puml", puml);
}
{
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, "D"));
REQUIRE(IsClass(j, "E"));
REQUIRE(IsClass(j, "F"));
REQUIRE(IsClass(j, "G"));
REQUIRE(IsClass(j, "H"));
REQUIRE(IsClass(j, "I"));
REQUIRE(IsClass(j, "J"));
REQUIRE(IsClass(j, "K"));
REQUIRE(IsClass(j, "R"));
REQUIRE(IsAggregation(j, "R", "A", "a"));
REQUIRE(IsAssociation(j, "R", "B", "b"));
REQUIRE(IsAssociation(j, "R", "C", "c"));
REQUIRE(IsAssociation(j, "R", "D", "d"));
REQUIRE(IsAssociation(j, "R", "E", "e"));
REQUIRE(IsAggregation(j, "R", "F", "f"));
REQUIRE(IsAssociation(j, "R", "G", "g"));
REQUIRE(IsAssociation(j, "R", "H", "h"));
REQUIRE(IsAssociation(j, "R", "I", "i"));
REQUIRE(IsAssociation(j, "R", "J", "j"));
REQUIRE(IsAssociation(j, "R", "K", "k"));
save_json(config.output_directory(), diagram->name + ".json", j);
}
{
auto mmd = generate_class_mermaid(diagram, *model);
mermaid::AliasMatcher _A(mmd);
REQUIRE_THAT(mmd, StartsWith("classDiagram"));
REQUIRE_THAT(mmd, IsClass(_A("A")));
REQUIRE_THAT(mmd, IsClass(_A("B")));
REQUIRE_THAT(mmd, IsClass(_A("C")));
REQUIRE_THAT(mmd, IsClass(_A("D")));
REQUIRE_THAT(mmd, IsClass(_A("E")));
REQUIRE_THAT(mmd, IsClass(_A("F")));
REQUIRE_THAT(mmd, IsClass(_A("G")));
REQUIRE_THAT(mmd, IsClass(_A("H")));
REQUIRE_THAT(mmd, IsClass(_A("I")));
REQUIRE_THAT(mmd, IsClass(_A("J")));
REQUIRE_THAT(mmd, IsClass(_A("K")));
REQUIRE_THAT(mmd, IsClass(_A("R")));
REQUIRE_THAT(mmd, (IsField<Public>("some_int", "int")));
REQUIRE_THAT(mmd, (IsField<Public>("some_int_pointer", "int *")));
REQUIRE_THAT(
mmd, (IsField<Public>("some_int_pointer_pointer", "int **")));
REQUIRE_THAT(mmd, IsAggregation(_A("R"), _A("A"), "+a"));
REQUIRE_THAT(mmd, IsAssociation(_A("R"), _A("B"), "+b"));
REQUIRE_THAT(mmd, IsAssociation(_A("R"), _A("C"), "+c"));
REQUIRE_THAT(mmd, IsAssociation(_A("R"), _A("D"), "+d"));
REQUIRE_THAT(mmd, IsAssociation(_A("R"), _A("E"), "+e"));
REQUIRE_THAT(mmd, IsAggregation(_A("R"), _A("F"), "+f"));
REQUIRE_THAT(mmd, IsAssociation(_A("R"), _A("G"), "+g"));
REQUIRE_THAT(mmd, IsAssociation(_A("R"), _A("H"), "+h"));
REQUIRE_THAT(mmd, IsAssociation(_A("R"), _A("I"), "+i"));
REQUIRE_THAT(mmd, IsAssociation(_A("R"), _A("J"), "+j"));
REQUIRE_THAT(mmd, IsAssociation(_A("R"), _A("K"), "+k"));
save_mermaid(config.output_directory(), diagram->name + ".mmd", mmd);
}
REQUIRE(IsAggregation<Public>(src, "R", "A", "a"));
REQUIRE(IsAssociation<Public>(src, "R", "B", "b"));
REQUIRE(IsAssociation<Public>(src, "R", "C", "c"));
REQUIRE(IsAssociation<Public>(src, "R", "D", "d"));
REQUIRE(IsAssociation<Public>(src, "R", "E", "e"));
REQUIRE(IsAggregation<Public>(src, "R", "F", "f"));
REQUIRE(IsAssociation<Public>(src, "R", "G", "g"));
REQUIRE(IsAssociation<Public>(src, "R", "H", "h"));
REQUIRE(IsAssociation<Public>(src, "R", "I", "i"));
REQUIRE(IsAssociation<Public>(src, "R", "J", "j"));
REQUIRE(IsAssociation<Public>(src, "R", "K", "k"));
});
}

165
tests/t00006/test_case.h
View File

@@ -1,5 +1,5 @@
/**
* tests/t00006/test_case.cc
* tests/t00006/test_case.h
*
* Copyright (c) 2021-2024 Bartek Kryza <bkryza@gmail.com>
*
@@ -16,8 +16,10 @@
* limitations under the License.
*/
TEST_CASE("t00006", "[test-case][class]")
TEST_CASE("t00006")
{
using namespace clanguml::test;
auto [config, db] = load_config("t00006");
auto diagram = config.diagrams["t00006_class"];
@@ -28,127 +30,44 @@ TEST_CASE("t00006", "[test-case][class]")
REQUIRE(model->name() == "t00006_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(IsClass(src, "H"));
REQUIRE(IsClass(src, "I"));
REQUIRE(IsClass(src, "J"));
REQUIRE(IsClass(src, "K"));
REQUIRE(IsClass(src, "L"));
REQUIRE(IsClass(src, "M"));
REQUIRE(IsClass(src, "N"));
REQUIRE(IsClass(src, "NN"));
REQUIRE(IsClass(src, "NNN"));
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")));
REQUIRE_THAT(src, IsClass(_A("H")));
REQUIRE_THAT(src, IsClass(_A("I")));
REQUIRE_THAT(src, IsClass(_A("J")));
REQUIRE_THAT(src, IsClass(_A("K")));
REQUIRE_THAT(src, IsClass(_A("L")));
REQUIRE_THAT(src, IsClass(_A("M")));
REQUIRE_THAT(src, IsClass(_A("N")));
REQUIRE_THAT(src, IsClass(_A("NN")));
REQUIRE_THAT(src, IsClass(_A("NNN")));
REQUIRE(IsInstantiation(
src, "custom_container<T>", "custom_container<E>"));
REQUIRE_THAT(src,
IsInstantiation(
_A("custom_container<T>"), _A("custom_container<E>")));
REQUIRE_THAT(src, IsAggregation(_A("R"), _A("A"), "+a"));
REQUIRE_THAT(src, IsAssociation(_A("R"), _A("B"), "+b"));
REQUIRE_THAT(src, IsAggregation(_A("R"), _A("C"), "+c"));
REQUIRE_THAT(src, IsAssociation(_A("R"), _A("D"), "+d"));
REQUIRE_THAT(
src, IsAggregation(_A("R"), _A("custom_container<E>"), "+e"));
REQUIRE_THAT(src, IsAggregation(_A("R"), _A("F"), "+f"));
REQUIRE_THAT(src, IsAssociation(_A("R"), _A("G"), "+g"));
REQUIRE_THAT(src, IsAggregation(_A("R"), _A("H"), "+h"));
REQUIRE_THAT(src, IsAssociation(_A("R"), _A("I"), "+i"));
REQUIRE_THAT(src, IsAggregation(_A("R"), _A("J"), "+j"));
REQUIRE_THAT(src, IsAssociation(_A("R"), _A("K"), "+k"));
REQUIRE_THAT(src, IsAggregation(_A("R"), _A("L"), "+lm"));
REQUIRE_THAT(src, IsAggregation(_A("R"), _A("M"), "+lm"));
REQUIRE_THAT(src, IsAggregation(_A("R"), _A("N"), "+ns"));
REQUIRE_THAT(src, IsAggregation(_A("R"), _A("NN"), "+ns"));
REQUIRE_THAT(src, IsAggregation(_A("R"), _A("NNN"), "+ns"));
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, "D"));
REQUIRE(IsClass(j, "E"));
REQUIRE(IsClass(j, "F"));
REQUIRE(IsClass(j, "G"));
REQUIRE(IsClass(j, "H"));
REQUIRE(IsClass(j, "I"));
REQUIRE(IsClass(j, "J"));
REQUIRE(IsClass(j, "K"));
REQUIRE(IsClass(j, "L"));
REQUIRE(IsClass(j, "M"));
REQUIRE(IsClass(j, "N"));
REQUIRE(IsClass(j, "NN"));
REQUIRE(IsClass(j, "NNN"));
REQUIRE(IsAggregation(j, "R", "custom_container<E>", "e"));
REQUIRE(
IsInstantiation(j, "custom_container<T>", "custom_container<E>"));
save_json(config.output_directory(), diagram->name + ".json", j);
}
{
auto src = generate_class_mermaid(diagram, *model);
using mermaid::AliasMatcher;
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")));
REQUIRE_THAT(src, IsClass(_A("H")));
REQUIRE_THAT(src, IsClass(_A("I")));
REQUIRE_THAT(src, IsClass(_A("J")));
REQUIRE_THAT(src, IsClass(_A("K")));
REQUIRE_THAT(src, IsClass(_A("L")));
REQUIRE_THAT(src, IsClass(_A("M")));
REQUIRE_THAT(src, IsClass(_A("N")));
REQUIRE_THAT(src, IsClass(_A("NN")));
REQUIRE_THAT(src, IsClass(_A("NNN")));
REQUIRE_THAT(src,
IsInstantiation(
_A("custom_container<T>"), _A("custom_container<E>")));
REQUIRE_THAT(src, IsAggregation(_A("R"), _A("A"), "+a"));
REQUIRE_THAT(src, IsAssociation(_A("R"), _A("B"), "+b"));
REQUIRE_THAT(src, IsAggregation(_A("R"), _A("C"), "+c"));
REQUIRE_THAT(src, IsAssociation(_A("R"), _A("D"), "+d"));
REQUIRE_THAT(
src, IsAggregation(_A("R"), _A("custom_container<E>"), "+e"));
REQUIRE_THAT(src, IsAggregation(_A("R"), _A("F"), "+f"));
REQUIRE_THAT(src, IsAssociation(_A("R"), _A("G"), "+g"));
REQUIRE_THAT(src, IsAggregation(_A("R"), _A("H"), "+h"));
REQUIRE_THAT(src, IsAssociation(_A("R"), _A("I"), "+i"));
REQUIRE_THAT(src, IsAggregation(_A("R"), _A("J"), "+j"));
REQUIRE_THAT(src, IsAssociation(_A("R"), _A("K"), "+k"));
REQUIRE_THAT(src, IsAggregation(_A("R"), _A("L"), "+lm"));
REQUIRE_THAT(src, IsAggregation(_A("R"), _A("M"), "+lm"));
REQUIRE_THAT(src, IsAggregation(_A("R"), _A("N"), "+ns"));
REQUIRE_THAT(src, IsAggregation(_A("R"), _A("NN"), "+ns"));
REQUIRE_THAT(src, IsAggregation(_A("R"), _A("NNN"), "+ns"));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}
REQUIRE(IsAggregation<Public>(src, "R", "A", "a"));
REQUIRE(IsAssociation<Public>(src, "R", "B", "b"));
REQUIRE(IsAggregation<Public>(src, "R", "C", "c"));
REQUIRE(IsAssociation<Public>(src, "R", "D", "d"));
REQUIRE(
IsAggregation<Public>(src, "R", "custom_container<E>", "e"));
REQUIRE(IsAggregation<Public>(src, "R", "F", "f"));
REQUIRE(IsAssociation<Public>(src, "R", "G", "g"));
REQUIRE(IsAggregation<Public>(src, "R", "H", "h"));
REQUIRE(IsAssociation<Public>(src, "R", "I", "i"));
REQUIRE(IsAggregation<Public>(src, "R", "J", "j"));
REQUIRE(IsAssociation<Public>(src, "R", "K", "k"));
REQUIRE(IsAggregation<Public>(src, "R", "L", "lm"));
REQUIRE(IsAggregation<Public>(src, "R", "M", "lm"));
REQUIRE(IsAggregation<Public>(src, "R", "N", "ns"));
REQUIRE(IsAggregation<Public>(src, "R", "NN", "ns"));
REQUIRE(IsAggregation<Public>(src, "R", "NNN", "ns"));
});
}

62
tests/t00007/test_case.h
View File

@@ -1,5 +1,5 @@
/**
* tests/t00007/test_case.cc
* tests/t00007/test_case.h
*
* Copyright (c) 2021-2024 Bartek Kryza <bkryza@gmail.com>
*
@@ -16,8 +16,10 @@
* limitations under the License.
*/
TEST_CASE("t00007", "[test-case][class]")
TEST_CASE("t00007")
{
using namespace clanguml::test;
auto [config, db] = load_config("t00007");
auto diagram = config.diagrams["t00007_class"];
@@ -28,52 +30,14 @@ TEST_CASE("t00007", "[test-case][class]")
REQUIRE(model->name() == "t00007_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, "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("R")));
REQUIRE_THAT(src, IsAggregation(_A("R"), _A("A"), "+a"));
REQUIRE_THAT(src, IsAssociation(_A("R"), _A("B"), "+b"));
REQUIRE_THAT(src, IsAssociation(_A("R"), _A("C"), "+c"));
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, "R"));
REQUIRE(IsAggregation(j, "R", "A", "a"));
REQUIRE(IsAssociation(j, "R", "B", "b"));
REQUIRE(IsAssociation(j, "R", "C", "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("A")));
REQUIRE_THAT(src, IsClass(_A("B")));
REQUIRE_THAT(src, IsClass(_A("C")));
REQUIRE_THAT(src, IsClass(_A("R")));
REQUIRE_THAT(src, IsAggregation(_A("R"), _A("A"), "+a"));
REQUIRE_THAT(src, IsAssociation(_A("R"), _A("B"), "+b"));
REQUIRE_THAT(src, IsAssociation(_A("R"), _A("C"), "+c"));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}
REQUIRE(IsAggregation<Public>(src, "R", "A", "a"));
REQUIRE(IsAssociation<Public>(src, "R", "B", "b"));
REQUIRE(IsAssociation<Public>(src, "R", "C", "c"));
});
}

102
tests/t00008/test_case.h
View File

@@ -1,5 +1,5 @@
/**
* tests/t00008/test_case.cc
* tests/t00008/test_case.h
*
* Copyright (c) 2021-2024 Bartek Kryza <bkryza@gmail.com>
*
@@ -16,8 +16,10 @@
* limitations under the License.
*/
TEST_CASE("t00008", "[test-case][class]")
TEST_CASE("t00008")
{
using namespace clanguml::test;
auto [config, db] = load_config("t00008");
auto diagram = config.diagrams["t00008_class"];
@@ -28,73 +30,35 @@ TEST_CASE("t00008", "[test-case][class]")
REQUIRE(model->name() == "t00008_class");
{
auto src = generate_class_puml(diagram, *model);
AliasMatcher _A(src);
CHECK_CLASS_DIAGRAM(
config, diagram, *model,
[](const auto &src) {
// TODO: add option to resolve using declared types
// REQUIRE(IsClassTemplate(src, "A<T,P,bool (*)(int, int),int N>"));
REQUIRE(IsClassTemplate(src, "A<T,P=T,CMP=nullptr,int N=3>"));
REQUIRE(IsClassTemplate(src, "B<T,C<>>"));
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
// TODO: add option to resolve using declared types
// REQUIRE_THAT(puml, IsClassTemplate("A", "T, P, bool (*)(int, int),
// int N"));
REQUIRE_THAT(src, IsClassTemplate("A", "T,P=T,CMP=nullptr,int N=3"));
REQUIRE_THAT(src, IsClassTemplate("B", "T,C<>"));
REQUIRE(IsField<Public>(
src, "A<T,P=T,CMP=nullptr,int N=3>", "value", "T"));
REQUIRE(IsField<Public>(
src, "A<T,P=T,CMP=nullptr,int N=3>", "pointer", "T *"));
REQUIRE(IsField<Public>(
src, "A<T,P=T,CMP=nullptr,int N=3>", "reference", "T &"));
REQUIRE(IsField<Public>(src, "A<T,P=T,CMP=nullptr,int N=3>",
"values", "std::vector<P>"));
REQUIRE(IsField<Public>(src, "A<T,P=T,CMP=nullptr,int N=3>", "ints",
"std::array<int,N>"));
// TODO: add option to resolve using declared types
// REQUIRE(IsField(src, Public("bool (*)(int, int) comparator"));
REQUIRE(IsField<Public>(
src, "A<T,P=T,CMP=nullptr,int N=3>", "comparator", "CMP"));
REQUIRE_THAT(src, (IsField<Public>("value", "T")));
REQUIRE_THAT(src, (IsField<Public>("pointer", "T *")));
REQUIRE_THAT(src, (IsField<Public>("reference", "T &")));
REQUIRE_THAT(src, (IsField<Public>("values", "std::vector<P>")));
REQUIRE_THAT(src, (IsField<Public>("ints", "std::array<int,N>")));
// TODO: add option to resolve using declared types
// REQUIRE_THAT(puml, IsField(Public("bool (*)(int, int) comparator")));
REQUIRE_THAT(src, (IsField<Public>("comparator", "CMP")));
REQUIRE_THAT(src, !IsClass(_A("E::nested_template")));
REQUIRE_THAT(src, IsClassTemplate("E::nested_template", "ET"));
REQUIRE_THAT(src, IsClassTemplate("E::nested_template", "char"));
REQUIRE_THAT(src,
IsInstantiation(
_A("E::nested_template<ET>"), _A("E::nested_template<char>")));
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
{
auto j = generate_class_json(diagram, *model);
using namespace json;
REQUIRE(IsClassTemplate(j, "A<T,P=T,CMP=nullptr,int N=3>"));
REQUIRE(IsClassTemplate(j, "E::nested_template<ET>"));
REQUIRE(IsClass(j, "E::nested_template<char>"));
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<T,P=T,CMP=nullptr,int N=3>")));
REQUIRE_THAT(src, IsClass(_A("B<T,C<>>")));
REQUIRE_THAT(src, (IsField<Public>("value", "T")));
REQUIRE_THAT(src, (IsField<Public>("pointer", "T *")));
REQUIRE_THAT(src, (IsField<Public>("reference", "T &")));
REQUIRE_THAT(src, (IsField<Public>("values", "std::vector<P>")));
REQUIRE_THAT(src, (IsField<Public>("ints", "std::array<int,N>")));
// TODO: add option to resolve using declared types
// REQUIRE_THAT(puml, IsField(Public("bool (*)(int, int) comparator")));
REQUIRE_THAT(src, (IsField<Public>("comparator", "CMP")));
REQUIRE_THAT(src, !IsClass(_A("E::nested_template")));
REQUIRE_THAT(src, IsClass(_A("E::nested_template<ET>")));
REQUIRE_THAT(src, IsClass(_A("E::nested_template<char>")));
REQUIRE_THAT(src,
IsInstantiation(
_A("E::nested_template<ET>"), _A("E::nested_template<char>")));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}
REQUIRE(IsClassTemplate(src, "E::nested_template<ET>"));
REQUIRE(IsClassTemplate(src, "E::nested_template<char>"));
REQUIRE(IsInstantiation(
src, "E::nested_template<ET>", "E::nested_template<char>"));
},
[](const plantuml_t &src) {
REQUIRE(!IsClass(src, "E::nested_template"));
});
}

94
tests/t00009/test_case.h
View File

@@ -1,5 +1,5 @@
/**
* tests/t00009/test_case.cc
* tests/t00009/test_case.h
*
* Copyright (c) 2021-2024 Bartek Kryza <bkryza@gmail.com>
*
@@ -16,8 +16,10 @@
* limitations under the License.
*/
TEST_CASE("t00009", "[test-case][class]")
TEST_CASE("t00009")
{
using namespace clanguml::test;
auto [config, db] = load_config("t00009");
auto diagram = config.diagrams["t00009_class"];
@@ -28,78 +30,24 @@ TEST_CASE("t00009", "[test-case][class]")
REQUIRE(model->name() == "t00009_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(IsClass(src, "B"));
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
REQUIRE_THAT(src, IsClassTemplate("A", "T"));
REQUIRE_THAT(src, IsClass(_A("B")));
REQUIRE(IsField<Public>(src, "A<T>", "value", "T"));
REQUIRE(IsField<Public>(src, "B", "aint", "A<int>"));
REQUIRE(IsField<Public>(src, "B", "astring", "A<std::string> *"));
REQUIRE(IsField<Public>(
src, "B", "avector", "A<std::vector<std::string>> &"));
REQUIRE_THAT(src, (IsField<Public>("value", "T")));
REQUIRE_THAT(src, (IsField<Public>("aint", "A<int>")));
REQUIRE_THAT(src, (IsField<Public>("astring", "A<std::string> *")));
REQUIRE_THAT(
src, (IsField<Public>("avector", "A<std::vector<std::string>> &")));
REQUIRE(IsInstantiation(src, "A<T>", "A<int>", "up"));
REQUIRE(IsInstantiation(src, "A<T>", "A<std::string>", "up"));
REQUIRE_THAT(src, IsInstantiation(_A("A<T>"), _A("A<int>"), "up"));
REQUIRE_THAT(
src, IsInstantiation(_A("A<T>"), _A("A<std::string>"), "up"));
REQUIRE_THAT(
src, IsAggregation(_A("B"), _A("A<int>"), "+aint", "", "", "up"));
REQUIRE_THAT(src,
IsAssociation(
_A("B"), _A("A<std::string>"), "+astring", "", "", "up"));
REQUIRE_THAT(src,
IsAssociation(_A("B"), _A("A<std::vector<std::string>>"),
"+avector", "", "", "up"));
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(IsClass(j, "A<int>"));
REQUIRE(IsClass(j, "A<std::string>"));
REQUIRE(IsClass(j, "A<std::vector<std::string>>"));
REQUIRE(IsField(j, "A<T>", "value", "T"));
REQUIRE(IsField(j, "B", "aint", "A<int>"));
REQUIRE(IsField(j, "B", "astring", "A<std::string> *"));
REQUIRE(IsField(j, "B", "avector", "A<std::vector<std::string>> &"));
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<T>")));
REQUIRE_THAT(src, IsClass(_A("B")));
REQUIRE_THAT(src, (IsField<Public>("value", "T")));
REQUIRE_THAT(src, (IsField<Public>("aint", "A<int>")));
REQUIRE_THAT(src, (IsField<Public>("astring", "A<std::string> *")));
REQUIRE_THAT(
src, (IsField<Public>("avector", "A<std::vector<std::string>> &")));
REQUIRE_THAT(src, IsInstantiation(_A("A<T>"), _A("A<int>")));
REQUIRE_THAT(src, IsInstantiation(_A("A<T>"), _A("A<std::string>")));
REQUIRE_THAT(src, IsAggregation(_A("B"), _A("A<int>"), "+aint"));
REQUIRE_THAT(
src, IsAssociation(_A("B"), _A("A<std::string>"), "+astring"));
REQUIRE_THAT(src,
IsAssociation(
_A("B"), _A("A<std::vector<std::string>>"), "+avector"));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}
REQUIRE(
IsAggregation<Public>(src, "B", "A<int>", "aint", "", "", "up"));
REQUIRE(IsAssociation<Public>(
src, "B", "A<std::string>", "astring", "", "", "up"));
REQUIRE(IsAssociation<Public>(
src, "B", "A<std::vector<std::string>>", "avector", "", "", "up"));
});
}

73
tests/t00010/test_case.h
View File

@@ -1,5 +1,5 @@
/**
* tests/t00010/test_case.cc
* tests/t00010/test_case.h
*
* Copyright (c) 2021-2024 Bartek Kryza <bkryza@gmail.com>
*
@@ -16,8 +16,10 @@
* limitations under the License.
*/
TEST_CASE("t00010", "[test-case][class]")
TEST_CASE("t00010")
{
using namespace clanguml::test;
auto [config, db] = load_config("t00010");
auto diagram = config.diagrams["t00010_class"];
@@ -28,63 +30,18 @@ TEST_CASE("t00010", "[test-case][class]")
REQUIRE(model->name() == "t00010_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,P>"));
REQUIRE(IsClassTemplate(src, "B<T>"));
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
REQUIRE_THAT(src, IsClassTemplate("A", "T,P"));
REQUIRE_THAT(src, IsClassTemplate("B", "T"));
REQUIRE(IsField<Public>(src, "B<T>", "astring", "A<T,std::string>"));
REQUIRE(IsField<Public>(src, "C", "aintstring", "B<int>"));
REQUIRE_THAT(src, (IsField<Public>("astring", "A<T,std::string>")));
REQUIRE_THAT(src, (IsField<Public>("aintstring", "B<int>")));
REQUIRE(IsInstantiation(src, "A<T,P>", "A<T,std::string>"));
REQUIRE(IsInstantiation(src, "B<T>", "B<int>"));
REQUIRE_THAT(
src, IsInstantiation(_A("A<T,P>"), _A("A<T,std::string>")));
REQUIRE_THAT(src, IsInstantiation(_A("B<T>"), _A("B<int>")));
REQUIRE_THAT(
src, IsAggregation(_A("B<T>"), _A("A<T,std::string>"), "+astring"));
REQUIRE_THAT(src, IsAggregation(_A("C"), _A("B<int>"), "+aintstring"));
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
{
auto j = generate_class_json(diagram, *model);
using namespace json;
REQUIRE(IsClassTemplate(j, "A<T,P>"));
REQUIRE(IsClassTemplate(j, "B<T>"));
REQUIRE(IsClass(j, "B<int>"));
REQUIRE(IsClass(j, "A<T,std::string>"));
REQUIRE(IsClass(j, "B<int>"));
REQUIRE(IsField(j, "C", "aintstring", "B<int>"));
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<T,P>")));
REQUIRE_THAT(src, IsClass(_A("B<T>")));
REQUIRE_THAT(src, (IsField<Public>("astring", "A<T,std::string>")));
REQUIRE_THAT(src, (IsField<Public>("aintstring", "B<int>")));
REQUIRE_THAT(
src, IsInstantiation(_A("A<T,P>"), _A("A<T,std::string>")));
REQUIRE_THAT(src, IsInstantiation(_A("B<T>"), _A("B<int>")));
REQUIRE_THAT(
src, IsAggregation(_A("B<T>"), _A("A<T,std::string>"), "+astring"));
REQUIRE_THAT(src, IsAggregation(_A("C"), _A("B<int>"), "+aintstring"));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}
REQUIRE(
IsAggregation<Public>(src, "B<T>", "A<T,std::string>", "astring"));
REQUIRE(IsAggregation<Public>(src, "C", "B<int>", "aintstring"));
});
}

57
tests/t00011/test_case.h
View File

@@ -1,5 +1,5 @@
/**
* tests/t00011/test_case.cc
* tests/t00011/test_case.h
*
* Copyright (c) 2021-2024 Bartek Kryza <bkryza@gmail.com>
*
@@ -16,8 +16,10 @@
* limitations under the License.
*/
TEST_CASE("t00011", "[test-case][class]")
TEST_CASE("t00011")
{
using namespace clanguml::test;
auto [config, db] = load_config("t00011");
auto diagram = config.diagrams["t00011_class"];
@@ -28,48 +30,13 @@ TEST_CASE("t00011", "[test-case][class]")
REQUIRE(model->name() == "t00011_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, "external::C"));
REQUIRE(IsClassTemplate(src, "D<T>"));
REQUIRE_THAT(src, IsClass(_A("A")));
REQUIRE_THAT(src, IsClass(_A("B")));
REQUIRE_THAT(src, !IsClass(_A("external::C")));
REQUIRE_THAT(src, IsClass(_A("D<T>")));
REQUIRE_THAT(src, IsAssociation(_A("B"), _A("A")));
REQUIRE_THAT(src, IsFriend<Public>(_A("A"), _A("B")));
// REQUIRE_THAT(puml, IsFriend(_A("A"), _A("D<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, "B"));
REQUIRE(IsClassTemplate(j, "D<T>"));
REQUIRE(IsFriend(j, "A", "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("B")));
REQUIRE_THAT(src, !IsClass(_A("external::C")));
REQUIRE_THAT(src, IsClass(_A("D<T>")));
REQUIRE_THAT(src, IsAssociation(_A("B"), _A("A")));
REQUIRE_THAT(src, IsFriend<Public>(_A("A"), _A("B")));
// REQUIRE_THAT(src, IsFriend(_A("A"), _A("D<T>")));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}
REQUIRE(IsAssociation<Public>(src, "B", "A"));
REQUIRE(IsFriend<Public>(src, "A", "B"));
});
}

69
tests/t00012/test_case.h
View File

@@ -1,5 +1,5 @@
/**
* tests/t00012/test_case.cc
* tests/t00012/test_case.h
*
* Copyright (c) 2021-2024 Bartek Kryza <bkryza@gmail.com>
*
@@ -16,8 +16,10 @@
* limitations under the License.
*/
TEST_CASE("t00012", "[test-case][class]")
TEST_CASE("t00012")
{
using namespace clanguml::test;
auto [config, db] = load_config("t00012");
auto diagram = config.diagrams["t00012_class"];
@@ -28,58 +30,15 @@ TEST_CASE("t00012", "[test-case][class]")
REQUIRE(model->name() == "t00012_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,Ts...>"));
REQUIRE(IsClassTemplate(src, "B<int... Is>"));
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
REQUIRE_THAT(src, IsClassTemplate("A", "T,Ts..."));
REQUIRE_THAT(src, IsClassTemplate("B", "int... Is"));
REQUIRE_THAT(src, IsInstantiation(_A("B<int... Is>"), _A("B<3,2,1>")));
REQUIRE_THAT(
src, IsInstantiation(_A("B<int... Is>"), _A("B<1,1,1,1>")));
REQUIRE_THAT(src,
IsInstantiation(_A("C<T,int... Is>"),
_A("C<std::map<int,"
"std::vector<std::vector<std::vector<std::string>>>>,3,3,"
"3>")));
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
{
auto j = generate_class_json(diagram, *model);
using namespace json;
REQUIRE(IsClassTemplate(j, "A<T,Ts...>"));
REQUIRE(IsClassTemplate(j, "B<int... Is>"));
REQUIRE(IsClass(j, "A<int,std::string,float>"));
REQUIRE(IsClass(j, "A<int,std::string,bool>"));
REQUIRE(IsClass(j,
"C<std::map<int,std::vector<std::vector<std::vector<std::string>>>>"
",3,3,3>"));
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,Ts...>")));
REQUIRE_THAT(src, IsClass(_A("B<int... Is>")));
REQUIRE_THAT(src, IsInstantiation(_A("B<int... Is>"), _A("B<3,2,1>")));
REQUIRE_THAT(
src, IsInstantiation(_A("B<int... Is>"), _A("B<1,1,1,1>")));
REQUIRE_THAT(src,
IsInstantiation(_A("C<T,int... Is>"),
_A("C<std::map<int,"
"std::vector<std::vector<std::vector<std::string>>>>,3,3,"
"3>")));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}
REQUIRE(IsInstantiation(src, "B<int... Is>", "B<3,2,1>"));
REQUIRE(IsInstantiation(src, "B<int... Is>", "B<1,1,1,1>"));
REQUIRE(IsInstantiation(src, "C<T,int... Is>",
"C<std::map<int,"
"std::vector<std::vector<std::vector<std::string>>>>,3,3,"
"3>"));
});
}

120
tests/t00013/test_case.h
View File

@@ -1,5 +1,5 @@
/**
* tests/t00013/test_case.cc
* tests/t00013/test_case.h
*
* Copyright (c) 2021-2024 Bartek Kryza <bkryza@gmail.com>
*
@@ -16,8 +16,10 @@
* limitations under the License.
*/
TEST_CASE("t00013", "[test-case][class]")
TEST_CASE("t00013")
{
using namespace clanguml::test;
auto [config, db] = load_config("t00013");
auto diagram = config.diagrams["t00013_class"];
@@ -28,95 +30,29 @@ TEST_CASE("t00013", "[test-case][class]")
REQUIRE(model->name() == "t00013_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(IsClassTemplate(src, "E<T>"));
REQUIRE(IsClassTemplate(src, "G<T,Args...>"));
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, IsClassTemplate("E", "T"));
REQUIRE_THAT(src, IsClassTemplate("G", "T,Args..."));
REQUIRE_THAT(src, !IsDependency(_A("R"), _A("R")));
REQUIRE_THAT(src, IsDependency(_A("R"), _A("A")));
REQUIRE_THAT(src, IsDependency(_A("R"), _A("B")));
REQUIRE_THAT(src, IsDependency(_A("R"), _A("C")));
REQUIRE_THAT(src, IsDependency(_A("R"), _A("D")));
REQUIRE_THAT(src, IsDependency(_A("D"), _A("R")));
REQUIRE_THAT(src, IsDependency(_A("R"), _A("E<T>")));
REQUIRE_THAT(src, IsDependency(_A("R"), _A("E<int>")));
REQUIRE_THAT(src, IsInstantiation(_A("E<T>"), _A("E<int>")));
REQUIRE_THAT(src, IsInstantiation(_A("E<T>"), _A("E<std::string>")));
REQUIRE_THAT(
src, IsAggregation(_A("R"), _A("E<std::string>"), "-estring"));
REQUIRE_THAT(src, IsDependency(_A("R"), _A("ABCD::F<T>")));
REQUIRE_THAT(
src, IsInstantiation(_A("ABCD::F<T>"), _A("ABCD::F<int>")));
REQUIRE_THAT(src, IsDependency(_A("R"), _A("ABCD::F<int>")));
REQUIRE_THAT(src,
IsInstantiation(
_A("G<T,Args...>"), _A("G<int,float,std::string>")));
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, "D"));
REQUIRE(IsInstantiation(j, "E<T>", "E<int>"));
REQUIRE(IsDependency(j, "R", "A"));
REQUIRE(IsDependency(j, "R", "B"));
REQUIRE(IsDependency(j, "R", "C"));
REQUIRE(IsDependency(j, "R", "D"));
REQUIRE(IsDependency(j, "D", "R"));
REQUIRE(IsDependency(j, "R", "E<int>"));
REQUIRE(IsInstantiation(j, "G<T,Args...>", "G<int,float,std::string>"));
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("B")));
REQUIRE_THAT(src, IsClass(_A("C")));
REQUIRE_THAT(src, IsClass(_A("D")));
REQUIRE_THAT(src, IsClass(_A("E<T>")));
REQUIRE_THAT(src, IsClass(_A("G<T,Args...>")));
REQUIRE_THAT(src, !IsDependency(_A("R"), _A("R")));
REQUIRE_THAT(src, IsDependency(_A("R"), _A("A")));
REQUIRE_THAT(src, IsDependency(_A("R"), _A("B")));
REQUIRE_THAT(src, IsDependency(_A("R"), _A("C")));
REQUIRE_THAT(src, IsDependency(_A("R"), _A("D")));
REQUIRE_THAT(src, IsDependency(_A("D"), _A("R")));
REQUIRE_THAT(src, IsDependency(_A("R"), _A("E<T>")));
REQUIRE_THAT(src, IsDependency(_A("R"), _A("E<int>")));
REQUIRE_THAT(src, IsInstantiation(_A("E<T>"), _A("E<int>")));
REQUIRE_THAT(src, IsInstantiation(_A("E<T>"), _A("E<std::string>")));
REQUIRE_THAT(
src, IsAggregation(_A("R"), _A("E<std::string>"), "-estring"));
REQUIRE_THAT(src, IsDependency(_A("R"), _A("ABCD::F<T>")));
REQUIRE_THAT(
src, IsInstantiation(_A("ABCD::F<T>"), _A("ABCD::F<int>")));
REQUIRE_THAT(src, IsDependency(_A("R"), _A("ABCD::F<int>")));
REQUIRE_THAT(src,
IsInstantiation(
_A("G<T,Args...>"), _A("G<int,float,std::string>")));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}
REQUIRE(!IsDependency(src, "R", "R"));
REQUIRE(IsDependency(src, "R", "A"));
REQUIRE(IsDependency(src, "R", "B"));
REQUIRE(IsDependency(src, "R", "C"));
REQUIRE(IsDependency(src, "R", "D"));
REQUIRE(IsDependency(src, "D", "R"));
REQUIRE(IsDependency(src, "R", "E<T>"));
REQUIRE(IsDependency(src, "R", "E<int>"));
REQUIRE(IsInstantiation(src, "E<T>", "E<int>"));
REQUIRE(IsInstantiation(src, "E<T>", "E<std::string>"));
REQUIRE(IsAggregation<Private>(src, "R", "E<std::string>", "estring"));
REQUIRE(IsDependency(src, "R", "ABCD::F<T>"));
REQUIRE(IsInstantiation(src, "ABCD::F<T>", "ABCD::F<int>"));
REQUIRE(IsDependency(src, "R", "ABCD::F<int>"));
REQUIRE(
IsInstantiation(src, "G<T,Args...>", "G<int,float,std::string>"));
});
}

528
tests/t00014/test_case.h
View File

File diff suppressed because it is too large Load Diff

53
tests/t00015/test_case.h
View File

@@ -1,5 +1,5 @@
/**
* tests/t00015/test_case.cc
* tests/t00015/test_case.h
*
* Copyright (c) 2021-2024 Bartek Kryza <bkryza@gmail.com>
*
@@ -16,8 +16,10 @@
* limitations under the License.
*/
TEST_CASE("t00015", "[test-case][class]")
TEST_CASE("t00015")
{
using namespace clanguml::test;
auto [config, db] = load_config("t00015");
auto diagram = config.diagrams["t00015_class"];
@@ -28,44 +30,11 @@ TEST_CASE("t00015", "[test-case][class]")
REQUIRE(model->name() == "t00015_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("ns1::A")));
REQUIRE_THAT(src, IsClass(_A("ns1::ns2_v0_9_0::A")));
REQUIRE_THAT(src, IsClass(_A("ns1::Anon")));
REQUIRE_THAT(src, IsClass(_A("ns3::ns1::ns2::Anon")));
REQUIRE_THAT(src, IsClass(_A("ns3::B")));
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
{
auto j = generate_class_json(diagram, *model);
using namespace json;
REQUIRE(IsClass(j, "ns1::A"));
REQUIRE(IsClass(j, "ns1::ns2_v0_9_0::A"));
REQUIRE(IsClass(j, "ns1::Anon"));
REQUIRE(IsClass(j, "ns3::ns1::ns2::Anon"));
REQUIRE(IsClass(j, "ns3::B"));
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("ns1::A")));
REQUIRE_THAT(src, IsClass(_A("ns1::ns2_v0_9_0::A")));
REQUIRE_THAT(src, IsClass(_A("ns1::Anon")));
REQUIRE_THAT(src, IsClass(_A("ns3::ns1::ns2::Anon")));
REQUIRE_THAT(src, IsClass(_A("ns3::B")));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}
CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(IsClass(src, "ns1::A"));
REQUIRE(IsClass(src, "ns1::ns2_v0_9_0::A"));
REQUIRE(IsClass(src, "ns1::Anon"));
REQUIRE(IsClass(src, "ns3::ns1::ns2::Anon"));
REQUIRE(IsClass(src, "ns3::B"));
});
}

85
tests/t00016/test_case.h
View File

@@ -1,5 +1,5 @@
/**
* tests/t00016/test_case.cc
* tests/t00016/test_case.h
*
* Copyright (c) 2021-2024 Bartek Kryza <bkryza@gmail.com>
*
@@ -16,8 +16,10 @@
* limitations under the License.
*/
TEST_CASE("t00016", "[test-case][class]")
TEST_CASE("t00016")
{
using namespace clanguml::test;
auto [config, db] = load_config("t00016");
auto diagram = config.diagrams["t00016_class"];
@@ -28,69 +30,20 @@ TEST_CASE("t00016", "[test-case][class]")
REQUIRE(model->name() == "t00016_class");
{
auto src = generate_class_puml(diagram, *model);
AliasMatcher _A(src);
CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(IsClassTemplate(src, "is_numeric<typename>"));
REQUIRE(IsClassTemplate(src, "is_numeric<int>"));
REQUIRE(IsClassTemplate(src, "is_numeric<bool>"));
REQUIRE(IsClassTemplate(src, "is_numeric<char>"));
REQUIRE(IsClassTemplate(src, "is_numeric<float>"));
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
REQUIRE_THAT(src, IsClassTemplate("is_numeric", "typename"));
REQUIRE_THAT(src, IsClassTemplate("is_numeric", "int"));
REQUIRE_THAT(src, IsClassTemplate("is_numeric", "bool"));
REQUIRE_THAT(src, IsClassTemplate("is_numeric", "char"));
REQUIRE_THAT(src, IsClassTemplate("is_numeric", "float"));
REQUIRE_THAT(src,
IsInstantiation(
_A("is_numeric<typename>"), _A("is_numeric<int>"), "up"));
REQUIRE_THAT(src,
IsInstantiation(
_A("is_numeric<typename>"), _A("is_numeric<bool>"), "up"));
REQUIRE_THAT(src,
IsInstantiation(
_A("is_numeric<typename>"), _A("is_numeric<char>"), "up"));
REQUIRE_THAT(src,
IsInstantiation(
_A("is_numeric<typename>"), _A("is_numeric<float>"), "up"));
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
{
auto j = generate_class_json(diagram, *model);
using namespace json;
REQUIRE(IsClassTemplate(j, "is_numeric<typename>"));
REQUIRE(IsClass(j, "is_numeric<int>"));
REQUIRE(IsClass(j, "is_numeric<bool>"));
REQUIRE(IsClass(j, "is_numeric<char>"));
REQUIRE(IsClass(j, "is_numeric<float>"));
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("is_numeric<typename>")));
REQUIRE_THAT(src, IsClass(_A("is_numeric<int>")));
REQUIRE_THAT(src, IsClass(_A("is_numeric<bool>")));
REQUIRE_THAT(src, IsClass(_A("is_numeric<char>")));
REQUIRE_THAT(src, IsClass(_A("is_numeric<float>")));
REQUIRE_THAT(src,
IsInstantiation(_A("is_numeric<typename>"), _A("is_numeric<int>")));
REQUIRE_THAT(src,
IsInstantiation(
_A("is_numeric<typename>"), _A("is_numeric<bool>")));
REQUIRE_THAT(src,
IsInstantiation(
_A("is_numeric<typename>"), _A("is_numeric<char>")));
REQUIRE_THAT(src,
IsInstantiation(
_A("is_numeric<typename>"), _A("is_numeric<float>")));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}
REQUIRE(IsInstantiation(
src, "is_numeric<typename>", "is_numeric<int>", "up"));
REQUIRE(IsInstantiation(
src, "is_numeric<typename>", "is_numeric<bool>", "up"));
REQUIRE(IsInstantiation(
src, "is_numeric<typename>", "is_numeric<char>", "up"));
REQUIRE(IsInstantiation(
src, "is_numeric<typename>", "is_numeric<float>", "up"));
});
}

148
tests/t00017/test_case.h
View File

@@ -1,5 +1,5 @@
/**
* tests/t00017/test_case.cc
* tests/t00017/test_case.h
*
* Copyright (c) 2021-2024 Bartek Kryza <bkryza@gmail.com>
*
@@ -16,8 +16,10 @@
* limitations under the License.
*/
TEST_CASE("t00017", "[test-case][class]")
TEST_CASE("t00017")
{
using namespace clanguml::test;
auto [config, db] = load_config("t00017");
auto diagram = config.diagrams["t00017_class"];
@@ -28,107 +30,47 @@ TEST_CASE("t00017", "[test-case][class]")
REQUIRE(model->name() == "t00017_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(IsClass(src, "H"));
REQUIRE(IsClass(src, "I"));
REQUIRE(IsClass(src, "J"));
REQUIRE(IsClass(src, "K"));
REQUIRE(IsClass(src, "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("F")));
REQUIRE_THAT(src, IsClass(_A("G")));
REQUIRE_THAT(src, IsClass(_A("H")));
REQUIRE_THAT(src, IsClass(_A("I")));
REQUIRE_THAT(src, IsClass(_A("J")));
REQUIRE_THAT(src, IsClass(_A("K")));
REQUIRE_THAT(src, IsClass(_A("R")));
REQUIRE(IsField<Private>(src, "R", "some_int", "int"));
REQUIRE((IsField<Private>(src, "R", "some_int_pointer", "int *")));
REQUIRE((IsField<Private>(
src, "R", "some_int_pointer_pointer", "int **")));
REQUIRE_THAT(src, (IsField<Private>("some_int", "int")));
REQUIRE_THAT(src, (IsField<Private>("some_int_pointer", "int *")));
REQUIRE_THAT(
src, (IsField<Private>("some_int_pointer_pointer", "int **")));
// Relationship members should not be rendered as part of this testcase
REQUIRE_THAT(src, !(IsField<Private>("a", _A("A"))));
REQUIRE_THAT(src, !(IsField<Private>("b", _A("B"))));
REQUIRE_THAT(src, IsAggregation(_A("R"), _A("A"), "-a"));
REQUIRE_THAT(src, IsAssociation(_A("R"), _A("B"), "-b"));
REQUIRE_THAT(src, IsAssociation(_A("R"), _A("C"), "-c"));
REQUIRE_THAT(src, IsAssociation(_A("R"), _A("D"), "-d"));
REQUIRE_THAT(src, IsAssociation(_A("R"), _A("E"), "-e"));
REQUIRE_THAT(src, IsAggregation(_A("R"), _A("F"), "-f"));
REQUIRE_THAT(src, IsAssociation(_A("R"), _A("G"), "-g"));
REQUIRE_THAT(src, IsAssociation(_A("R"), _A("H"), "-h"));
REQUIRE_THAT(src, IsAssociation(_A("R"), _A("I"), "-i"));
REQUIRE_THAT(src, IsAssociation(_A("R"), _A("J"), "-j"));
REQUIRE_THAT(src, IsAssociation(_A("R"), _A("K"), "-k"));
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, "D"));
REQUIRE(IsClass(j, "E"));
REQUIRE(IsClass(j, "F"));
REQUIRE(IsClass(j, "G"));
REQUIRE(IsClass(j, "H"));
REQUIRE(IsClass(j, "I"));
REQUIRE(IsClass(j, "J"));
REQUIRE(IsClass(j, "K"));
REQUIRE(IsClass(j, "R"));
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("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, IsClass(_A("H")));
REQUIRE_THAT(src, IsClass(_A("I")));
REQUIRE_THAT(src, IsClass(_A("J")));
REQUIRE_THAT(src, IsClass(_A("K")));
REQUIRE_THAT(src, IsClass(_A("R")));
REQUIRE_THAT(src, (IsField<Private>("some_int", "int")));
REQUIRE_THAT(src, (IsField<Private>("some_int_pointer", "int *")));
REQUIRE_THAT(
src, (IsField<Private>("some_int_pointer_pointer", "int **")));
// Relationship members should not be rendered as part of this testcase
REQUIRE_THAT(src, !(IsField<Private>("a", _A("A"))));
REQUIRE_THAT(src, !(IsField<Private>("b", _A("B"))));
REQUIRE_THAT(src, IsAggregation(_A("R"), _A("A"), "-a"));
REQUIRE_THAT(src, IsAssociation(_A("R"), _A("B"), "-b"));
REQUIRE_THAT(src, IsAssociation(_A("R"), _A("C"), "-c"));
REQUIRE_THAT(src, IsAssociation(_A("R"), _A("D"), "-d"));
REQUIRE_THAT(src, IsAssociation(_A("R"), _A("E"), "-e"));
REQUIRE_THAT(src, IsAggregation(_A("R"), _A("F"), "-f"));
REQUIRE_THAT(src, IsAssociation(_A("R"), _A("G"), "-g"));
REQUIRE_THAT(src, IsAssociation(_A("R"), _A("H"), "-h"));
REQUIRE_THAT(src, IsAssociation(_A("R"), _A("I"), "-i"));
REQUIRE_THAT(src, IsAssociation(_A("R"), _A("J"), "-j"));
REQUIRE_THAT(src, IsAssociation(_A("R"), _A("K"), "-k"));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}
REQUIRE(IsAggregation<Private>(src, "R", "A", "a"));
REQUIRE(IsAssociation<Private>(src, "R", "B", "b"));
REQUIRE(IsAssociation<Private>(src, "R", "C", "c"));
REQUIRE(IsAssociation<Private>(src, "R", "D", "d"));
REQUIRE(IsAssociation<Private>(src, "R", "E", "e"));
REQUIRE(IsAggregation<Private>(src, "R", "F", "f"));
REQUIRE(IsAssociation<Private>(src, "R", "G", "g"));
REQUIRE(IsAssociation<Private>(src, "R", "H", "h"));
REQUIRE(IsAssociation<Private>(src, "R", "I", "i"));
REQUIRE(IsAssociation<Private>(src, "R", "J", "j"));
REQUIRE(IsAssociation<Private>(src, "R", "K", "k"));
},
[](const plantuml_t &src) {
// Relationship members should not be rendered as part of this
// testcase
REQUIRE(!IsField<Private>(src, "R", "a", "A"));
REQUIRE(!IsField<Private>(src, "R", "b", "B"));
},
[](const mermaid_t &src) {
REQUIRE(!IsField<Private>(src, "R", "a", "A"));
REQUIRE(!IsField<Private>(src, "R", "b", "B"));
});
}

54
tests/t00018/test_case.h
View File

@@ -1,5 +1,5 @@
/**
* tests/t00018/test_case.cc
* tests/t00018/test_case.h
*
* Copyright (c) 2021-2024 Bartek Kryza <bkryza@gmail.com>
*
@@ -16,8 +16,10 @@
* limitations under the License.
*/
TEST_CASE("t00018", "[test-case][class]")
TEST_CASE("t00018")
{
using namespace clanguml::test;
auto [config, db] = load_config("t00018");
auto diagram = config.diagrams["t00018_class"];
@@ -28,45 +30,13 @@ TEST_CASE("t00018", "[test-case][class]")
REQUIRE(model->name() == "t00018_class");
{
auto src = generate_class_puml(diagram, *model);
AliasMatcher _A(src);
CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(IsClass(src, "widget"));
REQUIRE(IsClass(src, "impl::widget"));
REQUIRE(IsDependency(src, "impl::widget", "widget"));
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
REQUIRE_THAT(src, IsClass(_A("widget")));
REQUIRE_THAT(src, IsClass(_A("impl::widget")));
REQUIRE_THAT(
src, IsAggregation(_A("widget"), _A("impl::widget"), "-pImpl"));
REQUIRE_THAT(src, IsDependency(_A("impl::widget"), _A("widget")));
REQUIRE_THAT(src, !IsDependency(_A("widget"), _A("widget")));
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
{
auto j = generate_class_json(diagram, *model);
using namespace json;
REQUIRE(IsClass(j, "widget"));
REQUIRE(IsClass(j, "impl::widget"));
REQUIRE(IsDependency(j, "impl::widget", "widget"));
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("widget")));
REQUIRE_THAT(src, IsClass(_A("impl::widget")));
REQUIRE_THAT(
src, IsAggregation(_A("widget"), _A("impl::widget"), "-pImpl"));
REQUIRE_THAT(src, IsDependency(_A("impl::widget"), _A("widget")));
REQUIRE_THAT(src, !IsDependency(_A("widget"), _A("widget")));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}
REQUIRE(IsAggregation<Private>(src, "widget", "impl::widget", "pImpl"));
REQUIRE(IsDependency(src, "impl::widget", "widget"));
REQUIRE(!IsDependency(src, "widget", "widget"));
});
}

116
tests/t00019/test_case.h
View File

@@ -1,5 +1,5 @@
/**
* tests/t00019/test_case.cc
* tests/t00019/test_case.h
*
* Copyright (c) 2021-2024 Bartek Kryza <bkryza@gmail.com>
*
@@ -16,8 +16,10 @@
* limitations under the License.
*/
TEST_CASE("t00019", "[test-case][class]")
TEST_CASE("t00019")
{
using namespace clanguml::test;
auto [config, db] = load_config("t00019");
auto diagram = config.diagrams["t00019_class"];
@@ -28,101 +30,33 @@ TEST_CASE("t00019", "[test-case][class]")
REQUIRE(model->name() == "t00019_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(IsClassTemplate(src, "Layer1<LowerLayer>"));
REQUIRE(IsClassTemplate(src, "Layer2<LowerLayer>"));
REQUIRE(IsClassTemplate(src, "Layer3<LowerLayer>"));
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
REQUIRE_THAT(src, IsClass(_A("Base")));
REQUIRE_THAT(src, IsClassTemplate("Layer1", "LowerLayer"));
REQUIRE_THAT(src, IsClassTemplate("Layer2", "LowerLayer"));
REQUIRE_THAT(src, IsClassTemplate("Layer3", "LowerLayer"));
REQUIRE(IsBaseClass(src, "Base", "Layer3<Base>"));
REQUIRE(!IsDependency(src, "Base", "Layer3<Base>"));
REQUIRE_THAT(src, IsBaseClass(_A("Base"), _A("Layer3<Base>")));
REQUIRE_THAT(src, !IsDependency(_A("Base"), _A("Layer3<Base>")));
REQUIRE(IsBaseClass(src, "Layer3<Base>", "Layer2<Layer3<Base>>"));
REQUIRE(!IsDependency(src, "Layer3<Base>", "Layer2<Layer3<Base>>"));
REQUIRE_THAT(
src, IsBaseClass(_A("Layer3<Base>"), _A("Layer2<Layer3<Base>>")));
REQUIRE_THAT(
src, !IsDependency(_A("Layer3<Base>"), _A("Layer2<Layer3<Base>>")));
REQUIRE(IsBaseClass(
src, "Layer2<Layer3<Base>>", "Layer1<Layer2<Layer3<Base>>>"));
REQUIRE_THAT(src,
IsBaseClass(_A("Layer2<Layer3<Base>>"),
_A("Layer1<Layer2<Layer3<Base>>>")));
REQUIRE(!IsDependency(
src, "Layer2<Layer3<Base>>", "Layer1<Layer2<Layer3<Base>>>"));
REQUIRE_THAT(src,
!IsDependency(_A("Layer2<Layer3<Base>>"),
_A("Layer1<Layer2<Layer3<Base>>>")));
REQUIRE(IsAggregation<Public>(
src, "A", "Layer1<Layer2<Layer3<Base>>>", "layers"));
REQUIRE(!IsDependency(src, "A", "Layer1<Layer2<Layer3<Base>>>"));
REQUIRE_THAT(src,
IsAggregation(
_A("A"), _A("Layer1<Layer2<Layer3<Base>>>"), "+layers"));
REQUIRE_THAT(
src, !IsDependency(_A("A"), _A("Layer1<Layer2<Layer3<Base>>>")));
REQUIRE(
!IsAggregation<Public>(src, "A", "Layer2<Layer3<Base>>", "layers"));
REQUIRE_THAT(src,
!IsAggregation(_A("A"), _A("Layer2<Layer3<Base>>"), "+layers"));
REQUIRE(!IsAggregation<Public>(src, "A", "Layer3<Base>", "layers"));
REQUIRE_THAT(
src, !IsAggregation(_A("A"), _A("Layer3<Base>"), "+layers"));
REQUIRE_THAT(src, !IsAggregation(_A("A"), _A("Base"), "+layers"));
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
{
auto j = generate_class_json(diagram, *model);
using namespace json;
REQUIRE(IsClass(j, "Base"));
REQUIRE(IsClassTemplate(j, "Layer1<LowerLayer>"));
REQUIRE(IsClassTemplate(j, "Layer2<LowerLayer>"));
REQUIRE(IsClassTemplate(j, "Layer3<LowerLayer>"));
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("Layer1<LowerLayer>")));
REQUIRE_THAT(src, IsClass(_A("Layer2<LowerLayer>")));
REQUIRE_THAT(src, IsClass(_A("Layer3<LowerLayer>")));
REQUIRE_THAT(src, IsBaseClass(_A("Base"), _A("Layer3<Base>")));
REQUIRE_THAT(src, !IsDependency(_A("Base"), _A("Layer3<Base>")));
REQUIRE_THAT(
src, IsBaseClass(_A("Layer3<Base>"), _A("Layer2<Layer3<Base>>")));
REQUIRE_THAT(
src, !IsDependency(_A("Layer3<Base>"), _A("Layer2<Layer3<Base>>")));
REQUIRE_THAT(src,
IsBaseClass(_A("Layer2<Layer3<Base>>"),
_A("Layer1<Layer2<Layer3<Base>>>")));
REQUIRE_THAT(src,
!IsDependency(_A("Layer2<Layer3<Base>>"),
_A("Layer1<Layer2<Layer3<Base>>>")));
REQUIRE_THAT(src,
IsAggregation(
_A("A"), _A("Layer1<Layer2<Layer3<Base>>>"), "+layers"));
REQUIRE_THAT(
src, !IsDependency(_A("A"), _A("Layer1<Layer2<Layer3<Base>>>")));
REQUIRE_THAT(src,
!IsAggregation(_A("A"), _A("Layer2<Layer3<Base>>"), "+layers"));
REQUIRE_THAT(
src, !IsAggregation(_A("A"), _A("Layer3<Base>"), "+layers"));
REQUIRE_THAT(src, !IsAggregation(_A("A"), _A("Base"), "+layers"));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}
REQUIRE(!IsAggregation<Public>(src, "A", "Base", "layers"));
});
}

101
tests/t00020/test_case.h
View File

@@ -1,5 +1,5 @@
/**
* tests/t00020/test_case.cc
* tests/t00020/test_case.h
*
* Copyright (c) 2021-2024 Bartek Kryza <bkryza@gmail.com>
*
@@ -16,8 +16,10 @@
* limitations under the License.
*/
TEST_CASE("t00020", "[test-case][class]")
TEST_CASE("t00020")
{
using namespace clanguml::test;
auto [config, db] = load_config("t00020");
auto diagram = config.diagrams["t00020_class"];
@@ -28,53 +30,66 @@ TEST_CASE("t00020", "[test-case][class]")
REQUIRE(model->name() == "t00020_class");
{
auto src = generate_class_puml(diagram, *model);
AliasMatcher _A(src);
CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(IsAbstractClass(src, "AbstractFactory"));
REQUIRE(IsAbstractClass(src, "ProductA"));
REQUIRE(IsAbstractClass(src, "ProductB"));
REQUIRE(IsClass(src, "ProductA1"));
REQUIRE(IsClass(src, "ProductA2"));
REQUIRE(IsClass(src, "ProductB1"));
REQUIRE(IsClass(src, "ProductB2"));
REQUIRE(IsClass(src, "Factory1"));
REQUIRE(IsClass(src, "Factory2"));
});
/*
{
auto src = generate_class_puml(diagram, *model);
AliasMatcher _A(src);
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
REQUIRE_THAT(src, IsAbstractClass(_A("ProductA")));
REQUIRE_THAT(src, IsAbstractClass(_A("ProductB")));
REQUIRE_THAT(src, IsClass(_A("ProductA1")));
REQUIRE_THAT(src, IsClass(_A("ProductA2")));
REQUIRE_THAT(src, IsClass(_A("ProductB1")));
REQUIRE_THAT(src, IsClass(_A("ProductB2")));
REQUIRE_THAT(src, IsAbstractClass(_A("AbstractFactory")));
REQUIRE_THAT(src, IsClass(_A("Factory1")));
REQUIRE_THAT(src, IsClass(_A("Factory2")));
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
REQUIRE_THAT(src, IsAbstractClass(_A("ProductA")));
REQUIRE_THAT(src, IsAbstractClass(_A("ProductB")));
REQUIRE_THAT(src, IsClass(_A("ProductA1")));
REQUIRE_THAT(src, IsClass(_A("ProductA2")));
REQUIRE_THAT(src, IsClass(_A("ProductB1")));
REQUIRE_THAT(src, IsClass(_A("ProductB2")));
REQUIRE_THAT(src, IsAbstractClass(_A("AbstractFactory")));
REQUIRE_THAT(src, IsClass(_A("Factory1")));
REQUIRE_THAT(src, IsClass(_A("Factory2")));
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);
}
{
auto j = generate_class_json(diagram, *model);
using namespace json;
using namespace json;
REQUIRE(IsClass(j, "ProductA1"));
REQUIRE(IsClass(j, "ProductA2"));
REQUIRE(IsClass(j, "ProductB1"));
REQUIRE(IsClass(j, "ProductB2"));
REQUIRE(IsAbstractClass(j, "AbstractFactory"));
REQUIRE(IsClass(j, "ProductA1"));
REQUIRE(IsClass(j, "ProductA2"));
REQUIRE(IsClass(j, "ProductB1"));
REQUIRE(IsClass(j, "ProductB2"));
REQUIRE(IsAbstractClass(j, "AbstractFactory"));
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::IsAbstractClass;
mermaid::AliasMatcher _A(src);
using mermaid::IsAbstractClass;
REQUIRE_THAT(src, IsAbstractClass(_A("ProductA")));
REQUIRE_THAT(src, IsAbstractClass(_A("ProductB")));
REQUIRE_THAT(src, IsClass(_A("ProductA1")));
REQUIRE_THAT(src, IsClass(_A("ProductA2")));
REQUIRE_THAT(src, IsClass(_A("ProductB1")));
REQUIRE_THAT(src, IsClass(_A("ProductB2")));
REQUIRE_THAT(src, IsAbstractClass(_A("AbstractFactory")));
REQUIRE_THAT(src, IsClass(_A("Factory1")));
REQUIRE_THAT(src, IsClass(_A("Factory2")));
REQUIRE_THAT(src, IsAbstractClass(_A("ProductA")));
REQUIRE_THAT(src, IsAbstractClass(_A("ProductB")));
REQUIRE_THAT(src, IsClass(_A("ProductA1")));
REQUIRE_THAT(src, IsClass(_A("ProductA2")));
REQUIRE_THAT(src, IsClass(_A("ProductB1")));
REQUIRE_THAT(src, IsClass(_A("ProductB2")));
REQUIRE_THAT(src, IsAbstractClass(_A("AbstractFactory")));
REQUIRE_THAT(src, IsClass(_A("Factory1")));
REQUIRE_THAT(src, IsClass(_A("Factory2")));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}
save_mermaid(config.output_directory(), diagram->name + ".mmd",
src);
}*/
}

57
tests/t00021/test_case.h
View File

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

45
tests/t00022/test_case.h
View File

@@ -1,5 +1,5 @@
/**
* tests/t00022/test_case.cc
* tests/t00022/test_case.h
*
* Copyright (c) 2021-2024 Bartek Kryza <bkryza@gmail.com>
*
@@ -16,8 +16,10 @@
* limitations under the License.
*/
TEST_CASE("t00022", "[test-case][class]")
TEST_CASE("t00022")
{
using namespace clanguml::test;
auto [config, db] = load_config("t00022");
auto diagram = config.diagrams["t00022_class"];
@@ -28,38 +30,9 @@ TEST_CASE("t00022", "[test-case][class]")
REQUIRE(model->name() == "t00022_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, IsAbstractClass(_A("A")));
REQUIRE_THAT(src, IsClass(_A("A1")));
REQUIRE_THAT(src, IsClass(_A("A2")));
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
{
auto j = generate_class_json(diagram, *model);
using namespace json;
REQUIRE(IsClass(j, "A1"));
REQUIRE(IsClass(j, "A2"));
REQUIRE(IsAbstractClass(j, "A"));
save_json(config.output_directory(), diagram->name + ".json", j);
}
{
auto src = generate_class_mermaid(diagram, *model);
mermaid::AliasMatcher _A(src);
using mermaid::IsAbstractClass;
REQUIRE_THAT(src, IsAbstractClass(_A("A")));
REQUIRE_THAT(src, IsClass(_A("A1")));
REQUIRE_THAT(src, IsClass(_A("A2")));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}
CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(IsClass(src, "A1"));
REQUIRE(IsClass(src, "A2"));
REQUIRE(IsAbstractClass(src, "A"));
});
}

46
tests/t00023/test_case.h
View File

@@ -1,5 +1,5 @@
/**
* tests/t00023/test_case.cc
* tests/t00023/test_case.h
*
* Copyright (c) 2021-2024 Bartek Kryza <bkryza@gmail.com>
*
@@ -16,8 +16,10 @@
* limitations under the License.
*/
TEST_CASE("t00023", "[test-case][class]")
TEST_CASE("t00023")
{
using namespace clanguml::test;
auto [config, db] = load_config("t00023");
auto diagram = config.diagrams["t00023_class"];
@@ -28,39 +30,9 @@ TEST_CASE("t00023", "[test-case][class]")
REQUIRE(model->name() == "t00023_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, IsAbstractClass(_A("Strategy")));
REQUIRE_THAT(src, IsClass(_A("StrategyA")));
REQUIRE_THAT(src, IsClass(_A("StrategyB")));
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
{
auto j = generate_class_json(diagram, *model);
using namespace json;
REQUIRE(IsClass(j, "StrategyA"));
REQUIRE(IsClass(j, "StrategyB"));
REQUIRE(IsAbstractClass(j, "Strategy"));
save_json(config.output_directory(), diagram->name + ".json", j);
}
{
auto src = generate_class_mermaid(diagram, *model);
mermaid::AliasMatcher _A(src);
using mermaid::IsAbstractClass;
REQUIRE_THAT(src, IsAbstractClass(_A("Strategy")));
REQUIRE_THAT(src, IsClass(_A("StrategyA")));
REQUIRE_THAT(src, IsClass(_A("StrategyB")));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}
CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(IsAbstractClass(src, "Strategy"));
REQUIRE(IsClass(src, "StrategyA"));
REQUIRE(IsClass(src, "StrategyB"));
});
}

61
tests/t00024/test_case.h
View File

@@ -1,5 +1,5 @@
/**
* tests/t00024/test_case.cc
* tests/t00024/test_case.h
*
* Copyright (c) 2021-2024 Bartek Kryza <bkryza@gmail.com>
*
@@ -16,8 +16,10 @@
* limitations under the License.
*/
TEST_CASE("t00024", "[test-case][class]")
TEST_CASE("t00024")
{
using namespace clanguml::test;
auto [config, db] = load_config("t00024");
auto diagram = config.diagrams["t00024_class"];
@@ -28,50 +30,13 @@ TEST_CASE("t00024", "[test-case][class]")
REQUIRE(model->name() == "t00024_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, IsAbstractClass(_A("Target")));
REQUIRE_THAT(src, IsClass(_A("Target1")));
REQUIRE_THAT(src, IsClass(_A("Target2")));
REQUIRE_THAT(src, IsClass(_A("Proxy")));
REQUIRE_THAT(src, IsBaseClass(_A("Target"), _A("Target1")));
REQUIRE_THAT(src, IsBaseClass(_A("Target"), _A("Target2")));
REQUIRE_THAT(src, IsBaseClass(_A("Target"), _A("Proxy")));
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
{
auto j = generate_class_json(diagram, *model);
using namespace json;
REQUIRE(IsClass(j, "Target1"));
REQUIRE(IsClass(j, "Target2"));
REQUIRE(IsAbstractClass(j, "Target"));
REQUIRE(IsBaseClass(j, "Target", "Target1"));
REQUIRE(IsBaseClass(j, "Target", "Target2"));
REQUIRE(IsBaseClass(j, "Target", "Proxy"));
save_json(config.output_directory(), diagram->name + ".json", j);
}
{
auto src = generate_class_mermaid(diagram, *model);
mermaid::AliasMatcher _A(src);
using mermaid::IsAbstractClass;
REQUIRE_THAT(src, IsAbstractClass(_A("Target")));
REQUIRE_THAT(src, IsClass(_A("Target1")));
REQUIRE_THAT(src, IsClass(_A("Target2")));
REQUIRE_THAT(src, IsClass(_A("Proxy")));
REQUIRE_THAT(src, IsBaseClass(_A("Target"), _A("Target1")));
REQUIRE_THAT(src, IsBaseClass(_A("Target"), _A("Target2")));
REQUIRE_THAT(src, IsBaseClass(_A("Target"), _A("Proxy")));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}
CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(IsClass(src, "Target1"));
REQUIRE(IsClass(src, "Target2"));
REQUIRE(IsClass(src, "Proxy"));
REQUIRE(IsAbstractClass(src, "Target"));
REQUIRE(IsBaseClass(src, "Target", "Target1"));
REQUIRE(IsBaseClass(src, "Target", "Target2"));
REQUIRE(IsBaseClass(src, "Target", "Proxy"));
});
}

86
tests/t00025/test_case.h
View File

@@ -1,5 +1,5 @@
/**
* tests/t00025/test_case.cc
* tests/t00025/test_case.h
*
* Copyright (c) 2021-2024 Bartek Kryza <bkryza@gmail.com>
*
@@ -16,8 +16,10 @@
* limitations under the License.
*/
TEST_CASE("t00025", "[test-case][class]")
TEST_CASE("t00025")
{
using namespace clanguml::test;
auto [config, db] = load_config("t00025");
auto diagram = config.diagrams["t00025_class"];
@@ -28,68 +30,22 @@ TEST_CASE("t00025", "[test-case][class]")
REQUIRE(model->name() == "t00025_class");
{
auto src = generate_class_puml(diagram, *model);
AliasMatcher _A(src);
CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(IsClass(src, "Target1"));
REQUIRE(IsClass(src, "Target2"));
REQUIRE(IsClassTemplate(src, "Proxy<T>"));
REQUIRE(IsDependency(src, "Proxy<Target1>", "Target1"));
REQUIRE(IsDependency(src, "Proxy<Target2>", "Target2"));
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
REQUIRE_THAT(src, IsClass(_A("Target1")));
REQUIRE_THAT(src, IsClass(_A("Target2")));
REQUIRE_THAT(src, IsClassTemplate("Proxy", "T"));
REQUIRE_THAT(
src, IsInstantiation(_A("Proxy<T>"), _A("Proxy<Target1>")));
REQUIRE_THAT(
src, IsInstantiation(_A("Proxy<T>"), _A("Proxy<Target2>")));
REQUIRE_THAT(src,
IsAggregation(_A("ProxyHolder"), _A("Proxy<Target1>"), "+proxy1"));
REQUIRE_THAT(src,
IsAggregation(_A("ProxyHolder"), _A("Proxy<Target2>"), "+proxy2"));
REQUIRE_THAT(
src, !IsAggregation(_A("ProxyHolder"), _A("Target1"), "+proxy1"));
REQUIRE_THAT(
src, !IsAggregation(_A("ProxyHolder"), _A("Target2"), "+proxy2"));
REQUIRE_THAT(src, IsDependency(_A("Proxy<Target1>"), _A("Target1")));
REQUIRE_THAT(src, IsDependency(_A("Proxy<Target2>"), _A("Target2")));
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
{
auto j = generate_class_json(diagram, *model);
using namespace json;
REQUIRE(IsClass(j, "Target1"));
REQUIRE(IsClass(j, "Target2"));
REQUIRE(IsClassTemplate(j, "Proxy<T>"));
REQUIRE(IsDependency(j, "Proxy<Target1>", "Target1"));
REQUIRE(IsDependency(j, "Proxy<Target2>", "Target2"));
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("Target1")));
REQUIRE_THAT(src, IsClass(_A("Target2")));
REQUIRE_THAT(src, IsClass(_A("Proxy<T>")));
REQUIRE_THAT(
src, IsInstantiation(_A("Proxy<T>"), _A("Proxy<Target1>")));
REQUIRE_THAT(
src, IsInstantiation(_A("Proxy<T>"), _A("Proxy<Target2>")));
REQUIRE_THAT(src,
IsAggregation(_A("ProxyHolder"), _A("Proxy<Target1>"), "+proxy1"));
REQUIRE_THAT(src,
IsAggregation(_A("ProxyHolder"), _A("Proxy<Target2>"), "+proxy2"));
REQUIRE_THAT(
src, !IsAggregation(_A("ProxyHolder"), _A("Target1"), "+proxy1"));
REQUIRE_THAT(
src, !IsAggregation(_A("ProxyHolder"), _A("Target2"), "+proxy2"));
REQUIRE_THAT(src, IsDependency(_A("Proxy<Target1>"), _A("Target1")));
REQUIRE_THAT(src, IsDependency(_A("Proxy<Target2>"), _A("Target2")));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}
REQUIRE(IsInstantiation(src, "Proxy<T>", "Proxy<Target1>"));
REQUIRE(IsInstantiation(src, "Proxy<T>", "Proxy<Target2>"));
REQUIRE(IsAggregation<Public>(
src, "ProxyHolder", "Proxy<Target1>", "proxy1"));
REQUIRE(IsAggregation<Public>(
src, "ProxyHolder", "Proxy<Target2>", "proxy2"));
REQUIRE(
!IsAggregation<Public>(src, "ProxyHolder", "Target1", "proxy1"));
REQUIRE(
!IsAggregation<Public>(src, "ProxyHolder", "Target2", "proxy2"));
});
}

59
tests/t00026/test_case.h
View File

@@ -1,5 +1,5 @@
/**
* tests/t00026/test_case.cc
* tests/t00026/test_case.h
*
* Copyright (c) 2021-2024 Bartek Kryza <bkryza@gmail.com>
*
@@ -16,8 +16,10 @@
* limitations under the License.
*/
TEST_CASE("t00026", "[test-case][class]")
TEST_CASE("t00026")
{
using namespace clanguml::test;
auto [config, db] = load_config("t00026");
auto diagram = config.diagrams["t00026_class"];
@@ -28,48 +30,15 @@ TEST_CASE("t00026", "[test-case][class]")
REQUIRE(model->name() == "t00026_class");
{
auto src = generate_class_puml(diagram, *model);
AliasMatcher _A(src);
CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(IsClassTemplate(src, "Memento<T>"));
REQUIRE(IsClassTemplate(src, "Originator<T>"));
REQUIRE(IsClassTemplate(src, "Caretaker<T>"));
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
REQUIRE_THAT(src, IsClassTemplate("Memento", "T"));
REQUIRE_THAT(src, IsClassTemplate("Originator", "T"));
REQUIRE_THAT(src, IsClassTemplate("Caretaker", "T"));
REQUIRE_THAT(src,
IsInstantiation(
_A("Originator<T>"), _A("Originator<std::string>")));
REQUIRE_THAT(src,
IsInstantiation(_A("Caretaker<T>"), _A("Caretaker<std::string>")));
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
{
auto j = generate_class_json(diagram, *model);
using namespace json;
REQUIRE(IsClassTemplate(j, "Memento<T>"));
REQUIRE(IsClassTemplate(j, "Originator<T>"));
REQUIRE(IsInstantiation(j, "Originator<T>", "Originator<std::string>"));
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("Memento<T>")));
REQUIRE_THAT(src, IsClass(_A("Originator<T>")));
REQUIRE_THAT(src, IsClass(_A("Caretaker<T>")));
REQUIRE_THAT(src,
IsInstantiation(
_A("Originator<T>"), _A("Originator<std::string>")));
REQUIRE_THAT(src,
IsInstantiation(_A("Caretaker<T>"), _A("Caretaker<std::string>")));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}
REQUIRE(
IsInstantiation(src, "Originator<T>", "Originator<std::string>"));
REQUIRE(
IsInstantiation(src, "Originator<T>", "Originator<std::string>"));
REQUIRE(IsInstantiation(src, "Caretaker<T>", "Caretaker<std::string>"));
});
}

29
tests/t00027/test_case.h
View File

@@ -16,8 +16,10 @@
* limitations under the License.
*/
TEST_CASE("t00027", "[test-case][class]")
TEST_CASE("t00027")
{
using namespace clanguml::test;
auto [config, db] = load_config("t00027");
auto diagram = config.diagrams["t00027_class"];
@@ -28,6 +30,29 @@ TEST_CASE("t00027", "[test-case][class]")
REQUIRE(model->name() == "t00027_class");
CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(IsAbstractClass(src, "Shape"));
REQUIRE(IsAbstractClass(src, "ShapeDecorator"));
REQUIRE(IsClassTemplate(src, "Line<T<>...>"));
REQUIRE(IsInstantiation(src, "Line<T<>...>", "Line<Color>"));
REQUIRE(IsInstantiation(src, "Line<T<>...>", "Line<Color,Weight>"));
REQUIRE(IsAggregation<Public>(src, "Window", "Text<Color>", "description"));
REQUIRE(IsInstantiation(src, "Line<T<>...>", "Line<Color>"));
REQUIRE(IsInstantiation(src, "Line<T<>...>", "Line<Color,Weight>"));
REQUIRE(IsInstantiation(src, "Text<T<>...>", "Text<Color>"));
REQUIRE(IsInstantiation(src, "Text<T<>...>", "Text<Color,Weight>"));
REQUIRE(IsAggregation<Public>(
src, "Window", "Line<Color,Weight>", "border"));
REQUIRE(IsAggregation<Public>(src, "Window", "Line<Color>", "divider"));
REQUIRE(IsAggregation<Public>(
src, "Window", "Text<Color,Weight>", "title"));
REQUIRE(
IsAggregation<Public>(src, "Window", "Text<Color>", "description"));
});
/*
{
auto src = generate_class_puml(diagram, *model);
AliasMatcher _A(src);
@@ -102,5 +127,5 @@ TEST_CASE("t00027", "[test-case][class]")
IsAggregation(_A("Window"), _A("Text<Color>"), "+description"));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}
}*/
}

161
tests/t00028/test_case.h
View File

@@ -1,5 +1,5 @@
/**
* tests/t00028/test_case.cc
* tests/t00028/test_case.h
*
* Copyright (c) 2021-2024 Bartek Kryza <bkryza@gmail.com>
*
@@ -16,8 +16,10 @@
* limitations under the License.
*/
TEST_CASE("t00028", "[test-case][class]")
TEST_CASE("t00028")
{
using namespace clanguml::test;
auto [config, db] = load_config("t00028");
auto diagram = config.diagrams["t00028_class"];
@@ -28,78 +30,105 @@ TEST_CASE("t00028", "[test-case][class]")
REQUIRE(model->name() == "t00028_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("B")));
REQUIRE_THAT(src, IsClass(_A("C")));
REQUIRE_THAT(src, IsClass(_A("D")));
REQUIRE_THAT(src, IsClassTemplate("E", "T"));
REQUIRE_THAT(src, IsEnum(_A("F")));
REQUIRE_THAT(src, IsClass(_A("R")));
REQUIRE_THAT(src, HasNote(_A("A"), "top", "A class note."));
REQUIRE_THAT(src, HasNote(_A("B"), "left", "B class note."));
REQUIRE_THAT(src, HasNote(_A("C"), "bottom", "C class note."));
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_THAT(src, HasNote(_A("D"), "left", d_note));
REQUIRE_THAT(
src, HasNote(_A("E<T>"), "left", "E template class note."));
REQUIRE_THAT(src, HasNote(_A("F"), "bottom", "F enum note."));
REQUIRE_THAT(src, !HasNote(_A("G"), "left", "G class note."));
REQUIRE_THAT(src, HasNote(_A("R"), "right", "R class note."));
REQUIRE_THAT(src,
HasMemberNote(
_A("R"), "aaa", "left", "R contains an instance of A."));
REQUIRE_THAT(
src, !HasMemberNote(_A("R"), "bbb", "right", "R class note."));
REQUIRE_THAT(
src, HasMemberNote(_A("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, "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."));
});
/*
{
auto src = generate_class_puml(diagram, *model);
AliasMatcher _A(src);
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
{
auto j = generate_class_json(diagram, *model);
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
using namespace json;
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, IsClassTemplate("E", "T"));
REQUIRE_THAT(src, IsEnum(_A("F")));
REQUIRE_THAT(src, IsClass(_A("R")));
REQUIRE_THAT(src, HasNote(_A("A"), "top", "A class note."));
REQUIRE_THAT(src, HasNote(_A("B"), "left", "B class note."));
REQUIRE_THAT(src, HasNote(_A("C"), "bottom", "C class note."));
const auto d_note = R"(
D
class
note.)";
REQUIRE_THAT(src, HasNote(_A("D"), "left", d_note));
REQUIRE_THAT(
src, HasNote(_A("E<T>"), "left", "E template class note."));
REQUIRE_THAT(src, HasNote(_A("F"), "bottom", "F enum note."));
REQUIRE_THAT(src, !HasNote(_A("G"), "left", "G class note."));
REQUIRE_THAT(src, HasNote(_A("R"), "right", "R class note."));
REQUIRE_THAT(src,
HasMemberNote(
_A("R"), "aaa", "left", "R contains an instance of A."));
REQUIRE_THAT(
src, !HasMemberNote(_A("R"), "bbb", "right", "R class note."));
REQUIRE_THAT(
src, HasMemberNote(_A("R"), "ccc", "left", "Reference to C."));
save_json(config.output_directory(), diagram->name + ".json", j);
}
{
auto src = generate_class_mermaid(diagram, *model);
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
{
auto j = generate_class_json(diagram, *model);
mermaid::AliasMatcher _A(src);
using mermaid::HasNote;
using mermaid::IsEnum;
using namespace json;
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<T>")));
REQUIRE_THAT(src, IsEnum(_A("F")));
REQUIRE_THAT(src, IsClass(_A("R")));
REQUIRE_THAT(src, HasNote(_A("A"), "top", "A class note."));
REQUIRE_THAT(src, HasNote(_A("B"), "left", "B class note."));
REQUIRE_THAT(src, HasNote(_A("C"), "bottom", "C class note."));
const auto d_note = R"(
D
class
note.)";
REQUIRE_THAT(src, HasNote(_A("D"), "left", d_note));
REQUIRE_THAT(
src, HasNote(_A("E<T>"), "left", "E template class note."));
REQUIRE_THAT(src, HasNote(_A("F"), "bottom", "F enum note."));
REQUIRE_THAT(src, !HasNote(_A("G"), "left", "G class note."));
REQUIRE_THAT(src, HasNote(_A("R"), "right", "R class note."));
save_json(config.output_directory(), diagram->name + ".json", j);
}
{
auto src = generate_class_mermaid(diagram, *model);
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}
mermaid::AliasMatcher _A(src);
using mermaid::HasNote;
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("D")));
REQUIRE_THAT(src, IsClass(_A("E<T>")));
REQUIRE_THAT(src, IsEnum(_A("F")));
REQUIRE_THAT(src, IsClass(_A("R")));
REQUIRE_THAT(src, HasNote(_A("A"), "top", "A class note."));
REQUIRE_THAT(src, HasNote(_A("B"), "left", "B class note."));
REQUIRE_THAT(src, HasNote(_A("C"), "bottom", "C class note."));
const auto d_note = R"(
D
class
note.)";
REQUIRE_THAT(src, HasNote(_A("D"), "left", d_note));
REQUIRE_THAT(
src, HasNote(_A("E<T>"), "left", "E template class note."));
REQUIRE_THAT(src, HasNote(_A("F"), "bottom", "F enum note."));
REQUIRE_THAT(src, !HasNote(_A("G"), "left", "G class note."));
REQUIRE_THAT(src, HasNote(_A("R"), "right", "R class note."));
save_mermaid(config.output_directory(), diagram->name + ".mmd",
src);
}*/
}

81
tests/t00029/test_case.h
View File

@@ -16,8 +16,10 @@
* limitations under the License.
*/
TEST_CASE("t00029", "[test-case][class]")
TEST_CASE("t00029")
{
using namespace clanguml::test;
auto [config, db] = load_config("t00029");
auto diagram = config.diagrams["t00029_class"];
@@ -28,66 +30,23 @@ TEST_CASE("t00029", "[test-case][class]")
REQUIRE(model->name() == "t00029_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(IsClassTemplate(src, "C<T>"));
REQUIRE(!IsClassTemplate(src, "D<T>"));
REQUIRE(IsEnum(src, "E"));
REQUIRE(!IsEnum(src, "F"));
REQUIRE(IsClass(src, "G1"));
REQUIRE(IsClass(src, "G2"));
REQUIRE(IsClass(src, "G3"));
REQUIRE(IsClass(src, "G4"));
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
REQUIRE(IsClass(src, "R"));
REQUIRE_THAT(src, IsClass(_A("A")));
REQUIRE_THAT(src, !IsClass(_A("B")));
REQUIRE_THAT(src, IsClassTemplate("C", "T"));
REQUIRE_THAT(src, !IsClassTemplate("D", "T"));
REQUIRE_THAT(src, IsEnum(_A("E")));
REQUIRE_THAT(src, !IsEnum(_A("F")));
REQUIRE_THAT(src, IsClass(_A("G1")));
REQUIRE_THAT(src, IsClass(_A("G2")));
REQUIRE_THAT(src, IsClass(_A("G3")));
REQUIRE_THAT(src, IsClass(_A("G4")));
REQUIRE_THAT(src, IsClass(_A("R")));
REQUIRE_THAT(src, IsAggregation(_A("R"), _A("G1"), "+g1"));
REQUIRE_THAT(src, !IsAggregation(_A("R"), _A("G2"), "+g2"));
REQUIRE_THAT(src, !IsAggregation(_A("R"), _A("G3"), "+g3"));
REQUIRE_THAT(src, IsAssociation(_A("R"), _A("G4"), "+g4"));
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
{
auto j = generate_class_json(diagram, *model);
using namespace json;
REQUIRE(IsAggregation(j, "R", "G1", "g1"));
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<T>")));
REQUIRE_THAT(src, !IsClass(_A("D<T>")));
REQUIRE_THAT(src, IsEnum(_A("E")));
REQUIRE_THAT(src, !IsEnum(_A("F")));
REQUIRE_THAT(src, IsClass(_A("G1")));
REQUIRE_THAT(src, IsClass(_A("G2")));
REQUIRE_THAT(src, IsClass(_A("G3")));
REQUIRE_THAT(src, IsClass(_A("G4")));
REQUIRE_THAT(src, IsClass(_A("R")));
REQUIRE_THAT(src, IsAggregation(_A("R"), _A("G1"), "+g1"));
REQUIRE_THAT(src, !IsAggregation(_A("R"), _A("G2"), "+g2"));
REQUIRE_THAT(src, !IsAggregation(_A("R"), _A("G3"), "+g3"));
REQUIRE_THAT(src, IsAssociation(_A("R"), _A("G4"), "+g4"));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}
REQUIRE(IsAggregation<Public>(src, "R", "G1", "g1"));
REQUIRE(!IsAggregation<Public>(src, "R", "G2", "g2"));
REQUIRE(!IsAggregation<Public>(src, "R", "G3", "g3"));
REQUIRE(IsAssociation<Public>(src, "R", "G4", "g4"));
});
}

67
tests/t00030/test_case.h
View File

@@ -1,5 +1,5 @@
/**
* tests/t00030/test_case.cc
* tests/t00030/test_case.h
*
* Copyright (c) 2021-2024 Bartek Kryza <bkryza@gmail.com>
*
@@ -16,8 +16,10 @@
* limitations under the License.
*/
TEST_CASE("t00030", "[test-case][class]")
TEST_CASE("t00030")
{
using namespace clanguml::test;
auto [config, db] = load_config("t00030");
auto diagram = config.diagrams["t00030_class"];
@@ -28,55 +30,16 @@ TEST_CASE("t00030", "[test-case][class]")
REQUIRE(model->name() == "t00030_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_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, IsAssociation(_A("R"), _A("A"), "+aaa"));
REQUIRE_THAT(
src, IsComposition(_A("R"), _A("B"), "+bbb", "0..1", "1..*"));
REQUIRE_THAT(
src, IsAggregation(_A("R"), _A("C"), "+ccc", "0..1", "1..5"));
REQUIRE_THAT(src, IsAssociation(_A("R"), _A("D"), "+ddd", "", "1"));
REQUIRE_THAT(src, IsAggregation(_A("R"), _A("E"), "+eee", "", "1"));
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
{
auto j = generate_class_json(diagram, *model);
using namespace json;
REQUIRE(IsAggregation(j, "R", "C", "ccc"));
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("B")));
REQUIRE_THAT(src, IsClass(_A("C")));
REQUIRE_THAT(src, IsClass(_A("D")));
REQUIRE_THAT(src, IsAssociation(_A("R"), _A("A"), "+aaa"));
REQUIRE_THAT(
src, IsComposition(_A("R"), _A("B"), "+bbb", "0..1", "1..*"));
REQUIRE_THAT(
src, IsAggregation(_A("R"), _A("C"), "+ccc", "0..1", "1..5"));
REQUIRE_THAT(src, IsAssociation(_A("R"), _A("D"), "+ddd", "", "1"));
REQUIRE_THAT(src, IsAggregation(_A("R"), _A("E"), "+eee", "", "1"));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}
REQUIRE(IsAssociation<Public>(src, "R", "A", "aaa"));
REQUIRE(IsComposition<Public>(src, "R", "B", "bbb", "0..1", "1..*"));
REQUIRE(IsAggregation<Public>(src, "R", "C", "ccc", "0..1", "1..5"));
REQUIRE(IsAssociation<Public>(src, "R", "D", "ddd", "", "1"));
REQUIRE(IsAggregation<Public>(src, "R", "E", "eee", "", "1"));
});
}

127
tests/t30001/test_case.h
View File

@@ -1,5 +1,5 @@
/**
* tests/t30001/test_case.cc
* tests/t30001/test_case.h
*
* Copyright (c) 2021-2024 Bartek Kryza <bkryza@gmail.com>
*
@@ -16,8 +16,11 @@
* limitations under the License.
*/
TEST_CASE("t30001", "[test-case][package]")
TEST_CASE("t30001")
{
using namespace clanguml::test;
using namespace std::string_literals;
auto [config, db] = load_config("t30001");
auto diagram = config.diagrams["t30001_package"];
@@ -28,104 +31,34 @@ TEST_CASE("t30001", "[test-case][package]")
REQUIRE(model->name() == "t30001_package");
{
auto src = generate_package_puml(diagram, *model);
AliasMatcher _A(src);
CHECK_PACKAGE_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(HasTitle(src, "Basic package diagram example"));
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
REQUIRE(!IsNamespacePackage(src, "clanguml"s));
REQUIRE(!IsNamespacePackage(src, "t30001"s));
REQUIRE(IsNamespacePackage(src, "A"s));
REQUIRE(IsNamespacePackage(src, "A"s, "AA"s));
REQUIRE(IsNamespacePackage(src, "A"s, "AA"s, "AAA"s));
REQUIRE(IsNamespacePackage(src, "B"s, "AA"s, "AAA"s));
REQUIRE(IsNamespacePackage(src, "B"s, "AA"s, "BBB"s));
REQUIRE(IsNamespacePackage(src, "B"s, "BB"s));
REQUIRE(IsNamespacePackage(src, "B"s));
REQUIRE_THAT(src, HasTitle("Basic package diagram example"));
REQUIRE(
HasNote(src, "AA", "top", "This is namespace AA in namespace A"));
REQUIRE_THAT(src, IsPackage("A"));
REQUIRE_THAT(src, IsPackage("AAA"));
REQUIRE_THAT(src, IsPackage("AAA"));
REQUIRE(HasLink(src, "AAA",
fmt::format("https://github.com/bkryza/clang-uml/blob/{}/tests/"
"t30001/t30001.cc#L6",
clanguml::util::get_git_commit()),
"AAA"));
// TODO: Fix _A() to handle fully qualified names, right
// now it only finds the first element with unqualified
// name match
REQUIRE_THAT(src,
HasNote(_A("AA"), "top", "This is namespace AA in namespace A"));
REQUIRE(HasLink(src, "BBB",
fmt::format("https://github.com/bkryza/clang-uml/blob/{}/tests/"
"t30001/t30001.cc#L8",
clanguml::util::get_git_commit()),
"BBB"));
REQUIRE_THAT(src,
HasLink(_A("AAA"),
fmt::format("https://github.com/bkryza/clang-uml/blob/{}/tests/"
"t30001/t30001.cc#L6",
clanguml::util::get_git_commit()),
"AAA"));
REQUIRE_THAT(src,
HasLink(_A("BBB"),
fmt::format("https://github.com/bkryza/clang-uml/blob/{}/tests/"
"t30001/t30001.cc#L8",
clanguml::util::get_git_commit()),
"BBB"));
REQUIRE_THAT(src, HasComment("t30001 test diagram of type package"));
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
{
auto j = generate_package_json(diagram, *model);
using namespace json;
using namespace std::string_literals;
REQUIRE(HasTitle(j, "Basic package diagram example"));
REQUIRE(!IsNamespacePackage(j, "clanguml"s));
REQUIRE(!IsNamespacePackage(j, "t30001"s));
REQUIRE(IsNamespacePackage(j, "A"s));
REQUIRE(IsNamespacePackage(j, "A"s, "AA"s));
REQUIRE(IsNamespacePackage(j, "A"s, "AA"s, "AAA"s));
REQUIRE(IsNamespacePackage(j, "B"s, "AA"s, "AAA"s));
REQUIRE(IsNamespacePackage(j, "B"s, "AA"s, "BBB"s));
REQUIRE(IsNamespacePackage(j, "B"s, "BB"s));
REQUIRE(IsNamespacePackage(j, "B"s));
save_json(config.output_directory(), diagram->name + ".json", j);
}
{
auto src = generate_package_mermaid(diagram, *model);
mermaid::AliasMatcher _A(src);
using mermaid::HasComment;
using mermaid::HasLink;
using mermaid::HasPackageNote;
using mermaid::HasTitle;
using mermaid::IsPackage;
REQUIRE_THAT(src, HasTitle("Basic package diagram example"));
REQUIRE_THAT(src, IsPackage(_A("A")));
REQUIRE_THAT(src, IsPackage(_A("AAA")));
REQUIRE_THAT(src, IsPackage(_A("AAA")));
// TODO: Fix _A() to handle fully qualified names, right
// now it only finds the first element with unqualified
// name match
REQUIRE_THAT(src,
HasPackageNote(
_A("AA"), "top", "This is namespace AA in namespace A"));
REQUIRE_THAT(src,
HasLink(_A("AAA"),
fmt::format("https://github.com/bkryza/clang-uml/blob/{}/tests/"
"t30001/t30001.cc#L6",
clanguml::util::get_git_commit()),
"AAA"));
REQUIRE_THAT(src,
HasLink(_A("BBB"),
fmt::format("https://github.com/bkryza/clang-uml/blob/{}/tests/"
"t30001/t30001.cc#L8",
clanguml::util::get_git_commit()),
"BBB"));
REQUIRE_THAT(src, HasComment("t30001 test diagram of type package"));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}
REQUIRE(HasComment(src, "t30001 test diagram of type package"));
});
}

308
tests/t30002/test_case.h
View File

@@ -1,5 +1,5 @@
/**
* tests/t30002/test_case.cc
* tests/t30002/test_case.h
*
* Copyright (c) 2021-2024 Bartek Kryza <bkryza@gmail.com>
*
@@ -16,8 +16,11 @@
* limitations under the License.
*/
TEST_CASE("t30002", "[test-case][package]")
TEST_CASE("t30002")
{
using namespace clanguml::test;
using namespace std::string_literals;
auto [config, db] = load_config("t30002");
auto diagram = config.diagrams["t30002_package"];
@@ -28,146 +31,191 @@ TEST_CASE("t30002", "[test-case][package]")
REQUIRE(model->name() == "t30002_package");
{
auto src = generate_package_puml(diagram, *model);
AliasMatcher _A(src);
CHECK_PACKAGE_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(IsNamespacePackage(src, "A"s, "AA"s));
REQUIRE(IsNamespacePackage(src, "A"s, "AA"s, "A1"s));
REQUIRE(IsNamespacePackage(src, "A"s, "AA"s, "A2"s));
REQUIRE(IsNamespacePackage(src, "A"s, "AA"s, "A3"s));
REQUIRE(IsNamespacePackage(src, "A"s, "AA"s, "A4"s));
REQUIRE(IsNamespacePackage(src, "A"s, "AA"s, "A5"s));
REQUIRE(IsNamespacePackage(src, "A"s, "AA"s, "A6"s));
REQUIRE(IsNamespacePackage(src, "A"s, "AA"s, "A7"s));
REQUIRE(IsNamespacePackage(src, "A"s, "AA"s, "A8"s));
REQUIRE(IsNamespacePackage(src, "A"s, "AA"s, "A9"s));
REQUIRE(IsNamespacePackage(src, "A"s, "AA"s, "A10"s));
REQUIRE(IsNamespacePackage(src, "A"s, "AA"s, "A11"s));
REQUIRE(IsNamespacePackage(src, "A"s, "AA"s, "A12"s));
REQUIRE(IsNamespacePackage(src, "A"s, "AA"s, "A13"s));
REQUIRE(IsNamespacePackage(src, "A"s, "AA"s, "A14"s));
REQUIRE(IsNamespacePackage(src, "A"s, "AA"s, "A15"s));
REQUIRE(IsNamespacePackage(src, "A"s, "AA"s, "A16"s));
REQUIRE(IsNamespacePackage(src, "A"s, "AA"s, "A17"s));
REQUIRE(IsNamespacePackage(src, "A"s, "AA"s, "A18"s));
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
REQUIRE(IsNamespacePackage(src, "B"s, "BB"s, "BBB"s));
REQUIRE_THAT(src, IsPackage("A1"));
REQUIRE_THAT(src, IsPackage("A2"));
REQUIRE_THAT(src, IsPackage("A3"));
REQUIRE_THAT(src, IsPackage("A4"));
REQUIRE_THAT(src, IsPackage("A5"));
REQUIRE_THAT(src, IsPackage("A6"));
REQUIRE_THAT(src, IsPackage("A7"));
REQUIRE_THAT(src, IsPackage("A8"));
REQUIRE_THAT(src, IsPackage("A9"));
REQUIRE_THAT(src, IsPackage("A11"));
REQUIRE_THAT(src, IsPackage("A12"));
REQUIRE_THAT(src, IsPackage("A13"));
REQUIRE_THAT(src, IsPackage("A14"));
REQUIRE_THAT(src, IsPackage("A15"));
REQUIRE_THAT(src, IsPackage("A16"));
REQUIRE_THAT(src, IsPackage("A17"));
REQUIRE_THAT(src, IsPackage("A18"));
REQUIRE(IsDependency(src, "BBB", "A1"));
REQUIRE(IsDependency(src, "BBB", "A2"));
REQUIRE(IsDependency(src, "BBB", "A3"));
REQUIRE(IsDependency(src, "BBB", "A4"));
REQUIRE(IsDependency(src, "BBB", "A5"));
REQUIRE(IsDependency(src, "BBB", "A6"));
REQUIRE(IsDependency(src, "BBB", "A7"));
REQUIRE(IsDependency(src, "BBB", "A8"));
REQUIRE(IsDependency(src, "BBB", "A9"));
REQUIRE(IsDependency(src, "BBB", "A10"));
REQUIRE(IsDependency(src, "BBB", "A11"));
REQUIRE(IsDependency(src, "BBB", "A12"));
REQUIRE(IsDependency(src, "BBB", "A13"));
REQUIRE(IsDependency(src, "BBB", "A14"));
REQUIRE(IsDependency(src, "BBB", "A15"));
REQUIRE(IsDependency(src, "BBB", "A16"));
REQUIRE(IsDependency(src, "BBB", "A17"));
REQUIRE(IsDependency(src, "BBB", "A18"));
});
/*
{
auto src = generate_package_puml(diagram, *model);
AliasMatcher _A(src);
REQUIRE_THAT(src, IsDependency(_A("BBB"), _A("A1")));
REQUIRE_THAT(src, IsDependency(_A("BBB"), _A("A2")));
REQUIRE_THAT(src, IsDependency(_A("BBB"), _A("A3")));
REQUIRE_THAT(src, IsDependency(_A("BBB"), _A("A4")));
REQUIRE_THAT(src, IsDependency(_A("BBB"), _A("A5")));
REQUIRE_THAT(src, IsDependency(_A("BBB"), _A("A6")));
REQUIRE_THAT(src, IsDependency(_A("BBB"), _A("A7")));
REQUIRE_THAT(src, IsDependency(_A("BBB"), _A("A8")));
REQUIRE_THAT(src, IsDependency(_A("BBB"), _A("A9")));
REQUIRE_THAT(src, IsDependency(_A("BBB"), _A("A10")));
REQUIRE_THAT(src, IsDependency(_A("BBB"), _A("A11")));
REQUIRE_THAT(src, IsDependency(_A("BBB"), _A("A12")));
REQUIRE_THAT(src, IsDependency(_A("BBB"), _A("A13")));
REQUIRE_THAT(src, IsDependency(_A("BBB"), _A("A14")));
REQUIRE_THAT(src, IsDependency(_A("BBB"), _A("A15")));
REQUIRE_THAT(src, IsDependency(_A("BBB"), _A("A16")));
REQUIRE_THAT(src, IsDependency(_A("BBB"), _A("A17")));
REQUIRE_THAT(src, IsDependency(_A("BBB"), _A("A18")));
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
REQUIRE_THAT(src, IsPackage("A1"));
REQUIRE_THAT(src, IsPackage("A2"));
REQUIRE_THAT(src, IsPackage("A3"));
REQUIRE_THAT(src, IsPackage("A4"));
REQUIRE_THAT(src, IsPackage("A5"));
REQUIRE_THAT(src, IsPackage("A6"));
REQUIRE_THAT(src, IsPackage("A7"));
REQUIRE_THAT(src, IsPackage("A8"));
REQUIRE_THAT(src, IsPackage("A9"));
REQUIRE_THAT(src, IsPackage("A11"));
REQUIRE_THAT(src, IsPackage("A12"));
REQUIRE_THAT(src, IsPackage("A13"));
REQUIRE_THAT(src, IsPackage("A14"));
REQUIRE_THAT(src, IsPackage("A15"));
REQUIRE_THAT(src, IsPackage("A16"));
REQUIRE_THAT(src, IsPackage("A17"));
REQUIRE_THAT(src, IsPackage("A18"));
{
auto j = generate_package_json(diagram, *model);
REQUIRE_THAT(src, IsDependency(_A("BBB"), _A("A1")));
REQUIRE_THAT(src, IsDependency(_A("BBB"), _A("A2")));
REQUIRE_THAT(src, IsDependency(_A("BBB"), _A("A3")));
REQUIRE_THAT(src, IsDependency(_A("BBB"), _A("A4")));
REQUIRE_THAT(src, IsDependency(_A("BBB"), _A("A5")));
REQUIRE_THAT(src, IsDependency(_A("BBB"), _A("A6")));
REQUIRE_THAT(src, IsDependency(_A("BBB"), _A("A7")));
REQUIRE_THAT(src, IsDependency(_A("BBB"), _A("A8")));
REQUIRE_THAT(src, IsDependency(_A("BBB"), _A("A9")));
REQUIRE_THAT(src, IsDependency(_A("BBB"), _A("A10")));
REQUIRE_THAT(src, IsDependency(_A("BBB"), _A("A11")));
REQUIRE_THAT(src, IsDependency(_A("BBB"), _A("A12")));
REQUIRE_THAT(src, IsDependency(_A("BBB"), _A("A13")));
REQUIRE_THAT(src, IsDependency(_A("BBB"), _A("A14")));
REQUIRE_THAT(src, IsDependency(_A("BBB"), _A("A15")));
REQUIRE_THAT(src, IsDependency(_A("BBB"), _A("A16")));
REQUIRE_THAT(src, IsDependency(_A("BBB"), _A("A17")));
REQUIRE_THAT(src, IsDependency(_A("BBB"), _A("A18")));
using namespace json;
using namespace std::string_literals;
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
REQUIRE(IsNamespacePackage(j, "A"s, "AA"s));
REQUIRE(IsNamespacePackage(j, "A"s, "AA"s, "A1"s));
REQUIRE(IsNamespacePackage(j, "A"s, "AA"s, "A2"s));
REQUIRE(IsNamespacePackage(j, "A"s, "AA"s, "A3"s));
REQUIRE(IsNamespacePackage(j, "A"s, "AA"s, "A4"s));
REQUIRE(IsNamespacePackage(j, "A"s, "AA"s, "A5"s));
REQUIRE(IsNamespacePackage(j, "A"s, "AA"s, "A6"s));
REQUIRE(IsNamespacePackage(j, "A"s, "AA"s, "A7"s));
REQUIRE(IsNamespacePackage(j, "A"s, "AA"s, "A8"s));
REQUIRE(IsNamespacePackage(j, "A"s, "AA"s, "A9"s));
REQUIRE(IsNamespacePackage(j, "A"s, "AA"s, "A10"s));
REQUIRE(IsNamespacePackage(j, "A"s, "AA"s, "A11"s));
REQUIRE(IsNamespacePackage(j, "A"s, "AA"s, "A12"s));
REQUIRE(IsNamespacePackage(j, "A"s, "AA"s, "A13"s));
REQUIRE(IsNamespacePackage(j, "A"s, "AA"s, "A14"s));
REQUIRE(IsNamespacePackage(j, "A"s, "AA"s, "A15"s));
REQUIRE(IsNamespacePackage(j, "A"s, "AA"s, "A16"s));
REQUIRE(IsNamespacePackage(j, "A"s, "AA"s, "A17"s));
REQUIRE(IsNamespacePackage(j, "A"s, "AA"s, "A18"s));
{
auto j = generate_package_json(diagram, *model);
REQUIRE(IsNamespacePackage(j, "B"s, "BB"s, "BBB"s));
using namespace json;
using namespace std::string_literals;
REQUIRE(IsDependency(j, "BBB", "A1"));
REQUIRE(IsDependency(j, "BBB", "A2"));
REQUIRE(IsDependency(j, "BBB", "A3"));
REQUIRE(IsDependency(j, "BBB", "A4"));
REQUIRE(IsDependency(j, "BBB", "A5"));
REQUIRE(IsDependency(j, "BBB", "A6"));
REQUIRE(IsDependency(j, "BBB", "A7"));
REQUIRE(IsDependency(j, "BBB", "A8"));
REQUIRE(IsDependency(j, "BBB", "A9"));
REQUIRE(IsDependency(j, "BBB", "A10"));
REQUIRE(IsDependency(j, "BBB", "A11"));
REQUIRE(IsDependency(j, "BBB", "A12"));
REQUIRE(IsDependency(j, "BBB", "A13"));
REQUIRE(IsDependency(j, "BBB", "A14"));
REQUIRE(IsDependency(j, "BBB", "A15"));
REQUIRE(IsDependency(j, "BBB", "A16"));
REQUIRE(IsDependency(j, "BBB", "A17"));
REQUIRE(IsDependency(j, "BBB", "A18"));
REQUIRE(IsNamespacePackage(j, "A"s, "AA"s));
REQUIRE(IsNamespacePackage(j, "A"s, "AA"s, "A1"s));
REQUIRE(IsNamespacePackage(j, "A"s, "AA"s, "A2"s));
REQUIRE(IsNamespacePackage(j, "A"s, "AA"s, "A3"s));
REQUIRE(IsNamespacePackage(j, "A"s, "AA"s, "A4"s));
REQUIRE(IsNamespacePackage(j, "A"s, "AA"s, "A5"s));
REQUIRE(IsNamespacePackage(j, "A"s, "AA"s, "A6"s));
REQUIRE(IsNamespacePackage(j, "A"s, "AA"s, "A7"s));
REQUIRE(IsNamespacePackage(j, "A"s, "AA"s, "A8"s));
REQUIRE(IsNamespacePackage(j, "A"s, "AA"s, "A9"s));
REQUIRE(IsNamespacePackage(j, "A"s, "AA"s, "A10"s));
REQUIRE(IsNamespacePackage(j, "A"s, "AA"s, "A11"s));
REQUIRE(IsNamespacePackage(j, "A"s, "AA"s, "A12"s));
REQUIRE(IsNamespacePackage(j, "A"s, "AA"s, "A13"s));
REQUIRE(IsNamespacePackage(j, "A"s, "AA"s, "A14"s));
REQUIRE(IsNamespacePackage(j, "A"s, "AA"s, "A15"s));
REQUIRE(IsNamespacePackage(j, "A"s, "AA"s, "A16"s));
REQUIRE(IsNamespacePackage(j, "A"s, "AA"s, "A17"s));
REQUIRE(IsNamespacePackage(j, "A"s, "AA"s, "A18"s));
save_json(config.output_directory(), diagram->name + ".json", j);
}
REQUIRE(IsNamespacePackage(j, "B"s, "BB"s, "BBB"s));
{
auto src = generate_package_mermaid(diagram, *model);
mermaid::AliasMatcher _A(src);
using mermaid::IsPackage;
using mermaid::IsPackageDependency;
REQUIRE(IsDependency(j, "BBB", "A1"));
REQUIRE(IsDependency(j, "BBB", "A2"));
REQUIRE(IsDependency(j, "BBB", "A3"));
REQUIRE(IsDependency(j, "BBB", "A4"));
REQUIRE(IsDependency(j, "BBB", "A5"));
REQUIRE(IsDependency(j, "BBB", "A6"));
REQUIRE(IsDependency(j, "BBB", "A7"));
REQUIRE(IsDependency(j, "BBB", "A8"));
REQUIRE(IsDependency(j, "BBB", "A9"));
REQUIRE(IsDependency(j, "BBB", "A10"));
REQUIRE(IsDependency(j, "BBB", "A11"));
REQUIRE(IsDependency(j, "BBB", "A12"));
REQUIRE(IsDependency(j, "BBB", "A13"));
REQUIRE(IsDependency(j, "BBB", "A14"));
REQUIRE(IsDependency(j, "BBB", "A15"));
REQUIRE(IsDependency(j, "BBB", "A16"));
REQUIRE(IsDependency(j, "BBB", "A17"));
REQUIRE(IsDependency(j, "BBB", "A18"));
REQUIRE_THAT(src, IsPackage(_A("A1")));
REQUIRE_THAT(src, IsPackage(_A("A2")));
REQUIRE_THAT(src, IsPackage(_A("A3")));
REQUIRE_THAT(src, IsPackage(_A("A4")));
REQUIRE_THAT(src, IsPackage(_A("A5")));
REQUIRE_THAT(src, IsPackage(_A("A6")));
REQUIRE_THAT(src, IsPackage(_A("A7")));
REQUIRE_THAT(src, IsPackage(_A("A8")));
REQUIRE_THAT(src, IsPackage(_A("A9")));
REQUIRE_THAT(src, IsPackage(_A("A11")));
REQUIRE_THAT(src, IsPackage(_A("A12")));
REQUIRE_THAT(src, IsPackage(_A("A13")));
REQUIRE_THAT(src, IsPackage(_A("A14")));
REQUIRE_THAT(src, IsPackage(_A("A15")));
REQUIRE_THAT(src, IsPackage(_A("A16")));
REQUIRE_THAT(src, IsPackage(_A("A17")));
REQUIRE_THAT(src, IsPackage(_A("A18")));
save_json(config.output_directory(), diagram->name + ".json", j);
}
REQUIRE_THAT(src, IsPackageDependency(_A("BBB"), _A("A1")));
REQUIRE_THAT(src, IsPackageDependency(_A("BBB"), _A("A2")));
REQUIRE_THAT(src, IsPackageDependency(_A("BBB"), _A("A3")));
REQUIRE_THAT(src, IsPackageDependency(_A("BBB"), _A("A4")));
REQUIRE_THAT(src, IsPackageDependency(_A("BBB"), _A("A5")));
REQUIRE_THAT(src, IsPackageDependency(_A("BBB"), _A("A6")));
REQUIRE_THAT(src, IsPackageDependency(_A("BBB"), _A("A7")));
REQUIRE_THAT(src, IsPackageDependency(_A("BBB"), _A("A8")));
REQUIRE_THAT(src, IsPackageDependency(_A("BBB"), _A("A9")));
REQUIRE_THAT(src, IsPackageDependency(_A("BBB"), _A("A10")));
REQUIRE_THAT(src, IsPackageDependency(_A("BBB"), _A("A11")));
REQUIRE_THAT(src, IsPackageDependency(_A("BBB"), _A("A12")));
REQUIRE_THAT(src, IsPackageDependency(_A("BBB"), _A("A13")));
REQUIRE_THAT(src, IsPackageDependency(_A("BBB"), _A("A14")));
REQUIRE_THAT(src, IsPackageDependency(_A("BBB"), _A("A15")));
REQUIRE_THAT(src, IsPackageDependency(_A("BBB"), _A("A16")));
REQUIRE_THAT(src, IsPackageDependency(_A("BBB"), _A("A17")));
REQUIRE_THAT(src, IsPackageDependency(_A("BBB"), _A("A18")));
{
auto src = generate_package_mermaid(diagram, *model);
mermaid::AliasMatcher _A(src);
using mermaid::IsPackage;
using mermaid::IsPackageDependency;
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}
REQUIRE_THAT(src, IsPackage(_A("A1")));
REQUIRE_THAT(src, IsPackage(_A("A2")));
REQUIRE_THAT(src, IsPackage(_A("A3")));
REQUIRE_THAT(src, IsPackage(_A("A4")));
REQUIRE_THAT(src, IsPackage(_A("A5")));
REQUIRE_THAT(src, IsPackage(_A("A6")));
REQUIRE_THAT(src, IsPackage(_A("A7")));
REQUIRE_THAT(src, IsPackage(_A("A8")));
REQUIRE_THAT(src, IsPackage(_A("A9")));
REQUIRE_THAT(src, IsPackage(_A("A11")));
REQUIRE_THAT(src, IsPackage(_A("A12")));
REQUIRE_THAT(src, IsPackage(_A("A13")));
REQUIRE_THAT(src, IsPackage(_A("A14")));
REQUIRE_THAT(src, IsPackage(_A("A15")));
REQUIRE_THAT(src, IsPackage(_A("A16")));
REQUIRE_THAT(src, IsPackage(_A("A17")));
REQUIRE_THAT(src, IsPackage(_A("A18")));
REQUIRE_THAT(src, IsPackageDependency(_A("BBB"), _A("A1")));
REQUIRE_THAT(src, IsPackageDependency(_A("BBB"), _A("A2")));
REQUIRE_THAT(src, IsPackageDependency(_A("BBB"), _A("A3")));
REQUIRE_THAT(src, IsPackageDependency(_A("BBB"), _A("A4")));
REQUIRE_THAT(src, IsPackageDependency(_A("BBB"), _A("A5")));
REQUIRE_THAT(src, IsPackageDependency(_A("BBB"), _A("A6")));
REQUIRE_THAT(src, IsPackageDependency(_A("BBB"), _A("A7")));
REQUIRE_THAT(src, IsPackageDependency(_A("BBB"), _A("A8")));
REQUIRE_THAT(src, IsPackageDependency(_A("BBB"), _A("A9")));
REQUIRE_THAT(src, IsPackageDependency(_A("BBB"), _A("A10")));
REQUIRE_THAT(src, IsPackageDependency(_A("BBB"), _A("A11")));
REQUIRE_THAT(src, IsPackageDependency(_A("BBB"), _A("A12")));
REQUIRE_THAT(src, IsPackageDependency(_A("BBB"), _A("A13")));
REQUIRE_THAT(src, IsPackageDependency(_A("BBB"), _A("A14")));
REQUIRE_THAT(src, IsPackageDependency(_A("BBB"), _A("A15")));
REQUIRE_THAT(src, IsPackageDependency(_A("BBB"), _A("A16")));
REQUIRE_THAT(src, IsPackageDependency(_A("BBB"), _A("A17")));
REQUIRE_THAT(src, IsPackageDependency(_A("BBB"), _A("A18")));
save_mermaid(config.output_directory(), diagram->name + ".mmd",
src);
}
*/
}

69
tests/t30003/test_case.h
View File

@@ -1,5 +1,5 @@
/**
* tests/t30003/test_case.cc
* tests/t30003/test_case.h
*
* Copyright (c) 2021-2024 Bartek Kryza <bkryza@gmail.com>
*
@@ -16,8 +16,11 @@
* limitations under the License.
*/
TEST_CASE("t30003", "[test-case][package]")
TEST_CASE("t30003")
{
using namespace clanguml::test;
using namespace std::string_literals;
auto [config, db] = load_config("t30003");
auto diagram = config.diagrams["t30003_package"];
@@ -27,58 +30,16 @@ TEST_CASE("t30003", "[test-case][package]")
auto model = generate_package_diagram(*db, diagram);
REQUIRE(model->name() == "t30003_package");
{
auto src = generate_package_puml(diagram, *model);
AliasMatcher _A(src);
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
CHECK_PACKAGE_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(IsNamespacePackage(src, "ns1"s));
REQUIRE(IsNamespacePackage(src, "ns1"s, "ns2_v1_0_0"s));
REQUIRE(IsNamespacePackage(src, "ns1"s, "ns2_v0_9_0"s));
REQUIRE(IsNamespacePackage(src, "ns3"s));
REQUIRE(IsNamespacePackage(src, "ns3"s, "ns1"s));
REQUIRE(IsNamespacePackage(src, "ns3"s, "ns1"s, "ns2"s));
REQUIRE_THAT(src, IsPackage("ns1"));
REQUIRE_THAT(src, IsPackage("ns2"));
REQUIRE_THAT(src, IsPackage("ns3"));
REQUIRE_THAT(src, IsPackage("ns2_v1_0_0"));
REQUIRE_THAT(src, IsPackage("ns2_v0_9_0"));
REQUIRE_THAT(src, IsDeprecated(_A("ns2_v0_9_0")));
REQUIRE_THAT(src, IsDeprecated(_A("ns3")));
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
{
auto j = generate_package_json(diagram, *model);
using namespace json;
using namespace std::string_literals;
REQUIRE(IsNamespacePackage(j, "ns1"s));
REQUIRE(IsNamespacePackage(j, "ns1"s, "ns2_v1_0_0"s));
REQUIRE(IsNamespacePackage(j, "ns1"s, "ns2_v0_9_0"s));
REQUIRE(IsNamespacePackage(j, "ns3"s));
REQUIRE(IsNamespacePackage(j, "ns3"s, "ns1"s));
REQUIRE(IsNamespacePackage(j, "ns3"s, "ns1"s, "ns2"s));
REQUIRE(IsDeprecated(j, "ns2_v0_9_0"));
REQUIRE(IsDeprecated(j, "ns3"));
save_json(config.output_directory(), diagram->name + ".json", j);
}
{
auto src = generate_package_mermaid(diagram, *model);
mermaid::AliasMatcher _A(src);
using mermaid::IsPackage;
REQUIRE_THAT(src, IsPackage(_A("ns1")));
REQUIRE_THAT(src, IsPackage(_A("ns2")));
REQUIRE_THAT(src, IsPackage(_A("ns3")));
REQUIRE_THAT(src, IsPackage(_A("ns2_v1_0_0")));
REQUIRE_THAT(src, IsPackage(_A("ns2_v0_9_0")));
// REQUIRE_THAT(src, IsDeprecated(_A("ns2_v0_9_0")));
// REQUIRE_THAT(src, IsDeprecated(_A("ns3")));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}
// REQUIRE(IsDeprecated(src, "ns2_v0_9_0"));
// REQUIRE(IsDeprecated(src, "ns3"));
});
}

19
tests/t30004/test_case.h
View File

@@ -1,5 +1,5 @@
/**
* tests/t30004/test_case.cc
* tests/t30004/test_case.h
*
* Copyright (c) 2021-2024 Bartek Kryza <bkryza@gmail.com>
*
@@ -16,8 +16,11 @@
* limitations under the License.
*/
TEST_CASE("t30004", "[test-case][package]")
TEST_CASE("t30004")
{
using namespace clanguml::test;
using namespace std::string_literals;
auto [config, db] = load_config("t30004");
auto diagram = config.diagrams["t30004_package"];
@@ -28,7 +31,15 @@ TEST_CASE("t30004", "[test-case][package]")
REQUIRE(model->name() == "t30004_package");
{
CHECK_PACKAGE_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(IsNamespacePackage(src, "A"s));
REQUIRE(IsNamespacePackage(src, "A"s, "AAA"s));
REQUIRE(IsNamespacePackage(src, "A"s, "BBB"s));
REQUIRE(IsNamespacePackage(src, "A"s, "CCC"s));
REQUIRE(!IsNamespacePackage(src, "A"s, "DDD"s));
REQUIRE(IsNamespacePackage(src, "A"s, "EEE"s));
});
/*{
auto src = generate_package_puml(diagram, *model);
AliasMatcher _A(src);
@@ -72,5 +83,5 @@ TEST_CASE("t30004", "[test-case][package]")
REQUIRE_THAT(src, IsPackage(_A("EEE")));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}
}*/
}

24
tests/t30005/test_case.h
View File

@@ -1,5 +1,5 @@
/**
* tests/t30005/test_case.cc
* tests/t30005/test_case.h
*
* Copyright (c) 2021-2024 Bartek Kryza <bkryza@gmail.com>
*
@@ -16,8 +16,11 @@
* limitations under the License.
*/
TEST_CASE("t30005", "[test-case][package]")
TEST_CASE("t30005")
{
using namespace clanguml::test;
using namespace std::string_literals;
auto [config, db] = load_config("t30005");
auto diagram = config.diagrams["t30005_package"];
@@ -28,6 +31,21 @@ TEST_CASE("t30005", "[test-case][package]")
REQUIRE(model->name() == "t30005_package");
CHECK_PACKAGE_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(IsNamespacePackage(src, "A"s));
REQUIRE(IsNamespacePackage(src, "A"s, "AA"s));
REQUIRE(IsNamespacePackage(src, "A"s, "AA"s, "AAA"s));
REQUIRE(IsNamespacePackage(src, "B"s));
REQUIRE(IsNamespacePackage(src, "B"s, "BB"s));
REQUIRE(IsNamespacePackage(src, "B"s, "BB"s, "BBB"s));
REQUIRE(IsNamespacePackage(src, "C"s));
REQUIRE(IsNamespacePackage(src, "C"s, "CC"s));
REQUIRE(IsNamespacePackage(src, "C"s, "CC"s, "CCC"s));
REQUIRE(IsDependency(src, "BBB", "AAA"));
REQUIRE(IsDependency(src, "CCC", "AAA"));
});
/*
{
auto src = generate_package_puml(diagram, *model);
AliasMatcher _A(src);
@@ -82,5 +100,5 @@ TEST_CASE("t30005", "[test-case][package]")
REQUIRE_THAT(src, IsPackageDependency(_A("CCC"), _A("AAA")));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}
}*/
}

17
tests/t30006/test_case.h
View File

@@ -16,8 +16,11 @@
* limitations under the License.
*/
TEST_CASE("t30006", "[test-case][package]")
TEST_CASE("t30006")
{
using namespace clanguml::test;
using namespace std::string_literals;
auto [config, db] = load_config("t30006");
auto diagram = config.diagrams["t30006_package"];
@@ -28,6 +31,16 @@ TEST_CASE("t30006", "[test-case][package]")
REQUIRE(model->name() == "t30006_package");
CHECK_PACKAGE_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(IsNamespacePackage(src, "A"s));
REQUIRE(IsNamespacePackage(src, "B"s));
REQUIRE(IsNamespacePackage(src, "C"s));
REQUIRE(IsDependency(src, "A", "B"));
REQUIRE(IsDependency(src, "A", "C"));
});
/*
{
auto src = generate_package_puml(diagram, *model);
AliasMatcher _A(src);
@@ -75,5 +88,5 @@ TEST_CASE("t30006", "[test-case][package]")
REQUIRE_THAT(src, IsPackageDependency(_A("A"), _A("C")));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}
}*/
}

93
tests/t30007/test_case.h
View File

@@ -16,8 +16,11 @@
* limitations under the License.
*/
TEST_CASE("t30007", "[test-case][package]")
TEST_CASE("t30007")
{
using namespace clanguml::test;
using namespace std::string_literals;
auto [config, db] = load_config("t30007");
auto diagram = config.diagrams["t30007_package"];
@@ -28,56 +31,68 @@ TEST_CASE("t30007", "[test-case][package]")
REQUIRE(model->name() == "t30007_package");
{
auto src = generate_package_puml(diagram, *model);
AliasMatcher _A(src);
CHECK_PACKAGE_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(IsNamespacePackage(src, "A"s));
REQUIRE(IsNamespacePackage(src, "A"s, "AA"s));
REQUIRE(IsNamespacePackage(src, "B"s));
REQUIRE(IsNamespacePackage(src, "C"s));
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
REQUIRE(IsDependency(src, "AA", "B"));
REQUIRE(IsDependency(src, "AA", "C"));
});
/*
{
auto src = generate_package_puml(diagram, *model);
AliasMatcher _A(src);
REQUIRE_THAT(src, IsPackage("A"));
REQUIRE_THAT(src, IsPackage("B"));
REQUIRE_THAT(src, IsPackage("C"));
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
REQUIRE_THAT(src, IsDependency(_A("AA"), _A("B")));
REQUIRE_THAT(src, IsDependency(_A("AA"), _A("C")));
REQUIRE_THAT(src, IsPackage("A"));
REQUIRE_THAT(src, IsPackage("B"));
REQUIRE_THAT(src, IsPackage("C"));
REQUIRE_THAT(src, IsLayoutHint(_A("C"), "up", _A("AA")));
REQUIRE_THAT(src, IsLayoutHint(_A("C"), "left", _A("B")));
REQUIRE_THAT(src, IsDependency(_A("AA"), _A("B")));
REQUIRE_THAT(src, IsDependency(_A("AA"), _A("C")));
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
REQUIRE_THAT(src, IsLayoutHint(_A("C"), "up", _A("AA")));
REQUIRE_THAT(src, IsLayoutHint(_A("C"), "left", _A("B")));
{
auto j = generate_package_json(diagram, *model);
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
using namespace json;
using namespace std::string_literals;
{
auto j = generate_package_json(diagram, *model);
REQUIRE(IsNamespacePackage(j, "A"s));
REQUIRE(IsNamespacePackage(j, "A"s, "AA"s));
REQUIRE(IsNamespacePackage(j, "B"s));
REQUIRE(IsNamespacePackage(j, "C"s));
using namespace json;
using namespace std::string_literals;
REQUIRE(IsDependency(j, "AA", "B"));
REQUIRE(IsDependency(j, "AA", "C"));
REQUIRE(IsNamespacePackage(j, "A"s));
REQUIRE(IsNamespacePackage(j, "A"s, "AA"s));
REQUIRE(IsNamespacePackage(j, "B"s));
REQUIRE(IsNamespacePackage(j, "C"s));
save_json(config.output_directory(), diagram->name + ".json", j);
}
REQUIRE(IsDependency(j, "AA", "B"));
REQUIRE(IsDependency(j, "AA", "C"));
{
auto src = generate_package_mermaid(diagram, *model);
mermaid::AliasMatcher _A(src);
using mermaid::IsPackage;
using mermaid::IsPackageDependency;
save_json(config.output_directory(), diagram->name + ".json", j);
}
REQUIRE_THAT(src, IsPackage(_A("A")));
REQUIRE_THAT(src, IsPackage(_A("B")));
REQUIRE_THAT(src, IsPackage(_A("C")));
{
auto src = generate_package_mermaid(diagram, *model);
mermaid::AliasMatcher _A(src);
using mermaid::IsPackage;
using mermaid::IsPackageDependency;
REQUIRE_THAT(src, IsPackageDependency(_A("AA"), _A("B")));
REQUIRE_THAT(src, IsPackageDependency(_A("AA"), _A("C")));
REQUIRE_THAT(src, IsPackage(_A("A")));
REQUIRE_THAT(src, IsPackage(_A("B")));
REQUIRE_THAT(src, IsPackage(_A("C")));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}
REQUIRE_THAT(src, IsPackageDependency(_A("AA"), _A("B")));
REQUIRE_THAT(src, IsPackageDependency(_A("AA"), _A("C")));
save_mermaid(config.output_directory(), diagram->name + ".mmd",
src);
}
*/
}

136
tests/t30008/test_case.h
View File

@@ -16,8 +16,11 @@
* limitations under the License.
*/
TEST_CASE("t30008", "[test-case][package]")
TEST_CASE("t30008")
{
using namespace clanguml::test;
using namespace std::string_literals;
auto [config, db] = load_config("t30008");
auto diagram = config.diagrams["t30008_package"];
@@ -28,79 +31,98 @@ TEST_CASE("t30008", "[test-case][package]")
REQUIRE(model->name() == "t30008_package");
{
auto src = generate_package_puml(diagram, *model);
AliasMatcher _A(src);
CHECK_PACKAGE_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(IsNamespacePackage(src, "dependants"s, "A"s));
REQUIRE(IsNamespacePackage(src, "dependants"s, "B"s));
REQUIRE(IsNamespacePackage(src, "dependants"s, "C"s));
REQUIRE(!IsNamespacePackage(src, "dependants"s, "X"s));
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
REQUIRE(IsDependency(src, "B", "A"));
REQUIRE(IsDependency(src, "C", "B"));
REQUIRE_THAT(src, IsPackage("A"));
REQUIRE_THAT(src, IsPackage("B"));
REQUIRE_THAT(src, IsPackage("C"));
REQUIRE_THAT(src, !IsPackage("X"));
REQUIRE(IsNamespacePackage(src, "dependencies"s, "D"s));
REQUIRE(IsNamespacePackage(src, "dependencies"s, "E"s));
REQUIRE(IsNamespacePackage(src, "dependencies"s, "F"s));
REQUIRE(!IsNamespacePackage(src, "dependencies"s, "Y"s));
REQUIRE_THAT(src, IsDependency(_A("B"), _A("A")));
REQUIRE_THAT(src, IsDependency(_A("C"), _A("B")));
REQUIRE(IsDependency(src, "E", "D"));
REQUIRE(IsDependency(src, "F", "E"));
});
/*
{
auto src = generate_package_puml(diagram, *model);
AliasMatcher _A(src);
REQUIRE_THAT(src, IsPackage("D"));
REQUIRE_THAT(src, IsPackage("E"));
REQUIRE_THAT(src, IsPackage("F"));
REQUIRE_THAT(src, !IsPackage("Y"));
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
REQUIRE_THAT(src, IsDependency(_A("E"), _A("D")));
REQUIRE_THAT(src, IsDependency(_A("F"), _A("E")));
REQUIRE_THAT(src, IsPackage("A"));
REQUIRE_THAT(src, IsPackage("B"));
REQUIRE_THAT(src, IsPackage("C"));
REQUIRE_THAT(src, !IsPackage("X"));
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
REQUIRE_THAT(src, IsDependency(_A("B"), _A("A")));
REQUIRE_THAT(src, IsDependency(_A("C"), _A("B")));
{
auto j = generate_package_json(diagram, *model);
REQUIRE_THAT(src, IsPackage("D"));
REQUIRE_THAT(src, IsPackage("E"));
REQUIRE_THAT(src, IsPackage("F"));
REQUIRE_THAT(src, !IsPackage("Y"));
using namespace json;
using namespace std::string_literals;
REQUIRE_THAT(src, IsDependency(_A("E"), _A("D")));
REQUIRE_THAT(src, IsDependency(_A("F"), _A("E")));
REQUIRE(IsNamespacePackage(j, "dependants"s, "A"s));
REQUIRE(IsNamespacePackage(j, "dependants"s, "B"s));
REQUIRE(IsNamespacePackage(j, "dependants"s, "C"s));
REQUIRE(!IsNamespacePackage(j, "dependants"s, "X"s));
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
REQUIRE(IsDependency(j, "B", "A"));
REQUIRE(IsDependency(j, "C", "B"));
{
auto j = generate_package_json(diagram, *model);
REQUIRE(IsNamespacePackage(j, "dependencies"s, "D"s));
REQUIRE(IsNamespacePackage(j, "dependencies"s, "E"s));
REQUIRE(IsNamespacePackage(j, "dependencies"s, "F"s));
REQUIRE(!IsNamespacePackage(j, "dependencies"s, "Y"s));
using namespace json;
using namespace std::string_literals;
REQUIRE(IsDependency(j, "E", "D"));
REQUIRE(IsDependency(j, "F", "E"));
REQUIRE(IsNamespacePackage(j, "dependants"s, "A"s));
REQUIRE(IsNamespacePackage(j, "dependants"s, "B"s));
REQUIRE(IsNamespacePackage(j, "dependants"s, "C"s));
REQUIRE(!IsNamespacePackage(j, "dependants"s, "X"s));
save_json(config.output_directory(), diagram->name + ".json", j);
}
REQUIRE(IsDependency(j, "B", "A"));
REQUIRE(IsDependency(j, "C", "B"));
{
auto src = generate_package_mermaid(diagram, *model);
mermaid::AliasMatcher _A(src);
using mermaid::IsPackage;
using mermaid::IsPackageDependency;
REQUIRE(IsNamespacePackage(j, "dependencies"s, "D"s));
REQUIRE(IsNamespacePackage(j, "dependencies"s, "E"s));
REQUIRE(IsNamespacePackage(j, "dependencies"s, "F"s));
REQUIRE(!IsNamespacePackage(j, "dependencies"s, "Y"s));
REQUIRE_THAT(src, IsPackage(_A("A")));
REQUIRE_THAT(src, IsPackage(_A("B")));
REQUIRE_THAT(src, IsPackage(_A("C")));
REQUIRE_THAT(src, !IsPackage(_A("X")));
REQUIRE(IsDependency(j, "E", "D"));
REQUIRE(IsDependency(j, "F", "E"));
REQUIRE_THAT(src, IsPackageDependency(_A("B"), _A("A")));
REQUIRE_THAT(src, IsPackageDependency(_A("C"), _A("B")));
save_json(config.output_directory(), diagram->name + ".json", j);
}
REQUIRE_THAT(src, IsPackage(_A("D")));
REQUIRE_THAT(src, IsPackage(_A("E")));
REQUIRE_THAT(src, IsPackage(_A("F")));
REQUIRE_THAT(src, !IsPackage(_A("Y")));
{
auto src = generate_package_mermaid(diagram, *model);
mermaid::AliasMatcher _A(src);
using mermaid::IsPackage;
using mermaid::IsPackageDependency;
REQUIRE_THAT(src, IsPackageDependency(_A("E"), _A("D")));
REQUIRE_THAT(src, IsPackageDependency(_A("F"), _A("E")));
REQUIRE_THAT(src, IsPackage(_A("A")));
REQUIRE_THAT(src, IsPackage(_A("B")));
REQUIRE_THAT(src, IsPackage(_A("C")));
REQUIRE_THAT(src, !IsPackage(_A("X")));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}
REQUIRE_THAT(src, IsPackageDependency(_A("B"), _A("A")));
REQUIRE_THAT(src, IsPackageDependency(_A("C"), _A("B")));
REQUIRE_THAT(src, IsPackage(_A("D")));
REQUIRE_THAT(src, IsPackage(_A("E")));
REQUIRE_THAT(src, IsPackage(_A("F")));
REQUIRE_THAT(src, !IsPackage(_A("Y")));
REQUIRE_THAT(src, IsPackageDependency(_A("E"), _A("D")));
REQUIRE_THAT(src, IsPackageDependency(_A("F"), _A("E")));
save_mermaid(config.output_directory(), diagram->name + ".mmd",
src);
}*/
}

103
tests/t30009/test_case.h
View File

@@ -16,8 +16,11 @@
* limitations under the License.
*/
TEST_CASE("t30009", "[test-case][package]")
TEST_CASE("t30009")
{
using namespace clanguml::test;
using namespace std::string_literals;
auto [config, db] = load_config("t30009");
auto diagram = config.diagrams["t30009_package"];
@@ -28,56 +31,70 @@ TEST_CASE("t30009", "[test-case][package]")
REQUIRE(model->name() == "t30009_package");
{
auto src = generate_package_puml(diagram, *model);
AliasMatcher _A(src);
CHECK_PACKAGE_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(IsNamespacePackage(src, "One"s));
REQUIRE(IsNamespacePackage(src, "Two"s));
REQUIRE(IsNamespacePackage(src, "One"s, "A"s));
REQUIRE(IsNamespacePackage(src, "One"s, "B"s));
REQUIRE(IsNamespacePackage(src, "One"s, "C"s));
REQUIRE(IsNamespacePackage(src, "One"s, "D"s));
REQUIRE(IsNamespacePackage(src, "Two"s, "A"s));
REQUIRE(IsNamespacePackage(src, "Two"s, "B"s));
REQUIRE(IsNamespacePackage(src, "Two"s, "C"s));
REQUIRE(IsNamespacePackage(src, "Two"s, "D"s));
});
/*
{
auto src = generate_package_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 packages exist
REQUIRE_THAT(src, IsPackage("One"));
REQUIRE_THAT(src, IsPackage("Two"));
REQUIRE_THAT(src, IsPackage("A"));
REQUIRE_THAT(src, IsPackage("B"));
REQUIRE_THAT(src, IsPackage("C"));
REQUIRE_THAT(src, IsPackage("D"));
// Check if all packages exist
REQUIRE_THAT(src, IsPackage("One"));
REQUIRE_THAT(src, IsPackage("Two"));
REQUIRE_THAT(src, IsPackage("A"));
REQUIRE_THAT(src, IsPackage("B"));
REQUIRE_THAT(src, IsPackage("C"));
REQUIRE_THAT(src, IsPackage("D"));
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
{
auto j = generate_package_json(diagram, *model);
{
auto j = generate_package_json(diagram, *model);
using namespace json;
using namespace std::string_literals;
using namespace json;
using namespace std::string_literals;
REQUIRE(IsNamespacePackage(j, "One"s));
REQUIRE(IsNamespacePackage(j, "Two"s));
REQUIRE(IsNamespacePackage(j, "One"s, "A"s));
REQUIRE(IsNamespacePackage(j, "One"s, "B"s));
REQUIRE(IsNamespacePackage(j, "One"s, "C"s));
REQUIRE(IsNamespacePackage(j, "One"s, "D"s));
REQUIRE(IsNamespacePackage(j, "Two"s, "A"s));
REQUIRE(IsNamespacePackage(j, "Two"s, "B"s));
REQUIRE(IsNamespacePackage(j, "Two"s, "C"s));
REQUIRE(IsNamespacePackage(j, "Two"s, "D"s));
REQUIRE(IsNamespacePackage(j, "One"s));
REQUIRE(IsNamespacePackage(j, "Two"s));
REQUIRE(IsNamespacePackage(j, "One"s, "A"s));
REQUIRE(IsNamespacePackage(j, "One"s, "B"s));
REQUIRE(IsNamespacePackage(j, "One"s, "C"s));
REQUIRE(IsNamespacePackage(j, "One"s, "D"s));
REQUIRE(IsNamespacePackage(j, "Two"s, "A"s));
REQUIRE(IsNamespacePackage(j, "Two"s, "B"s));
REQUIRE(IsNamespacePackage(j, "Two"s, "C"s));
REQUIRE(IsNamespacePackage(j, "Two"s, "D"s));
save_json(config.output_directory(), diagram->name + ".json", j);
}
save_json(config.output_directory(), diagram->name + ".json", j);
}
{
auto src = generate_package_mermaid(diagram, *model);
mermaid::AliasMatcher _A(src);
using mermaid::IsPackage;
{
auto src = generate_package_mermaid(diagram, *model);
mermaid::AliasMatcher _A(src);
using mermaid::IsPackage;
REQUIRE_THAT(src, IsPackage(_A("One")));
REQUIRE_THAT(src, IsPackage(_A("Two")));
REQUIRE_THAT(src, IsPackage(_A("A")));
REQUIRE_THAT(src, IsPackage(_A("B")));
REQUIRE_THAT(src, IsPackage(_A("C")));
REQUIRE_THAT(src, IsPackage(_A("D")));
REQUIRE_THAT(src, IsPackage(_A("One")));
REQUIRE_THAT(src, IsPackage(_A("Two")));
REQUIRE_THAT(src, IsPackage(_A("A")));
REQUIRE_THAT(src, IsPackage(_A("B")));
REQUIRE_THAT(src, IsPackage(_A("C")));
REQUIRE_THAT(src, IsPackage(_A("D")));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}
save_mermaid(config.output_directory(), diagram->name + ".mmd",
src);
}*/
}

109
tests/t30010/test_case.h
View File

@@ -16,8 +16,11 @@
* limitations under the License.
*/
TEST_CASE("t30010", "[test-case][package]")
TEST_CASE("t30010")
{
using namespace clanguml::test;
using namespace std::string_literals;
auto [config, db] = load_config("t30010");
auto diagram = config.diagrams["t30010_package"];
@@ -28,61 +31,75 @@ TEST_CASE("t30010", "[test-case][package]")
REQUIRE(model->name() == "t30010_package");
{
auto src = generate_package_puml(diagram, *model);
AliasMatcher _A(src);
CHECK_PACKAGE_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(IsDirectoryPackage(src, "app"s));
REQUIRE(IsDirectoryPackage(src, "libraries"s, "lib1"s));
REQUIRE(IsDirectoryPackage(src, "libraries"s, "lib2"s));
REQUIRE(IsDirectoryPackage(src, "libraries"s, "lib3"s));
REQUIRE(IsDirectoryPackage(src, "libraries"s, "lib4"s));
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
REQUIRE(IsDependency(src, "app", "lib1"));
REQUIRE(IsDependency(src, "app", "lib2"));
REQUIRE(IsDependency(src, "app", "lib3"));
REQUIRE(IsDependency(src, "app", "lib4"));
});
/*
{
auto src = generate_package_puml(diagram, *model);
AliasMatcher _A(src);
REQUIRE_THAT(src, IsPackage("app"));
REQUIRE_THAT(src, IsPackage("libraries"));
REQUIRE_THAT(src, IsPackage("lib1"));
REQUIRE_THAT(src, IsPackage("lib2"));
REQUIRE_THAT(src, !IsPackage("library1"));
REQUIRE_THAT(src, !IsPackage("library2"));
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
REQUIRE_THAT(src, IsDependency(_A("app"), _A("lib1")));
REQUIRE_THAT(src, IsDependency(_A("app"), _A("lib2")));
REQUIRE_THAT(src, IsDependency(_A("app"), _A("lib3")));
REQUIRE_THAT(src, IsDependency(_A("app"), _A("lib4")));
REQUIRE_THAT(src, IsPackage("app"));
REQUIRE_THAT(src, IsPackage("libraries"));
REQUIRE_THAT(src, IsPackage("lib1"));
REQUIRE_THAT(src, IsPackage("lib2"));
REQUIRE_THAT(src, !IsPackage("library1"));
REQUIRE_THAT(src, !IsPackage("library2"));
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
REQUIRE_THAT(src, IsDependency(_A("app"), _A("lib1")));
REQUIRE_THAT(src, IsDependency(_A("app"), _A("lib2")));
REQUIRE_THAT(src, IsDependency(_A("app"), _A("lib3")));
REQUIRE_THAT(src, IsDependency(_A("app"), _A("lib4")));
{
auto j = generate_package_json(diagram, *model);
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
using namespace json;
using namespace std::string_literals;
{
auto j = generate_package_json(diagram, *model);
REQUIRE(IsDirectoryPackage(j, "app"s));
REQUIRE(IsDirectoryPackage(j, "libraries"s, "lib1"s));
REQUIRE(IsDirectoryPackage(j, "libraries"s, "lib2"s));
REQUIRE(IsDirectoryPackage(j, "libraries"s, "lib3"s));
REQUIRE(IsDirectoryPackage(j, "libraries"s, "lib4"s));
using namespace json;
using namespace std::string_literals;
save_json(config.output_directory(), diagram->name + ".json", j);
}
REQUIRE(IsDirectoryPackage(j, "app"s));
REQUIRE(IsDirectoryPackage(j, "libraries"s, "lib1"s));
REQUIRE(IsDirectoryPackage(j, "libraries"s, "lib2"s));
REQUIRE(IsDirectoryPackage(j, "libraries"s, "lib3"s));
REQUIRE(IsDirectoryPackage(j, "libraries"s, "lib4"s));
{
auto src = generate_package_mermaid(diagram, *model);
mermaid::AliasMatcher _A(src);
using mermaid::IsPackage;
using mermaid::IsPackageDependency;
save_json(config.output_directory(), diagram->name + ".json", j);
}
REQUIRE_THAT(src, IsPackage(_A("app")));
REQUIRE_THAT(src, IsPackage(_A("libraries")));
REQUIRE_THAT(src, IsPackage(_A("lib1")));
REQUIRE_THAT(src, IsPackage(_A("lib2")));
REQUIRE_THAT(src, !IsPackage(_A("library1")));
REQUIRE_THAT(src, !IsPackage(_A("library2")));
{
auto src = generate_package_mermaid(diagram, *model);
mermaid::AliasMatcher _A(src);
using mermaid::IsPackage;
using mermaid::IsPackageDependency;
REQUIRE_THAT(src, IsPackageDependency(_A("app"), _A("lib1")));
REQUIRE_THAT(src, IsPackageDependency(_A("app"), _A("lib2")));
REQUIRE_THAT(src, IsPackageDependency(_A("app"), _A("lib3")));
REQUIRE_THAT(src, IsPackageDependency(_A("app"), _A("lib4")));
REQUIRE_THAT(src, IsPackage(_A("app")));
REQUIRE_THAT(src, IsPackage(_A("libraries")));
REQUIRE_THAT(src, IsPackage(_A("lib1")));
REQUIRE_THAT(src, IsPackage(_A("lib2")));
REQUIRE_THAT(src, !IsPackage(_A("library1")));
REQUIRE_THAT(src, !IsPackage(_A("library2")));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}
REQUIRE_THAT(src, IsPackageDependency(_A("app"), _A("lib1")));
REQUIRE_THAT(src, IsPackageDependency(_A("app"), _A("lib2")));
REQUIRE_THAT(src, IsPackageDependency(_A("app"), _A("lib3")));
REQUIRE_THAT(src, IsPackageDependency(_A("app"), _A("lib4")));
save_mermaid(config.output_directory(), diagram->name + ".mmd",
src);
}*/
}

118
tests/t30011/test_case.h
View File

@@ -16,8 +16,11 @@
* limitations under the License.
*/
TEST_CASE("t30011", "[test-case][package]")
TEST_CASE("t30011")
{
using namespace clanguml::test;
using namespace std::string_literals;
auto [config, db] = load_config("t30011");
auto diagram = config.diagrams["t30011_package"];
@@ -28,66 +31,81 @@ TEST_CASE("t30011", "[test-case][package]")
REQUIRE(model->name() == "t30011_package");
{
auto src = generate_package_puml(diagram, *model);
AliasMatcher _A(src);
CHECK_PACKAGE_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(IsDirectoryPackage(src, "app"s));
REQUIRE(IsDirectoryPackage(src, "libraries"s, "lib1"s));
REQUIRE(IsDirectoryPackage(src, "libraries"s, "lib2"s));
REQUIRE(IsDirectoryPackage(src, "libraries"s, "lib3"s));
REQUIRE(IsDirectoryPackage(src, "libraries"s, "lib4"s));
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
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));
});
/*
{
auto src = generate_package_puml(diagram, *model);
AliasMatcher _A(src);
REQUIRE_THAT(src, IsPackage("app"));
REQUIRE_THAT(src, IsPackage("libraries"));
REQUIRE_THAT(src, IsPackage("lib1"));
REQUIRE_THAT(src, IsPackage("lib2"));
REQUIRE_THAT(src, !IsPackage("library1"));
REQUIRE_THAT(src, !IsPackage("library2"));
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
REQUIRE_THAT(src, IsDependency(_A("app"), _A("lib1")));
REQUIRE_THAT(src, IsDependency(_A("app"), _A("lib2")));
REQUIRE_THAT(src, IsDependency(_A("app"), _A("lib3")));
REQUIRE_THAT(src, IsDependency(_A("app"), _A("lib4")));
REQUIRE_THAT(src, IsPackage("app"));
REQUIRE_THAT(src, IsPackage("libraries"));
REQUIRE_THAT(src, IsPackage("lib1"));
REQUIRE_THAT(src, IsPackage("lib2"));
REQUIRE_THAT(src, !IsPackage("library1"));
REQUIRE_THAT(src, !IsPackage("library2"));
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
REQUIRE_THAT(src, IsDependency(_A("app"), _A("lib1")));
REQUIRE_THAT(src, IsDependency(_A("app"), _A("lib2")));
REQUIRE_THAT(src, IsDependency(_A("app"), _A("lib3")));
REQUIRE_THAT(src, IsDependency(_A("app"), _A("lib4")));
{
auto j = generate_package_json(diagram, *model);
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
using namespace json;
using namespace std::string_literals;
{
auto j = generate_package_json(diagram, *model);
REQUIRE(IsDirectoryPackage(j, "app"s));
REQUIRE(IsDirectoryPackage(j, "libraries"s, "lib1"s));
REQUIRE(IsDirectoryPackage(j, "libraries"s, "lib2"s));
REQUIRE(IsDirectoryPackage(j, "libraries"s, "lib3"s));
REQUIRE(IsDirectoryPackage(j, "libraries"s, "lib4"s));
using namespace json;
using namespace std::string_literals;
REQUIRE(IsDependency(j, "app"s, "lib1"s));
REQUIRE(IsDependency(j, "app"s, "lib2"s));
REQUIRE(IsDependency(j, "app"s, "lib3"s));
REQUIRE(IsDependency(j, "app"s, "lib4"s));
REQUIRE(IsDirectoryPackage(j, "app"s));
REQUIRE(IsDirectoryPackage(j, "libraries"s, "lib1"s));
REQUIRE(IsDirectoryPackage(j, "libraries"s, "lib2"s));
REQUIRE(IsDirectoryPackage(j, "libraries"s, "lib3"s));
REQUIRE(IsDirectoryPackage(j, "libraries"s, "lib4"s));
save_json(config.output_directory(), diagram->name + ".json", j);
}
REQUIRE(IsDependency(j, "app"s, "lib1"s));
REQUIRE(IsDependency(j, "app"s, "lib2"s));
REQUIRE(IsDependency(j, "app"s, "lib3"s));
REQUIRE(IsDependency(j, "app"s, "lib4"s));
{
auto src = generate_package_mermaid(diagram, *model);
mermaid::AliasMatcher _A(src);
using mermaid::IsPackage;
using mermaid::IsPackageDependency;
save_json(config.output_directory(), diagram->name + ".json", j);
}
REQUIRE_THAT(src, IsPackage(_A("app")));
REQUIRE_THAT(src, IsPackage(_A("libraries")));
REQUIRE_THAT(src, IsPackage(_A("lib1")));
REQUIRE_THAT(src, IsPackage(_A("lib2")));
REQUIRE_THAT(src, !IsPackage(_A("library1")));
REQUIRE_THAT(src, !IsPackage(_A("library2")));
{
auto src = generate_package_mermaid(diagram, *model);
mermaid::AliasMatcher _A(src);
using mermaid::IsPackage;
using mermaid::IsPackageDependency;
REQUIRE_THAT(src, IsPackageDependency(_A("app"), _A("lib1")));
REQUIRE_THAT(src, IsPackageDependency(_A("app"), _A("lib2")));
REQUIRE_THAT(src, IsPackageDependency(_A("app"), _A("lib3")));
REQUIRE_THAT(src, IsPackageDependency(_A("app"), _A("lib4")));
REQUIRE_THAT(src, IsPackage(_A("app")));
REQUIRE_THAT(src, IsPackage(_A("libraries")));
REQUIRE_THAT(src, IsPackage(_A("lib1")));
REQUIRE_THAT(src, IsPackage(_A("lib2")));
REQUIRE_THAT(src, !IsPackage(_A("library1")));
REQUIRE_THAT(src, !IsPackage(_A("library2")));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}
REQUIRE_THAT(src, IsPackageDependency(_A("app"), _A("lib1")));
REQUIRE_THAT(src, IsPackageDependency(_A("app"), _A("lib2")));
REQUIRE_THAT(src, IsPackageDependency(_A("app"), _A("lib3")));
REQUIRE_THAT(src, IsPackageDependency(_A("app"), _A("lib4")));
save_mermaid(config.output_directory(), diagram->name + ".mmd",
src);
}
*/
}

15
tests/t30012/test_case.h
View File

@@ -16,8 +16,11 @@
* limitations under the License.
*/
TEST_CASE("t30012", "[test-case][package]")
TEST_CASE("t30012")
{
using namespace clanguml::test;
using namespace std::string_literals;
auto [config, db] = load_config("t30012");
auto diagram = config.diagrams["t30012_package"];
@@ -28,6 +31,14 @@ TEST_CASE("t30012", "[test-case][package]")
REQUIRE(model->name() == "t30012_package");
CHECK_PACKAGE_DIAGRAM(config, diagram, *model, [](const auto &src) {
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));
REQUIRE(IsModulePackage(src, "app"s, "lib2"s));
});
/*
{
auto src = generate_package_puml(diagram, *model);
AliasMatcher _A(src);
@@ -73,5 +84,5 @@ TEST_CASE("t30012", "[test-case][package]")
REQUIRE_THAT(src, IsPackage(_A("mod2")));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}
}*/
}

276
tests/t30013/test_case.h
View File

@@ -16,8 +16,11 @@
* limitations under the License.
*/
TEST_CASE("t30013", "[test-case][package]")
TEST_CASE("t30013")
{
using namespace clanguml::test;
using namespace std::string_literals;
auto [config, db] = load_config("t30013");
auto diagram = config.diagrams["t30013_package"];
@@ -28,130 +31,173 @@ TEST_CASE("t30013", "[test-case][package]")
REQUIRE(model->name() == "t30013_package");
{
auto src = generate_package_puml(diagram, *model);
AliasMatcher _A(src);
CHECK_PACKAGE_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(IsModulePackage(src, "app"s));
REQUIRE(IsModulePackage(src, "mod1"s));
REQUIRE(IsModulePackage(src, "mod2"s));
REQUIRE(IsModulePackage(src, "mod3"s));
REQUIRE(IsModulePackage(src, "mod4"s));
REQUIRE(IsModulePackage(src, "mod5"s));
REQUIRE(IsModulePackage(src, "mod6"s));
REQUIRE(IsModulePackage(src, "mod7"s));
REQUIRE(IsModulePackage(src, "mod8"s));
REQUIRE(IsModulePackage(src, "mod9"s));
REQUIRE(IsModulePackage(src, "mod10"s));
REQUIRE(IsModulePackage(src, "mod11"s));
REQUIRE(IsModulePackage(src, "mod12"s));
REQUIRE(IsModulePackage(src, "mod13"s));
REQUIRE(IsModulePackage(src, "mod14"s));
REQUIRE(IsModulePackage(src, "mod15"s));
REQUIRE(IsModulePackage(src, "mod16"s));
REQUIRE(IsModulePackage(src, "mod17"s));
REQUIRE(IsModulePackage(src, "mod18"s));
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
REQUIRE(IsDependency(src, "app", "mod1"));
REQUIRE(IsDependency(src, "app", "mod2"));
REQUIRE(IsDependency(src, "app", "mod3"));
REQUIRE(IsDependency(src, "app", "mod4"));
REQUIRE(IsDependency(src, "app", "mod5"));
REQUIRE(IsDependency(src, "app", "mod6"));
REQUIRE(IsDependency(src, "app", "mod7"));
REQUIRE(IsDependency(src, "app", "mod8"));
REQUIRE(IsDependency(src, "app", "mod9"));
REQUIRE(IsDependency(src, "app", "mod10"));
REQUIRE(IsDependency(src, "app", "mod11"));
REQUIRE(IsDependency(src, "app", "mod12"));
REQUIRE(IsDependency(src, "app", "mod13"));
REQUIRE(IsDependency(src, "app", "mod14"));
REQUIRE(IsDependency(src, "app", "mod15"));
REQUIRE(IsDependency(src, "app", "mod16"));
REQUIRE(IsDependency(src, "app", "mod17"));
REQUIRE(IsDependency(src, "app", "mod18"));
});
/*
{
auto src = generate_package_puml(diagram, *model);
AliasMatcher _A(src);
// Check if all packages exist
REQUIRE_THAT(src, IsPackage("app"));
REQUIRE_THAT(src, IsPackage("mod1"));
REQUIRE_THAT(src, IsPackage("mod2"));
REQUIRE_THAT(src, IsPackage("mod3"));
REQUIRE_THAT(src, IsPackage("mod4"));
REQUIRE_THAT(src, IsPackage("mod5"));
REQUIRE_THAT(src, IsPackage("mod6"));
REQUIRE_THAT(src, IsPackage("mod7"));
REQUIRE_THAT(src, IsPackage("mod8"));
REQUIRE_THAT(src, IsPackage("mod9"));
REQUIRE_THAT(src, IsPackage("mod10"));
REQUIRE_THAT(src, IsPackage("mod11"));
REQUIRE_THAT(src, IsPackage("mod12"));
REQUIRE_THAT(src, IsPackage("mod13"));
REQUIRE_THAT(src, IsPackage("mod14"));
REQUIRE_THAT(src, IsPackage("mod15"));
REQUIRE_THAT(src, IsPackage("mod16"));
REQUIRE_THAT(src, IsPackage("mod17"));
REQUIRE_THAT(src, IsPackage("mod18"));
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
REQUIRE_THAT(src, IsDependency(_A("app"), _A("mod1")));
REQUIRE_THAT(src, IsDependency(_A("app"), _A("mod2")));
REQUIRE_THAT(src, IsDependency(_A("app"), _A("mod3")));
REQUIRE_THAT(src, IsDependency(_A("app"), _A("mod4")));
REQUIRE_THAT(src, IsDependency(_A("app"), _A("mod5")));
REQUIRE_THAT(src, IsDependency(_A("app"), _A("mod6")));
REQUIRE_THAT(src, IsDependency(_A("app"), _A("mod7")));
REQUIRE_THAT(src, IsDependency(_A("app"), _A("mod8")));
REQUIRE_THAT(src, IsDependency(_A("app"), _A("mod9")));
REQUIRE_THAT(src, IsDependency(_A("app"), _A("mod10")));
REQUIRE_THAT(src, IsDependency(_A("app"), _A("mod11")));
REQUIRE_THAT(src, IsDependency(_A("app"), _A("mod12")));
REQUIRE_THAT(src, IsDependency(_A("app"), _A("mod13")));
REQUIRE_THAT(src, IsDependency(_A("app"), _A("mod14")));
REQUIRE_THAT(src, IsDependency(_A("app"), _A("mod15")));
REQUIRE_THAT(src, IsDependency(_A("app"), _A("mod16")));
REQUIRE_THAT(src, IsDependency(_A("app"), _A("mod17")));
REQUIRE_THAT(src, IsDependency(_A("app"), _A("mod18")));
// Check if all packages exist
REQUIRE_THAT(src, IsPackage("app"));
REQUIRE_THAT(src, IsPackage("mod1"));
REQUIRE_THAT(src, IsPackage("mod2"));
REQUIRE_THAT(src, IsPackage("mod3"));
REQUIRE_THAT(src, IsPackage("mod4"));
REQUIRE_THAT(src, IsPackage("mod5"));
REQUIRE_THAT(src, IsPackage("mod6"));
REQUIRE_THAT(src, IsPackage("mod7"));
REQUIRE_THAT(src, IsPackage("mod8"));
REQUIRE_THAT(src, IsPackage("mod9"));
REQUIRE_THAT(src, IsPackage("mod10"));
REQUIRE_THAT(src, IsPackage("mod11"));
REQUIRE_THAT(src, IsPackage("mod12"));
REQUIRE_THAT(src, IsPackage("mod13"));
REQUIRE_THAT(src, IsPackage("mod14"));
REQUIRE_THAT(src, IsPackage("mod15"));
REQUIRE_THAT(src, IsPackage("mod16"));
REQUIRE_THAT(src, IsPackage("mod17"));
REQUIRE_THAT(src, IsPackage("mod18"));
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
REQUIRE_THAT(src, IsDependency(_A("app"), _A("mod1")));
REQUIRE_THAT(src, IsDependency(_A("app"), _A("mod2")));
REQUIRE_THAT(src, IsDependency(_A("app"), _A("mod3")));
REQUIRE_THAT(src, IsDependency(_A("app"), _A("mod4")));
REQUIRE_THAT(src, IsDependency(_A("app"), _A("mod5")));
REQUIRE_THAT(src, IsDependency(_A("app"), _A("mod6")));
REQUIRE_THAT(src, IsDependency(_A("app"), _A("mod7")));
REQUIRE_THAT(src, IsDependency(_A("app"), _A("mod8")));
REQUIRE_THAT(src, IsDependency(_A("app"), _A("mod9")));
REQUIRE_THAT(src, IsDependency(_A("app"), _A("mod10")));
REQUIRE_THAT(src, IsDependency(_A("app"), _A("mod11")));
REQUIRE_THAT(src, IsDependency(_A("app"), _A("mod12")));
REQUIRE_THAT(src, IsDependency(_A("app"), _A("mod13")));
REQUIRE_THAT(src, IsDependency(_A("app"), _A("mod14")));
REQUIRE_THAT(src, IsDependency(_A("app"), _A("mod15")));
REQUIRE_THAT(src, IsDependency(_A("app"), _A("mod16")));
REQUIRE_THAT(src, IsDependency(_A("app"), _A("mod17")));
REQUIRE_THAT(src, IsDependency(_A("app"), _A("mod18")));
{
auto j = generate_package_json(diagram, *model);
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
using namespace json;
using namespace std::string_literals;
REQUIRE(IsModulePackage(j, "app"s));
REQUIRE(IsModulePackage(j, "mod1"s));
REQUIRE(IsModulePackage(j, "mod2"s));
REQUIRE(IsModulePackage(j, "mod3"s));
REQUIRE(IsModulePackage(j, "mod4"s));
REQUIRE(IsModulePackage(j, "mod5"s));
REQUIRE(IsModulePackage(j, "mod6"s));
REQUIRE(IsModulePackage(j, "mod7"s));
REQUIRE(IsModulePackage(j, "mod8"s));
REQUIRE(IsModulePackage(j, "mod9"s));
REQUIRE(IsModulePackage(j, "mod10"s));
REQUIRE(IsModulePackage(j, "mod11"s));
REQUIRE(IsModulePackage(j, "mod12"s));
REQUIRE(IsModulePackage(j, "mod13"s));
REQUIRE(IsModulePackage(j, "mod14"s));
REQUIRE(IsModulePackage(j, "mod15"s));
REQUIRE(IsModulePackage(j, "mod16"s));
REQUIRE(IsModulePackage(j, "mod17"s));
REQUIRE(IsModulePackage(j, "mod18"s));
{
auto j = generate_package_json(diagram, *model);
save_json(config.output_directory(), diagram->name + ".json", j);
}
using namespace json;
using namespace std::string_literals;
REQUIRE(IsModulePackage(j, "app"s));
REQUIRE(IsModulePackage(j, "mod1"s));
REQUIRE(IsModulePackage(j, "mod2"s));
REQUIRE(IsModulePackage(j, "mod3"s));
REQUIRE(IsModulePackage(j, "mod4"s));
REQUIRE(IsModulePackage(j, "mod5"s));
REQUIRE(IsModulePackage(j, "mod6"s));
REQUIRE(IsModulePackage(j, "mod7"s));
REQUIRE(IsModulePackage(j, "mod8"s));
REQUIRE(IsModulePackage(j, "mod9"s));
REQUIRE(IsModulePackage(j, "mod10"s));
REQUIRE(IsModulePackage(j, "mod11"s));
REQUIRE(IsModulePackage(j, "mod12"s));
REQUIRE(IsModulePackage(j, "mod13"s));
REQUIRE(IsModulePackage(j, "mod14"s));
REQUIRE(IsModulePackage(j, "mod15"s));
REQUIRE(IsModulePackage(j, "mod16"s));
REQUIRE(IsModulePackage(j, "mod17"s));
REQUIRE(IsModulePackage(j, "mod18"s));
{
auto src = generate_package_mermaid(diagram, *model);
save_json(config.output_directory(), diagram->name + ".json", j);
}
mermaid::AliasMatcher _A(src);
using mermaid::IsPackage;
using mermaid::IsPackageDependency;
{
auto src = generate_package_mermaid(diagram, *model);
REQUIRE_THAT(src, IsPackage(_A("app")));
REQUIRE_THAT(src, IsPackage(_A("mod1")));
REQUIRE_THAT(src, IsPackage(_A("mod2")));
REQUIRE_THAT(src, IsPackage(_A("mod3")));
REQUIRE_THAT(src, IsPackage(_A("mod4")));
REQUIRE_THAT(src, IsPackage(_A("mod5")));
REQUIRE_THAT(src, IsPackage(_A("mod6")));
REQUIRE_THAT(src, IsPackage(_A("mod7")));
REQUIRE_THAT(src, IsPackage(_A("mod8")));
REQUIRE_THAT(src, IsPackage(_A("mod9")));
REQUIRE_THAT(src, IsPackage(_A("mod10")));
REQUIRE_THAT(src, IsPackage(_A("mod11")));
REQUIRE_THAT(src, IsPackage(_A("mod12")));
REQUIRE_THAT(src, IsPackage(_A("mod13")));
REQUIRE_THAT(src, IsPackage(_A("mod14")));
REQUIRE_THAT(src, IsPackage(_A("mod15")));
REQUIRE_THAT(src, IsPackage(_A("mod16")));
REQUIRE_THAT(src, IsPackage(_A("mod17")));
REQUIRE_THAT(src, IsPackage(_A("mod18")));
mermaid::AliasMatcher _A(src);
using mermaid::IsPackage;
using mermaid::IsPackageDependency;
REQUIRE_THAT(src, IsPackageDependency(_A("app"), _A("mod1")));
REQUIRE_THAT(src, IsPackageDependency(_A("app"), _A("mod2")));
REQUIRE_THAT(src, IsPackageDependency(_A("app"), _A("mod3")));
REQUIRE_THAT(src, IsPackageDependency(_A("app"), _A("mod4")));
REQUIRE_THAT(src, IsPackageDependency(_A("app"), _A("mod5")));
REQUIRE_THAT(src, IsPackageDependency(_A("app"), _A("mod6")));
REQUIRE_THAT(src, IsPackageDependency(_A("app"), _A("mod7")));
REQUIRE_THAT(src, IsPackageDependency(_A("app"), _A("mod8")));
REQUIRE_THAT(src, IsPackageDependency(_A("app"), _A("mod9")));
REQUIRE_THAT(src, IsPackageDependency(_A("app"), _A("mod10")));
REQUIRE_THAT(src, IsPackageDependency(_A("app"), _A("mod11")));
REQUIRE_THAT(src, IsPackageDependency(_A("app"), _A("mod12")));
REQUIRE_THAT(src, IsPackageDependency(_A("app"), _A("mod13")));
REQUIRE_THAT(src, IsPackageDependency(_A("app"), _A("mod14")));
REQUIRE_THAT(src, IsPackageDependency(_A("app"), _A("mod15")));
REQUIRE_THAT(src, IsPackageDependency(_A("app"), _A("mod16")));
REQUIRE_THAT(src, IsPackageDependency(_A("app"), _A("mod17")));
REQUIRE_THAT(src, IsPackageDependency(_A("app"), _A("mod18")));
REQUIRE_THAT(src, IsPackage(_A("app")));
REQUIRE_THAT(src, IsPackage(_A("mod1")));
REQUIRE_THAT(src, IsPackage(_A("mod2")));
REQUIRE_THAT(src, IsPackage(_A("mod3")));
REQUIRE_THAT(src, IsPackage(_A("mod4")));
REQUIRE_THAT(src, IsPackage(_A("mod5")));
REQUIRE_THAT(src, IsPackage(_A("mod6")));
REQUIRE_THAT(src, IsPackage(_A("mod7")));
REQUIRE_THAT(src, IsPackage(_A("mod8")));
REQUIRE_THAT(src, IsPackage(_A("mod9")));
REQUIRE_THAT(src, IsPackage(_A("mod10")));
REQUIRE_THAT(src, IsPackage(_A("mod11")));
REQUIRE_THAT(src, IsPackage(_A("mod12")));
REQUIRE_THAT(src, IsPackage(_A("mod13")));
REQUIRE_THAT(src, IsPackage(_A("mod14")));
REQUIRE_THAT(src, IsPackage(_A("mod15")));
REQUIRE_THAT(src, IsPackage(_A("mod16")));
REQUIRE_THAT(src, IsPackage(_A("mod17")));
REQUIRE_THAT(src, IsPackage(_A("mod18")));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}
REQUIRE_THAT(src, IsPackageDependency(_A("app"), _A("mod1")));
REQUIRE_THAT(src, IsPackageDependency(_A("app"), _A("mod2")));
REQUIRE_THAT(src, IsPackageDependency(_A("app"), _A("mod3")));
REQUIRE_THAT(src, IsPackageDependency(_A("app"), _A("mod4")));
REQUIRE_THAT(src, IsPackageDependency(_A("app"), _A("mod5")));
REQUIRE_THAT(src, IsPackageDependency(_A("app"), _A("mod6")));
REQUIRE_THAT(src, IsPackageDependency(_A("app"), _A("mod7")));
REQUIRE_THAT(src, IsPackageDependency(_A("app"), _A("mod8")));
REQUIRE_THAT(src, IsPackageDependency(_A("app"), _A("mod9")));
REQUIRE_THAT(src, IsPackageDependency(_A("app"), _A("mod10")));
REQUIRE_THAT(src, IsPackageDependency(_A("app"), _A("mod11")));
REQUIRE_THAT(src, IsPackageDependency(_A("app"), _A("mod12")));
REQUIRE_THAT(src, IsPackageDependency(_A("app"), _A("mod13")));
REQUIRE_THAT(src, IsPackageDependency(_A("app"), _A("mod14")));
REQUIRE_THAT(src, IsPackageDependency(_A("app"), _A("mod15")));
REQUIRE_THAT(src, IsPackageDependency(_A("app"), _A("mod16")));
REQUIRE_THAT(src, IsPackageDependency(_A("app"), _A("mod17")));
REQUIRE_THAT(src, IsPackageDependency(_A("app"), _A("mod18")));
save_mermaid(config.output_directory(), diagram->name + ".mmd",
src);
}
*/
}

15
tests/t30014/test_case.h
View File

@@ -16,8 +16,11 @@
* limitations under the License.
*/
TEST_CASE("t30014", "[test-case][package]")
TEST_CASE("t30014")
{
using namespace clanguml::test;
using namespace std::string_literals;
auto [config, db] = load_config("t30014");
auto diagram = config.diagrams["t30014_package"];
@@ -28,6 +31,14 @@ TEST_CASE("t30014", "[test-case][package]")
REQUIRE(model->name() == "t30014_package");
CHECK_PACKAGE_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(IsModulePackage(src, "app"s));
REQUIRE(IsModulePackage(src, "app"s, ":lib1"s));
REQUIRE(IsModulePackage(src, "app"s, ":lib2"s));
REQUIRE(IsModulePackage(src, "app"s, ":lib1"s, "mod1"s));
REQUIRE(!IsModulePackage(src, "app"s, ":lib1"s, "mod2"s));
});
/*
{
auto src = generate_package_puml(diagram, *model);
AliasMatcher _A(src);
@@ -72,5 +83,5 @@ TEST_CASE("t30014", "[test-case][package]")
REQUIRE_THAT(src, IsPackage(_A("mod1")));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}
}*/
}

283
tests/t30015/test_case.h
View File

@@ -16,8 +16,11 @@
* limitations under the License.
*/
TEST_CASE("t30015", "[test-case][package]")
TEST_CASE("t30015")
{
using namespace clanguml::test;
using namespace std::string_literals;
auto [config, db] = load_config("t30015");
auto diagram = config.diagrams["t30015_package"];
@@ -28,134 +31,178 @@ TEST_CASE("t30015", "[test-case][package]")
REQUIRE(model->name() == "t30015_package");
{
auto src = generate_package_puml(diagram, *model);
AliasMatcher _A(src);
CHECK_PACKAGE_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(IsModulePackage(src, "app"s));
REQUIRE(IsModulePackage(src, "lib1"s));
REQUIRE(IsModulePackage(src, "lib1"s, ":mod1"s));
REQUIRE(IsModulePackage(src, "lib1"s, ":mod2"s));
REQUIRE(IsModulePackage(src, "lib1"s, ":mod3"s));
REQUIRE(IsModulePackage(src, "lib1"s, ":mod4"s));
REQUIRE(IsModulePackage(src, "lib1"s, ":mod5"s));
REQUIRE(IsModulePackage(src, "lib1"s, ":mod6"s));
REQUIRE(IsModulePackage(src, "lib1"s, ":mod7"s));
REQUIRE(IsModulePackage(src, "lib1"s, ":mod8"s));
REQUIRE(IsModulePackage(src, "lib1"s, ":mod9"s));
REQUIRE(IsModulePackage(src, "lib1"s, ":mod10"s));
REQUIRE(IsModulePackage(src, "lib1"s, ":mod11"s));
REQUIRE(IsModulePackage(src, "lib1"s, ":mod12"s));
REQUIRE(IsModulePackage(src, "lib1"s, ":mod13"s));
REQUIRE(IsModulePackage(src, "lib1"s, ":mod14"s));
REQUIRE(IsModulePackage(src, "lib1"s, ":mod15"s));
REQUIRE(IsModulePackage(src, "lib1"s, ":mod16"s));
REQUIRE(IsModulePackage(src, "lib1"s, ":mod17"s));
REQUIRE(IsModulePackage(src, "lib1"s, ":mod18"s));
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
REQUIRE(IsDependency(src, "app", ":mod1"));
REQUIRE(IsDependency(src, "app", ":mod2"));
REQUIRE(IsDependency(src, "app", ":mod3"));
REQUIRE(IsDependency(src, "app", ":mod4"));
REQUIRE(IsDependency(src, "app", ":mod5"));
REQUIRE(IsDependency(src, "app", ":mod6"));
REQUIRE(IsDependency(src, "app", ":mod7"));
REQUIRE(IsDependency(src, "app", ":mod8"));
REQUIRE(IsDependency(src, "app", ":mod9"));
REQUIRE(IsDependency(src, "app", ":mod10"));
REQUIRE(IsDependency(src, "app", ":mod11"));
REQUIRE(IsDependency(src, "app", ":mod12"));
REQUIRE(IsDependency(src, "app", ":mod13"));
REQUIRE(IsDependency(src, "app", ":mod14"));
REQUIRE(IsDependency(src, "app", ":mod15"));
REQUIRE(IsDependency(src, "app", ":mod16"));
REQUIRE(IsDependency(src, "app", ":mod17"));
REQUIRE(IsDependency(src, "app", ":mod18"));
});
/*
{
auto src = generate_package_puml(diagram, *model);
AliasMatcher _A(src);
// Check if all packages exist
REQUIRE_THAT(src, IsPackage("app"));
REQUIRE_THAT(src, IsPackage("lib1"));
REQUIRE_THAT(src, IsPackage(":mod1"));
REQUIRE_THAT(src, IsPackage(":mod2"));
REQUIRE_THAT(src, IsPackage(":mod3"));
REQUIRE_THAT(src, IsPackage(":mod4"));
REQUIRE_THAT(src, IsPackage(":mod5"));
REQUIRE_THAT(src, IsPackage(":mod6"));
REQUIRE_THAT(src, IsPackage(":mod7"));
REQUIRE_THAT(src, IsPackage(":mod8"));
REQUIRE_THAT(src, IsPackage(":mod9"));
REQUIRE_THAT(src, IsPackage(":mod10"));
REQUIRE_THAT(src, IsPackage(":mod11"));
REQUIRE_THAT(src, IsPackage(":mod12"));
REQUIRE_THAT(src, IsPackage(":mod13"));
REQUIRE_THAT(src, IsPackage(":mod14"));
REQUIRE_THAT(src, IsPackage(":mod15"));
REQUIRE_THAT(src, IsPackage(":mod16"));
REQUIRE_THAT(src, IsPackage(":mod17"));
REQUIRE_THAT(src, IsPackage(":mod18"));
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
REQUIRE_THAT(src, IsDependency(_A("app"), _A(":mod1")));
REQUIRE_THAT(src, IsDependency(_A("app"), _A(":mod2")));
REQUIRE_THAT(src, IsDependency(_A("app"), _A(":mod3")));
REQUIRE_THAT(src, IsDependency(_A("app"), _A(":mod4")));
REQUIRE_THAT(src, IsDependency(_A("app"), _A(":mod5")));
REQUIRE_THAT(src, IsDependency(_A("app"), _A(":mod6")));
REQUIRE_THAT(src, IsDependency(_A("app"), _A(":mod7")));
REQUIRE_THAT(src, IsDependency(_A("app"), _A(":mod8")));
REQUIRE_THAT(src, IsDependency(_A("app"), _A(":mod9")));
REQUIRE_THAT(src, IsDependency(_A("app"), _A(":mod10")));
REQUIRE_THAT(src, IsDependency(_A("app"), _A(":mod11")));
REQUIRE_THAT(src, IsDependency(_A("app"), _A(":mod12")));
REQUIRE_THAT(src, IsDependency(_A("app"), _A(":mod13")));
REQUIRE_THAT(src, IsDependency(_A("app"), _A(":mod14")));
REQUIRE_THAT(src, IsDependency(_A("app"), _A(":mod15")));
REQUIRE_THAT(src, IsDependency(_A("app"), _A(":mod16")));
REQUIRE_THAT(src, IsDependency(_A("app"), _A(":mod17")));
REQUIRE_THAT(src, IsDependency(_A("app"), _A(":mod18")));
// Check if all packages exist
REQUIRE_THAT(src, IsPackage("app"));
REQUIRE_THAT(src, IsPackage("lib1"));
REQUIRE_THAT(src, IsPackage(":mod1"));
REQUIRE_THAT(src, IsPackage(":mod2"));
REQUIRE_THAT(src, IsPackage(":mod3"));
REQUIRE_THAT(src, IsPackage(":mod4"));
REQUIRE_THAT(src, IsPackage(":mod5"));
REQUIRE_THAT(src, IsPackage(":mod6"));
REQUIRE_THAT(src, IsPackage(":mod7"));
REQUIRE_THAT(src, IsPackage(":mod8"));
REQUIRE_THAT(src, IsPackage(":mod9"));
REQUIRE_THAT(src, IsPackage(":mod10"));
REQUIRE_THAT(src, IsPackage(":mod11"));
REQUIRE_THAT(src, IsPackage(":mod12"));
REQUIRE_THAT(src, IsPackage(":mod13"));
REQUIRE_THAT(src, IsPackage(":mod14"));
REQUIRE_THAT(src, IsPackage(":mod15"));
REQUIRE_THAT(src, IsPackage(":mod16"));
REQUIRE_THAT(src, IsPackage(":mod17"));
REQUIRE_THAT(src, IsPackage(":mod18"));
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
REQUIRE_THAT(src, IsDependency(_A("app"), _A(":mod1")));
REQUIRE_THAT(src, IsDependency(_A("app"), _A(":mod2")));
REQUIRE_THAT(src, IsDependency(_A("app"), _A(":mod3")));
REQUIRE_THAT(src, IsDependency(_A("app"), _A(":mod4")));
REQUIRE_THAT(src, IsDependency(_A("app"), _A(":mod5")));
REQUIRE_THAT(src, IsDependency(_A("app"), _A(":mod6")));
REQUIRE_THAT(src, IsDependency(_A("app"), _A(":mod7")));
REQUIRE_THAT(src, IsDependency(_A("app"), _A(":mod8")));
REQUIRE_THAT(src, IsDependency(_A("app"), _A(":mod9")));
REQUIRE_THAT(src, IsDependency(_A("app"), _A(":mod10")));
REQUIRE_THAT(src, IsDependency(_A("app"), _A(":mod11")));
REQUIRE_THAT(src, IsDependency(_A("app"), _A(":mod12")));
REQUIRE_THAT(src, IsDependency(_A("app"), _A(":mod13")));
REQUIRE_THAT(src, IsDependency(_A("app"), _A(":mod14")));
REQUIRE_THAT(src, IsDependency(_A("app"), _A(":mod15")));
REQUIRE_THAT(src, IsDependency(_A("app"), _A(":mod16")));
REQUIRE_THAT(src, IsDependency(_A("app"), _A(":mod17")));
REQUIRE_THAT(src, IsDependency(_A("app"), _A(":mod18")));
{
auto j = generate_package_json(diagram, *model);
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
using namespace json;
using namespace std::string_literals;
{
auto j = generate_package_json(diagram, *model);
REQUIRE(IsModulePackage(j, "app"s));
REQUIRE(IsModulePackage(j, "lib1"s));
REQUIRE(IsModulePackage(j, "lib1"s, ":mod1"s));
REQUIRE(IsModulePackage(j, "lib1"s, ":mod2"s));
REQUIRE(IsModulePackage(j, "lib1"s, ":mod3"s));
REQUIRE(IsModulePackage(j, "lib1"s, ":mod4"s));
REQUIRE(IsModulePackage(j, "lib1"s, ":mod5"s));
REQUIRE(IsModulePackage(j, "lib1"s, ":mod6"s));
REQUIRE(IsModulePackage(j, "lib1"s, ":mod7"s));
REQUIRE(IsModulePackage(j, "lib1"s, ":mod8"s));
REQUIRE(IsModulePackage(j, "lib1"s, ":mod9"s));
REQUIRE(IsModulePackage(j, "lib1"s, ":mod10"s));
REQUIRE(IsModulePackage(j, "lib1"s, ":mod11"s));
REQUIRE(IsModulePackage(j, "lib1"s, ":mod12"s));
REQUIRE(IsModulePackage(j, "lib1"s, ":mod13"s));
REQUIRE(IsModulePackage(j, "lib1"s, ":mod14"s));
REQUIRE(IsModulePackage(j, "lib1"s, ":mod15"s));
REQUIRE(IsModulePackage(j, "lib1"s, ":mod16"s));
REQUIRE(IsModulePackage(j, "lib1"s, ":mod17"s));
REQUIRE(IsModulePackage(j, "lib1"s, ":mod18"s));
using namespace json;
using namespace std::string_literals;
save_json(config.output_directory(), diagram->name + ".json", j);
}
REQUIRE(IsModulePackage(j, "app"s));
REQUIRE(IsModulePackage(j, "lib1"s));
REQUIRE(IsModulePackage(j, "lib1"s, ":mod1"s));
REQUIRE(IsModulePackage(j, "lib1"s, ":mod2"s));
REQUIRE(IsModulePackage(j, "lib1"s, ":mod3"s));
REQUIRE(IsModulePackage(j, "lib1"s, ":mod4"s));
REQUIRE(IsModulePackage(j, "lib1"s, ":mod5"s));
REQUIRE(IsModulePackage(j, "lib1"s, ":mod6"s));
REQUIRE(IsModulePackage(j, "lib1"s, ":mod7"s));
REQUIRE(IsModulePackage(j, "lib1"s, ":mod8"s));
REQUIRE(IsModulePackage(j, "lib1"s, ":mod9"s));
REQUIRE(IsModulePackage(j, "lib1"s, ":mod10"s));
REQUIRE(IsModulePackage(j, "lib1"s, ":mod11"s));
REQUIRE(IsModulePackage(j, "lib1"s, ":mod12"s));
REQUIRE(IsModulePackage(j, "lib1"s, ":mod13"s));
REQUIRE(IsModulePackage(j, "lib1"s, ":mod14"s));
REQUIRE(IsModulePackage(j, "lib1"s, ":mod15"s));
REQUIRE(IsModulePackage(j, "lib1"s, ":mod16"s));
REQUIRE(IsModulePackage(j, "lib1"s, ":mod17"s));
REQUIRE(IsModulePackage(j, "lib1"s, ":mod18"s));
{
auto src = generate_package_mermaid(diagram, *model);
save_json(config.output_directory(), diagram->name + ".json", j);
}
mermaid::AliasMatcher _A(src);
using mermaid::IsPackage;
using mermaid::IsPackageDependency;
{
auto src = generate_package_mermaid(diagram, *model);
REQUIRE_THAT(src, IsPackage(_A("app")));
REQUIRE_THAT(src, IsPackage(_A("lib1")));
REQUIRE_THAT(src, IsPackage(_A(":mod1")));
REQUIRE_THAT(src, IsPackage(_A(":mod2")));
REQUIRE_THAT(src, IsPackage(_A(":mod3")));
REQUIRE_THAT(src, IsPackage(_A(":mod4")));
REQUIRE_THAT(src, IsPackage(_A(":mod5")));
REQUIRE_THAT(src, IsPackage(_A(":mod6")));
REQUIRE_THAT(src, IsPackage(_A(":mod7")));
REQUIRE_THAT(src, IsPackage(_A(":mod8")));
REQUIRE_THAT(src, IsPackage(_A(":mod9")));
REQUIRE_THAT(src, IsPackage(_A(":mod10")));
REQUIRE_THAT(src, IsPackage(_A(":mod11")));
REQUIRE_THAT(src, IsPackage(_A(":mod12")));
REQUIRE_THAT(src, IsPackage(_A(":mod13")));
REQUIRE_THAT(src, IsPackage(_A(":mod14")));
REQUIRE_THAT(src, IsPackage(_A(":mod15")));
REQUIRE_THAT(src, IsPackage(_A(":mod16")));
REQUIRE_THAT(src, IsPackage(_A(":mod17")));
REQUIRE_THAT(src, IsPackage(_A(":mod18")));
mermaid::AliasMatcher _A(src);
using mermaid::IsPackage;
using mermaid::IsPackageDependency;
REQUIRE_THAT(src, IsPackageDependency(_A("app"), _A(":mod1")));
REQUIRE_THAT(src, IsPackageDependency(_A("app"), _A(":mod2")));
REQUIRE_THAT(src, IsPackageDependency(_A("app"), _A(":mod3")));
REQUIRE_THAT(src, IsPackageDependency(_A("app"), _A(":mod4")));
REQUIRE_THAT(src, IsPackageDependency(_A("app"), _A(":mod5")));
REQUIRE_THAT(src, IsPackageDependency(_A("app"), _A(":mod6")));
REQUIRE_THAT(src, IsPackageDependency(_A("app"), _A(":mod7")));
REQUIRE_THAT(src, IsPackageDependency(_A("app"), _A(":mod8")));
REQUIRE_THAT(src, IsPackageDependency(_A("app"), _A(":mod9")));
REQUIRE_THAT(src, IsPackageDependency(_A("app"), _A(":mod10")));
REQUIRE_THAT(src, IsPackageDependency(_A("app"), _A(":mod11")));
REQUIRE_THAT(src, IsPackageDependency(_A("app"), _A(":mod12")));
REQUIRE_THAT(src, IsPackageDependency(_A("app"), _A(":mod13")));
REQUIRE_THAT(src, IsPackageDependency(_A("app"), _A(":mod14")));
REQUIRE_THAT(src, IsPackageDependency(_A("app"), _A(":mod15")));
REQUIRE_THAT(src, IsPackageDependency(_A("app"), _A(":mod16")));
REQUIRE_THAT(src, IsPackageDependency(_A("app"), _A(":mod17")));
REQUIRE_THAT(src, IsPackageDependency(_A("app"), _A(":mod18")));
REQUIRE_THAT(src, IsPackage(_A("app")));
REQUIRE_THAT(src, IsPackage(_A("lib1")));
REQUIRE_THAT(src, IsPackage(_A(":mod1")));
REQUIRE_THAT(src, IsPackage(_A(":mod2")));
REQUIRE_THAT(src, IsPackage(_A(":mod3")));
REQUIRE_THAT(src, IsPackage(_A(":mod4")));
REQUIRE_THAT(src, IsPackage(_A(":mod5")));
REQUIRE_THAT(src, IsPackage(_A(":mod6")));
REQUIRE_THAT(src, IsPackage(_A(":mod7")));
REQUIRE_THAT(src, IsPackage(_A(":mod8")));
REQUIRE_THAT(src, IsPackage(_A(":mod9")));
REQUIRE_THAT(src, IsPackage(_A(":mod10")));
REQUIRE_THAT(src, IsPackage(_A(":mod11")));
REQUIRE_THAT(src, IsPackage(_A(":mod12")));
REQUIRE_THAT(src, IsPackage(_A(":mod13")));
REQUIRE_THAT(src, IsPackage(_A(":mod14")));
REQUIRE_THAT(src, IsPackage(_A(":mod15")));
REQUIRE_THAT(src, IsPackage(_A(":mod16")));
REQUIRE_THAT(src, IsPackage(_A(":mod17")));
REQUIRE_THAT(src, IsPackage(_A(":mod18")));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}
REQUIRE_THAT(src, IsPackageDependency(_A("app"), _A(":mod1")));
REQUIRE_THAT(src, IsPackageDependency(_A("app"), _A(":mod2")));
REQUIRE_THAT(src, IsPackageDependency(_A("app"), _A(":mod3")));
REQUIRE_THAT(src, IsPackageDependency(_A("app"), _A(":mod4")));
REQUIRE_THAT(src, IsPackageDependency(_A("app"), _A(":mod5")));
REQUIRE_THAT(src, IsPackageDependency(_A("app"), _A(":mod6")));
REQUIRE_THAT(src, IsPackageDependency(_A("app"), _A(":mod7")));
REQUIRE_THAT(src, IsPackageDependency(_A("app"), _A(":mod8")));
REQUIRE_THAT(src, IsPackageDependency(_A("app"), _A(":mod9")));
REQUIRE_THAT(src, IsPackageDependency(_A("app"), _A(":mod10")));
REQUIRE_THAT(src, IsPackageDependency(_A("app"), _A(":mod11")));
REQUIRE_THAT(src, IsPackageDependency(_A("app"), _A(":mod12")));
REQUIRE_THAT(src, IsPackageDependency(_A("app"), _A(":mod13")));
REQUIRE_THAT(src, IsPackageDependency(_A("app"), _A(":mod14")));
REQUIRE_THAT(src, IsPackageDependency(_A("app"), _A(":mod15")));
REQUIRE_THAT(src, IsPackageDependency(_A("app"), _A(":mod16")));
REQUIRE_THAT(src, IsPackageDependency(_A("app"), _A(":mod17")));
REQUIRE_THAT(src, IsPackageDependency(_A("app"), _A(":mod18")));
save_mermaid(config.output_directory(), diagram->name + ".mmd",
src);
}
*/
}

102
tests/t40001/test_case.h
View File

@@ -1,5 +1,5 @@
/**
* tests/t40001/test_case.cc
* tests/t40001/test_case.h
*
* Copyright (c) 2021-2024 Bartek Kryza <bkryza@gmail.com>
*
@@ -16,8 +16,10 @@
* limitations under the License.
*/
TEST_CASE("t40001", "[test-case][include]")
TEST_CASE("t40001")
{
using namespace clanguml::test;
auto [config, db] = load_config("t40001");
auto diagram = config.diagrams["t40001_include"];
@@ -28,89 +30,23 @@ TEST_CASE("t40001", "[test-case][include]")
REQUIRE(model->name() == "t40001_include");
{
auto src = generate_include_puml(diagram, *model);
CHECK_INCLUDE_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(HasTitle(src, "Basic include diagram example"));
AliasMatcher _A(src);
REQUIRE(IsFolder(src, "include/lib1"));
REQUIRE(IsFile(src, "include/lib1/lib1.h"));
REQUIRE(IsFile(src, "src/t40001.cc"));
REQUIRE(IsFile(src, "include/t40001_include1.h"));
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
REQUIRE_THAT(src, HasTitle("Basic include diagram example"));
REQUIRE(IsSystemHeader(src, "string"));
REQUIRE(IsSystemHeader(src, "yaml-cpp/yaml.h"));
REQUIRE_THAT(src, IsFolder("lib1"));
REQUIRE_THAT(src, IsFile("lib1.h"));
REQUIRE_THAT(src, IsFile("t40001.cc"));
REQUIRE_THAT(src, IsFile("t40001_include1.h"));
REQUIRE(IsHeaderDependency(
src, "src/t40001.cc", "include/t40001_include1.h"));
REQUIRE(IsHeaderDependency(
src, "include/t40001_include1.h", "include/lib1/lib1.h"));
REQUIRE_THAT(src, IsFile("string"));
REQUIRE_THAT(src, IsFile("yaml-cpp/yaml.h"));
REQUIRE_THAT(
src, IsAssociation(_A("t40001.cc"), _A("t40001_include1.h")));
REQUIRE_THAT(src, IsAssociation(_A("t40001_include1.h"), _A("lib1.h")));
REQUIRE_THAT(src, IsDependency(_A("t40001_include1.h"), _A("string")));
REQUIRE_THAT(src, HasComment("t40001 test diagram of type include"));
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
{
auto j = generate_include_json(diagram, *model);
using namespace json;
REQUIRE(HasTitle(j, "Basic include diagram example"));
REQUIRE(IsFolder(j, "include"));
REQUIRE(IsFolder(j, "include/lib1"));
REQUIRE(IsFolder(j, "src"));
REQUIRE(IsHeader(j, "include/lib1/lib1.h"));
REQUIRE(IsHeader(j, "include/t40001_include1.h"));
REQUIRE(IsFile(j, "src/t40001.cc"));
REQUIRE(IsSystemHeader(j, "yaml-cpp/yaml.h"));
REQUIRE(IsFile(j, "string"));
REQUIRE(IsAssociation(j, "src/t40001.cc", "include/t40001_include1.h"));
REQUIRE(IsAssociation(
j, "include/t40001_include1.h", "include/lib1/lib1.h"));
REQUIRE(IsDependency(j, "include/t40001_include1.h", "string"));
save_json(config.output_directory(), diagram->name + ".json", j);
}
{
auto src = generate_include_mermaid(diagram, *model);
mermaid::AliasMatcher _A(src);
using mermaid::HasComment;
using mermaid::HasTitle;
using mermaid::IsFile;
using mermaid::IsFolder;
using mermaid::IsIncludeDependency;
REQUIRE_THAT(src, HasTitle("Basic include diagram example"));
REQUIRE_THAT(src, IsFolder(_A("lib1")));
REQUIRE_THAT(src, IsFile(_A("lib1.h")));
REQUIRE_THAT(src, IsFile(_A("t40001.cc")));
REQUIRE_THAT(src, IsFile(_A("t40001_include1.h")));
REQUIRE_THAT(src, IsFile(_A("string")));
REQUIRE_THAT(src, IsFile(_A("yaml-cpp/yaml.h")));
REQUIRE_THAT(
src, IsAssociation(_A("t40001.cc"), _A("t40001_include1.h")));
REQUIRE_THAT(src, IsAssociation(_A("t40001_include1.h"), _A("lib1.h")));
REQUIRE_THAT(
src, IsIncludeDependency(_A("t40001_include1.h"), _A("string")));
REQUIRE_THAT(src, HasComment("t40001 test diagram of type include"));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}
REQUIRE(IsSystemHeaderDependency(
src, "include/t40001_include1.h", "string"));
});
}

180
tests/t40002/test_case.h
View File

@@ -1,5 +1,5 @@
/**
* tests/t40002/test_case.cc
* tests/t40002/test_case.h
*
* Copyright (c) 2021-2024 Bartek Kryza <bkryza@gmail.com>
*
@@ -16,8 +16,10 @@
* limitations under the License.
*/
TEST_CASE("t40002", "[test-case][include]")
TEST_CASE("t40002")
{
using namespace clanguml::test;
auto [config, db] = load_config("t40002");
auto diagram = config.diagrams["t40002_include"];
@@ -28,141 +30,53 @@ TEST_CASE("t40002", "[test-case][include]")
REQUIRE(model->name() == "t40002_include");
{
auto src = generate_include_puml(diagram, *model);
CHECK_INCLUDE_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(IsFolder(src, "include"));
REQUIRE(IsFolder(src, "include/lib1"));
REQUIRE(IsFolder(src, "include/lib2"));
REQUIRE(IsFolder(src, "src"));
REQUIRE(IsFolder(src, "src/lib1"));
REQUIRE(IsFolder(src, "src/lib2"));
REQUIRE(IsFile(src, "include/lib1/lib1.h"));
REQUIRE(IsFile(src, "include/lib2/lib2.h"));
REQUIRE(!IsFile(src, "include/lib2/lib2_detail.h"));
REQUIRE(IsFile(src, "src/lib1/lib1.cc"));
REQUIRE(IsFile(src, "src/lib2/lib2.cc"));
REQUIRE(IsFile(src, "src/t40002.cc"));
AliasMatcher _A(src);
REQUIRE(!IsFile(src, "string"));
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
REQUIRE(
IsHeaderDependency(src, "src/t40002.cc", "include/lib1/lib1.h"));
REQUIRE(IsHeaderDependency(
src, "include/lib1/lib1.h", "include/lib2/lib2.h"));
REQUIRE(
IsHeaderDependency(src, "src/lib1/lib1.cc", "include/lib1/lib1.h"));
REQUIRE(
IsHeaderDependency(src, "src/lib2/lib2.cc", "include/lib2/lib2.h"));
REQUIRE_THAT(src, IsFolder("lib1"));
REQUIRE_THAT(src, IsFolder("lib2"));
REQUIRE_THAT(src, IsFile("lib1.h"));
REQUIRE_THAT(src, IsFile("lib2.h"));
REQUIRE_THAT(src, !IsFile("lib2_detail.h"));
REQUIRE_THAT(src, IsFile("t40002.cc"));
REQUIRE_THAT(src, IsFile("lib1.cc"));
REQUIRE_THAT(src, IsFile("lib2.cc"));
REQUIRE(HasLink(src, "t40002.cc",
fmt::format("https://github.com/bkryza/clang-uml/blob/{}/tests/"
"t40002/src/t40002.cc#L0",
clanguml::util::get_git_commit()),
"t40002.cc"));
REQUIRE_THAT(src, !IsFile("string"));
REQUIRE(HasLink(src, "lib1.cc",
fmt::format("https://github.com/bkryza/clang-uml/blob/{}/tests/"
"t40002/src/lib1/lib1.cc#L0",
clanguml::util::get_git_commit()),
"lib1.cc"));
REQUIRE_THAT(src, IsAssociation(_A("t40002.cc"), _A("lib1.h")));
REQUIRE_THAT(src, IsAssociation(_A("lib1.h"), _A("lib2.h")));
REQUIRE_THAT(src, IsAssociation(_A("lib1.cc"), _A("lib1.h")));
REQUIRE_THAT(src, IsAssociation(_A("lib2.cc"), _A("lib2.h")));
REQUIRE(HasLink(src, "lib1.h",
fmt::format("https://github.com/bkryza/clang-uml/blob/{}/tests/"
"t40002/include/lib1/lib1.h#L0",
clanguml::util::get_git_commit()),
"lib1.h"));
REQUIRE_THAT(src,
HasLink(_A("t40002.cc"),
fmt::format("https://github.com/bkryza/clang-uml/blob/{}/tests/"
"t40002/src/t40002.cc#L0",
clanguml::util::get_git_commit()),
"t40002.cc"));
REQUIRE_THAT(src,
HasLink(_A("lib1.cc"),
fmt::format("https://github.com/bkryza/clang-uml/blob/{}/tests/"
"t40002/src/lib1/lib1.cc#L0",
clanguml::util::get_git_commit()),
"lib1.cc"));
REQUIRE_THAT(src,
HasLink(_A("lib1.h"),
fmt::format("https://github.com/bkryza/clang-uml/blob/{}/tests/"
"t40002/include/lib1/lib1.h#L0",
clanguml::util::get_git_commit()),
"lib1.h"));
REQUIRE_THAT(src,
HasLink(_A("lib2.h"),
fmt::format("https://github.com/bkryza/clang-uml/blob/{}/tests/"
"t40002/include/lib2/lib2.h#L0",
clanguml::util::get_git_commit()),
"lib2.h"));
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
{
auto j = generate_include_json(diagram, *model);
using namespace json;
REQUIRE(IsFolder(j, "include"));
REQUIRE(IsFolder(j, "include/lib1"));
REQUIRE(IsFolder(j, "include/lib2"));
REQUIRE(IsFolder(j, "src"));
REQUIRE(IsFolder(j, "src/lib1"));
REQUIRE(IsFolder(j, "src/lib2"));
REQUIRE(IsFile(j, "include/lib1/lib1.h"));
REQUIRE(IsFile(j, "include/lib2/lib2.h"));
REQUIRE(!IsFile(j, "include/lib2/lib2_detail.h"));
REQUIRE(IsFile(j, "src/lib1/lib1.cc"));
REQUIRE(IsFile(j, "src/lib2/lib2.cc"));
REQUIRE(IsFile(j, "src/t40002.cc"));
REQUIRE(!IsFile(j, "string"));
REQUIRE(IsAssociation(j, "src/t40002.cc", "include/lib1/lib1.h"));
REQUIRE(IsAssociation(j, "include/lib1/lib1.h", "include/lib2/lib2.h"));
REQUIRE(IsAssociation(j, "src/lib1/lib1.cc", "include/lib1/lib1.h"));
REQUIRE(IsAssociation(j, "src/lib2/lib2.cc", "include/lib2/lib2.h"));
save_json(config.output_directory(), diagram->name + ".json", j);
}
{
auto src = generate_include_mermaid(diagram, *model);
mermaid::AliasMatcher _A(src);
using mermaid::HasLink;
using mermaid::IsFile;
using mermaid::IsFolder;
REQUIRE_THAT(src, IsFolder(_A("lib1")));
REQUIRE_THAT(src, IsFolder(_A("lib2")));
REQUIRE_THAT(src, IsFile(_A("lib1.h")));
REQUIRE_THAT(src, IsFile(_A("lib2.h")));
REQUIRE_THAT(src, !IsFile(_A("lib2_detail.h")));
REQUIRE_THAT(src, IsFile(_A("t40002.cc")));
REQUIRE_THAT(src, IsFile(_A("lib1.cc")));
REQUIRE_THAT(src, IsFile(_A("lib2.cc")));
REQUIRE_THAT(src, !IsFile(_A("string")));
REQUIRE_THAT(src, IsAssociation(_A("t40002.cc"), _A("lib1.h")));
REQUIRE_THAT(src, IsAssociation(_A("lib1.h"), _A("lib2.h")));
REQUIRE_THAT(src, IsAssociation(_A("lib1.cc"), _A("lib1.h")));
REQUIRE_THAT(src, IsAssociation(_A("lib2.cc"), _A("lib2.h")));
REQUIRE_THAT(src,
HasLink(_A("t40002.cc"),
fmt::format("https://github.com/bkryza/clang-uml/blob/{}/tests/"
"t40002/src/t40002.cc#L0",
clanguml::util::get_git_commit()),
"t40002.cc"));
REQUIRE_THAT(src,
HasLink(_A("lib1.cc"),
fmt::format("https://github.com/bkryza/clang-uml/blob/{}/tests/"
"t40002/src/lib1/lib1.cc#L0",
clanguml::util::get_git_commit()),
"lib1.cc"));
REQUIRE_THAT(src,
HasLink(_A("lib1.h"),
fmt::format("https://github.com/bkryza/clang-uml/blob/{}/tests/"
"t40002/include/lib1/lib1.h#L0",
clanguml::util::get_git_commit()),
"lib1.h"));
REQUIRE_THAT(src,
HasLink(_A("lib2.h"),
fmt::format("https://github.com/bkryza/clang-uml/blob/{}/tests/"
"t40002/include/lib2/lib2.h#L0",
clanguml::util::get_git_commit()),
"lib2.h"));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}
REQUIRE(HasLink(src, "lib2.h",
fmt::format("https://github.com/bkryza/clang-uml/blob/{}/tests/"
"t40002/include/lib2/lib2.h#L0",
clanguml::util::get_git_commit()),
"lib2.h"));
});
}

88
tests/t40003/test_case.h
View File

@@ -1,5 +1,5 @@
/**
* tests/t40003/test_case.cc
* tests/t40003/test_case.h
*
* Copyright (c) 2021-2024 Bartek Kryza <bkryza@gmail.com>
*
@@ -16,8 +16,10 @@
* limitations under the License.
*/
TEST_CASE("t40003", "[test-case][include]")
TEST_CASE("t40003")
{
using namespace clanguml::test;
auto [config, db] = load_config("t40003");
auto diagram = config.diagrams["t40003_include"];
@@ -28,72 +30,22 @@ TEST_CASE("t40003", "[test-case][include]")
REQUIRE(model->name() == "t40003_include");
{
auto src = generate_include_puml(diagram, *model);
CHECK_INCLUDE_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(IsFolder(src, "include/dependants"));
REQUIRE(IsFolder(src, "include/dependencies"));
REQUIRE(IsFolder(src, "src/dependants"));
REQUIRE(IsFolder(src, "src/dependencies"));
AliasMatcher _A(src);
REQUIRE(IsFile(src, "include/dependants/t1.h"));
REQUIRE(IsFile(src, "include/dependants/t2.h"));
REQUIRE(IsFile(src, "include/dependants/t3.h"));
REQUIRE(!IsFile(src, "include/dependants/t4.h"));
REQUIRE(IsFile(src, "src/dependants/t1.cc"));
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
REQUIRE_THAT(src, IsFolder("dependants"));
REQUIRE_THAT(src, IsFolder("dependencies"));
REQUIRE_THAT(src, IsFile("t1.h"));
REQUIRE_THAT(src, IsFile("t2.h"));
REQUIRE_THAT(src, IsFile("t3.h"));
REQUIRE_THAT(src, !IsFile("t4.h"));
REQUIRE_THAT(src, IsFile("t5.h"));
REQUIRE_THAT(src, !IsFile("t6.h"));
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
{
auto j = generate_include_json(diagram, *model);
using namespace json;
REQUIRE(IsFolder(j, "include/dependants"));
REQUIRE(IsFolder(j, "include/dependencies"));
REQUIRE(IsFolder(j, "src/dependants"));
REQUIRE(IsFolder(j, "src/dependencies"));
REQUIRE(IsFile(j, "include/dependants/t1.h"));
REQUIRE(IsFile(j, "include/dependants/t2.h"));
REQUIRE(IsFile(j, "include/dependants/t3.h"));
REQUIRE(!IsFile(j, "include/dependants/t4.h"));
REQUIRE(IsFile(j, "src/dependants/t1.cc"));
REQUIRE(IsFile(j, "include/dependencies/t1.h"));
REQUIRE(IsFile(j, "include/dependencies/t2.h"));
REQUIRE(IsFile(j, "include/dependencies/t3.h"));
REQUIRE(!IsFile(j, "include/dependencies/t4.h"));
REQUIRE(IsFile(j, "src/dependencies/t2.cc"));
save_json(config.output_directory(), diagram->name + ".json", j);
}
{
auto src = generate_include_mermaid(diagram, *model);
mermaid::AliasMatcher _A(src);
using mermaid::HasLink;
using mermaid::IsFile;
using mermaid::IsFolder;
REQUIRE_THAT(src, IsFolder(_A("dependants")));
REQUIRE_THAT(src, IsFolder(_A("dependencies")));
REQUIRE_THAT(src, IsFile(_A("t1.h")));
REQUIRE_THAT(src, IsFile(_A("t2.h")));
REQUIRE_THAT(src, IsFile(_A("t3.h")));
REQUIRE_THAT(src, !IsFile(_A("t4.h")));
REQUIRE_THAT(src, IsFile(_A("t5.h")));
REQUIRE_THAT(src, !IsFile(_A("t6.h")));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}
REQUIRE(IsFile(src, "include/dependencies/t1.h"));
REQUIRE(IsFile(src, "include/dependencies/t2.h"));
REQUIRE(IsFile(src, "include/dependencies/t3.h"));
REQUIRE(!IsFile(src, "include/dependencies/t4.h"));
REQUIRE(IsFile(src, "src/dependencies/t2.cc"));
});
}

735
tests/test_cases.cc
View File

File diff suppressed because it is too large Load Diff

1819
tests/test_cases.h
View File

File diff suppressed because it is too large Load Diff

6
tests/test_thread_pool_executor.cc
View File

@@ -15,13 +15,13 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#define CATCH_CONFIG_MAIN
#define DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN
#include "catch.h"
#include "doctest/doctest.h"
#include "util/thread_pool_executor.h"
TEST_CASE("Test thread_pool_executor", "[unit-test]")
TEST_CASE("Test thread_pool_executor")
{
using clanguml::util::thread_pool_executor;

33
tests/test_util.cc
View File

@@ -15,16 +15,17 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#define CATCH_CONFIG_MAIN
#define DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN
#include "util/util.h"
#include <common/clang_utils.h>
#include <filesystem>
#include "catch.h"
#include "doctest/doctest.h"
TEST_CASE("Test split", "[unit-test]")
TEST_CASE("Test split")
{
using C = std::vector<std::string>;
using namespace clanguml::util;
@@ -45,7 +46,7 @@ TEST_CASE("Test split", "[unit-test]")
CHECK(split("std::vector::detail::", "::") == C{"std", "vector", "detail"});
}
TEST_CASE("Test abbreviate", "[unit-test]")
TEST_CASE("Test abbreviate")
{
using namespace clanguml::util;
@@ -55,7 +56,7 @@ TEST_CASE("Test abbreviate", "[unit-test]")
CHECK(abbreviate("abcdefg", 5) == "ab...");
}
TEST_CASE("Test starts_with", "[unit-test]")
TEST_CASE("Test starts_with")
{
using clanguml::util::starts_with;
using std::filesystem::path;
@@ -73,7 +74,7 @@ TEST_CASE("Test starts_with", "[unit-test]")
CHECK_FALSE(starts_with(path{"c/file1.h"}, path{"c/file2.h"}));
}
TEST_CASE("Test replace_all", "[unit-test]")
TEST_CASE("Test replace_all")
{
using namespace clanguml::util;
@@ -95,7 +96,7 @@ TEST_CASE("Test replace_all", "[unit-test]")
CHECK(text == orig);
}
TEST_CASE("Test extract_template_parameter_index", "[unit-test]")
TEST_CASE("Test extract_template_parameter_index")
{
using namespace clanguml::common;
@@ -124,7 +125,7 @@ TEST_CASE("Test extract_template_parameter_index", "[unit-test]")
}
}
TEST_CASE("Test parse_unexposed_template_params", "[unit-test]")
TEST_CASE("Test parse_unexposed_template_params")
{
using namespace clanguml::common;
@@ -200,7 +201,7 @@ TEST_CASE("Test parse_unexposed_template_params", "[unit-test]")
CHECK(declaration_template[2].type().value() == "Tail");
}
TEST_CASE("Test remove_prefix", "[unit-test]")
TEST_CASE("Test remove_prefix")
{
using namespace clanguml::util;
@@ -224,7 +225,7 @@ TEST_CASE("Test remove_prefix", "[unit-test]")
CHECK(collection.empty());
}
TEST_CASE("Test path_to_url", "[unit-test]")
TEST_CASE("Test path_to_url")
{
namespace fs = std::filesystem;
using namespace clanguml::util;
@@ -258,7 +259,7 @@ TEST_CASE("Test path_to_url", "[unit-test]")
#endif
}
TEST_CASE("Test ensure_path_is_absolute", "[unit-test]")
TEST_CASE("Test ensure_path_is_absolute")
{
using namespace clanguml::util;
@@ -278,7 +279,7 @@ TEST_CASE("Test ensure_path_is_absolute", "[unit-test]")
path{"/"}.make_preferred());
}
TEST_CASE("Test hash_seed", "[unit-test]")
TEST_CASE("Test hash_seed")
{
using namespace clanguml::util;
@@ -287,7 +288,7 @@ TEST_CASE("Test hash_seed", "[unit-test]")
CHECK(hash_seed(1) != hash_seed(2));
}
TEST_CASE("Test tokenize_unexposed_template_parameter", "[unit-test]")
TEST_CASE("Test tokenize_unexposed_template_parameter")
{
using namespace clanguml::common;
@@ -398,7 +399,7 @@ TEST_CASE("Test tokenize_unexposed_template_parameter", "[unit-test]")
}
}
TEST_CASE("Test format_message_comment", "[unit-test]")
TEST_CASE("Test format_message_comment")
{
using namespace clanguml::util;
@@ -419,7 +420,7 @@ TEST_CASE("Test format_message_comment", "[unit-test]")
15) == "This is a url:\nhttp://example.com/test/12345");
}
TEST_CASE("Test is_relative_to", "[unit-test]")
TEST_CASE("Test is_relative_to")
{
using std::filesystem::path;
using namespace clanguml::util;
@@ -432,7 +433,7 @@ TEST_CASE("Test is_relative_to", "[unit-test]")
CHECK_FALSE(is_relative_to(child, base2));
}
TEST_CASE("Test parse_source_location", "[unit-test]")
TEST_CASE("Test parse_source_location")
{
using namespace clanguml::common;