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

Refactored class, package and include diagram test cases (#266)

Browse Source
This commit is contained in:
Bartek Kryza
2024-05-14 11:39:07 +02:00
parent eeae5caef5
commit 27eaea5bbe
105 changed files with 660 additions and 4427 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -247,18 +247,33 @@ void generator::generate(const package &p, nlohmann::json &parent) const
void generator::generate(const class_ &c, nlohmann::json &parent) const
{
nlohmann::json object = c;
if (!config().generate_fully_qualified_name())
object["display_name"] =
common::generators::json::render_name(c.full_name_no_ns());
parent["elements"].push_back(std::move(object));
}
void generator::generate(const enum_ &e, nlohmann::json &parent) const
{
nlohmann::json object = e;
if (!config().generate_fully_qualified_name())
object["display_name"] =
common::generators::json::render_name(e.full_name_no_ns());
parent["elements"].push_back(std::move(object));
}
void generator::generate(const concept_ &c, nlohmann::json &parent) const
{
nlohmann::json object = c;
if (!config().generate_fully_qualified_name())
object["display_name"] =
common::generators::json::render_name(c.full_name_no_ns());
parent["elements"].push_back(std::move(object));
}

6
src/class_diagram/generators/mermaid/class_diagram_generator.cc
View File

@@ -281,7 +281,8 @@ void generator::generate_member(
void generator::generate(const concept_ &c, std::ostream &ostr) const
{
ostr << indent(1) << "class" << " " << c.alias();
ostr << indent(1) << "class"
<< " " << c.alias();
ostr << " {" << '\n';
ostr << indent(2) << "<<concept>>\n";
@@ -299,7 +300,8 @@ void generator::generate(const concept_ &c, std::ostream &ostr) const
<< fmt::format("\"({})\"\n", fmt::join(parameters, ","));
for (const auto &req : c.requires_statements()) {
ostr << indent(2) << fmt::format("\"{}\"\n", render_name(req));
ostr << indent(2)
<< fmt::format("\"{}\"\n", render_name(req, false));
}
}

6
src/class_diagram/generators/plantuml/class_diagram_generator.cc
View File

@@ -67,7 +67,7 @@ void generator::generate_alias(const class_ &c, std::ostream &ostr) const
class_type = "abstract";
std::string full_name;
if (config().generate_fully_qualified_name())
if (!config().generate_fully_qualified_name())
full_name = c.full_name_no_ns();
else
full_name = c.full_name();
@@ -89,7 +89,7 @@ void generator::generate_alias(const enum_ &e, std::ostream &ostr) const
{
print_debug(e, ostr);
if (config().generate_fully_qualified_name())
if (!config().generate_fully_qualified_name())
ostr << "enum"
<< " \"" << e.name();
else
@@ -106,7 +106,7 @@ void generator::generate_alias(const concept_ &c, std::ostream &ostr) const
{
print_debug(c, ostr);
if (config().generate_fully_qualified_name())
if (!config().generate_fully_qualified_name())
ostr << "class"
<< " \"" << c.full_name_no_ns();
else

29
src/common/generators/json/generator.cc
View File

@@ -18,18 +18,10 @@
#include "generator.h"
namespace clanguml::common::model {
namespace clanguml::common {
namespace model {
using nlohmann::json;
namespace detail {
std::string render_name(std::string name)
{
util::replace_all(name, "##", "::");
return name;
}
} // namespace detail
void to_json(nlohmann::json &j, const source_location &sl)
{
j = json{{"file", sl.file_relative()},
@@ -40,9 +32,10 @@ void to_json(nlohmann::json &j, const source_location &sl)
void to_json(nlohmann::json &j, const element &c)
{
j = json{{"id", std::to_string(c.id())},
{"name", detail::render_name(c.name())},
{"name", common::generators::json::render_name(c.name())},
{"namespace", c.get_namespace().to_string()}, {"type", c.type_name()},
{"display_name", detail::render_name(c.full_name(true))}};
{"display_name",
common::generators::json::render_name(c.full_name(true))}};
if (const auto &comment = c.comment(); comment)
j["comment"] = comment.value();
@@ -81,4 +74,16 @@ void to_json(nlohmann::json &j, const relationship &c)
if (const auto &comment = c.comment(); comment)
j["comment"] = comment.value();
}
} // namespace model
namespace generators::json {
std::string render_name(std::string name)
{
util::replace_all(name, "##", "::");
return name;
}
} // namespace generators::json
} // namespace clanguml::common::model

2
src/common/generators/json/generator.h
View File

@@ -51,6 +51,8 @@ using clanguml::common::model::element;
using clanguml::common::model::message_t;
using clanguml::common::model::relationship_t;
std::string render_name(std::string name);
/**
* @brief Base class for diagram generators
*

4
src/common/generators/mermaid/generator.cc
View File

@@ -78,12 +78,14 @@ std::string indent(const unsigned level)
return std::string(level * kIndentWidth, ' '); // NOLINT
}
std::string render_name(std::string name)
std::string render_name(std::string name, bool round_brackets)
{
util::replace_all(name, "<", "&lt;");
util::replace_all(name, ">", "&gt;");
if (round_brackets) {
util::replace_all(name, "(", "&lpar;");
util::replace_all(name, ")", "&rpar;");
}
util::replace_all(name, "##", "::");
util::replace_all(name, "{", "&lbrace;");
util::replace_all(name, "}", "&rbrace;");

2
src/common/generators/mermaid/generator.h
View File

@@ -44,7 +44,7 @@ std::string to_mermaid(message_t r);
std::string indent(unsigned level);
std::string render_name(std::string name);
std::string render_name(std::string name, bool round_brackets = true);
/**
* @brief Base class for diagram generators

4
src/config/config.cc
View File

@@ -268,8 +268,8 @@ std::string inheritable_diagram_options::simplify_template_type(
bool inheritable_diagram_options::generate_fully_qualified_name() const
{
return generate_packages() &&
(package_type() == package_type_t::kNamespace);
return (package_type() == package_type_t::kNamespace) &&
!generate_packages();
}
std::vector<std::string> diagram::get_translation_units() const

2
src/package_diagram/generators/mermaid/package_diagram_generator.cc
View File

@@ -89,7 +89,7 @@ void generator::generate(const package &p, std::ostream &ostr) const
<< "]\n";
if (p.is_deprecated())
ostr << indent(1) << "%% <<deprecated>>";
ostr << indent(1) << "%% <<deprecated>>\n";
}
for (const auto &subpackage : p) {

12
tests/t00002/test_case.h
View File

@@ -21,20 +21,12 @@ TEST_CASE("t00002")
using namespace clanguml::test;
using namespace std::string_literals;
auto [config, db] = load_config("t00002");
auto diagram = config.diagrams["t00002_class"];
REQUIRE(diagram->name == "t00002_class");
auto [config, db, diagram, model] =
CHECK_CLASS_MODEL("t00002", "t00002_class");
REQUIRE(diagram->include().namespaces.size() == 1);
REQUIRE(diagram->exclude().namespaces.size() == 0);
auto model = generate_class_diagram(*db, diagram);
REQUIRE(model->name() == "t00002_class");
REQUIRE(model->should_include({"clanguml", "t00002"}, "A"));
REQUIRE(!model->should_include({"std"}, "vector"));

23
tests/t00003/test_case.h
View File

@@ -16,45 +16,32 @@
* limitations under the License.
*/
// #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"];
REQUIRE(diagram->name == "t00003_class");
auto [config, db, diagram, model] =
CHECK_CLASS_MODEL("t00003", "t00003_class");
REQUIRE(diagram->include().namespaces.size() == 1);
REQUIRE(diagram->exclude().namespaces.size() == 0);
auto model = generate_class_diagram(*db, diagram);
REQUIRE(model->name() == "t00003_class");
CHECK_CLASS_DIAGRAM(config, diagram, *model,
[](const auto &src) {
CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(IsClass(src, "A"));
REQUIRE(!IsDependency(src, "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(IsMethod<Public, Deleted>(src, "A", "A", "void", "const A &"));
REQUIRE(IsMethod<Public, Default>(src, "A", "~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_int", "int", "int i = 12"));
REQUIRE(IsMethod<Public>(src, "A", "default_string", "std::string",
"int i, std::string s = \"abc\""));

20
tests/t00004/test_case.h
View File

@@ -20,21 +20,13 @@ TEST_CASE("t00004")
{
using namespace clanguml::test;
auto [config, db] = load_config("t00004");
auto diagram = config.diagrams["t00004_class"];
REQUIRE(diagram->name == "t00004_class");
auto [config, db, diagram, model] =
CHECK_CLASS_MODEL("t00004", "t00004_class");
REQUIRE(diagram->include().namespaces.size() == 1);
REQUIRE(diagram->exclude().namespaces.size() == 0);
auto model = generate_class_diagram(*db, diagram);
REQUIRE(model->name() == "t00004_class");
CHECK_CLASS_DIAGRAM(config, diagram, *model,
[](const auto &src) {
CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(IsClass(src, "A"));
REQUIRE(IsClass(src, "A::AA"));
REQUIRE(IsClass(src, "A::AA::AAA"));
@@ -58,8 +50,8 @@ TEST_CASE("t00004")
REQUIRE(!IsInnerClass(src, "C<T>", "C::B"));
REQUIRE(IsInstantiation(src, "C::B<V>", "C::B<int>"));
REQUIRE(IsClass(src, "detail::D"));
REQUIRE(IsClass(src, "detail::D::DD"));
REQUIRE(IsEnum(src, "detail::D::AA"));
REQUIRE(IsClass(src, {"detail", "D"}));
REQUIRE(IsClass(src, {"detail", "D::DD"}));
REQUIRE(IsEnum(src, {"detail", "D::AA"}));
});
}

18
tests/t00005/test_case.h
View File

@@ -20,18 +20,10 @@ TEST_CASE("t00005")
{
using namespace clanguml::test;
auto [config, db] = load_config("t00005");
auto [config, db, diagram, model] =
CHECK_CLASS_MODEL("t00005", "t00005_class");
auto diagram = config.diagrams["t00005_class"];
REQUIRE(diagram->name == "t00005_class");
auto model = generate_class_diagram(*db, diagram);
REQUIRE(model->name() == "t00005_class");
CHECK_CLASS_DIAGRAM(config, diagram, *model,
[](const auto &src) {
CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(IsClass(src, "A"));
REQUIRE(IsClass(src, "B"));
REQUIRE(IsClass(src, "C"));
@@ -47,8 +39,8 @@ TEST_CASE("t00005")
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(
(IsField<Public>(src, "R", "some_int_pointer_pointer", "int **")));
REQUIRE(IsAggregation<Public>(src, "R", "A", "a"));
REQUIRE(IsAssociation<Public>(src, "R", "B", "b"));

21
tests/t00006/test_case.h
View File

@@ -20,18 +20,10 @@ TEST_CASE("t00006")
{
using namespace clanguml::test;
auto [config, db] = load_config("t00006");
auto [config, db, diagram, model] =
CHECK_CLASS_MODEL("t00006", "t00006_class");
auto diagram = config.diagrams["t00006_class"];
REQUIRE(diagram->name == "t00006_class");
auto model = generate_class_diagram(*db, diagram);
REQUIRE(model->name() == "t00006_class");
CHECK_CLASS_DIAGRAM(config, diagram, *model,
[](const auto &src) {
CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(IsClass(src, "A"));
REQUIRE(IsClass(src, "B"));
REQUIRE(IsClass(src, "C"));
@@ -49,15 +41,14 @@ TEST_CASE("t00006")
REQUIRE(IsClass(src, "NN"));
REQUIRE(IsClass(src, "NNN"));
REQUIRE(IsInstantiation(
src, "custom_container<T>", "custom_container<E>"));
REQUIRE(
IsInstantiation(src, "custom_container<T>", "custom_container<E>"));
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", "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"));

11
tests/t00007/test_case.h
View File

@@ -20,15 +20,8 @@ TEST_CASE("t00007")
{
using namespace clanguml::test;
auto [config, db] = load_config("t00007");
auto diagram = config.diagrams["t00007_class"];
REQUIRE(diagram->name == "t00007_class");
auto model = generate_class_diagram(*db, diagram);
REQUIRE(model->name() == "t00007_class");
auto [config, db, diagram, model] =
CHECK_CLASS_MODEL("t00007", "t00007_class");
CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(IsClass(src, "A"));

11
tests/t00008/test_case.h
View File

@@ -20,15 +20,8 @@ TEST_CASE("t00008")
{
using namespace clanguml::test;
auto [config, db] = load_config("t00008");
auto diagram = config.diagrams["t00008_class"];
REQUIRE(diagram->name == "t00008_class");
auto model = generate_class_diagram(*db, diagram);
REQUIRE(model->name() == "t00008_class");
auto [config, db, diagram, model] =
CHECK_CLASS_MODEL("t00008", "t00008_class");
CHECK_CLASS_DIAGRAM(
config, diagram, *model,

11
tests/t00009/test_case.h
View File

@@ -20,15 +20,8 @@ TEST_CASE("t00009")
{
using namespace clanguml::test;
auto [config, db] = load_config("t00009");
auto diagram = config.diagrams["t00009_class"];
REQUIRE(diagram->name == "t00009_class");
auto model = generate_class_diagram(*db, diagram);
REQUIRE(model->name() == "t00009_class");
auto [config, db, diagram, model] =
CHECK_CLASS_MODEL("t00009", "t00009_class");
CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(IsClassTemplate(src, "A<T>"));

11
tests/t00010/test_case.h
View File

@@ -20,15 +20,8 @@ TEST_CASE("t00010")
{
using namespace clanguml::test;
auto [config, db] = load_config("t00010");
auto diagram = config.diagrams["t00010_class"];
REQUIRE(diagram->name == "t00010_class");
auto model = generate_class_diagram(*db, diagram);
REQUIRE(model->name() == "t00010_class");
auto [config, db, diagram, model] =
CHECK_CLASS_MODEL("t00010", "t00010_class");
CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(IsClassTemplate(src, "A<T,P>"));

11
tests/t00011/test_case.h
View File

@@ -20,15 +20,8 @@ TEST_CASE("t00011")
{
using namespace clanguml::test;
auto [config, db] = load_config("t00011");
auto diagram = config.diagrams["t00011_class"];
REQUIRE(diagram->name == "t00011_class");
auto model = generate_class_diagram(*db, diagram);
REQUIRE(model->name() == "t00011_class");
auto [config, db, diagram, model] =
CHECK_CLASS_MODEL("t00011", "t00011_class");
CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(IsClass(src, "A"));

11
tests/t00012/test_case.h
View File

@@ -20,15 +20,8 @@ TEST_CASE("t00012")
{
using namespace clanguml::test;
auto [config, db] = load_config("t00012");
auto diagram = config.diagrams["t00012_class"];
REQUIRE(diagram->name == "t00012_class");
auto model = generate_class_diagram(*db, diagram);
REQUIRE(model->name() == "t00012_class");
auto [config, db, diagram, model] =
CHECK_CLASS_MODEL("t00012", "t00012_class");
CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(IsClassTemplate(src, "A<T,Ts...>"));

11
tests/t00013/test_case.h
View File

@@ -20,15 +20,8 @@ TEST_CASE("t00013")
{
using namespace clanguml::test;
auto [config, db] = load_config("t00013");
auto diagram = config.diagrams["t00013_class"];
REQUIRE(diagram->name == "t00013_class");
auto model = generate_class_diagram(*db, diagram);
REQUIRE(model->name() == "t00013_class");
auto [config, db, diagram, model] =
CHECK_CLASS_MODEL("t00013", "t00013_class");
CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(IsClass(src, "A"));

256
tests/t00014/test_case.h
View File

@@ -20,15 +20,8 @@ TEST_CASE("t00014")
{
using namespace clanguml::test;
auto [config, db] = load_config("t00014");
auto diagram = config.diagrams["t00014_class"];
REQUIRE(diagram->name == "t00014_class");
auto model = generate_class_diagram(*db, diagram);
REQUIRE(model->name() == "t00014_class");
auto [config, db, diagram, model] =
CHECK_CLASS_MODEL("t00014", "t00014_class");
CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(!src.contains("type-parameter-"));
@@ -126,249 +119,4 @@ TEST_CASE("t00014")
REQUIRE(IsDependency(src, "R<T>", "A<char,std::string>"));
REQUIRE(IsDependency(src, "R<T>", "A<wchar_t,std::string>"));
});
/*
{
auto src = generate_class_puml(diagram, *model);
AliasMatcher _A(src);
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
REQUIRE_THAT(src, !Contains("type-parameter-"));
REQUIRE_THAT(src, IsClassTemplate("A", "T,P"));
REQUIRE_THAT(src, IsClassTemplate("A", "T,std::string"));
REQUIRE_THAT(
src, IsClassTemplate("A", "T,std::unique_ptr<std::string>"));
REQUIRE_THAT(src, IsClassTemplate("A", "double,T"));
// TODO: Figure out how to handle the same templates with different
// template
// parameter names
// REQUIRE_THAT(puml, !IsClassTemplate("A", "long,U"));
REQUIRE_THAT(src, IsClassTemplate("A", "long,T"));
REQUIRE_THAT(src, IsClassTemplate("A", "long,bool"));
REQUIRE_THAT(src, IsClassTemplate("A", "double,bool"));
REQUIRE_THAT(src, IsClassTemplate("A", "long,float"));
REQUIRE_THAT(src, IsClassTemplate("A", "double,float"));
REQUIRE_THAT(src, IsClassTemplate("A", "bool,std::string"));
REQUIRE_THAT(src, IsClassTemplate("A", "std::string,std::string"));
REQUIRE_THAT(src, IsClassTemplate("A", "char,std::string"));
REQUIRE_THAT(src, IsClass(_A("B")));
REQUIRE_THAT(src, IsClassTemplate("R", "T"));
REQUIRE_THAT(src, IsField<Private>("bapair", "PairPairBA<bool>"));
REQUIRE_THAT(src, IsField<Private>("abool", "APtr<bool>"));
REQUIRE_THAT(src, IsField<Private>("aboolfloat",
"AAPtr<bool,float>")); REQUIRE_THAT(src, IsField<Private>("afloat",
"ASharedPtr<float>")); REQUIRE_THAT( src, IsField<Private>("boolstring",
"A<bool,std::string>")); REQUIRE_THAT(src, IsField<Private>("floatstring",
"AStringPtr<float>")); REQUIRE_THAT(src, IsField<Private>("atfloat",
"AAPtr<T,float>"));
REQUIRE_THAT(src, IsField<Private>("intstring", "AIntString"));
REQUIRE_THAT(src, IsField<Private>("stringstring",
"AStringString")); REQUIRE_THAT(src, IsField<Private>("bstringstring",
"BStringString"));
REQUIRE_THAT(src, IsField<Protected>("bs", "BVector"));
REQUIRE_THAT(src, IsField<Public>("cb",
"SimpleCallback<ACharString>")); #if LLVM_VERSION_MAJOR >= 16 REQUIRE_THAT(
src, IsField<Public>("gcb", "GenericCallback<AWCharString>"));
#else
REQUIRE_THAT(
src, IsField<Public>("gcb",
"GenericCallback<R::AWCharString>")); #endif REQUIRE_THAT(src,
IsField<Public>("vcb", "VoidCallback"));
REQUIRE_THAT(
src, !IsClassTemplate("std::std::function",
"void(T...,int),int)"));
REQUIRE_THAT(
src, IsInstantiation(_A("A<T,P>"), _A("A<T,std::string>")));
REQUIRE_THAT(
src, IsInstantiation(_A("A<long,T>"), _A("A<long,float>")));
REQUIRE_THAT(src, IsInstantiation(_A("A<long,T>"),
_A("A<long,bool>")));
REQUIRE_THAT(src, IsInstantiation(_A("A<T,P>"), _A("A<long,T>")));
// REQUIRE_THAT(puml, !IsInstantiation(_A("A<long,T>"),
// _A("A<long,U>")));
REQUIRE_THAT(
src, IsInstantiation(_A("A<double,T>"), _A("A<double,float>")));
REQUIRE_THAT(
src, IsInstantiation(_A("A<double,T>"), _A("A<double,bool>")));
REQUIRE_THAT(src, IsInstantiation(_A("A<T,P>"), _A("A<double,T>")));
REQUIRE_THAT(
src, IsInstantiation(_A("A<T,P>"), _A("A<T,std::string>")));
REQUIRE_THAT(src,
IsInstantiation(_A("A<T,std::string>"),
_A("A<bool,std::string>"))); REQUIRE_THAT(src,
IsInstantiation(_A("A<T,std::string>"),
_A("A<char,std::string>"))); REQUIRE_THAT(src, IsInstantiation(
_A("A<T,std::string>"), _A("A<wchar_t,std::string>")));
REQUIRE_THAT(src,
IsInstantiation(_A("A<T,std::unique_ptr<std::string>>"),
_A("A<float,std::unique_ptr<std::string>>")));
REQUIRE_THAT(src,
IsInstantiation(
_A("A<T,P>"), _A("A<T,std::unique_ptr<std::string>>")));
REQUIRE_THAT(src, IsAggregation(_A("R<T>"), _A("B"), "+vps"));
REQUIRE_THAT(src, IsAggregation(_A("R<T>"), _A("B"), "-bapair"));
REQUIRE_THAT(
src, IsAggregation(_A("R<T>"), _A("A<long,float>"),
"-aboolfloat")); REQUIRE_THAT( src, IsAggregation(_A("R<T>"),
_A("A<long,bool>"), "-bapair")); REQUIRE_THAT(src, IsAggregation(_A("R<T>"),
_A("A<double,bool>"), "-aboolfloat")); REQUIRE_THAT( src,
IsAggregation(_A("R<T>"), _A("A<double,T>"), "-atfloat")); REQUIRE_THAT(
src, IsAggregation(_A("R<T>"), _A("A<long,float>"),
"-atfloat")); REQUIRE_THAT( src, IsAssociation(_A("R<T>"),
_A("A<double,float>"), "-afloat")); REQUIRE_THAT(src, IsAggregation(
_A("R<T>"), _A("A<bool,std::string>"), "-boolstring"));
REQUIRE_THAT(src,
IsAggregation(_A("R<T>"),
_A("A<float,std::unique_ptr<std::string>>"),
"-floatstring")); REQUIRE_THAT(src, IsDependency(_A("R<T>"),
_A("A<char,std::string>"))); REQUIRE_THAT( src, IsDependency(_A("R<T>"),
_A("A<wchar_t,std::string>")));
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
{
auto j = generate_class_json(diagram, *model);
using namespace json;
REQUIRE(json::IsClass(j, "A<T,P>"));
REQUIRE(json::IsClass(j, "A<T,std::string>"));
REQUIRE(json::IsClass(j, "A<T,std::unique_ptr<std::string>>"));
REQUIRE(json::IsClass(j, "A<double,T>"));
REQUIRE(json::IsClass(j, "A<long,T>"));
REQUIRE(json::IsClass(j, "A<long,bool>"));
REQUIRE(json::IsClass(j, "A<double,bool>"));
REQUIRE(json::IsClass(j, "A<long,float>"));
REQUIRE(json::IsClass(j, "A<double,bool>"));
REQUIRE(json::IsClass(j, "A<double,float>"));
REQUIRE(json::IsClass(j, "A<bool,std::string>"));
REQUIRE(json::IsClass(j, "A<std::string,std::string>"));
REQUIRE(json::IsClass(j, "A<char,std::string>"));
REQUIRE(json::IsClass(j, "B"));
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, !Contains("type-parameter-"));
REQUIRE_THAT(src, IsClass(_A("A<T,P>")));
REQUIRE_THAT(src, IsClass(_A("A<T,std::string>")));
REQUIRE_THAT(src, IsClass(_A("A<T,std::unique_ptr<std::string>>")));
REQUIRE_THAT(src, IsClass(_A("A<double,T>")));
// TODO: Figure out how to handle the same templates with different
// template
// parameter names
// REQUIRE_THAT(puml, !IsClass("A", "long,U"));
REQUIRE_THAT(src, IsClass(_A("A<long,T>")));
REQUIRE_THAT(src, IsClass(_A("A<long,bool>")));
REQUIRE_THAT(src, IsClass(_A("A<double,bool>")));
REQUIRE_THAT(src, IsClass(_A("A<long,float>")));
REQUIRE_THAT(src, IsClass(_A("A<double,float>")));
REQUIRE_THAT(src, IsClass(_A("A<bool,std::string>")));
REQUIRE_THAT(src, IsClass(_A("A<std::string,std::string>")));
REQUIRE_THAT(src, IsClass(_A("A<char,std::string>")));
REQUIRE_THAT(src, IsClass(_A("B")));
REQUIRE_THAT(src, IsClass(_A("R<T>")));
REQUIRE_THAT(src, IsField<Private>("bapair", "PairPairBA<bool>"));
REQUIRE_THAT(src, IsField<Private>("abool", "APtr<bool>"));
REQUIRE_THAT(src, IsField<Private>("aboolfloat",
"AAPtr<bool,float>")); REQUIRE_THAT(src, IsField<Private>("afloat",
"ASharedPtr<float>")); REQUIRE_THAT( src, IsField<Private>("boolstring",
"A<bool,std::string>")); REQUIRE_THAT(src, IsField<Private>("floatstring",
"AStringPtr<float>")); REQUIRE_THAT(src, IsField<Private>("atfloat",
"AAPtr<T,float>"));
REQUIRE_THAT(src, IsField<Private>("intstring", "AIntString"));
REQUIRE_THAT(src, IsField<Private>("stringstring",
"AStringString")); REQUIRE_THAT(src, IsField<Private>("bstringstring",
"BStringString"));
REQUIRE_THAT(src, IsField<Protected>("bs", "BVector"));
REQUIRE_THAT(src, IsField<Public>("cb",
"SimpleCallback<ACharString>")); #if LLVM_VERSION_MAJOR >= 16 REQUIRE_THAT(
src, IsField<Public>("gcb", "GenericCallback<AWCharString>"));
#else
REQUIRE_THAT(
src, IsField<Public>("gcb",
"GenericCallback<R::AWCharString>")); #endif REQUIRE_THAT(src,
IsField<Public>("vcb", "VoidCallback"));
REQUIRE_THAT(
src, !IsClassTemplate("std::std::function",
"void(T...,int),int)"));
REQUIRE_THAT(
src, IsInstantiation(_A("A<T,P>"), _A("A<T,std::string>")));
REQUIRE_THAT(
src, IsInstantiation(_A("A<long,T>"), _A("A<long,float>")));
REQUIRE_THAT(src, IsInstantiation(_A("A<long,T>"),
_A("A<long,bool>")));
REQUIRE_THAT(src, IsInstantiation(_A("A<T,P>"), _A("A<long,T>")));
// REQUIRE_THAT(puml, !IsInstantiation(_A("A<long,T>"),
// _A("A<long,U>")));
REQUIRE_THAT(
src, IsInstantiation(_A("A<double,T>"), _A("A<double,float>")));
REQUIRE_THAT(
src, IsInstantiation(_A("A<double,T>"), _A("A<double,bool>")));
REQUIRE_THAT(src, IsInstantiation(_A("A<T,P>"), _A("A<double,T>")));
REQUIRE_THAT(
src, IsInstantiation(_A("A<T,P>"), _A("A<T,std::string>")));
REQUIRE_THAT(src,
IsInstantiation(_A("A<T,std::string>"),
_A("A<bool,std::string>"))); REQUIRE_THAT(src,
IsInstantiation(_A("A<T,std::string>"),
_A("A<char,std::string>"))); REQUIRE_THAT(src, IsInstantiation(
_A("A<T,std::string>"), _A("A<wchar_t,std::string>")));
REQUIRE_THAT(src,
IsInstantiation(_A("A<T,std::unique_ptr<std::string>>"),
_A("A<float,std::unique_ptr<std::string>>")));
REQUIRE_THAT(src,
IsInstantiation(
_A("A<T,P>"), _A("A<T,std::unique_ptr<std::string>>")));
REQUIRE_THAT(src, IsAggregation(_A("R<T>"), _A("B"), "+vps"));
REQUIRE_THAT(src, IsAggregation(_A("R<T>"), _A("B"), "-bapair"));
REQUIRE_THAT(
src, IsAggregation(_A("R<T>"), _A("A<long,float>"),
"-aboolfloat")); REQUIRE_THAT( src, IsAggregation(_A("R<T>"),
_A("A<long,bool>"), "-bapair")); REQUIRE_THAT(src, IsAggregation(_A("R<T>"),
_A("A<double,bool>"), "-aboolfloat")); REQUIRE_THAT( src,
IsAggregation(_A("R<T>"), _A("A<double,T>"), "-atfloat")); REQUIRE_THAT(
src, IsAggregation(_A("R<T>"), _A("A<long,float>"),
"-atfloat")); REQUIRE_THAT( src, IsAssociation(_A("R<T>"),
_A("A<double,float>"), "-afloat")); REQUIRE_THAT(src, IsAggregation(
_A("R<T>"), _A("A<bool,std::string>"), "-boolstring"));
REQUIRE_THAT(src,
IsAggregation(_A("R<T>"),
_A("A<float,std::unique_ptr<std::string>>"),
"-floatstring")); #if !defined(__APPLE__)
// TODO(#176)
REQUIRE_THAT(src, IsDependency(_A("R<T>"),
_A("A<char,std::string>"))); REQUIRE_THAT( src, IsDependency(_A("R<T>"),
_A("A<wchar_t,std::string>"))); #endif
save_mermaid(config.output_directory(), diagram->name + ".mmd",
src);
}
*/
}

11
tests/t00015/test_case.h
View File

@@ -20,15 +20,8 @@ TEST_CASE("t00015")
{
using namespace clanguml::test;
auto [config, db] = load_config("t00015");
auto diagram = config.diagrams["t00015_class"];
REQUIRE(diagram->name == "t00015_class");
auto model = generate_class_diagram(*db, diagram);
REQUIRE(model->name() == "t00015_class");
auto [config, db, diagram, model] =
CHECK_CLASS_MODEL("t00015", "t00015_class");
CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(IsClass(src, "ns1::A"));

11
tests/t00016/test_case.h
View File

@@ -20,15 +20,8 @@ TEST_CASE("t00016")
{
using namespace clanguml::test;
auto [config, db] = load_config("t00016");
auto diagram = config.diagrams["t00016_class"];
REQUIRE(diagram->name == "t00016_class");
auto model = generate_class_diagram(*db, diagram);
REQUIRE(model->name() == "t00016_class");
auto [config, db, diagram, model] =
CHECK_CLASS_MODEL("t00016", "t00016_class");
CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(IsClassTemplate(src, "is_numeric<typename>"));

11
tests/t00017/test_case.h
View File

@@ -20,15 +20,8 @@ TEST_CASE("t00017")
{
using namespace clanguml::test;
auto [config, db] = load_config("t00017");
auto diagram = config.diagrams["t00017_class"];
REQUIRE(diagram->name == "t00017_class");
auto model = generate_class_diagram(*db, diagram);
REQUIRE(model->name() == "t00017_class");
auto [config, db, diagram, model] =
CHECK_CLASS_MODEL("t00017", "t00017_class");
CHECK_CLASS_DIAGRAM(
config, diagram, *model,

11
tests/t00018/test_case.h
View File

@@ -20,15 +20,8 @@ TEST_CASE("t00018")
{
using namespace clanguml::test;
auto [config, db] = load_config("t00018");
auto diagram = config.diagrams["t00018_class"];
REQUIRE(diagram->name == "t00018_class");
auto model = generate_class_diagram(*db, diagram);
REQUIRE(model->name() == "t00018_class");
auto [config, db, diagram, model] =
CHECK_CLASS_MODEL("t00018", "t00018_class");
CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(IsClass(src, "widget"));

11
tests/t00019/test_case.h
View File

@@ -20,15 +20,8 @@ TEST_CASE("t00019")
{
using namespace clanguml::test;
auto [config, db] = load_config("t00019");
auto diagram = config.diagrams["t00019_class"];
REQUIRE(diagram->name == "t00019_class");
auto model = generate_class_diagram(*db, diagram);
REQUIRE(model->name() == "t00019_class");
auto [config, db, diagram, model] =
CHECK_CLASS_MODEL("t00019", "t00019_class");
CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(IsClass(src, "Base"));

62
tests/t00020/test_case.h
View File

@@ -20,15 +20,8 @@ TEST_CASE("t00020")
{
using namespace clanguml::test;
auto [config, db] = load_config("t00020");
auto diagram = config.diagrams["t00020_class"];
REQUIRE(diagram->name == "t00020_class");
auto model = generate_class_diagram(*db, diagram);
REQUIRE(model->name() == "t00020_class");
auto [config, db, diagram, model] =
CHECK_CLASS_MODEL("t00020", "t00020_class");
CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(IsAbstractClass(src, "AbstractFactory"));
@@ -41,55 +34,4 @@ TEST_CASE("t00020")
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")));
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
{
auto j = generate_class_json(diagram, *model);
using namespace json;
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);
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")));
save_mermaid(config.output_directory(), diagram->name + ".mmd",
src);
}*/
}

11
tests/t00021/test_case.h
View File

@@ -20,15 +20,8 @@ TEST_CASE("t00021")
{
using namespace clanguml::test;
auto [config, db] = load_config("t00021");
auto diagram = config.diagrams["t00021_class"];
REQUIRE(diagram->name == "t00021_class");
auto model = generate_class_diagram(*db, diagram);
REQUIRE(model->name() == "t00021_class");
auto [config, db, diagram, model] =
CHECK_CLASS_MODEL("t00021", "t00021_class");
CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(IsAbstractClass(src, "Item"));

11
tests/t00022/test_case.h
View File

@@ -20,15 +20,8 @@ TEST_CASE("t00022")
{
using namespace clanguml::test;
auto [config, db] = load_config("t00022");
auto diagram = config.diagrams["t00022_class"];
REQUIRE(diagram->name == "t00022_class");
auto model = generate_class_diagram(*db, diagram);
REQUIRE(model->name() == "t00022_class");
auto [config, db, diagram, model] =
CHECK_CLASS_MODEL("t00022", "t00022_class");
CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(IsClass(src, "A1"));

11
tests/t00023/test_case.h
View File

@@ -20,15 +20,8 @@ TEST_CASE("t00023")
{
using namespace clanguml::test;
auto [config, db] = load_config("t00023");
auto diagram = config.diagrams["t00023_class"];
REQUIRE(diagram->name == "t00023_class");
auto model = generate_class_diagram(*db, diagram);
REQUIRE(model->name() == "t00023_class");
auto [config, db, diagram, model] =
CHECK_CLASS_MODEL("t00023", "t00023_class");
CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(IsAbstractClass(src, "Strategy"));

11
tests/t00024/test_case.h
View File

@@ -20,15 +20,8 @@ TEST_CASE("t00024")
{
using namespace clanguml::test;
auto [config, db] = load_config("t00024");
auto diagram = config.diagrams["t00024_class"];
REQUIRE(diagram->name == "t00024_class");
auto model = generate_class_diagram(*db, diagram);
REQUIRE(model->name() == "t00024_class");
auto [config, db, diagram, model] =
CHECK_CLASS_MODEL("t00024", "t00024_class");
CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(IsClass(src, "Target1"));

11
tests/t00025/test_case.h
View File

@@ -20,15 +20,8 @@ TEST_CASE("t00025")
{
using namespace clanguml::test;
auto [config, db] = load_config("t00025");
auto diagram = config.diagrams["t00025_class"];
REQUIRE(diagram->name == "t00025_class");
auto model = generate_class_diagram(*db, diagram);
REQUIRE(model->name() == "t00025_class");
auto [config, db, diagram, model] =
CHECK_CLASS_MODEL("t00025", "t00025_class");
CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(IsClass(src, "Target1"));

11
tests/t00026/test_case.h
View File

@@ -20,15 +20,8 @@ TEST_CASE("t00026")
{
using namespace clanguml::test;
auto [config, db] = load_config("t00026");
auto diagram = config.diagrams["t00026_class"];
REQUIRE(diagram->name == "t00026_class");
auto model = generate_class_diagram(*db, diagram);
REQUIRE(model->name() == "t00026_class");
auto [config, db, diagram, model] =
CHECK_CLASS_MODEL("t00026", "t00026_class");
CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(IsClassTemplate(src, "Memento<T>"));

90
tests/t00027/test_case.h
View File

@@ -20,15 +20,8 @@ TEST_CASE("t00027")
{
using namespace clanguml::test;
auto [config, db] = load_config("t00027");
auto diagram = config.diagrams["t00027_class"];
REQUIRE(diagram->name == "t00027_class");
auto model = generate_class_diagram(*db, diagram);
REQUIRE(model->name() == "t00027_class");
auto [config, db, diagram, model] =
CHECK_CLASS_MODEL("t00027", "t00027_class");
CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(IsAbstractClass(src, "Shape"));
@@ -37,7 +30,8 @@ TEST_CASE("t00027")
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(
IsAggregation<Public>(src, "Window", "Text<Color>", "description"));
REQUIRE(IsInstantiation(src, "Line<T<>...>", "Line<Color>"));
REQUIRE(IsInstantiation(src, "Line<T<>...>", "Line<Color,Weight>"));
@@ -52,80 +46,4 @@ TEST_CASE("t00027")
REQUIRE(
IsAggregation<Public>(src, "Window", "Text<Color>", "description"));
});
/*
{
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("Shape")));
REQUIRE_THAT(src, IsAbstractClass(_A("ShapeDecorator")));
REQUIRE_THAT(src, IsClassTemplate("Line", "T<>..."));
REQUIRE_THAT(src, IsClassTemplate("Text", "T<>..."));
REQUIRE_THAT(
src, IsInstantiation(_A("Line<T<>...>"), _A("Line<Color>")));
REQUIRE_THAT(
src, IsInstantiation(_A("Line<T<>...>"), _A("Line<Color,Weight>")));
REQUIRE_THAT(
src, IsInstantiation(_A("Text<T<>...>"), _A("Text<Color>")));
REQUIRE_THAT(
src, IsInstantiation(_A("Text<T<>...>"), _A("Text<Color,Weight>")));
REQUIRE_THAT(src,
IsAggregation(_A("Window"), _A("Line<Color,Weight>"), "+border"));
REQUIRE_THAT(
src, IsAggregation(_A("Window"), _A("Line<Color>"), "+divider"));
REQUIRE_THAT(src,
IsAggregation(_A("Window"), _A("Text<Color,Weight>"), "+title"));
REQUIRE_THAT(src,
IsAggregation(_A("Window"), _A("Text<Color>"), "+description"));
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
{
auto j = generate_class_json(diagram, *model);
using namespace json;
REQUIRE(IsAbstractClass(j, "Shape"));
REQUIRE(IsAbstractClass(j, "ShapeDecorator"));
REQUIRE(IsClassTemplate(j, "Line<T<>...>"));
REQUIRE(IsInstantiation(j, "Line<T<>...>", "Line<Color>"));
REQUIRE(IsInstantiation(j, "Line<T<>...>", "Line<Color,Weight>"));
REQUIRE(IsAggregation(j, "Window", "Text<Color>", "description"));
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("Shape")));
REQUIRE_THAT(src, IsAbstractClass(_A("ShapeDecorator")));
REQUIRE_THAT(src, IsClass(_A("Line<T<>...>")));
REQUIRE_THAT(src, IsClass(_A("Text<T<>...>")));
REQUIRE_THAT(
src, IsInstantiation(_A("Line<T<>...>"), _A("Line<Color>")));
REQUIRE_THAT(
src, IsInstantiation(_A("Line<T<>...>"), _A("Line<Color,Weight>")));
REQUIRE_THAT(
src, IsInstantiation(_A("Text<T<>...>"), _A("Text<Color>")));
REQUIRE_THAT(
src, IsInstantiation(_A("Text<T<>...>"), _A("Text<Color,Weight>")));
REQUIRE_THAT(src,
IsAggregation(_A("Window"), _A("Line<Color,Weight>"), "+border"));
REQUIRE_THAT(
src, IsAggregation(_A("Window"), _A("Line<Color>"), "+divider"));
REQUIRE_THAT(src,
IsAggregation(_A("Window"), _A("Text<Color,Weight>"), "+title"));
REQUIRE_THAT(src,
IsAggregation(_A("Window"), _A("Text<Color>"), "+description"));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}*/
}

87
tests/t00028/test_case.h
View File

@@ -20,15 +20,8 @@ TEST_CASE("t00028")
{
using namespace clanguml::test;
auto [config, db] = load_config("t00028");
auto diagram = config.diagrams["t00028_class"];
REQUIRE(diagram->name == "t00028_class");
auto model = generate_class_diagram(*db, diagram);
REQUIRE(model->name() == "t00028_class");
auto [config, db, diagram, model] =
CHECK_CLASS_MODEL("t00028", "t00028_class");
CHECK_CLASS_DIAGRAM(
config, diagram, *model,
@@ -63,80 +56,4 @@ note.)";
REQUIRE(HasNote(src, "R", "left", "R contains an instance of A."));
REQUIRE(!HasNote(src, "G", "left", "G class note."));
});
/*
{
auto src = generate_class_puml(diagram, *model);
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."));
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_puml(config.output_directory(), diagram->name + ".puml", src);
}
{
auto j = generate_class_json(diagram, *model);
using namespace json;
save_json(config.output_directory(), diagram->name + ".json", j);
}
{
auto src = generate_class_mermaid(diagram, *model);
mermaid::AliasMatcher _A(src);
using mermaid::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);
}*/
}

9
tests/t00029/test_case.h
View File

@@ -20,13 +20,8 @@ TEST_CASE("t00029")
{
using namespace clanguml::test;
auto [config, db] = load_config("t00029");
auto diagram = config.diagrams["t00029_class"];
REQUIRE(diagram->name == "t00029_class");
auto model = generate_class_diagram(*db, diagram);
auto [config, db, diagram, model] =
CHECK_CLASS_MODEL("t00029", "t00029_class");
REQUIRE(model->name() == "t00029_class");

11
tests/t00030/test_case.h
View File

@@ -20,15 +20,8 @@ TEST_CASE("t00030")
{
using namespace clanguml::test;
auto [config, db] = load_config("t00030");
auto diagram = config.diagrams["t00030_class"];
REQUIRE(diagram->name == "t00030_class");
auto model = generate_class_diagram(*db, diagram);
REQUIRE(model->name() == "t00030_class");
auto [config, db, diagram, model] =
CHECK_CLASS_MODEL("t00030", "t00030_class");
CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(IsClass(src, "A"));

11
tests/t00031/test_case.h
View File

@@ -20,15 +20,8 @@ TEST_CASE("t00031")
{
using namespace clanguml::test;
auto [config, db] = load_config("t00031");
auto diagram = config.diagrams["t00031_class"];
REQUIRE(diagram->name == "t00031_class");
auto model = generate_class_diagram(*db, diagram);
REQUIRE(model->name() == "t00031_class");
auto [config, db, diagram, model] =
CHECK_CLASS_MODEL("t00031", "t00031_class");
CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(IsClass(src, "A"));

11
tests/t00032/test_case.h
View File

@@ -20,15 +20,8 @@ TEST_CASE("t00032")
{
using namespace clanguml::test;
auto [config, db] = load_config("t00032");
auto diagram = config.diagrams["t00032_class"];
REQUIRE(diagram->name == "t00032_class");
auto model = generate_class_diagram(*db, diagram);
REQUIRE(model->name() == "t00032_class");
auto [config, db, diagram, model] =
CHECK_CLASS_MODEL("t00032", "t00032_class");
CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(IsClass(src, "Base"));

11
tests/t00033/test_case.h
View File

@@ -20,15 +20,8 @@ TEST_CASE("t00033")
{
using namespace clanguml::test;
auto [config, db] = load_config("t00033");
auto diagram = config.diagrams["t00033_class"];
REQUIRE(diagram->name == "t00033_class");
auto model = generate_class_diagram(*db, diagram);
REQUIRE(model->name() == "t00033_class");
auto [config, db, diagram, model] =
CHECK_CLASS_MODEL("t00033", "t00033_class");
CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(IsClassTemplate(src, "A<T>"));

11
tests/t00034/test_case.h
View File

@@ -20,15 +20,8 @@ TEST_CASE("t00034")
{
using namespace clanguml::test;
auto [config, db] = load_config("t00034");
auto diagram = config.diagrams["t00034_class"];
REQUIRE(diagram->name == "t00034_class");
auto model = generate_class_diagram(*db, diagram);
REQUIRE(model->name() == "t00034_class");
auto [config, db, diagram, model] =
CHECK_CLASS_MODEL("t00034", "t00034_class");
CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(IsClassTemplate(src, "lift_void<T>"));

11
tests/t00035/test_case.h
View File

@@ -20,15 +20,8 @@ TEST_CASE("t00035")
{
using namespace clanguml::test;
auto [config, db] = load_config("t00035");
auto diagram = config.diagrams["t00035_class"];
REQUIRE(diagram->name == "t00035_class");
auto model = generate_class_diagram(*db, diagram);
REQUIRE(model->name() == "t00035_class");
auto [config, db, diagram, model] =
CHECK_CLASS_MODEL("t00035", "t00035_class");
CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(IsClass(src, "Top"));

10
tests/t00036/test_case.h
View File

@@ -21,17 +21,11 @@ TEST_CASE("t00036")
using namespace clanguml::test;
using namespace std::string_literals;
auto [config, db] = load_config("t00036");
auto [config, db, diagram, model] =
CHECK_CLASS_MODEL("t00036", "t00036_class");
auto diagram = config.diagrams["t00036_class"];
REQUIRE(diagram->name == "t00036_class");
REQUIRE(diagram->generate_packages() == true);
auto model = generate_class_diagram(*db, diagram);
REQUIRE(model->name() == "t00036_class");
CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(IsClassTemplate(src, {"ns1::ns11", "A<T>"}));
REQUIRE(IsClassTemplate(src, {"ns1::ns11", "A<int>"}));

10
tests/t00037/test_case.h
View File

@@ -20,17 +20,11 @@ TEST_CASE("t00037")
{
using namespace clanguml::test;
auto [config, db] = load_config("t00037");
auto [config, db, diagram, model] =
CHECK_CLASS_MODEL("t00037", "t00037_class");
auto diagram = config.diagrams["t00037_class"];
REQUIRE(diagram->name == "t00037_class");
REQUIRE(diagram->generate_packages() == true);
auto model = generate_class_diagram(*db, diagram);
REQUIRE(model->name() == "t00037_class");
CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(IsClass(src, "ST"));
REQUIRE(IsClass(src, "A"));

12
tests/t00038/test_case.h
View File

@@ -20,16 +20,8 @@ TEST_CASE("t00038")
{
using namespace clanguml::test;
auto [config, db] = load_config("t00038");
auto diagram = config.diagrams["t00038_class"];
REQUIRE(diagram->name == "t00038_class");
REQUIRE(diagram->generate_packages() == false);
auto model = generate_class_diagram(*db, diagram);
REQUIRE(model->name() == "t00038_class");
auto [config, db, diagram, model] =
CHECK_CLASS_MODEL("t00038", "t00038_class");
CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(IsClass(src, "A"));

11
tests/t00039/test_case.h
View File

@@ -20,15 +20,8 @@ TEST_CASE("t00039")
{
using namespace clanguml::test;
auto [config, db] = load_config("t00039");
auto diagram = config.diagrams["t00039_class"];
REQUIRE(diagram->name == "t00039_class");
REQUIRE(diagram->generate_packages() == false);
auto model = generate_class_diagram(*db, diagram);
REQUIRE(model->name() == "t00039_class");
auto [config, db, diagram, model] =
CHECK_CLASS_MODEL("t00039", "t00039_class");
CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(IsClass(src, "A"));

12
tests/t00040/test_case.h
View File

@@ -20,16 +20,8 @@ TEST_CASE("t00040")
{
using namespace clanguml::test;
auto [config, db] = load_config("t00040");
auto diagram = config.diagrams["t00040_class"];
REQUIRE(diagram->name == "t00040_class");
REQUIRE(diagram->generate_packages() == false);
auto model = generate_class_diagram(*db, diagram);
REQUIRE(model->name() == "t00040_class");
auto [config, db, diagram, model] =
CHECK_CLASS_MODEL("t00040", "t00040_class");
CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(IsClass(src, "A"));

10
tests/t00041/test_case.h
View File

@@ -20,17 +20,11 @@ TEST_CASE("t00041")
{
using namespace clanguml::test;
auto [config, db] = load_config("t00041");
auto [config, db, diagram, model] =
CHECK_CLASS_MODEL("t00041", "t00041_class");
auto diagram = config.diagrams["t00041_class"];
REQUIRE(diagram->name == "t00041_class");
REQUIRE(diagram->generate_packages() == false);
auto model = generate_class_diagram(*db, diagram);
REQUIRE(model->name() == "t00041_class");
CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(!IsClass(src, "A"));
REQUIRE(!IsClass(src, "AA"));

10
tests/t00042/test_case.h
View File

@@ -20,17 +20,11 @@ TEST_CASE("t00042")
{
using namespace clanguml::test;
auto [config, db] = load_config("t00042");
auto [config, db, diagram, model] =
CHECK_CLASS_MODEL("t00042", "t00042_class");
auto diagram = config.diagrams["t00042_class"];
REQUIRE(diagram->name == "t00042_class");
REQUIRE(diagram->generate_packages() == false);
auto model = generate_class_diagram(*db, diagram);
REQUIRE(model->name() == "t00042_class");
CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(IsClassTemplate(src, "A<T>"));
REQUIRE(IsClassTemplate(src, "B<T,K>"));

12
tests/t00043/test_case.h
View File

@@ -20,16 +20,8 @@ TEST_CASE("t00043")
{
using namespace clanguml::test;
auto [config, db] = load_config("t00043");
auto diagram = config.diagrams["t00043_class"];
REQUIRE(diagram->name == "t00043_class");
REQUIRE(diagram->generate_packages() == true);
auto model = generate_class_diagram(*db, diagram);
REQUIRE(model->name() == "t00043_class");
auto [config, db, diagram, model] =
CHECK_CLASS_MODEL("t00043", "t00043_class");
CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(IsClass(src, {"dependants", "A"}));

12
tests/t00044/test_case.h
View File

@@ -20,16 +20,8 @@ TEST_CASE("t00044")
{
using namespace clanguml::test;
auto [config, db] = load_config("t00044");
auto diagram = config.diagrams["t00044_class"];
REQUIRE(diagram->name == "t00044_class");
REQUIRE(diagram->generate_packages() == true);
auto model = generate_class_diagram(*db, diagram);
REQUIRE(model->name() == "t00044_class");
auto [config, db, diagram, model] =
CHECK_CLASS_MODEL("t00044", "t00044_class");
CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(!src.contains("type-parameter-"));

11
tests/t00045/test_case.h
View File

@@ -20,15 +20,8 @@ TEST_CASE("t00045")
{
using namespace clanguml::test;
auto [config, db] = load_config("t00045");
auto diagram = config.diagrams["t00045_class"];
REQUIRE(diagram->name == "t00045_class");
auto model = generate_class_diagram(*db, diagram);
REQUIRE(model->name() == "t00045_class");
auto [config, db, diagram, model] =
CHECK_CLASS_MODEL("t00045", "t00045_class");
CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(IsClass(src, "A"));

13
tests/t00046/test_case.h
View File

@@ -20,15 +20,8 @@ TEST_CASE("t00046")
{
using namespace clanguml::test;
auto [config, db] = load_config("t00046");
auto diagram = config.diagrams["t00046_class"];
REQUIRE(diagram->name == "t00046_class");
auto model = generate_class_diagram(*db, diagram);
REQUIRE(model->name() == "t00046_class");
auto [config, db, diagram, model] =
CHECK_CLASS_MODEL("t00046", "t00046_class");
CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(IsClass(src, "A"));
@@ -40,6 +33,6 @@ TEST_CASE("t00046")
REQUIRE(IsClass(src, {"ns1::ns2", "R"}));
REQUIRE(IsField<Public>(
src, "ns1::ns2::R", "i", "std::vector<std::uint8_t>"));
src, {"ns1::ns2", "R"}, "i", "std::vector<std::uint8_t>"));
});
}

11
tests/t00047/test_case.h
View File

@@ -20,15 +20,8 @@ TEST_CASE("t00047")
{
using namespace clanguml::test;
auto [config, db] = load_config("t00047");
auto diagram = config.diagrams["t00047_class"];
REQUIRE(diagram->name == "t00047_class");
auto model = generate_class_diagram(*db, diagram);
REQUIRE(model->name() == "t00047_class");
auto [config, db, diagram, model] =
CHECK_CLASS_MODEL("t00047", "t00047_class");
CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(IsClassTemplate(src, "conditional_t<Ts...>"));

11
tests/t00048/test_case.h
View File

@@ -20,15 +20,8 @@ TEST_CASE("t00048")
{
using namespace clanguml::test;
auto [config, db] = load_config("t00048");
auto diagram = config.diagrams["t00048_class"];
REQUIRE(diagram->name == "t00048_class");
auto model = generate_class_diagram(*db, diagram);
REQUIRE(model->name() == "t00048_class");
auto [config, db, diagram, model] =
CHECK_CLASS_MODEL("t00048", "t00048_class");
CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
// Check if all classes exist

10
tests/t00049/test_case.h
View File

@@ -20,15 +20,9 @@ TEST_CASE("t00049")
{
using namespace clanguml::test;
auto [config, db] = load_config("t00049");
auto [config, db, diagram, model] =
CHECK_CLASS_MODEL("t00049", "t00049_class");
auto diagram = config.diagrams["t00049_class"];
REQUIRE(diagram->name == "t00049_class");
auto model = generate_class_diagram(*db, diagram);
REQUIRE(model->name() == "t00049_class");
CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(IsClass(src, "R"));

11
tests/t00050/test_case.h
View File

@@ -20,15 +20,8 @@ TEST_CASE("t00050")
{
using namespace clanguml::test;
auto [config, db] = load_config("t00050");
auto diagram = config.diagrams["t00050_class"];
REQUIRE(diagram->name == "t00050_class");
auto model = generate_class_diagram(*db, diagram);
REQUIRE(model->name() == "t00050_class");
auto [config, db, diagram, model] =
CHECK_CLASS_MODEL("t00050", "t00050_class");
CHECK_CLASS_DIAGRAM(
config, diagram, *model,

113
tests/t00051/test_case.h
View File

@@ -20,15 +20,8 @@ TEST_CASE("t00051")
{
using namespace clanguml::test;
auto [config, db] = load_config("t00051");
auto diagram = config.diagrams["t00051_class"];
REQUIRE(diagram->name == "t00051_class");
auto model = generate_class_diagram(*db, diagram);
REQUIRE(model->name() == "t00051_class");
auto [config, db, diagram, model] =
CHECK_CLASS_MODEL("t00051", "t00051_class");
CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(IsClass(src, "A"));
@@ -59,106 +52,4 @@ TEST_CASE("t00051")
REQUIRE(IsDependency(src, "A",
"B<(lambda at t00051.cc:43:18),(lambda at t00051.cc:43:27)>"));
});
/*
{
auto src = generate_class_puml(diagram, *model);
AliasMatcher _A(src);
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
// Check if all classes exist
REQUIRE_THAT(src, IsClass(_A("A")));
REQUIRE_THAT(src, IsInnerClass(_A("A"), _A("A::custom_thread1")));
REQUIRE_THAT(src, IsInnerClass(_A("A"), _A("A::custom_thread2")));
REQUIRE_THAT(src,
(IsMethod<Public>("custom_thread1<Function,Args...>", "void",
"Function && f, Args &&... args")));
REQUIRE_THAT(src,
(IsMethod<Public>(
"thread", "void", "(lambda at t00051.cc:59:27) &&")));
REQUIRE_THAT(src,
(IsMethod<Private>("start_thread3",
"B<(lambda at t00051.cc:43:18),(lambda at "
"t00051.cc:43:27)>")));
REQUIRE_THAT(src,
(IsMethod<Private>("get_function", "(lambda at t00051.cc:48:16)")));
REQUIRE_THAT(src, IsClassTemplate("B", "F,FF=F"));
REQUIRE_THAT(src, (IsMethod<Public>("f", "void")));
REQUIRE_THAT(src, (IsMethod<Public>("ff", "void")));
REQUIRE_THAT(src,
IsClassTemplate("B",
"(lambda at t00051.cc:43:18),(lambda at t00051.cc:43:27)"));
REQUIRE_THAT(src,
IsInstantiation(_A("B<F,FF=F>"),
_A("B<(lambda at t00051.cc:43:18),(lambda at "
"t00051.cc:43:27)>")));
REQUIRE_THAT(src,
IsDependency(_A("A"),
_A("B<(lambda at t00051.cc:43:18),(lambda "
"at t00051.cc:43:27)>")));
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
{
auto j = generate_class_json(diagram, *model);
using namespace json;
REQUIRE(IsClass(j, "A"));
REQUIRE(IsInnerClass(j, "A", "A::custom_thread1"));
REQUIRE(IsInnerClass(j, "A", "A::custom_thread2"));
save_json(config.output_directory(), diagram->name + ".json", j);
}
{
auto src = generate_class_mermaid(diagram, *model);
mermaid::AliasMatcher _A(src);
using mermaid::IsInnerClass;
using mermaid::IsMethod;
// Check if all classes exist
REQUIRE_THAT(src, IsClass(_A("A")));
REQUIRE_THAT(src, IsInnerClass(_A("A"), _A("A::custom_thread1")));
REQUIRE_THAT(src, IsInnerClass(_A("A"), _A("A::custom_thread2")));
REQUIRE_THAT(src,
(IsMethod<Public>("custom_thread1<Function,Args...>", "void",
"Function && f, Args &&... args")));
REQUIRE_THAT(src,
(IsMethod<Public>(
"thread", "void", "(lambda at t00051.cc:59:27) &&")));
REQUIRE_THAT(src,
(IsMethod<Private>("start_thread3",
"B<(lambda at t00051.cc:43:18),(lambda at t00051.cc:43:27)>")));
REQUIRE_THAT(src,
(IsMethod<Private>("get_function", "(lambda at t00051.cc:48:16)")));
REQUIRE_THAT(src, IsClass(_A("B<F,FF=F>")));
REQUIRE_THAT(src, (IsMethod<Public>("f", "void")));
REQUIRE_THAT(src, (IsMethod<Public>("ff", "void")));
REQUIRE_THAT(src,
IsClass(_A("B<(lambda at t00051.cc:43:18),(lambda at "
"t00051.cc:43:27)>")));
REQUIRE_THAT(src,
IsInstantiation(_A("B<F,FF=F>"),
_A("B<(lambda at t00051.cc:43:18),(lambda at "
"t00051.cc:43:27)>")));
REQUIRE_THAT(src,
IsDependency(_A("A"),
_A("B<(lambda at t00051.cc:43:18),(lambda "
"at t00051.cc:43:27)>")));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}
*/
}

64
tests/t00052/test_case.h
View File

@@ -20,15 +20,8 @@ TEST_CASE("t00052")
{
using namespace clanguml::test;
auto [config, db] = load_config("t00052");
auto diagram = config.diagrams["t00052_class"];
REQUIRE(diagram->name == "t00052_class");
auto model = generate_class_diagram(*db, diagram);
REQUIRE(model->name() == "t00052_class");
auto [config, db, diagram, model] =
CHECK_CLASS_MODEL("t00052", "t00052_class");
CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(IsClass(src, "A"));
@@ -40,57 +33,4 @@ TEST_CASE("t00052")
REQUIRE(IsMethod<Public>(src, "B<T>", "b", "T", "T t"));
REQUIRE(IsMethod<Public>(src, "B<T>", "bb<F>", "T", "F && f, T t"));
});
/*
{
auto src = generate_class_puml(diagram, *model);
AliasMatcher _A(src);
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
// Check if all classes exist
REQUIRE_THAT(src, IsClass(_A("A")));
// Check if class templates exist
REQUIRE_THAT(src, IsClassTemplate("B", "T"));
// Check if all methods exist
REQUIRE_THAT(src, (IsMethod<Public>("a<T>", "T", "T p")));
REQUIRE_THAT(src, (IsMethod<Public>("aa<F,Q>", "void", "F && f, Q q")));
REQUIRE_THAT(src, (IsMethod<Public>("b", "T", "T t")));
REQUIRE_THAT(src, (IsMethod<Public>("bb<F>", "T", "F && f, T 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(IsClassTemplate(j, "B<T>"));
save_json(config.output_directory(), diagram->name + ".json", j);
}
{
auto src = generate_class_mermaid(diagram, *model);
mermaid::AliasMatcher _A(src);
using mermaid::IsMethod;
// Check if all classes exist
REQUIRE_THAT(src, IsClass(_A("A")));
// Check if class templates exist
REQUIRE_THAT(src, IsClass(_A("B<T>")));
// Check if all methods exist
REQUIRE_THAT(src, (IsMethod<Public>("a<T>", "T", "T p")));
REQUIRE_THAT(src, (IsMethod<Public>("aa<F,Q>", "void", "F && f, Q q")));
REQUIRE_THAT(src, (IsMethod<Public>("b", "T", "T t")));
REQUIRE_THAT(src, (IsMethod<Public>("bb<F>", "T", "F && f, T t")));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}
*/
}

88
tests/t00053/test_case.h
View File

@@ -20,15 +20,8 @@ TEST_CASE("t00053")
{
using namespace clanguml::test;
auto [config, db] = load_config("t00053");
auto diagram = config.diagrams["t00053_class"];
REQUIRE(diagram->name == "t00053_class");
auto model = generate_class_diagram(*db, diagram);
REQUIRE(model->name() == "t00053_class");
auto [config, db, diagram, model] =
CHECK_CLASS_MODEL("t00053", "t00053_class");
CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(IsClass(src, "a"));
@@ -47,81 +40,4 @@ TEST_CASE("t00053")
REQUIRE(IsClass(src, "F"));
REQUIRE(IsClass(src, "G"));
});
/*
{
auto src = generate_class_puml(diagram, *model);
AliasMatcher _A(src);
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
// Check if all classes exist
REQUIRE_THAT(src, IsClass(_A("a")));
REQUIRE_THAT(src, IsClass(_A("b")));
REQUIRE_THAT(src, IsClass(_A("c")));
REQUIRE_THAT(src, IsClass(_A("d")));
REQUIRE_THAT(src, IsClass(_A("e")));
REQUIRE_THAT(src, IsClass(_A("f")));
REQUIRE_THAT(src, IsClass(_A("g")));
REQUIRE_THAT(src, IsClass(_A("A")));
REQUIRE_THAT(src, IsClass(_A("B")));
REQUIRE_THAT(src, IsClass(_A("C")));
REQUIRE_THAT(src, IsClass(_A("D")));
REQUIRE_THAT(src, IsClass(_A("E")));
REQUIRE_THAT(src, IsClass(_A("F")));
REQUIRE_THAT(src, IsClass(_A("G")));
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
{
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, "A"));
REQUIRE(IsClass(j, "B"));
REQUIRE(IsClass(j, "C"));
REQUIRE(IsClass(j, "D"));
REQUIRE(IsClass(j, "E"));
REQUIRE(IsClass(j, "F"));
REQUIRE(IsClass(j, "G"));
save_json(config.output_directory(), diagram->name + ".json", j);
}
{
auto src = generate_class_mermaid(diagram, *model);
mermaid::AliasMatcher _A(src);
// Check if all classes exist
REQUIRE_THAT(src, IsClass(_A("a")));
REQUIRE_THAT(src, IsClass(_A("b")));
REQUIRE_THAT(src, IsClass(_A("c")));
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("A")));
REQUIRE_THAT(src, IsClass(_A("B")));
REQUIRE_THAT(src, IsClass(_A("C")));
REQUIRE_THAT(src, IsClass(_A("D")));
REQUIRE_THAT(src, IsClass(_A("E")));
REQUIRE_THAT(src, IsClass(_A("F")));
REQUIRE_THAT(src, IsClass(_A("G")));
save_mermaid(config.output_directory(), diagram->name + ".mmd",
src);
}
*/
}

99
tests/t00054/test_case.h
View File

@@ -20,15 +20,8 @@ TEST_CASE("t00054")
{
using namespace clanguml::test;
auto [config, db] = load_config("t00054");
auto diagram = config.diagrams["t00054_class"];
REQUIRE(diagram->name == "t00054_class");
auto model = generate_class_diagram(*db, diagram);
REQUIRE(model->name() == "t00054_class");
auto [config, db, diagram, model] =
CHECK_CLASS_MODEL("t00054", "t00054_class");
CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(IsClass(src, "a"));
@@ -51,92 +44,4 @@ TEST_CASE("t00054")
REQUIRE(IsEnum(src, {"detail4", "h"}));
REQUIRE(IsEnum(src, {"detail4", "j"}));
});
/*
{
auto src = generate_class_puml(diagram, *model);
AliasMatcher _A(src);
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
// Check if all classes exist
REQUIRE_THAT(src, IsClass(_A("a")));
REQUIRE_THAT(src, IsClass(_A("b")));
REQUIRE_THAT(src, IsClass(_A("c")));
REQUIRE_THAT(src, IsClass(_A("d")));
REQUIRE_THAT(src, IsClass(_A("e")));
REQUIRE_THAT(src, IsClass(_A("f")));
REQUIRE_THAT(src, IsClass(_A("g")));
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, IsEnum(_A("i")));
REQUIRE_THAT(src, IsEnum(_A("h")));
REQUIRE_THAT(src, IsEnum(_A("j")));
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, "detail::c"));
REQUIRE(IsClass(j, "detail::d"));
REQUIRE(IsClass(j, "detail::e"));
REQUIRE(IsClass(j, "f"));
REQUIRE(IsClass(j, "g"));
REQUIRE(IsClass(j, "A"));
REQUIRE(IsClass(j, "B"));
REQUIRE(IsClass(j, "detail2::C"));
REQUIRE(IsClass(j, "detail2::detail3::D"));
REQUIRE(IsClass(j, "detail2::detail3::E"));
REQUIRE(IsClass(j, "detail2::F"));
REQUIRE(IsClass(j, "G"));
REQUIRE(IsEnum(j, "detail4::i"));
REQUIRE(IsEnum(j, "detail4::h"));
REQUIRE(IsEnum(j, "detail4::j"));
save_json(config.output_directory(), diagram->name + ".json", j);
}
{
auto src = generate_class_mermaid(diagram, *model);
mermaid::AliasMatcher _A(src);
using mermaid::IsEnum;
// Check if all classes exist
REQUIRE_THAT(src, IsClass(_A("a")));
REQUIRE_THAT(src, IsClass(_A("b")));
REQUIRE_THAT(src, IsClass(_A("detail::c")));
REQUIRE_THAT(src, IsClass(_A("detail::d")));
REQUIRE_THAT(src, IsClass(_A("detail::e")));
REQUIRE_THAT(src, IsClass(_A("f")));
REQUIRE_THAT(src, IsClass(_A("g")));
REQUIRE_THAT(src, IsClass(_A("A")));
REQUIRE_THAT(src, IsClass(_A("B")));
REQUIRE_THAT(src, IsClass(_A("detail2::C")));
REQUIRE_THAT(src, IsClass(_A("detail2::detail3::D")));
REQUIRE_THAT(src, IsClass(_A("detail2::detail3::E")));
REQUIRE_THAT(src, IsClass(_A("detail2::F")));
REQUIRE_THAT(src, IsClass(_A("G")));
REQUIRE_THAT(src, IsEnum(_A("detail4::i")));
REQUIRE_THAT(src, IsEnum(_A("detail4::h")));
REQUIRE_THAT(src, IsEnum(_A("detail4::j")));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}*/
}

81
tests/t00055/test_case.h
View File

@@ -20,15 +20,8 @@ TEST_CASE("t00055")
{
using namespace clanguml::test;
auto [config, db] = load_config("t00055");
auto diagram = config.diagrams["t00055_class"];
REQUIRE(diagram->name == "t00055_class");
auto model = generate_class_diagram(*db, diagram);
REQUIRE(model->name() == "t00055_class");
auto [config, db, diagram, model] =
CHECK_CLASS_MODEL("t00055", "t00055_class");
CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(IsClass(src, "A"));
@@ -52,74 +45,4 @@ TEST_CASE("t00055")
REQUIRE(IsLayoutHint(src, "F", "down", "H"));
REQUIRE(IsLayoutHint(src, "H", "down", "J"));
});
/*
{
auto src = generate_class_puml(diagram, *model);
AliasMatcher _A(src);
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
// Check if all classes exist
REQUIRE_THAT(src, IsClass(_A("A")));
REQUIRE_THAT(src, IsClass(_A("B")));
REQUIRE_THAT(src, IsClass(_A("C")));
REQUIRE_THAT(src, IsClass(_A("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, IsLayoutHint(_A("A"), "right", _A("C")));
REQUIRE_THAT(src, IsLayoutHint(_A("C"), "right", _A("E")));
REQUIRE_THAT(src, IsLayoutHint(_A("E"), "right", _A("G")));
REQUIRE_THAT(src, IsLayoutHint(_A("G"), "right", _A("I")));
REQUIRE_THAT(src, IsLayoutHint(_A("B"), "down", _A("D")));
REQUIRE_THAT(src, IsLayoutHint(_A("D"), "down", _A("F")));
REQUIRE_THAT(src, IsLayoutHint(_A("F"), "down", _A("H")));
REQUIRE_THAT(src, IsLayoutHint(_A("H"), "down", _A("J")));
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"));
save_json(config.output_directory(), diagram->name + ".json", j);
}
{
auto src = generate_class_mermaid(diagram, *model);
mermaid::AliasMatcher _A(src);
// Check if all classes exist
REQUIRE_THAT(src, IsClass(_A("A")));
REQUIRE_THAT(src, IsClass(_A("B")));
REQUIRE_THAT(src, IsClass(_A("C")));
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")));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}*/
}

214
tests/t00056/test_case.h
View File

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

95
tests/t00057/test_case.h
View File

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

104
tests/t00058/test_case.h
View File

@@ -20,15 +20,8 @@ TEST_CASE("t00058")
{
using namespace clanguml::test;
auto [config, db] = load_config("t00058");
auto diagram = config.diagrams["t00058_class"];
REQUIRE(diagram->name == "t00058_class");
auto model = generate_class_diagram(*db, diagram);
REQUIRE(model->name() == "t00058_class");
auto [config, db, diagram, model] =
CHECK_CLASS_MODEL("t00058", "t00058_class");
CHECK_CLASS_DIAGRAM(
config, diagram, *model,
@@ -67,97 +60,4 @@ TEST_CASE("t00058")
REQUIRE(IsDependency(
src, "same_as_first_type<T,Args...>", "first_type<T,Args...>"));
});
/*
{
auto src = generate_class_puml(diagram, *model);
AliasMatcher _A(src);
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
REQUIRE_THAT(src, IsClassTemplate("A",
"int,int,double,std::string")); REQUIRE_THAT( src, IsClassTemplate("B",
"int,std::string,int,double,A<int,int>"));
REQUIRE_THAT(src, IsConcept(_A("same_as_first_type<T,Args...>")));
REQUIRE_THAT(src,
IsConstraint(_A("A<T,Args...>"),
_A("same_as_first_type<T,Args...>"), "T,Args..."));
REQUIRE_THAT(src,
IsConstraint(_A("B<T,P,Args...>"),
_A("same_as_first_type<T,Args...>"), "T,Args..."));
REQUIRE_THAT(src,
IsAggregation(_A("R"), _A("A<int,int,double,std::string>"),
"+aa")); REQUIRE_THAT(src, IsAggregation(_A("R"),
_A("B<int,std::string,int,double,A<int,int>>"), "+bb"));
REQUIRE_THAT(src,
IsInstantiation(
_A("A<T,Args...>"), _A("A<int,int,double,std::string>")));
REQUIRE_THAT(src,
IsInstantiation(_A("B<T,P,Args...>"),
_A("B<int,std::string,int,double,A<int,int>>")));
REQUIRE_THAT(src,
IsDependency(_A("same_as_first_type<T,Args...>"),
_A("first_type<T,Args...>")));
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
{
auto j = generate_class_json(diagram, *model);
using namespace json;
REQUIRE(IsClass(j, "A<int,int,double,std::string>"));
REQUIRE(IsClass(j, "B<int,std::string,int,double,A<int,int>>"));
save_json(config.output_directory(), diagram->name + ".json", j);
}
{
auto src = generate_class_mermaid(diagram, *model);
mermaid::AliasMatcher _A(src);
using mermaid::IsConcept;
using mermaid::IsConstraint;
REQUIRE_THAT(src, IsClass(_A("A<int,int,double,std::string>")));
REQUIRE_THAT(
src, IsClass(_A("B<int,std::string,int,double,A<int,int>>")));
REQUIRE_THAT(src, IsConcept(_A("same_as_first_type<T,Args...>")));
REQUIRE_THAT(src,
IsConstraint(_A("A<T,Args...>"),
_A("same_as_first_type<T,Args...>"), "T,Args..."));
REQUIRE_THAT(src,
IsConstraint(_A("B<T,P,Args...>"),
_A("same_as_first_type<T,Args...>"), "T,Args..."));
REQUIRE_THAT(src,
IsAggregation(_A("R"), _A("A<int,int,double,std::string>"),
"+aa")); REQUIRE_THAT(src, IsAggregation(_A("R"),
_A("B<int,std::string,int,double,A<int,int>>"), "+bb"));
REQUIRE_THAT(src,
IsInstantiation(
_A("A<T,Args...>"), _A("A<int,int,double,std::string>")));
REQUIRE_THAT(src,
IsInstantiation(_A("B<T,P,Args...>"),
_A("B<int,std::string,int,double,A<int,int>>")));
// TODO
// REQUIRE_THAT(src,
// IsDependency(_A("same_as_first_type<T,Args...>"),
// _A("first_type<T,Args...>")));
save_mermaid(config.output_directory(), diagram->name + ".mmd",
src);
}*/
}

154
tests/t00059/test_case.h
View File

@@ -20,15 +20,8 @@ TEST_CASE("t00059")
{
using namespace clanguml::test;
auto [config, db] = load_config("t00059");
auto diagram = config.diagrams["t00059_class"];
REQUIRE(diagram->name == "t00059_class");
auto model = generate_class_diagram(*db, diagram);
REQUIRE(model->name() == "t00059_class");
auto [config, db, diagram, model] =
CHECK_CLASS_MODEL("t00059", "t00059_class");
CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(IsConcept(src, "fruit_c<T>"));
@@ -39,7 +32,7 @@ TEST_CASE("t00059")
REQUIRE(IsConstraint(src, "orange_c<T>", "fruit_c<T>", "T", "up"));
REQUIRE(IsConceptRequirement(src, "apple_c<T>", "t.get_sweetness()"));
REQUIRE(IsConceptRequirement(src, "apple_c<T>", "t.get_bitterness()"));
REQUIRE(IsConceptRequirement(src, "orange_c<T>", "t.get_bitterness()"));
REQUIRE(IsClass(src, "gala_apple"));
REQUIRE(IsClass(src, "empire_apple"));
@@ -71,145 +64,4 @@ TEST_CASE("t00059")
REQUIRE(IsInstantiation(src, "fruit_factory<apple_c TA,orange_c TO>",
"fruit_factory<empire_apple,lima_orange>", "up"));
});
/*
{
auto src = generate_class_puml(diagram, *model);
AliasMatcher _A(src);
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
REQUIRE_THAT(src, IsConcept(_A("fruit_c<T>")));
REQUIRE_THAT(src, IsConcept(_A("apple_c<T>")));
REQUIRE_THAT(src, IsConcept(_A("orange_c<T>")));
REQUIRE_THAT(
src, IsConstraint(_A("apple_c<T>"), _A("fruit_c<T>"), "T",
"up")); REQUIRE_THAT( src, IsConstraint(_A("orange_c<T>"),
_A("fruit_c<T>"), "T", "up"));
REQUIRE_THAT(
src, IsConceptRequirement(_A("apple_c<T>"),
"t.get_sweetness()")); REQUIRE_THAT( src,
IsConceptRequirement(_A("apple_c<T>"), "t.get_bitterness()"));
REQUIRE_THAT(src, IsClass(_A("gala_apple")));
REQUIRE_THAT(src, IsClass(_A("empire_apple")));
REQUIRE_THAT(src, IsClass(_A("valencia_orange")));
REQUIRE_THAT(src, IsClass(_A("lima_orange")));
REQUIRE_THAT(src, IsClass(_A("R")));
REQUIRE_THAT(
src, IsClassTemplate("fruit_factory", "apple_c TA,orange_c
TO"));
REQUIRE_THAT(src,
IsDependency(_A("fruit_factory<gala_apple,valencia_orange>"),
_A("gala_apple"), "up"));
REQUIRE_THAT(src,
IsDependency(_A("fruit_factory<gala_apple,valencia_orange>"),
_A("valencia_orange"), "up"));
REQUIRE_THAT(src,
IsDependency(_A("fruit_factory<empire_apple,lima_orange>"),
_A("empire_apple"), "up"));
REQUIRE_THAT(src,
IsDependency(_A("fruit_factory<empire_apple,lima_orange>"),
_A("lima_orange"), "up"));
REQUIRE_THAT(src,
IsAggregation(_A("R"),
_A("fruit_factory<gala_apple,valencia_orange>"),
"+factory_1",
"", "", "up"));
REQUIRE_THAT(src,
IsAggregation(_A("R"),
_A("fruit_factory<empire_apple,lima_orange>"), "+factory_2",
"",
"", "up"));
REQUIRE_THAT(src,
IsInstantiation(_A("fruit_factory<apple_c TA,orange_c TO>"),
_A("fruit_factory<gala_apple,valencia_orange>"), "up"));
REQUIRE_THAT(src,
IsInstantiation(_A("fruit_factory<apple_c TA,orange_c TO>"),
_A("fruit_factory<empire_apple,lima_orange>"), "up"));
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
{
auto j = generate_class_json(diagram, *model);
using namespace json;
REQUIRE(IsConcept(j, "fruit_c<T>"));
REQUIRE(IsConcept(j, "apple_c<T>"));
REQUIRE(IsConcept(j, "orange_c<T>"));
save_json(config.output_directory(), diagram->name + ".json", j);
}
{
auto src = generate_class_mermaid(diagram, *model);
mermaid::AliasMatcher _A(src);
using mermaid::IsConcept;
using mermaid::IsConceptRequirement;
using mermaid::IsConstraint;
REQUIRE_THAT(src, IsConcept(_A("fruit_c<T>")));
REQUIRE_THAT(src, IsConcept(_A("apple_c<T>")));
REQUIRE_THAT(src, IsConcept(_A("orange_c<T>")));
REQUIRE_THAT(
src, IsConstraint(_A("apple_c<T>"), _A("fruit_c<T>"), "T"));
REQUIRE_THAT(
src, IsConstraint(_A("orange_c<T>"), _A("fruit_c<T>"), "T"));
REQUIRE_THAT(
src, IsConceptRequirement(_A("apple_c<T>"),
"t.get_sweetness()")); REQUIRE_THAT( src,
IsConceptRequirement(_A("apple_c<T>"), "t.get_bitterness()"));
REQUIRE_THAT(src, IsClass(_A("gala_apple")));
REQUIRE_THAT(src, IsClass(_A("empire_apple")));
REQUIRE_THAT(src, IsClass(_A("valencia_orange")));
REQUIRE_THAT(src, IsClass(_A("lima_orange")));
REQUIRE_THAT(src, IsClass(_A("R")));
REQUIRE_THAT(src, IsClass(_A("fruit_factory<apple_c TA,orange_c
TO>")));
REQUIRE_THAT(src,
IsDependency(_A("fruit_factory<gala_apple,valencia_orange>"),
_A("gala_apple")));
REQUIRE_THAT(src,
IsDependency(_A("fruit_factory<gala_apple,valencia_orange>"),
_A("valencia_orange")));
REQUIRE_THAT(src,
IsDependency(_A("fruit_factory<empire_apple,lima_orange>"),
_A("empire_apple")));
REQUIRE_THAT(src,
IsDependency(_A("fruit_factory<empire_apple,lima_orange>"),
_A("lima_orange")));
REQUIRE_THAT(src,
IsAggregation(_A("R"),
_A("fruit_factory<gala_apple,valencia_orange>"),
"+factory_1")); REQUIRE_THAT(src, IsAggregation(_A("R"),
_A("fruit_factory<empire_apple,lima_orange>"),
"+factory_2"));
REQUIRE_THAT(src,
IsInstantiation(_A("fruit_factory<apple_c TA,orange_c TO>"),
_A("fruit_factory<gala_apple,valencia_orange>")));
REQUIRE_THAT(src,
IsInstantiation(_A("fruit_factory<apple_c TA,orange_c TO>"),
_A("fruit_factory<empire_apple,lima_orange>")));
save_mermaid(config.output_directory(), diagram->name + ".mmd",
src);
}*/
}

68
tests/t00060/test_case.h
View File

@@ -20,15 +20,8 @@ TEST_CASE("t00060")
{
using namespace clanguml::test;
auto [config, db] = load_config("t00060");
auto diagram = config.diagrams["t00060_class"];
REQUIRE(diagram->name == "t00060_class");
auto model = generate_class_diagram(*db, diagram);
REQUIRE(model->name() == "t00060_class");
auto [config, db, diagram, model] =
CHECK_CLASS_MODEL("t00060", "t00060_class");
CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(IsClass(src, "A"));
@@ -41,61 +34,4 @@ TEST_CASE("t00060")
REQUIRE(IsClassTemplate(src, "G<T>"));
REQUIRE(IsClassTemplate(src, "H<T,P>"));
});
/*
{
auto src = generate_class_puml(diagram, *model);
AliasMatcher _A(src);
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
// Check if all classes exist
REQUIRE_THAT(src, IsClass(_A("A")));
REQUIRE_THAT(src, IsClass(_A("B")));
REQUIRE_THAT(src, IsClass(_A("C")));
REQUIRE_THAT(src, IsClass(_A("D")));
REQUIRE_THAT(src, !IsClass(_A("E")));
REQUIRE_THAT(src, !IsClass(_A("F")));
// Check if class templates exist
REQUIRE_THAT(src, IsClassTemplate("G", "T"));
REQUIRE_THAT(src, IsClassTemplate("H", "T,P"));
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"));
save_json(config.output_directory(), diagram->name + ".json", j);
}
{
auto src = generate_class_mermaid(diagram, *model);
mermaid::AliasMatcher _A(src);
// Check if all classes exist
REQUIRE_THAT(src, IsClass(_A("A")));
REQUIRE_THAT(src, IsClass(_A("B")));
REQUIRE_THAT(src, IsClass(_A("C")));
REQUIRE_THAT(src, IsClass(_A("D")));
REQUIRE_THAT(src, !IsClass(_A("E")));
REQUIRE_THAT(src, !IsClass(_A("F")));
// Check if class templates exist
REQUIRE_THAT(src, IsClass(_A("G<T>")));
REQUIRE_THAT(src, IsClass(_A("H<T,P>")));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}
*/
}

51
tests/t00061/test_case.h
View File

@@ -20,59 +20,12 @@ TEST_CASE("t00061")
{
using namespace clanguml::test;
auto [config, db] = load_config("t00061");
auto diagram = config.diagrams["t00061_class"];
REQUIRE(diagram->name == "t00061_class");
auto model = generate_class_diagram(*db, diagram);
REQUIRE(model->name() == "t00061_class");
auto [config, db, diagram, model] =
CHECK_CLASS_MODEL("t00061", "t00061_class");
CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(IsClass(src, "A"));
REQUIRE(!IsClass(src, "B"));
REQUIRE(!IsClass(src, "C"));
});
/*
{
auto src = generate_class_puml(diagram, *model);
AliasMatcher _A(src);
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
// Check if all classes exist
REQUIRE_THAT(src, IsClass(_A("A")));
REQUIRE_THAT(src, !IsClass(_A("B")));
REQUIRE_THAT(src, !IsClass(_A("C")));
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
{
auto j = generate_class_json(diagram, *model);
using namespace json;
REQUIRE(IsClass(j, "A"));
REQUIRE(!IsClass(j, "B"));
REQUIRE(!IsClass(j, "C"));
save_json(config.output_directory(), diagram->name + ".json", j);
}
{
auto src = generate_class_mermaid(diagram, *model);
mermaid::AliasMatcher _A(src);
// Check if all classes exist
REQUIRE_THAT(src, IsClass(_A("A")));
REQUIRE_THAT(src, !IsClass(_A("B")));
REQUIRE_THAT(src, !IsClass(_A("C")));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}
*/
}

141
tests/t00062/test_case.h
View File

@@ -20,15 +20,8 @@ TEST_CASE("t00062")
{
using namespace clanguml::test;
auto [config, db] = load_config("t00062");
auto diagram = config.diagrams["t00062_class"];
REQUIRE(diagram->name == "t00062_class");
auto model = generate_class_diagram(*db, diagram);
REQUIRE(model->name() == "t00062_class");
auto [config, db, diagram, model] =
CHECK_CLASS_MODEL("t00062", "t00062_class");
CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(!src.contains("type-parameter-"));
@@ -37,6 +30,7 @@ TEST_CASE("t00062")
REQUIRE(IsClassTemplate(src, "A<U &>"));
REQUIRE(IsClassTemplate(src, "A<U &&>"));
REQUIRE(IsClassTemplate(src, "A<U const&>"));
REQUIRE(IsClassTemplate(src, "A<U * *>"));
REQUIRE(IsClassTemplate(src, "A<M C::*>"));
REQUIRE(IsClassTemplate(src, "A<M C::* &&>"));
REQUIRE(IsClassTemplate(src, "A<M (C::*)(Arg)>"));
@@ -53,11 +47,9 @@ TEST_CASE("t00062")
REQUIRE(IsClassTemplate(src, "A<C<T,Args...>>"));
REQUIRE(IsField<Public>(src, "A<U &>", "u", "U &"));
REQUIRE(IsField<Public>(src, "A<U **>", "u", "U **"));
REQUIRE(IsField<Public>(src, "A<U ***>", "u", "U ***"));
REQUIRE(IsField<Public>(src, "A<U * * const*>", "u", "U ***"));
REQUIRE(IsField<Public>(src, "A<U &&>", "u", "U &&"));
REQUIRE(IsField<Public>(src, "A<const U &>", "u", "const U &"));
REQUIRE(IsField<Public>(src, "A<C &>", "c", "C &"));
REQUIRE(IsField<Public>(src, "A<U const&>", "u", "const U &"));
REQUIRE(IsField<Public>(src, "A<M C::*>", "m", "M C::*"));
REQUIRE(IsInstantiation(src, "A<T>", "A<U &>"));
@@ -77,127 +69,4 @@ TEST_CASE("t00062")
REQUIRE(IsInstantiation(src, "A<T>", "A<C<T>>"));
REQUIRE(IsInstantiation(src, "A<T>", "A<C<T,Args...>>"));
});
/*
{
auto src = generate_class_puml(diagram, *model);
AliasMatcher _A(src);
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
REQUIRE_THAT(src, !Contains("type-parameter-"));
// Check if all classes exist
REQUIRE_THAT(src, IsClassTemplate("A", "T"));
REQUIRE_THAT(src, IsClassTemplate("A", "U &"));
REQUIRE_THAT(src, IsClassTemplate("A", "U &&"));
REQUIRE_THAT(src, IsClassTemplate("A", "U const&"));
REQUIRE_THAT(src, IsClassTemplate("A", "M C::*"));
REQUIRE_THAT(src, IsClassTemplate("A", "M C::* &&"));
REQUIRE_THAT(src, IsClassTemplate("A", "M (C::*)(Arg)"));
REQUIRE_THAT(src, IsClassTemplate("A", "int (C::*)(bool)"));
REQUIRE_THAT(src, IsClassTemplate("A", "M (C::*)(Arg) &&"));
REQUIRE_THAT(src, IsClassTemplate("A", "M (C::*)(Arg1,Arg2,Arg3)"));
REQUIRE_THAT(src, IsClassTemplate("A", "float (C::*)(int) &&"));
REQUIRE_THAT(src, IsClassTemplate("A", "char[N]"));
REQUIRE_THAT(src, IsClassTemplate("A", "char[1000]"));
REQUIRE_THAT(src, IsClassTemplate("A", "U(...)"));
REQUIRE_THAT(src, IsClassTemplate("A", "C<T>"));
REQUIRE_THAT(src, IsClassTemplate("A", "C<T,Args...>"));
REQUIRE_THAT(src, (IsField<Public>("u", "U &")));
REQUIRE_THAT(src, (IsField<Public>("u", "U **")));
REQUIRE_THAT(src, (IsField<Public>("u", "U ***")));
REQUIRE_THAT(src, (IsField<Public>("u", "U &&")));
REQUIRE_THAT(src, (IsField<Public>("u", "const U &")));
REQUIRE_THAT(src, (IsField<Public>("c", "C &")));
REQUIRE_THAT(src, (IsField<Public>("m", "M C::*")));
REQUIRE_THAT(src, IsInstantiation(_A("A<T>"), _A("A<U &>")));
REQUIRE_THAT(src, IsInstantiation(_A("A<T>"), _A("A<U &&>")));
REQUIRE_THAT(src, IsInstantiation(_A("A<T>"), _A("A<M C::*>")));
REQUIRE_THAT(src, IsInstantiation(_A("A<U &&>"), _A("A<M C::* &&>")));
REQUIRE_THAT(src, IsInstantiation(_A("A<T>"), _A("A<M (C::*)(Arg)>")));
REQUIRE_THAT(src,
IsInstantiation(_A("A<M (C::*)(Arg)>"), _A("A<int (C::*)(bool)>")));
REQUIRE_THAT(src, IsInstantiation(_A("A<T>"), _A("A<char[N]>")));
REQUIRE_THAT(
src, IsInstantiation(_A("A<char[N]>"), _A("A<char[1000]>")));
REQUIRE_THAT(src, IsInstantiation(_A("A<T>"), _A("A<U(...)>")));
REQUIRE_THAT(src, IsInstantiation(_A("A<T>"), _A("A<U(...)>")));
REQUIRE_THAT(src, IsInstantiation(_A("A<T>"), _A("A<C<T>>")));
REQUIRE_THAT(src, IsInstantiation(_A("A<T>"), _A("A<C<T,Args...>>")));
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
{
auto j = generate_class_json(diagram, *model);
using namespace json;
save_json(config.output_directory(), diagram->name + ".json", j);
}
{
auto src = generate_class_mermaid(diagram, *model);
mermaid::AliasMatcher _A(src);
using mermaid::IsField;
REQUIRE_THAT(src, !Contains("type-parameter-"));
// Check if all classes exist
REQUIRE_THAT(src, IsClass(_A("A<T>")));
REQUIRE_THAT(src, IsClass(_A("A<U &>")));
REQUIRE_THAT(src, IsClass(_A("A<U &&>")));
REQUIRE_THAT(src, IsClass(_A("A<U const&>")));
REQUIRE_THAT(src, IsClass(_A("A<M C::*>")));
REQUIRE_THAT(src, IsClass(_A("A<M C::* &&>")));
REQUIRE_THAT(src, IsClass(_A("A<M (C::*)(Arg)>")));
REQUIRE_THAT(src, IsClass(_A("A<int (C::*)(bool)>")));
REQUIRE_THAT(src, IsClass(_A("A<M (C::*)(Arg) &&>")));
REQUIRE_THAT(src, IsClass(_A("A<M (C::*)(Arg1,Arg2,Arg3)>")));
REQUIRE_THAT(src, IsClass(_A("A<float (C::*)(int) &&>")));
REQUIRE_THAT(src, IsClass(_A("A<char[N]>")));
REQUIRE_THAT(src, IsClass(_A("A<char[1000]>")));
REQUIRE_THAT(src, IsClass(_A("A<U(...)>")));
REQUIRE_THAT(src, IsClass(_A("A<C<T>>")));
REQUIRE_THAT(src, IsClass(_A("A<C<T,Args...>>")));
REQUIRE_THAT(src, (IsField<Public>("u", "U &")));
REQUIRE_THAT(src, (IsField<Public>("u", "U **")));
REQUIRE_THAT(src, (IsField<Public>("u", "U ***")));
REQUIRE_THAT(src, (IsField<Public>("u", "U &&")));
REQUIRE_THAT(src, (IsField<Public>("u", "const U &")));
REQUIRE_THAT(src, (IsField<Public>("c", "C &")));
REQUIRE_THAT(src, (IsField<Public>("m", "M C::*")));
REQUIRE_THAT(src, IsInstantiation(_A("A<T>"), _A("A<U &>")));
REQUIRE_THAT(src, IsInstantiation(_A("A<T>"), _A("A<U &&>")));
REQUIRE_THAT(src, IsInstantiation(_A("A<T>"), _A("A<M C::*>")));
REQUIRE_THAT(src, IsInstantiation(_A("A<U &&>"), _A("A<M C::* &&>")));
REQUIRE_THAT(src, IsInstantiation(_A("A<T>"), _A("A<M (C::*)(Arg)>")));
REQUIRE_THAT(src,
IsInstantiation(_A("A<M (C::*)(Arg)>"), _A("A<int (C::*)(bool)>")));
REQUIRE_THAT(src, IsInstantiation(_A("A<T>"), _A("A<char[N]>")));
REQUIRE_THAT(
src, IsInstantiation(_A("A<char[N]>"), _A("A<char[1000]>")));
REQUIRE_THAT(src, IsInstantiation(_A("A<T>"), _A("A<U(...)>")));
REQUIRE_THAT(src, IsInstantiation(_A("A<T>"), _A("A<U(...)>")));
REQUIRE_THAT(src, IsInstantiation(_A("A<T>"), _A("A<C<T>>")));
REQUIRE_THAT(src, IsInstantiation(_A("A<T>"), _A("A<C<T,Args...>>")));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}*/
}

51
tests/t00063/test_case.h
View File

@@ -20,59 +20,12 @@ TEST_CASE("t00063")
{
using namespace clanguml::test;
auto [config, db] = load_config("t00063");
auto diagram = config.diagrams["t00063_class"];
REQUIRE(diagram->name == "t00063_class");
auto model = generate_class_diagram(*db, diagram);
REQUIRE(model->name() == "t00063_class");
auto [config, db, diagram, model] =
CHECK_CLASS_MODEL("t00063", "t00063_class");
CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(IsClass(src, "A"));
REQUIRE(!IsEnum(src, "B"));
REQUIRE(!IsEnum(src, "C"));
});
/*
{
auto src = generate_class_puml(diagram, *model);
AliasMatcher _A(src);
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
REQUIRE_THAT(src, IsClass(_A("A")));
REQUIRE_THAT(src, !IsEnum(_A("B")));
REQUIRE_THAT(src, !IsEnum(_A("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(!IsEnum(j, "B"));
REQUIRE(!IsEnum(j, "C"));
save_json(config.output_directory(), diagram->name + ".json", j);
}
{
auto src = generate_class_mermaid(diagram, *model);
mermaid::AliasMatcher _A(src);
using mermaid::IsEnum;
REQUIRE_THAT(src, IsClass(_A("A")));
REQUIRE_THAT(src, !IsEnum(_A("B")));
REQUIRE_THAT(src, !IsEnum(_A("C")));
save_mermaid(config.output_directory(), diagram->name + ".mmd",
src);
}
*/
}

142
tests/t00064/test_case.h
View File

@@ -20,15 +20,8 @@ TEST_CASE("t00064")
{
using namespace clanguml::test;
auto [config, db] = load_config("t00064");
auto diagram = config.diagrams["t00064_class"];
REQUIRE(diagram->name == "t00064_class");
auto model = generate_class_diagram(*db, diagram);
REQUIRE(model->name() == "t00064_class");
auto [config, db, diagram, model] =
CHECK_CLASS_MODEL("t00064", "t00064_class");
CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(!src.contains("type-parameter-"));
@@ -54,129 +47,24 @@ TEST_CASE("t00064")
REQUIRE(IsClassTemplate(src,
"type_group_pair_it<It,type_list<First...>,type_list<Second...>>"));
REQUIRE(IsMethod<Public>(src, "get", "ref_t", "unsigned int i"));
REQUIRE(IsMethod<Public>(src,
"type_group_pair_it<It,type_list<First...>,type_list<Second...>>",
"get", "ref_t", "unsigned int i"));
#if LLVM_VERSION_MAJOR < 16
REQUIRE(IsMethod<Public>(
src, "getp", "value_type const*", "unsigned int i"));
REQUIRE(IsMethod<Public, Constexpr>(
src, "find", "unsigned int", "value_type const& v"));
REQUIRE(IsMethod<Public>(src,
"type_group_pair_it<It,type_list<First...>,type_list<Second...>>",
"getp", "value_type const*", "unsigned int i"));
REQUIRE(IsMethod<Public, Constexpr>(src,
"type_group_pair_it<It,type_list<First...>,type_list<Second...>>",
"find", "unsigned int", "value_type const& v"));
#else
REQUIRE(
IsMethod<Public>(src, "getp", "const value_type *", "unsigned int i"));
IsMethod<Public>(src,
"type_group_pair_it<It,type_list<First...>,type_list<Second...>>",
"getp", "const value_type *", "unsigned int i"));
REQUIRE(
IsMethod<Public, Constexpr>(src,
IsMethod<Public, Constexpr>(src,"type_group_pair_it<It,type_list<First...>,type_list<Second...>>",
"find", "unsigned int", "const value_type & v"));
#endif
});
/*
{
auto src = generate_class_puml(diagram, *model);
AliasMatcher _A(src);
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
REQUIRE_THAT(src, !Contains("type-parameter-"));
REQUIRE_THAT(src, IsClass(_A("A")));
REQUIRE_THAT(src, IsClass(_A("B")));
REQUIRE_THAT(src, IsClass(_A("C")));
REQUIRE_THAT(src, IsClass(_A("R")));
REQUIRE_THAT(src, IsClassTemplate("type_list", "Ts..."));
REQUIRE_THAT(src, IsClassTemplate("type_list", "Ret(Arg &&),Ts..."));
REQUIRE_THAT(src, IsClassTemplate("type_list", "T const,Ts..."));
REQUIRE_THAT(src, IsClassTemplate("head", "typename"));
REQUIRE_THAT(src, IsClassTemplate("head", "type_list<Head,Tail...>"));
REQUIRE_THAT(
src, IsClassTemplate("type_group_pair", "typename,typename"));
REQUIRE_THAT(src,
IsClassTemplate(
"type_group_pair", "type_list<First...>,type_list<Second...>"));
REQUIRE_THAT(src,
IsClassTemplate(
"type_group_pair", "type_list<float,double>,type_list<A,B,C>"));
REQUIRE_THAT(src, IsClassTemplate("optional_ref", "T"));
REQUIRE_THAT(src,
IsClassTemplate("type_group_pair_it",
"It,type_list<First...>,type_list<Second...>"));
REQUIRE_THAT(src, (IsMethod<Public>("get", "ref_t", "unsigned int i")));
#if LLVM_VERSION_MAJOR < 16
REQUIRE_THAT(src,
(IsMethod<Public>("getp", "value_type const*", "unsigned int i")));
REQUIRE_THAT(src,
(IsMethod<Public, Constexpr>(
"find", "unsigned int", "value_type const& v")));
#else
REQUIRE_THAT(src,
(IsMethod<Public>("getp", "const value_type *", "unsigned int i")));
REQUIRE_THAT(src,
(IsMethod<Public, Constexpr>(
"find", "unsigned int", "const value_type & v")));
#endif
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
{
auto j = generate_class_json(diagram, *model);
using namespace json;
save_json(config.output_directory(), diagram->name + ".json", j);
}
{
auto src = generate_class_mermaid(diagram, *model);
mermaid::AliasMatcher _A(src);
using mermaid::IsMethod;
REQUIRE_THAT(src, !Contains("type-parameter-"));
REQUIRE_THAT(src, IsClass(_A("A")));
REQUIRE_THAT(src, IsClass(_A("B")));
REQUIRE_THAT(src, IsClass(_A("C")));
REQUIRE_THAT(src, IsClass(_A("R")));
REQUIRE_THAT(src, IsClass(_A("type_list<Ts...>")));
REQUIRE_THAT(src, IsClass(_A("type_list<Ret(Arg &&),Ts...>")));
REQUIRE_THAT(src, IsClass(_A("type_list<T const,Ts...>")));
REQUIRE_THAT(src, IsClass(_A("head<typename>")));
REQUIRE_THAT(src, IsClass(_A("head<type_list<Head,Tail...>>")));
REQUIRE_THAT(src, IsClass(_A("type_group_pair<typename,typename>")));
REQUIRE_THAT(src,
IsClass(_A(
"type_group_pair<type_list<First...>,type_list<Second...>>")));
REQUIRE_THAT(src,
IsClass(_A(
"type_group_pair<type_list<float,double>,type_list<A,B,C>>")));
REQUIRE_THAT(src, IsClass(_A("optional_ref<T>")));
REQUIRE_THAT(src,
IsClass(_A("type_group_pair_it<It,type_list<First...>,type_list<"
"Second...>>")));
REQUIRE_THAT(src, (IsMethod<Public>("get", "ref_t", "unsigned int i")));
#if LLVM_VERSION_MAJOR < 16
REQUIRE_THAT(src,
(IsMethod<Public>("getp", "value_type const*", "unsigned int i")));
REQUIRE_THAT(src,
(IsMethod<Public, Constexpr>(
"find", "unsigned int", "value_type const& v")));
#else
REQUIRE_THAT(src,
(IsMethod<Public>("getp", "const value_type *", "unsigned int i")));
REQUIRE_THAT(src,
(IsMethod<Public, Constexpr>(
"find", "unsigned int", "const value_type & v")));
#endif
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}
*/
}

66
tests/t00065/test_case.h
View File

@@ -19,16 +19,10 @@
TEST_CASE("t00065")
{
using namespace clanguml::test;
using namespace std::string_literals;
auto [config, db] = load_config("t00065");
auto diagram = config.diagrams["t00065_class"];
REQUIRE(diagram->name == "t00065_class");
auto model = generate_class_diagram(*db, diagram);
REQUIRE(model->name() == "t00065_class");
auto [config, db, diagram, model] =
CHECK_CLASS_MODEL("t00065", "t00065_class");
CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(IsClass(src, "R"));
@@ -37,55 +31,9 @@ TEST_CASE("t00065")
REQUIRE(IsEnum(src, "XYZ"));
REQUIRE(IsEnum(src, "ABC"));
REQUIRE(IsPackage("module1"));
REQUIRE(IsPackage("module2"));
REQUIRE(IsPackage("submodule1a"));
REQUIRE(IsPackage("concepts"));
REQUIRE(IsDirectoryPackage(src, "module1"s));
REQUIRE(IsDirectoryPackage(src, "module2"s));
REQUIRE(IsDirectoryPackage(src, "module1"s, "submodule1a"s));
REQUIRE(IsDirectoryPackage(src, "module2"s, "concepts"s));
});
/*
{
auto src = generate_class_puml(diagram, *model);
AliasMatcher _A(src);
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
// Check if all classes exist
REQUIRE_THAT(src, IsClass(_A("R")));
REQUIRE_THAT(src, IsClass(_A("A")));
REQUIRE_THAT(src, IsClass(_A("detail::AImpl")));
REQUIRE_THAT(src, IsEnum(_A("XYZ")));
REQUIRE_THAT(src, IsEnum(_A("ABC")));
REQUIRE_THAT(src, IsPackage("module1"));
REQUIRE_THAT(src, IsPackage("module2"));
REQUIRE_THAT(src, IsPackage("submodule1a"));
REQUIRE_THAT(src, IsPackage("concepts"));
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
{
auto j = generate_class_json(diagram, *model);
using namespace json;
save_json(config.output_directory(), diagram->name + ".json", j);
}
{
auto src = generate_class_mermaid(diagram, *model);
mermaid::AliasMatcher _A(src);
using mermaid::IsEnum;
// Check if all classes exist
REQUIRE_THAT(src, IsClass(_A("R")));
REQUIRE_THAT(src, IsClass(_A("A")));
REQUIRE_THAT(src, IsClass(_A("detail::AImpl")));
REQUIRE_THAT(src, IsEnum(_A("XYZ")));
REQUIRE_THAT(src, IsEnum(_A("ABC")));
save_mermaid(config.output_directory(), diagram->name + ".mmd",
src);
}*/
}

147
tests/t00066/test_case.h
View File

@@ -20,142 +20,39 @@ TEST_CASE("t00066")
{
using namespace clanguml::test;
auto [config, db] = load_config("t00066");
auto diagram = config.diagrams["t00066_class"];
REQUIRE(diagram->name == "t00066_class");
auto model = generate_class_diagram(*db, diagram);
REQUIRE(model->name() == "t00066_class");
auto [config, db, diagram, model] =
CHECK_CLASS_MODEL("t00066", "t00066_class");
CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(IsClass(src, "A"));
REQUIRE(!IsDependency(src, "A", "A"));
REQUIRE(IsMethod<Public, Default>(src,"A")));
REQUIRE(IsMethod<Public, Default>(src, "A", "void", "A &&"));
REQUIRE(IsMethod<Public, Deleted>(src, "A", "void", "const A &"));
REQUIRE(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(IsMethod<Public, Default>(src, "~A"));
REQUIRE(IsMethod<Public, Default>(src, "A", "~A"));
REQUIRE(IsMethod<Public>(src,"basic_method")));
REQUIRE(IsMethod<Public, Static>(src,"static_method", "int")));
REQUIRE(IsMethod<Public, Const>(src,"const_method")));
REQUIRE(IsMethod<Public>(src,"default_int", "int", "int i = 12")));
REQUIRE(IsMethod<Public>(src, "default_string", "std::string",
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(IsMethod<Public, Const>(src, "size", "std::size_t"));
REQUIRE(IsMethod<Public, Const>(src, "A", "size", "std::size_t"));
REQUIRE(IsMethod<Protected>(src, "protected_method"));
REQUIRE(IsMethod<Private>(src, "private_method"));
REQUIRE(IsField<Public>(src, "public_member", "int"));
REQUIRE(IsField<Protected>(src, "protected_member", "int"));
REQUIRE(IsField<Private>(src, "private_member", "int"));
REQUIRE(
(IsField<Public, Static>(src,"auto_member", "const unsigned long"));
REQUIRE(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(IsField<Private>(src,"a_", "int"));
REQUIRE(IsField<Private>(src,"b_", "int"));
REQUIRE(IsField<Private>(src,"c_", "int"));
REQUIRE(IsField<Private>(src, "A", "a_", "int"));
REQUIRE(IsField<Private>(src, "A", "b_", "int"));
REQUIRE(IsField<Private>(src, "A", "c_", "int"));
});
/*
{
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, !IsDependency(_A("A"), _A("A")));
REQUIRE_THAT(src, (IsMethod<Public, Default>("A")));
REQUIRE_THAT(src, (IsMethod<Public, Default>("A", "void", "A &&")));
REQUIRE_THAT(
src, (IsMethod<Public, Deleted>("A", "void", "const A &")));
REQUIRE_THAT(src, (IsMethod<Public, Default>("~A")));
REQUIRE_THAT(src, (IsMethod<Public>("basic_method")));
REQUIRE_THAT(src, (IsMethod<Public, Static>("static_method", "int")));
REQUIRE_THAT(src, (IsMethod<Public, Const>("const_method")));
REQUIRE_THAT(
src, (IsMethod<Public>("default_int", "int", "int i = 12")));
REQUIRE_THAT(src,
(IsMethod<Public>("default_string", "std::string",
"int i, std::string s = \"abc\"")));
REQUIRE_THAT(src, (IsMethod<Public, Const>("size", "std::size_t")));
REQUIRE_THAT(src, (IsMethod<Protected>("protected_method")));
REQUIRE_THAT(src, (IsMethod<Private>("private_method")));
REQUIRE_THAT(src, (IsField<Public>("public_member", "int")));
REQUIRE_THAT(src, (IsField<Protected>("protected_member", "int")));
REQUIRE_THAT(src, (IsField<Private>("private_member", "int")));
REQUIRE_THAT(src,
(IsField<Public, Static>("auto_member", "const unsigned long")));
REQUIRE_THAT(src, (IsField<Private>("a_", "int")));
REQUIRE_THAT(src, (IsField<Private>("b_", "int")));
REQUIRE_THAT(src, (IsField<Private>("c_", "int")));
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
{
auto j = generate_class_json(diagram, *model);
using namespace json;
save_json(config.output_directory(), diagram->name + ".json", j);
}
{
auto src = generate_class_mermaid(diagram, *model);
mermaid::AliasMatcher _A(src);
using mermaid::IsField;
using mermaid::IsMethod;
REQUIRE_THAT(src, IsClass(_A("A")));
REQUIRE_THAT(src, !IsDependency(_A("A"), _A("A")));
REQUIRE_THAT(src, (IsMethod<Public, Default>("A")));
REQUIRE_THAT(src, (IsMethod<Public, Default>("A", "void", "A &&")));
REQUIRE_THAT(
src, (IsMethod<Public, Deleted>("A", "void", "const A &")));
REQUIRE_THAT(src, (IsMethod<Public, Default>("~A")));
REQUIRE_THAT(src, (IsMethod<Public>("basic_method")));
REQUIRE_THAT(src, (IsMethod<Public, Static>("static_method", "int")));
REQUIRE_THAT(src, (IsMethod<Public, Const>("const_method")));
REQUIRE_THAT(
src, (IsMethod<Public>("default_int", "int", "int i = 12")));
REQUIRE_THAT(src,
(IsMethod<Public>("default_string", "std::string",
"int i, std::string s = \"abc\"")));
REQUIRE_THAT(src, (IsMethod<Public, Const>("size", "std::size_t")));
REQUIRE_THAT(src, (IsMethod<Protected>("protected_method")));
REQUIRE_THAT(src, (IsMethod<Private>("private_method")));
REQUIRE_THAT(src, (IsField<Public>("public_member", "int")));
REQUIRE_THAT(src, (IsField<Protected>("protected_member", "int")));
REQUIRE_THAT(src, (IsField<Private>("private_member", "int")));
REQUIRE_THAT(src,
(IsField<Public, Static>("auto_member", "const unsigned long")));
REQUIRE_THAT(src, (IsField<Private>("a_", "int")));
REQUIRE_THAT(src, (IsField<Private>("b_", "int")));
REQUIRE_THAT(src, (IsField<Private>("c_", "int")));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}*/
}

66
tests/t00067/test_case.h
View File

@@ -20,68 +20,16 @@ TEST_CASE("t00067")
{
using namespace clanguml::test;
auto [config, db] = load_config("t00067");
auto diagram = config.diagrams["t00067_class"];
REQUIRE(diagram->name == "t00067_class");
auto model = generate_class_diagram(*db, diagram);
REQUIRE(model->name() == "t00067_class");
auto [config, db, diagram, model] =
CHECK_CLASS_MODEL("t00067", "t00067_class");
CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(!(IsMethod<Public, Default>(src, "A")));
REQUIRE(!(IsMethod<Public, Default>(src, "A", "void", "A &&")));
REQUIRE(!(IsMethod<Public, Deleted>(src, "A", "void", "const A &")));
REQUIRE(!IsMethod<Public, Default>(src, "A", "A"));
REQUIRE(!IsMethod<Public, Default>(src, "A", "void", "A &&"));
REQUIRE(!IsMethod<Public, Deleted>(src, "A", "void", "const A &"));
REQUIRE(!(IsMethod<Public, Default>(src, "~A")));
REQUIRE(!IsMethod<Public, Default>(src, "A", "~A"));
REQUIRE(!(IsMethod<Public, Default>(src, "~A")));
REQUIRE(!IsMethod<Public, Default>(src, "A", "~A"));
});
/*
{
auto src = generate_class_puml(diagram, *model);
AliasMatcher _A(src);
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
REQUIRE_THAT(src, !(IsMethod<Public, Default>("A")));
REQUIRE_THAT(src, !(IsMethod<Public, Default>("A", "void", "A &&")));
REQUIRE_THAT(
src, !(IsMethod<Public, Deleted>("A", "void", "const A &")));
REQUIRE_THAT(src, !(IsMethod<Public, Default>("~A")));
REQUIRE_THAT(src, !(IsMethod<Public, Default>("~A")));
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
{
auto j = generate_class_json(diagram, *model);
using namespace json;
save_json(config.output_directory(), diagram->name + ".json", j);
}
{
auto src = generate_class_mermaid(diagram, *model);
mermaid::AliasMatcher _A(src);
using mermaid::IsMethod;
REQUIRE_THAT(src, !(IsMethod<Public, Default>("A")));
REQUIRE_THAT(src, !(IsMethod<Public, Default>("A", "void", "A &&")));
REQUIRE_THAT(
src, !(IsMethod<Public, Deleted>("A", "void", "const A &")));
REQUIRE_THAT(src, !(IsMethod<Public, Default>("~A")));
REQUIRE_THAT(src, !(IsMethod<Public, Default>("~A")));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}*/
}

26
tests/t00068/test_case.h
View File

@@ -20,13 +20,8 @@ TEST_CASE("t00068_r0")
{
using namespace clanguml::test;
auto [config, db] = load_config("t00068");
auto diagram = config.diagrams["t00068_r0_class"];
auto model = generate_class_diagram(*db, diagram);
REQUIRE(model->name() == "t00068_r0_class");
auto [config, db, diagram, model] =
CHECK_CLASS_MODEL("t00068", "t00068_r0_class");
CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(!IsClass(src, "A"));
@@ -47,13 +42,9 @@ TEST_CASE("t00068_r1")
{
using namespace clanguml::test;
auto [config, db] = load_config("t00068");
auto [config, db, diagram, model] =
CHECK_CLASS_MODEL("t00068", "t00068_r1_class");
auto diagram = config.diagrams["t00068_r1_class"];
auto model = generate_class_diagram(*db, diagram);
REQUIRE(model->name() == "t00068_r1_class");
CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(!IsClass(src, "A"));
REQUIRE(IsClass(src, "AA"));
@@ -73,13 +64,8 @@ TEST_CASE("t00068_r2")
{
using namespace clanguml::test;
auto [config, db] = load_config("t00068");
auto diagram = config.diagrams["t00068_r2_class"];
auto model = generate_class_diagram(*db, diagram);
REQUIRE(model->name() == "t00068_r2_class");
auto [config, db, diagram, model] =
CHECK_CLASS_MODEL("t00068", "t00068_r2_class");
CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(IsClass(src, "A"));

89
tests/t00069/test_case.h
View File

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

62
tests/t00070/test_case.h
View File

@@ -20,15 +20,8 @@ TEST_CASE("t00070")
{
using namespace clanguml::test;
auto [config, db] = load_config("t00070");
auto diagram = config.diagrams["t00070_class"];
REQUIRE(diagram->name == "t00070_class");
auto model = generate_class_diagram(*db, diagram);
REQUIRE(model->name() == "t00070_class");
auto [config, db, diagram, model] =
CHECK_CLASS_MODEL("t00070", "t00070_class");
CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(IsClass(src, "A"));
@@ -42,55 +35,4 @@ TEST_CASE("t00070")
REQUIRE(!IsClass(src, "BBBB"));
REQUIRE(!IsEnum(src, "CCC"));
});
/*
{
auto src = generate_class_puml(diagram, *model);
AliasMatcher _A(src);
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
{
auto j = generate_class_json(diagram, *model);
using namespace json;
REQUIRE(IsClass(j, "A"));
REQUIRE(IsClass(j, "B"));
REQUIRE(!IsClass(j, "C"));
REQUIRE(InPublicModule(j, "A", "t00070"));
REQUIRE(InPublicModule(j, "B", "t00070.lib1"));
REQUIRE(!IsClass(j, "BBBB"));
save_json(config.output_directory(), diagram->name + ".json", j);
}
{
auto src = generate_class_mermaid(diagram, *model);
mermaid::AliasMatcher _A(src);
using mermaid::IsClass;
using mermaid::IsEnum;
REQUIRE_THAT(src, IsClass(_A("A")));
REQUIRE_THAT(src, IsClass(_A("B")));
REQUIRE_THAT(src, !IsClass(_A("C")));
REQUIRE_THAT(src, IsClass(_A("BB<T>")));
REQUIRE_THAT(src, !IsClass(_A("CC<T>")));
REQUIRE_THAT(src, IsEnum(_A("BBB")));
REQUIRE_THAT(src, !IsClass(_A("BBBB")));
REQUIRE_THAT(src, !IsEnum(_A("CCC")));
save_mermaid(config.output_directory(), diagram->name + ".mmd",
src);
}*/
}

59
tests/t00071/test_case.h
View File

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

97
tests/t00072/test_case.h
View File

@@ -19,23 +19,17 @@
TEST_CASE("t00072")
{
using namespace clanguml::test;
using namespace std::string_literals;
auto [config, db] = load_config("t00072");
auto diagram = config.diagrams["t00072_class"];
REQUIRE(diagram->name == "t00072_class");
auto model = generate_class_diagram(*db, diagram);
REQUIRE(model->name() == "t00072_class");
auto [config, db, diagram, model] =
CHECK_CLASS_MODEL("t00072", "t00072_class");
CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(IsPackage(src, "app"));
REQUIRE(IsPackage(src, ":lib1"));
REQUIRE(IsPackage(src, ":lib2"));
REQUIRE(IsPackage(src, "mod1"));
REQUIRE(IsPackage(src, "mod2"));
REQUIRE(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));
REQUIRE(IsClass(src, "A"));
REQUIRE(IsClass(src, "C"));
@@ -49,79 +43,4 @@ TEST_CASE("t00072")
REQUIRE(IsClass(src, "D"));
REQUIRE(IsClass(src, "E"));
});
/*
{
auto src = generate_class_puml(diagram, *model);
AliasMatcher _A(src);
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
// Check if all classes exist
REQUIRE_THAT(src, IsPackage("app"));
REQUIRE_THAT(src, IsPackage(":lib1"));
REQUIRE_THAT(src, IsPackage(":lib2"));
REQUIRE_THAT(src, IsPackage("mod1"));
REQUIRE_THAT(src, IsPackage("mod2"));
REQUIRE_THAT(src, IsClass(_A("A")));
REQUIRE_THAT(src, IsClass(_A("C")));
REQUIRE_THAT(src, IsClassTemplate("CC", "T"));
REQUIRE_THAT(src, IsEnum(_A("detail::CCC")));
REQUIRE_THAT(src, IsClass(_A("B")));
REQUIRE_THAT(src, IsClassTemplate("BB", "T"));
REQUIRE_THAT(src, IsEnum(_A("detail::BBB")));
REQUIRE_THAT(src, IsClass(_A("D")));
REQUIRE_THAT(src, IsClass(_A("E")));
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
{
auto j = generate_class_json(diagram, *model);
using namespace json;
using namespace std::string_literals;
REQUIRE(IsClass(j, "A"));
REQUIRE(IsClass(j, "B"));
REQUIRE(IsClass(j, "C"));
REQUIRE(IsClass(j, "D"));
REQUIRE(IsEnum(j, "detail::CCC"));
REQUIRE(IsEnum(j, "detail::BBB"));
REQUIRE(IsModulePackage(j, "app"s));
REQUIRE(IsModulePackage(j, "app"s, ":lib1"s));
REQUIRE(IsModulePackage(j, "app"s, ":lib1"s, "mod1"s));
REQUIRE(IsModulePackage(j, "app"s, ":lib1"s, "mod2"s));
REQUIRE(IsModulePackage(j, "app"s, ":lib2"s));
save_json(config.output_directory(), diagram->name + ".json", j);
}
{
auto src = generate_class_mermaid(diagram, *model);
mermaid::AliasMatcher _A(src);
using mermaid::IsClass;
using mermaid::IsEnum;
REQUIRE_THAT(src, IsClass(_A("A")));
REQUIRE_THAT(src, IsClass(_A("C")));
REQUIRE_THAT(src, IsClass(_A("CC<T>")));
REQUIRE_THAT(src, IsEnum(_A("detail::CCC")));
REQUIRE_THAT(src, IsClass(_A("B")));
REQUIRE_THAT(src, IsClass(_A("BB<T>")));
REQUIRE_THAT(src, IsEnum(_A("detail::BBB")));
REQUIRE_THAT(src, IsClass(_A("D")));
REQUIRE_THAT(src, IsClass(_A("E")));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}
*/
}

76
tests/t00073/test_case.h
View File

@@ -20,15 +20,8 @@ TEST_CASE("t00073")
{
using namespace clanguml::test;
auto [config, db] = load_config("t00073");
auto diagram = config.diagrams["t00073_class"];
REQUIRE(diagram->name == "t00073_class");
auto model = generate_class_diagram(*db, diagram);
REQUIRE(model->name() == "t00073_class");
auto [config, db, diagram, model] =
CHECK_CLASS_MODEL("t00073", "t00073_class");
CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(IsClass(src, "A"));
@@ -45,69 +38,4 @@ TEST_CASE("t00073")
REQUIRE(IsAggregation<Public>(
src, "R", "Overload<AHandler,BHandler>", "dispatch"));
});
/*
{
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("AHandler")));
REQUIRE_THAT(src, IsClass(_A("BHandler")));
REQUIRE_THAT(src, IsClassTemplate("Overload", "Bases..."));
REQUIRE_THAT(src, IsClassTemplate("Overload", "AHandler,BHandler"));
REQUIRE_THAT(src, IsDependency(_A("AHandler"), _A("A")));
REQUIRE_THAT(src, IsDependency(_A("BHandler"), _A("B")));
REQUIRE_THAT(src,
IsInstantiation(
_A("Overload<Bases...>"),
_A("Overload<AHandler,BHandler>"))); REQUIRE_THAT(src, IsAggregation(
_A("R"), _A("Overload<AHandler,BHandler>"), "+dispatch"));
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
{
auto j = generate_class_json(diagram, *model);
using namespace json;
REQUIRE(IsClassTemplate(j, "Overload<Bases...>"));
REQUIRE(IsClass(j, "A"));
REQUIRE(IsClass(j, "B"));
REQUIRE(IsClass(j, "AHandler"));
REQUIRE(IsClass(j, "BHandler"));
REQUIRE(IsClass(j, "Overload<AHandler,BHandler>"));
save_json(config.output_directory(), diagram->name + ".json", j);
}
{
auto src = generate_class_mermaid(diagram, *model);
mermaid::AliasMatcher _A(src);
using mermaid::IsClass;
REQUIRE_THAT(src, IsClass(_A("A")));
REQUIRE_THAT(src, IsClass(_A("B")));
REQUIRE_THAT(src, IsClass(_A("AHandler")));
REQUIRE_THAT(src, IsClass(_A("BHandler")));
REQUIRE_THAT(src, IsClass(_A("Overload<Bases...>")));
REQUIRE_THAT(src, IsClass(_A("Overload<AHandler,BHandler>")));
REQUIRE_THAT(src, IsDependency(_A("AHandler"), _A("A")));
REQUIRE_THAT(src, IsDependency(_A("BHandler"), _A("B")));
REQUIRE_THAT(src,
IsInstantiation(
_A("Overload<Bases...>"),
_A("Overload<AHandler,BHandler>"))); REQUIRE_THAT(src, IsAggregation(
_A("R"), _A("Overload<AHandler,BHandler>"), "+dispatch"));
save_mermaid(config.output_directory(), diagram->name + ".mmd",
src);
}*/
}

90
tests/t00074/test_case.h
View File

@@ -20,87 +20,29 @@ TEST_CASE("t00074")
{
using namespace clanguml::test;
auto [config, db] = load_config("t00074");
auto [config, db, diagram, model] =
CHECK_CLASS_MODEL("t00074", "t00074_class");
auto diagram = config.diagrams["t00074_class"];
REQUIRE(diagram->name == "t00074_class");
auto model = generate_class_diagram(*db, diagram);
REQUIRE(model->name() == "t00074_class");
CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
CHECK_CLASS_DIAGRAM(
config, diagram, *model,
[](const auto &src) {
REQUIRE(IsConcept(src, "fruit_c<T>"));
REQUIRE(IsConcept(src, "apple_c<T>"));
REQUIRE(IsConcept(src, "orange_c<T>"));
REQUIRE(IsConstraint(src, "apple_c<T>", "fruit_c<T>", "T"));
REQUIRE(IsConstraint(src, "orange_c<T>", "fruit_c<T>", "T"));
REQUIRE(!IsConceptRequirement(src, "apple_c<T>", "t.get_sweetness()"));
},
[](const plantuml_t &src) {
REQUIRE(
!IsConceptRequirement(src, "orange_c<T>", "t.get_bitterness()"));
!IsConceptRequirement(src, "apple_c<T>", "t.get_sweetness()"));
REQUIRE(!IsConceptRequirement(
src, "orange_c<T>", "t.get_bitterness()"));
},
[](const mermaid_t &src) {
REQUIRE(
!IsConceptRequirement(src, "apple_c<T>", "t.get_sweetness()"));
REQUIRE(!IsConceptRequirement(
src, "orange_c<T>", "t.get_bitterness()"));
});
/*
{
auto src = generate_class_puml(diagram, *model);
AliasMatcher _A(src);
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
REQUIRE_THAT(src, IsConcept(_A("fruit_c<T>")));
REQUIRE_THAT(src, IsConcept(_A("apple_c<T>")));
REQUIRE_THAT(src, IsConcept(_A("orange_c<T>")));
REQUIRE_THAT(
src, IsConstraint(_A("apple_c<T>"), _A("fruit_c<T>"), "T"));
REQUIRE_THAT(
src, IsConstraint(_A("orange_c<T>"), _A("fruit_c<T>"), "T"));
REQUIRE_THAT(
src, !IsConceptRequirement(_A("apple_c<T>"), "t.get_sweetness()"));
REQUIRE_THAT(src,
!IsConceptRequirement(_A("orange_c<T>"), "t.get_bitterness()"));
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
{
auto j = generate_class_json(diagram, *model);
using namespace json;
REQUIRE(IsConcept(j, "fruit_c<T>"));
REQUIRE(IsConcept(j, "apple_c<T>"));
REQUIRE(IsConcept(j, "orange_c<T>"));
save_json(config.output_directory(), diagram->name + ".json", j);
}
{
auto src = generate_class_mermaid(diagram, *model);
mermaid::AliasMatcher _A(src);
using mermaid::IsConcept;
using mermaid::IsConceptRequirement;
using mermaid::IsConstraint;
REQUIRE_THAT(src, IsConcept(_A("fruit_c<T>")));
REQUIRE_THAT(src, IsConcept(_A("apple_c<T>")));
REQUIRE_THAT(src, IsConcept(_A("orange_c<T>")));
REQUIRE_THAT(
src, IsConstraint(_A("apple_c<T>"), _A("fruit_c<T>"), "T"));
REQUIRE_THAT(
src, IsConstraint(_A("orange_c<T>"), _A("fruit_c<T>"), "T"));
REQUIRE_THAT(
src, !IsConceptRequirement(_A("apple_c<T>"), "t.get_sweetness()"));
REQUIRE_THAT(
src, !IsConceptRequirement(_A("apple_c<T>"), "t.get_bitterness()"));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}*/
}

93
tests/t00075/test_case.h
View File

@@ -20,94 +20,25 @@ TEST_CASE("t00075")
{
using namespace clanguml::test;
auto [config, db] = load_config("t00075");
auto diagram = config.diagrams["t00075_class"];
REQUIRE(diagram->name == "t00075_class");
auto model = generate_class_diagram(*db, diagram);
REQUIRE(model->name() == "t00075_class");
auto [config, db, diagram, model] =
CHECK_CLASS_MODEL("t00075", "t00075_class");
CHECK_CLASS_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(IsClass(src, "A"));
REQUIRE(IsClass(src, "B"));
REQUIRE(IsClassTemplate(src, "ABE<ns1::ns2::C T>"));
REQUIRE(IsClass(src, "R"));
REQUIRE(IsClass(src, {"ns1::ns2", "A"}));
REQUIRE(IsClass(src, {"ns1::ns2", "B"}));
REQUIRE(IsClass(src, {"ns1::ns2", "ABE<ns1::ns2::C T>"}));
REQUIRE(IsClass(src, {"ns1::ns2", "R"}));
REQUIRE(IsEnum(src, "E"));
REQUIRE(IsEnum(src, {"ns1::ns2", "E"}));
REQUIRE(IsConcept(src, "C<T>"));
REQUIRE(IsConcept(src, {"ns1::ns2", "C<T>"}));
REQUIRE(IsConceptRequirement(src, "C<T>", "T{}"));
REQUIRE(IsConceptRequirement(src, "C<T>", "t.e()"));
REQUIRE(IsConceptRequirement(src, "C<T>", "(T t)"));
REQUIRE(!IsConceptRequirement(src, "C<T>", "(T ns1::ns2::t)"));
REQUIRE(IsConceptParameterList(src, "C<T>", "(T t)"));
REQUIRE(!IsConceptParameterList(src, "C<T>", "(T ns1::ns2::t)"));
REQUIRE(IsConstraint(src, "ABE<ns1::ns2::C T>", "C<T>", "T",
"up[#green,dashed,thickness=2]"));
REQUIRE(IsConstraint(src, {"ns1::ns2", "ABE<ns1::ns2::C T>"},
{"ns1::ns2", "C<T>"}, "T", "up[#green,dashed,thickness=2]"));
});
{
auto src = generate_class_puml(diagram, *model);
AliasMatcher _A(src);
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
// Check if all classes exist
REQUIRE_THAT(src, IsClass(_A("A")));
REQUIRE_THAT(src, IsClass(_A("B")));
REQUIRE_THAT(src, IsClass(_A("ABE<ns1::ns2::C T>")));
REQUIRE_THAT(src, IsClass(_A("R")));
REQUIRE_THAT(src, IsEnum(_A("E")));
REQUIRE_THAT(src, IsConcept(_A("C<T>")));
REQUIRE_THAT(src, IsConceptRequirement(_A("C<T>"), "T{}"));
REQUIRE_THAT(src, IsConceptRequirement(_A("C<T>"), "t.e()"));
REQUIRE_THAT(src, IsConceptRequirement(_A("C<T>"), "(T t)"));
REQUIRE_THAT(src, !IsConceptRequirement(_A("C<T>"), "(T ns1::ns2::t)"));
REQUIRE_THAT(src,
IsConstraint(_A("ABE<ns1::ns2::C T>"), _A("C<T>"), "T",
"up[#green,dashed,thickness=2]"));
save_puml(config.output_directory(), diagram->name + ".puml", src);
}
{
auto j = generate_class_json(diagram, *model);
using namespace json;
save_json(config.output_directory(), diagram->name + ".json", j);
}
{
auto src = generate_class_mermaid(diagram, *model);
mermaid::AliasMatcher _A(src);
using mermaid::IsClass;
using mermaid::IsConcept;
using mermaid::IsConceptRequirement;
using mermaid::IsEnum;
// Check if all classes exist
REQUIRE_THAT(src, IsClass(_A("ns1::ns2::A")));
REQUIRE_THAT(src, IsClass(_A("ns1::ns2::B")));
REQUIRE_THAT(src, IsClass(_A("ns1::ns2::ABE<ns1::ns2::C T>")));
REQUIRE_THAT(src, IsClass(_A("ns1::ns2::R")));
REQUIRE_THAT(src, IsEnum(_A("ns1::ns2::E")));
REQUIRE_THAT(src, IsConcept(_A("ns1::ns2::C<T>")));
REQUIRE_THAT(src, IsConceptRequirement(_A("ns1::ns2::C<T>"), "T{}"));
REQUIRE_THAT(src, IsConceptRequirement(_A("ns1::ns2::C<T>"), "t.e()"));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}
}

11
tests/t30001/test_case.h
View File

@@ -21,15 +21,8 @@ TEST_CASE("t30001")
using namespace clanguml::test;
using namespace std::string_literals;
auto [config, db] = load_config("t30001");
auto diagram = config.diagrams["t30001_package"];
REQUIRE(diagram->name == "t30001_package");
auto model = generate_package_diagram(*db, diagram);
REQUIRE(model->name() == "t30001_package");
auto [config, db, diagram, model] =
CHECK_PACKAGE_MODEL("t30001", "t30001_package");
CHECK_PACKAGE_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(HasTitle(src, "Basic package diagram example"));

156
tests/t30002/test_case.h
View File

@@ -21,15 +21,8 @@ TEST_CASE("t30002")
using namespace clanguml::test;
using namespace std::string_literals;
auto [config, db] = load_config("t30002");
auto diagram = config.diagrams["t30002_package"];
REQUIRE(diagram->name == "t30002_package");
auto model = generate_package_diagram(*db, diagram);
REQUIRE(model->name() == "t30002_package");
auto [config, db, diagram, model] =
CHECK_PACKAGE_MODEL("t30002", "t30002_package");
CHECK_PACKAGE_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(IsNamespacePackage(src, "A"s, "AA"s));
@@ -73,149 +66,4 @@ TEST_CASE("t30002")
REQUIRE(IsDependency(src, "BBB", "A17"));
REQUIRE(IsDependency(src, "BBB", "A18"));
});
/*
{
auto src = generate_package_puml(diagram, *model);
AliasMatcher _A(src);
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
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_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")));
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, "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));
REQUIRE(IsNamespacePackage(j, "B"s, "BB"s, "BBB"s));
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"));
save_json(config.output_directory(), diagram->name + ".json", j);
}
{
auto src = generate_package_mermaid(diagram, *model);
mermaid::AliasMatcher _A(src);
using mermaid::IsPackage;
using mermaid::IsPackageDependency;
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);
}
*/
}

15
tests/t30003/test_case.h
View File

@@ -21,15 +21,8 @@ TEST_CASE("t30003")
using namespace clanguml::test;
using namespace std::string_literals;
auto [config, db] = load_config("t30003");
auto diagram = config.diagrams["t30003_package"];
REQUIRE(diagram->name == "t30003_package");
auto model = generate_package_diagram(*db, diagram);
REQUIRE(model->name() == "t30003_package");
auto [config, db, diagram, model] =
CHECK_PACKAGE_MODEL("t30003", "t30003_package");
CHECK_PACKAGE_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(IsNamespacePackage(src, "ns1"s));
@@ -39,7 +32,7 @@ TEST_CASE("t30003")
REQUIRE(IsNamespacePackage(src, "ns3"s, "ns1"s));
REQUIRE(IsNamespacePackage(src, "ns3"s, "ns1"s, "ns2"s));
// REQUIRE(IsDeprecated(src, "ns2_v0_9_0"));
// REQUIRE(IsDeprecated(src, "ns3"));
REQUIRE(IsDeprecated(src, "ns2_v0_9_0"));
REQUIRE(IsDeprecated(src, "ns3"));
});
}

56
tests/t30004/test_case.h
View File

@@ -21,15 +21,8 @@ TEST_CASE("t30004")
using namespace clanguml::test;
using namespace std::string_literals;
auto [config, db] = load_config("t30004");
auto diagram = config.diagrams["t30004_package"];
REQUIRE(diagram->name == "t30004_package");
auto model = generate_package_diagram(*db, diagram);
REQUIRE(model->name() == "t30004_package");
auto [config, db, diagram, model] =
CHECK_PACKAGE_MODEL("t30004", "t30004_package");
CHECK_PACKAGE_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(IsNamespacePackage(src, "A"s));
@@ -39,49 +32,4 @@ TEST_CASE("t30004")
REQUIRE(!IsNamespacePackage(src, "A"s, "DDD"s));
REQUIRE(IsNamespacePackage(src, "A"s, "EEE"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, IsPackage("AAA"));
REQUIRE_THAT(src, IsPackage("BBB"));
REQUIRE_THAT(src, IsPackage("CCC"));
REQUIRE_THAT(src, !IsPackage("DDD"));
REQUIRE_THAT(src, IsPackage("EEE"));
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, "A"s));
REQUIRE(IsNamespacePackage(j, "A"s, "AAA"s));
REQUIRE(IsNamespacePackage(j, "A"s, "BBB"s));
REQUIRE(IsNamespacePackage(j, "A"s, "CCC"s));
REQUIRE(!IsNamespacePackage(j, "A"s, "DDD"s));
REQUIRE(IsNamespacePackage(j, "A"s, "EEE"s));
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("AAA")));
REQUIRE_THAT(src, IsPackage(_A("BBB")));
REQUIRE_THAT(src, IsPackage(_A("CCC")));
REQUIRE_THAT(src, !IsPackage(_A("DDD")));
REQUIRE_THAT(src, IsPackage(_A("EEE")));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}*/
}

67
tests/t30005/test_case.h
View File

@@ -21,15 +21,8 @@ TEST_CASE("t30005")
using namespace clanguml::test;
using namespace std::string_literals;
auto [config, db] = load_config("t30005");
auto diagram = config.diagrams["t30005_package"];
REQUIRE(diagram->name == "t30005_package");
auto model = generate_package_diagram(*db, diagram);
REQUIRE(model->name() == "t30005_package");
auto [config, db, diagram, model] =
CHECK_PACKAGE_MODEL("t30005", "t30005_package");
CHECK_PACKAGE_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(IsNamespacePackage(src, "A"s));
@@ -45,60 +38,4 @@ TEST_CASE("t30005")
REQUIRE(IsDependency(src, "BBB", "AAA"));
REQUIRE(IsDependency(src, "CCC", "AAA"));
});
/*
{
auto src = generate_package_puml(diagram, *model);
AliasMatcher _A(src);
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
REQUIRE_THAT(src, IsPackage("AAA"));
REQUIRE_THAT(src, IsPackage("BBB"));
REQUIRE_THAT(src, IsPackage("CCC"));
REQUIRE_THAT(src, IsDependency(_A("BBB"), _A("AAA")));
REQUIRE_THAT(src, IsDependency(_A("CCC"), _A("AAA")));
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, "A"s));
REQUIRE(IsNamespacePackage(j, "A"s, "AA"s));
REQUIRE(IsNamespacePackage(j, "A"s, "AA"s, "AAA"s));
REQUIRE(IsNamespacePackage(j, "B"s));
REQUIRE(IsNamespacePackage(j, "B"s, "BB"s));
REQUIRE(IsNamespacePackage(j, "B"s, "BB"s, "BBB"s));
REQUIRE(IsNamespacePackage(j, "C"s));
REQUIRE(IsNamespacePackage(j, "C"s, "CC"s));
REQUIRE(IsNamespacePackage(j, "C"s, "CC"s, "CCC"s));
REQUIRE(IsDependency(j, "BBB", "AAA"));
REQUIRE(IsDependency(j, "CCC", "AAA"));
save_json(config.output_directory(), diagram->name + ".json", j);
}
{
auto src = generate_package_mermaid(diagram, *model);
mermaid::AliasMatcher _A(src);
using mermaid::IsPackage;
using mermaid::IsPackageDependency;
REQUIRE_THAT(src, IsPackage(_A("AAA")));
REQUIRE_THAT(src, IsPackage(_A("BBB")));
REQUIRE_THAT(src, IsPackage(_A("CCC")));
REQUIRE_THAT(src, IsPackageDependency(_A("BBB"), _A("AAA")));
REQUIRE_THAT(src, IsPackageDependency(_A("CCC"), _A("AAA")));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}*/
}

61
tests/t30006/test_case.h
View File

@@ -21,15 +21,8 @@ TEST_CASE("t30006")
using namespace clanguml::test;
using namespace std::string_literals;
auto [config, db] = load_config("t30006");
auto diagram = config.diagrams["t30006_package"];
REQUIRE(diagram->name == "t30006_package");
auto model = generate_package_diagram(*db, diagram);
REQUIRE(model->name() == "t30006_package");
auto [config, db, diagram, model] =
CHECK_PACKAGE_MODEL("t30006", "t30006_package");
CHECK_PACKAGE_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(IsNamespacePackage(src, "A"s));
@@ -39,54 +32,4 @@ TEST_CASE("t30006")
REQUIRE(IsDependency(src, "A", "B"));
REQUIRE(IsDependency(src, "A", "C"));
});
/*
{
auto src = generate_package_puml(diagram, *model);
AliasMatcher _A(src);
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
REQUIRE_THAT(src, IsPackage("A"));
REQUIRE_THAT(src, IsPackage("B"));
REQUIRE_THAT(src, IsPackage("C"));
REQUIRE_THAT(src, IsDependency(_A("A"), _A("B")));
REQUIRE_THAT(src, IsDependency(_A("A"), _A("C")));
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, "A"s));
REQUIRE(IsNamespacePackage(j, "B"s));
REQUIRE(IsNamespacePackage(j, "C"s));
REQUIRE(IsDependency(j, "A", "B"));
REQUIRE(IsDependency(j, "A", "C"));
save_json(config.output_directory(), diagram->name + ".json", j);
}
{
auto src = generate_package_mermaid(diagram, *model);
mermaid::AliasMatcher _A(src);
using mermaid::IsPackage;
using mermaid::IsPackageDependency;
REQUIRE_THAT(src, IsPackage(_A("A")));
REQUIRE_THAT(src, IsPackage(_A("B")));
REQUIRE_THAT(src, IsPackage(_A("C")));
REQUIRE_THAT(src, IsPackageDependency(_A("A"), _A("B")));
REQUIRE_THAT(src, IsPackageDependency(_A("A"), _A("C")));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}*/
}

69
tests/t30007/test_case.h
View File

@@ -21,15 +21,8 @@ TEST_CASE("t30007")
using namespace clanguml::test;
using namespace std::string_literals;
auto [config, db] = load_config("t30007");
auto diagram = config.diagrams["t30007_package"];
REQUIRE(diagram->name == "t30007_package");
auto model = generate_package_diagram(*db, diagram);
REQUIRE(model->name() == "t30007_package");
auto [config, db, diagram, model] =
CHECK_PACKAGE_MODEL("t30007", "t30007_package");
CHECK_PACKAGE_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(IsNamespacePackage(src, "A"s));
@@ -39,60 +32,8 @@ TEST_CASE("t30007")
REQUIRE(IsDependency(src, "AA", "B"));
REQUIRE(IsDependency(src, "AA", "C"));
REQUIRE(IsLayoutHint(src, "C", "up", "AA"));
REQUIRE(IsLayoutHint(src, "C", "left", "B"));
});
/*
{
auto src = generate_package_puml(diagram, *model);
AliasMatcher _A(src);
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
REQUIRE_THAT(src, IsPackage("A"));
REQUIRE_THAT(src, IsPackage("B"));
REQUIRE_THAT(src, IsPackage("C"));
REQUIRE_THAT(src, IsDependency(_A("AA"), _A("B")));
REQUIRE_THAT(src, IsDependency(_A("AA"), _A("C")));
REQUIRE_THAT(src, IsLayoutHint(_A("C"), "up", _A("AA")));
REQUIRE_THAT(src, IsLayoutHint(_A("C"), "left", _A("B")));
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, "A"s));
REQUIRE(IsNamespacePackage(j, "A"s, "AA"s));
REQUIRE(IsNamespacePackage(j, "B"s));
REQUIRE(IsNamespacePackage(j, "C"s));
REQUIRE(IsDependency(j, "AA", "B"));
REQUIRE(IsDependency(j, "AA", "C"));
save_json(config.output_directory(), diagram->name + ".json", j);
}
{
auto src = generate_package_mermaid(diagram, *model);
mermaid::AliasMatcher _A(src);
using mermaid::IsPackage;
using mermaid::IsPackageDependency;
REQUIRE_THAT(src, IsPackage(_A("A")));
REQUIRE_THAT(src, IsPackage(_A("B")));
REQUIRE_THAT(src, IsPackage(_A("C")));
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);
}
*/
}

88
tests/t30008/test_case.h
View File

@@ -21,15 +21,8 @@ TEST_CASE("t30008")
using namespace clanguml::test;
using namespace std::string_literals;
auto [config, db] = load_config("t30008");
auto diagram = config.diagrams["t30008_package"];
REQUIRE(diagram->name == "t30008_package");
auto model = generate_package_diagram(*db, diagram);
REQUIRE(model->name() == "t30008_package");
auto [config, db, diagram, model] =
CHECK_PACKAGE_MODEL("t30008", "t30008_package");
CHECK_PACKAGE_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(IsNamespacePackage(src, "dependants"s, "A"s));
@@ -48,81 +41,4 @@ TEST_CASE("t30008")
REQUIRE(IsDependency(src, "E", "D"));
REQUIRE(IsDependency(src, "F", "E"));
});
/*
{
auto src = generate_package_puml(diagram, *model);
AliasMatcher _A(src);
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
REQUIRE_THAT(src, IsPackage("A"));
REQUIRE_THAT(src, IsPackage("B"));
REQUIRE_THAT(src, IsPackage("C"));
REQUIRE_THAT(src, !IsPackage("X"));
REQUIRE_THAT(src, IsDependency(_A("B"), _A("A")));
REQUIRE_THAT(src, IsDependency(_A("C"), _A("B")));
REQUIRE_THAT(src, IsPackage("D"));
REQUIRE_THAT(src, IsPackage("E"));
REQUIRE_THAT(src, IsPackage("F"));
REQUIRE_THAT(src, !IsPackage("Y"));
REQUIRE_THAT(src, IsDependency(_A("E"), _A("D")));
REQUIRE_THAT(src, IsDependency(_A("F"), _A("E")));
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, "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));
REQUIRE(IsDependency(j, "B", "A"));
REQUIRE(IsDependency(j, "C", "B"));
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(IsDependency(j, "E", "D"));
REQUIRE(IsDependency(j, "F", "E"));
save_json(config.output_directory(), diagram->name + ".json", j);
}
{
auto src = generate_package_mermaid(diagram, *model);
mermaid::AliasMatcher _A(src);
using mermaid::IsPackage;
using mermaid::IsPackageDependency;
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_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);
}*/
}

65
tests/t30009/test_case.h
View File

@@ -21,15 +21,8 @@ TEST_CASE("t30009")
using namespace clanguml::test;
using namespace std::string_literals;
auto [config, db] = load_config("t30009");
auto diagram = config.diagrams["t30009_package"];
REQUIRE(diagram->name == "t30009_package");
auto model = generate_package_diagram(*db, diagram);
REQUIRE(model->name() == "t30009_package");
auto [config, db, diagram, model] =
CHECK_PACKAGE_MODEL("t30009", "t30009_package");
CHECK_PACKAGE_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(IsNamespacePackage(src, "One"s));
@@ -43,58 +36,4 @@ TEST_CASE("t30009")
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"));
// 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);
}
{
auto j = generate_package_json(diagram, *model);
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));
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("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);
}*/
}

70
tests/t30010/test_case.h
View File

@@ -21,15 +21,8 @@ TEST_CASE("t30010")
using namespace clanguml::test;
using namespace std::string_literals;
auto [config, db] = load_config("t30010");
auto diagram = config.diagrams["t30010_package"];
REQUIRE(diagram->name == "t30010_package");
auto model = generate_package_diagram(*db, diagram);
REQUIRE(model->name() == "t30010_package");
auto [config, db, diagram, model] =
CHECK_PACKAGE_MODEL("t30010", "t30010_package");
CHECK_PACKAGE_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(IsDirectoryPackage(src, "app"s));
@@ -43,63 +36,4 @@ TEST_CASE("t30010")
REQUIRE(IsDependency(src, "app", "lib3"));
REQUIRE(IsDependency(src, "app", "lib4"));
});
/*
{
auto src = generate_package_puml(diagram, *model);
AliasMatcher _A(src);
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
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, 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")));
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(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);
}
{
auto src = generate_package_mermaid(diagram, *model);
mermaid::AliasMatcher _A(src);
using mermaid::IsPackage;
using mermaid::IsPackageDependency;
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")));
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);
}*/
}

76
tests/t30011/test_case.h
View File

@@ -21,15 +21,8 @@ TEST_CASE("t30011")
using namespace clanguml::test;
using namespace std::string_literals;
auto [config, db] = load_config("t30011");
auto diagram = config.diagrams["t30011_package"];
REQUIRE(diagram->name == "t30011_package");
auto model = generate_package_diagram(*db, diagram);
REQUIRE(model->name() == "t30011_package");
auto [config, db, diagram, model] =
CHECK_PACKAGE_MODEL("t30011", "t30011_package");
CHECK_PACKAGE_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(IsDirectoryPackage(src, "app"s));
@@ -43,69 +36,4 @@ TEST_CASE("t30011")
REQUIRE(IsDependency(src, "app", "lib3"));
REQUIRE(IsDependency(src, "app", "lib4"));
});
/*
{
auto src = generate_package_puml(diagram, *model);
AliasMatcher _A(src);
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
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, 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")));
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(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));
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));
save_json(config.output_directory(), diagram->name + ".json", j);
}
{
auto src = generate_package_mermaid(diagram, *model);
mermaid::AliasMatcher _A(src);
using mermaid::IsPackage;
using mermaid::IsPackageDependency;
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")));
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);
}
*/
}

58
tests/t30012/test_case.h
View File

@@ -21,15 +21,8 @@ TEST_CASE("t30012")
using namespace clanguml::test;
using namespace std::string_literals;
auto [config, db] = load_config("t30012");
auto diagram = config.diagrams["t30012_package"];
REQUIRE(diagram->name == "t30012_package");
auto model = generate_package_diagram(*db, diagram);
REQUIRE(model->name() == "t30012_package");
auto [config, db, diagram, model] =
CHECK_PACKAGE_MODEL("t30012", "t30012_package");
CHECK_PACKAGE_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(IsModulePackage(src, "app"s));
@@ -38,51 +31,4 @@ TEST_CASE("t30012")
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);
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
// Check if all packages exist
REQUIRE_THAT(src, IsPackage("app"));
REQUIRE_THAT(src, IsPackage("lib1"));
REQUIRE_THAT(src, IsPackage("lib2"));
REQUIRE_THAT(src, IsPackage("mod1"));
REQUIRE_THAT(src, IsPackage("mod2"));
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(IsModulePackage(j, "app"s));
REQUIRE(IsModulePackage(j, "app"s, "lib1"s));
REQUIRE(IsModulePackage(j, "app"s, "lib1"s, "mod1"s));
REQUIRE(IsModulePackage(j, "app"s, "lib1"s, "mod2"s));
REQUIRE(IsModulePackage(j, "app"s, "lib2"s));
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("app")));
REQUIRE_THAT(src, IsPackage(_A("lib1")));
REQUIRE_THAT(src, IsPackage(_A("lib2")));
REQUIRE_THAT(src, IsPackage(_A("mod1")));
REQUIRE_THAT(src, IsPackage(_A("mod2")));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}*/
}

140
tests/t30013/test_case.h
View File

@@ -21,15 +21,8 @@ TEST_CASE("t30013")
using namespace clanguml::test;
using namespace std::string_literals;
auto [config, db] = load_config("t30013");
auto diagram = config.diagrams["t30013_package"];
REQUIRE(diagram->name == "t30013_package");
auto model = generate_package_diagram(*db, diagram);
REQUIRE(model->name() == "t30013_package");
auto [config, db, diagram, model] =
CHECK_PACKAGE_MODEL("t30013", "t30013_package");
CHECK_PACKAGE_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(IsModulePackage(src, "app"s));
@@ -71,133 +64,4 @@ TEST_CASE("t30013")
REQUIRE(IsDependency(src, "app", "mod17"));
REQUIRE(IsDependency(src, "app", "mod18"));
});
/*
{
auto src = generate_package_puml(diagram, *model);
AliasMatcher _A(src);
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
// 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, 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")));
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(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));
save_json(config.output_directory(), diagram->name + ".json", j);
}
{
auto src = generate_package_mermaid(diagram, *model);
mermaid::AliasMatcher _A(src);
using mermaid::IsPackage;
using mermaid::IsPackageDependency;
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")));
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);
}
*/
}

57
tests/t30014/test_case.h
View File

@@ -21,15 +21,8 @@ TEST_CASE("t30014")
using namespace clanguml::test;
using namespace std::string_literals;
auto [config, db] = load_config("t30014");
auto diagram = config.diagrams["t30014_package"];
REQUIRE(diagram->name == "t30014_package");
auto model = generate_package_diagram(*db, diagram);
REQUIRE(model->name() == "t30014_package");
auto [config, db, diagram, model] =
CHECK_PACKAGE_MODEL("t30014", "t30014_package");
CHECK_PACKAGE_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(IsModulePackage(src, "app"s));
@@ -38,50 +31,4 @@ TEST_CASE("t30014")
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);
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
// Check if all packages exist
REQUIRE_THAT(src, IsPackage("app"));
REQUIRE_THAT(src, IsPackage(":lib1"));
REQUIRE_THAT(src, IsPackage(":lib2"));
REQUIRE_THAT(src, IsPackage("mod1"));
REQUIRE_THAT(src, !IsPackage("mod2"));
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(IsModulePackage(j, "app"s));
REQUIRE(IsModulePackage(j, "app"s, ":lib1"s));
REQUIRE(IsModulePackage(j, "app"s, ":lib2"s));
REQUIRE(IsModulePackage(j, "app"s, ":lib1"s, "mod1"s));
REQUIRE(!IsModulePackage(j, "app"s, ":lib1"s, "mod2"s));
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("app")));
REQUIRE_THAT(src, IsPackage(_A(":lib1")));
REQUIRE_THAT(src, IsPackage(_A(":lib2")));
REQUIRE_THAT(src, IsPackage(_A("mod1")));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
}*/
}

144
tests/t30015/test_case.h
View File

@@ -21,15 +21,8 @@ TEST_CASE("t30015")
using namespace clanguml::test;
using namespace std::string_literals;
auto [config, db] = load_config("t30015");
auto diagram = config.diagrams["t30015_package"];
REQUIRE(diagram->name == "t30015_package");
auto model = generate_package_diagram(*db, diagram);
REQUIRE(model->name() == "t30015_package");
auto [config, db, diagram, model] =
CHECK_PACKAGE_MODEL("t30015", "t30015_package");
CHECK_PACKAGE_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(IsModulePackage(src, "app"s));
@@ -72,137 +65,4 @@ TEST_CASE("t30015")
REQUIRE(IsDependency(src, "app", ":mod17"));
REQUIRE(IsDependency(src, "app", ":mod18"));
});
/*
{
auto src = generate_package_puml(diagram, *model);
AliasMatcher _A(src);
REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(src, EndsWith("@enduml\n"));
// 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, 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")));
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(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));
save_json(config.output_directory(), diagram->name + ".json", j);
}
{
auto src = generate_package_mermaid(diagram, *model);
mermaid::AliasMatcher _A(src);
using mermaid::IsPackage;
using mermaid::IsPackageDependency;
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")));
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);
}
*/
}

11
tests/t40001/test_case.h
View File

@@ -20,15 +20,8 @@ TEST_CASE("t40001")
{
using namespace clanguml::test;
auto [config, db] = load_config("t40001");
auto diagram = config.diagrams["t40001_include"];
REQUIRE(diagram->name == "t40001_include");
auto model = generate_include_diagram(*db, diagram);
REQUIRE(model->name() == "t40001_include");
auto [config, db, diagram, model] =
CHECK_INCLUDE_MODEL("t40001", "t40001_include");
CHECK_INCLUDE_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(HasTitle(src, "Basic include diagram example"));

11
tests/t40002/test_case.h
View File

@@ -20,15 +20,8 @@ TEST_CASE("t40002")
{
using namespace clanguml::test;
auto [config, db] = load_config("t40002");
auto diagram = config.diagrams["t40002_include"];
REQUIRE(diagram->name == "t40002_include");
auto model = generate_include_diagram(*db, diagram);
REQUIRE(model->name() == "t40002_include");
auto [config, db, diagram, model] =
CHECK_INCLUDE_MODEL("t40002", "t40002_include");
CHECK_INCLUDE_DIAGRAM(config, diagram, *model, [](const auto &src) {
REQUIRE(IsFolder(src, "include"));

Some files were not shown because too many files have changed in this diff Show More