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

Added mermaid test cases for class diagrams

Browse Source
This commit is contained in:
Bartek Kryza
2023-09-12 00:55:05 +02:00
parent de5625a474
commit eb00cd21c3
71 changed files with 3189 additions and 1295 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
docs/test_cases/t00002_class_mermaid.svg
View File

@@ -1,4 +1,4 @@
<svg xmlns:xlink="http://www.w3.org/1999/xlink" xmlns="http://www.w3.org/2000/svg" aria-roledescription="classDiagram" role="graphics-document document" viewBox="0 0 426.921875 441" style="max-width: 426.922px; background-color: white;" width="100%" id="my-svg"> <svg xmlns:xlink="http://www.w3.org/1999/xlink" xmlns="http://www.w3.org/2000/svg" aria-roledescription="classDiagram" role="graphics-document document" viewBox="0 0 426.921875 441" style="max-width: 426.922px; background-color: white;" width="100%" id="my-svg" width="427">
<style>#my-svg{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;fill:#333;}#my-svg .error-icon{fill:#552222;}#my-svg .error-text{fill:#552222;stroke:#552222;}#my-svg .edge-thickness-normal{stroke-width:2px;}#my-svg .edge-thickness-thick{stroke-width:3.5px;}#my-svg .edge-pattern-solid{stroke-dasharray:0;}#my-svg .edge-pattern-dashed{stroke-dasharray:3;}#my-svg .edge-pattern-dotted{stroke-dasharray:2;}#my-svg .marker{fill:#333333;stroke:#333333;}#my-svg .marker.cross{stroke:#333333;}#my-svg svg{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;}#my-svg g.classGroup text{fill:#9370DB;fill:#131300;stroke:none;font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:10px;}#my-svg g.classGroup text .title{font-weight:bolder;}#my-svg .nodeLabel,#my-svg .edgeLabel{color:#131300;}#my-svg .edgeLabel .label rect{fill:#ECECFF;}#my-svg .label text{fill:#131300;}#my-svg .edgeLabel .label span{background:#ECECFF;}#my-svg .classTitle{font-weight:bolder;}#my-svg .node rect,#my-svg .node circle,#my-svg .node ellipse,#my-svg .node polygon,#my-svg .node path{fill:#ECECFF;stroke:#9370DB;stroke-width:1px;}#my-svg .divider{stroke:#9370DB;stroke-width:1;}#my-svg g.clickable{cursor:pointer;}#my-svg g.classGroup rect{fill:#ECECFF;stroke:#9370DB;}#my-svg g.classGroup line{stroke:#9370DB;stroke-width:1;}#my-svg .classLabel .box{stroke:none;stroke-width:0;fill:#ECECFF;opacity:0.5;}#my-svg .classLabel .label{fill:#9370DB;font-size:10px;}#my-svg .relation{stroke:#333333;stroke-width:1;fill:none;}#my-svg .dashed-line{stroke-dasharray:3;}#my-svg .dotted-line{stroke-dasharray:1 2;}#my-svg #compositionStart,#my-svg .composition{fill:#333333!important;stroke:#333333!important;stroke-width:1;}#my-svg #compositionEnd,#my-svg .composition{fill:#333333!important;stroke:#333333!important;stroke-width:1;}#my-svg #dependencyStart,#my-svg .dependency{fill:#333333!important;stroke:#333333!important;stroke-width:1;}#my-svg #dependencyStart,#my-svg .dependency{fill:#333333!important;stroke:#333333!important;stroke-width:1;}#my-svg #extensionStart,#my-svg .extension{fill:#ECECFF!important;stroke:#333333!important;stroke-width:1;}#my-svg #extensionEnd,#my-svg .extension{fill:#ECECFF!important;stroke:#333333!important;stroke-width:1;}#my-svg #aggregationStart,#my-svg .aggregation{fill:#ECECFF!important;stroke:#333333!important;stroke-width:1;}#my-svg #aggregationEnd,#my-svg .aggregation{fill:#ECECFF!important;stroke:#333333!important;stroke-width:1;}#my-svg #lollipopStart,#my-svg .lollipop{fill:#ECECFF!important;stroke:#333333!important;stroke-width:1;}#my-svg #lollipopEnd,#my-svg .lollipop{fill:#ECECFF!important;stroke:#333333!important;stroke-width:1;}#my-svg .edgeTerminals{font-size:11px;}#my-svg .classTitleText{text-anchor:middle;font-size:18px;fill:#333;}#my-svg :root{--mermaid-font-family:"trebuchet ms",verdana,arial,sans-serif;}</style> <style>#my-svg{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;fill:#333;}#my-svg .error-icon{fill:#552222;}#my-svg .error-text{fill:#552222;stroke:#552222;}#my-svg .edge-thickness-normal{stroke-width:2px;}#my-svg .edge-thickness-thick{stroke-width:3.5px;}#my-svg .edge-pattern-solid{stroke-dasharray:0;}#my-svg .edge-pattern-dashed{stroke-dasharray:3;}#my-svg .edge-pattern-dotted{stroke-dasharray:2;}#my-svg .marker{fill:#333333;stroke:#333333;}#my-svg .marker.cross{stroke:#333333;}#my-svg svg{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;}#my-svg g.classGroup text{fill:#9370DB;fill:#131300;stroke:none;font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:10px;}#my-svg g.classGroup text .title{font-weight:bolder;}#my-svg .nodeLabel,#my-svg .edgeLabel{color:#131300;}#my-svg .edgeLabel .label rect{fill:#ECECFF;}#my-svg .label text{fill:#131300;}#my-svg .edgeLabel .label span{background:#ECECFF;}#my-svg .classTitle{font-weight:bolder;}#my-svg .node rect,#my-svg .node circle,#my-svg .node ellipse,#my-svg .node polygon,#my-svg .node path{fill:#ECECFF;stroke:#9370DB;stroke-width:1px;}#my-svg .divider{stroke:#9370DB;stroke-width:1;}#my-svg g.clickable{cursor:pointer;}#my-svg g.classGroup rect{fill:#ECECFF;stroke:#9370DB;}#my-svg g.classGroup line{stroke:#9370DB;stroke-width:1;}#my-svg .classLabel .box{stroke:none;stroke-width:0;fill:#ECECFF;opacity:0.5;}#my-svg .classLabel .label{fill:#9370DB;font-size:10px;}#my-svg .relation{stroke:#333333;stroke-width:1;fill:none;}#my-svg .dashed-line{stroke-dasharray:3;}#my-svg .dotted-line{stroke-dasharray:1 2;}#my-svg #compositionStart,#my-svg .composition{fill:#333333!important;stroke:#333333!important;stroke-width:1;}#my-svg #compositionEnd,#my-svg .composition{fill:#333333!important;stroke:#333333!important;stroke-width:1;}#my-svg #dependencyStart,#my-svg .dependency{fill:#333333!important;stroke:#333333!important;stroke-width:1;}#my-svg #dependencyStart,#my-svg .dependency{fill:#333333!important;stroke:#333333!important;stroke-width:1;}#my-svg #extensionStart,#my-svg .extension{fill:#ECECFF!important;stroke:#333333!important;stroke-width:1;}#my-svg #extensionEnd,#my-svg .extension{fill:#ECECFF!important;stroke:#333333!important;stroke-width:1;}#my-svg #aggregationStart,#my-svg .aggregation{fill:#ECECFF!important;stroke:#333333!important;stroke-width:1;}#my-svg #aggregationEnd,#my-svg .aggregation{fill:#ECECFF!important;stroke:#333333!important;stroke-width:1;}#my-svg #lollipopStart,#my-svg .lollipop{fill:#ECECFF!important;stroke:#333333!important;stroke-width:1;}#my-svg #lollipopEnd,#my-svg .lollipop{fill:#ECECFF!important;stroke:#333333!important;stroke-width:1;}#my-svg .edgeTerminals{font-size:11px;}#my-svg .classTitleText{text-anchor:middle;font-size:18px;fill:#333;}#my-svg :root{--mermaid-font-family:"trebuchet ms",verdana,arial,sans-serif;}</style>
<g> <g>
<defs> <defs>
Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 22 KiB

After

Width:  |  Height:  |  Size: 22 KiB

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

@@ -236,7 +236,27 @@ void generator::generate_method(
} }
ostr << ")"; ostr << ")";
ostr << " : " << render_name(type); ostr << " : ";
std::vector<std::string> method_mods;
if (m.is_defaulted()) {
method_mods.push_back("default");
}
if (m.is_const()) {
method_mods.push_back("const");
}
if (m.is_constexpr()) {
method_mods.push_back("constexpr");
}
if (m.is_consteval()) {
method_mods.push_back("consteval");
}
if (!method_mods.empty()) {
ostr << fmt::format("[{}] ", fmt::join(method_mods, ","));
}
ostr << render_name(type);
if (m.is_pure_virtual()) if (m.is_pure_virtual())
ostr << "*"; ostr << "*";
@@ -389,14 +409,15 @@ void generator::generate_relationships(
try { try {
destination = r.destination(); destination = r.destination();
std::string puml_relation; std::string relation_str;
if (!r.multiplicity_source().empty())
puml_relation += "\"" + r.multiplicity_source() + "\" ";
puml_relation += mermaid_common::to_mermaid(r.type(), r.style()); if (!r.multiplicity_source().empty())
relation_str += "\"" + r.multiplicity_source() + "\" ";
relation_str += mermaid_common::to_mermaid(r.type(), r.style());
if (!r.multiplicity_destination().empty()) if (!r.multiplicity_destination().empty())
puml_relation += " \"" + r.multiplicity_destination() + "\""; relation_str += " \"" + r.multiplicity_destination() + "\"";
std::string target_alias; std::string target_alias;
try { try {
@@ -411,17 +432,20 @@ void generator::generate_relationships(
m_generated_aliases.end()) m_generated_aliases.end())
continue; continue;
relstr << indent(1) << c.alias() << " " << puml_relation << " " if (r.type() == relationship_t::kContainment) {
<< target_alias; relstr << indent(1) << target_alias << " " << relation_str
<< " " << c.alias();
if (!r.label().empty()) { }
relstr << " : " << mermaid_common::to_mermaid(r.access()) else {
<< r.label(); relstr << indent(1) << c.alias() << " " << relation_str << " "
rendered_relations.emplace(r.label()); << target_alias;
} }
if (r.type() == relationship_t::kContainment) { relstr << " : ";
relstr << " : [nested]\n";
if (!r.label().empty()) {
relstr << mermaid_common::to_mermaid(r.access()) << r.label();
rendered_relations.emplace(r.label());
} }
if (unique_relations.count(relstr.str()) == 0) { if (unique_relations.count(relstr.str()) == 0) {
@@ -514,12 +538,19 @@ void generator::generate_relationships(
m_generated_aliases.end()) m_generated_aliases.end())
continue; continue;
relstr << indent(1) << c.alias() << " " << puml_relation << " " if (r.type() == relationship_t::kContainment) {
<< target_alias; relstr << indent(1) << target_alias << " " << puml_relation
<< " " << c.alias();
}
else {
relstr << indent(1) << c.alias() << " " << puml_relation << " "
<< target_alias;
}
relstr << " : ";
if (!r.label().empty()) { if (!r.label().empty()) {
relstr << " : " << mermaid_common::to_mermaid(r.access()) relstr << mermaid_common::to_mermaid(r.access()) << r.label();
<< r.label();
rendered_relations.emplace(r.label()); rendered_relations.emplace(r.label());
} }
@@ -561,13 +592,20 @@ void generator::generate_relationships(const enum_ &e, std::ostream &ostr) const
m_generated_aliases.end()) m_generated_aliases.end())
continue; continue;
relstr << indent(1) << e.alias() << " " if (r.type() == relationship_t::kContainment) {
<< clanguml::common::generators::mermaid::to_mermaid( relstr << indent(1) << target_alias << " "
r.type(), r.style()) << clanguml::common::generators::mermaid::to_mermaid(
<< " " << target_alias; r.type(), r.style())
<< " " << e.alias();
}
else {
relstr << indent(1) << e.alias() << " "
<< clanguml::common::generators::mermaid::to_mermaid(
r.type(), r.style())
<< " " << target_alias;
}
if (!r.label().empty()) relstr << " : " << r.label();
relstr << " : " << r.label();
relstr << '\n'; relstr << '\n';
@@ -589,7 +627,7 @@ void generator::generate(const enum_ &e, std::ostream &ostr) const
ostr << " {" << '\n'; ostr << " {" << '\n';
ostr << indent(2) << "<<Enumeration>>\n"; ostr << indent(2) << "<<enumeration>>\n";
for (const auto &enum_constant : e.constants()) { for (const auto &enum_constant : e.constants()) {
ostr << indent(2) << enum_constant << '\n'; ostr << indent(2) << enum_constant << '\n';

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

@@ -28,7 +28,7 @@ std::string to_mermaid(relationship_t r, const std::string & /*style*/)
case relationship_t::kAggregation: case relationship_t::kAggregation:
return "o--"; return "o--";
case relationship_t::kContainment: case relationship_t::kContainment:
return "--"; return "()--";
case relationship_t::kAssociation: case relationship_t::kAssociation:
return "-->"; return "-->";
case relationship_t::kInstantiation: case relationship_t::kInstantiation:

7
tests/catch.h
View File

@@ -13299,13 +13299,14 @@ RegexMatcher::RegexMatcher(
bool RegexMatcher::match(std::string const &matchee) const bool RegexMatcher::match(std::string const &matchee) const
{ {
auto flags = std::regex::ECMAScript; // ECMAScript is the default syntax auto flags = std::regex::ECMAScript |
// option anyway std::regex::multiline; // ECMAScript is the default syntax
// option anyway
if (m_caseSensitivity == CaseSensitive::Choice::No) { if (m_caseSensitivity == CaseSensitive::Choice::No) {
flags |= std::regex::icase; flags |= std::regex::icase;
} }
auto reg = std::regex(m_regex, flags); auto reg = std::regex(m_regex, flags);
return std::regex_match(matchee, reg); return std::regex_search(matchee, reg);
} }
std::string RegexMatcher::describe() const std::string RegexMatcher::describe() const

35
tests/t00002/test_case.h
View File

@@ -109,6 +109,41 @@ TEST_CASE("t00002", "[test-case][class]")
{ {
auto mmd = generate_class_mermaid(diagram, *model); auto mmd = generate_class_mermaid(diagram, *model);
mermaid::AliasMatcher _A(mmd);
REQUIRE_THAT(mmd, StartsWith("classDiagram"));
REQUIRE_THAT(mmd, mermaid::IsAbstractClass(_A("A")));
REQUIRE_THAT(mmd, IsClass(_A("B")));
REQUIRE_THAT(mmd, IsClass(_A("C")));
REQUIRE_THAT(mmd, IsClass(_A("D")));
REQUIRE_THAT(mmd, IsBaseClass(_A("A"), _A("B")));
REQUIRE_THAT(mmd, IsBaseClass(_A("A"), _A("C")));
REQUIRE_THAT(mmd, IsBaseClass(_A("B"), _A("D")));
REQUIRE_THAT(mmd, IsBaseClass(_A("C"), _A("D")));
REQUIRE_THAT(mmd, IsAssociation(_A("D"), _A("A"), "-as"));
REQUIRE_THAT(mmd, (mermaid::IsMethod<Public, Abstract>("foo_a")));
REQUIRE_THAT(mmd, (mermaid::IsMethod<Public, Abstract>("foo_c")));
// REQUIRE_THAT(mmd, HasNote(_A("A"), "left", "This is class
// A")); REQUIRE_THAT(mmd, HasNote(_A("B"), "top", "This is class
// B"));
REQUIRE_THAT(mmd,
mermaid::HasLink(_A("A"),
fmt::format("https://github.com/bkryza/clang-uml/blob/{}/tests/"
"t00002/t00002.cc#L7",
clanguml::util::get_git_commit()),
"This is class A"));
REQUIRE_THAT(mmd,
mermaid::HasLink(_A("B"),
fmt::format("https://github.com/bkryza/clang-uml/blob/{}/tests/"
"t00002/t00002.cc#L16",
clanguml::util::get_git_commit()),
"This is class B"));
save_mermaid(config.output_directory(), diagram->name + ".mmd", mmd); save_mermaid(config.output_directory(), diagram->name + ".mmd", mmd);
} }
} }

40
tests/t00003/test_case.h
View File

@@ -96,6 +96,46 @@ TEST_CASE("t00003", "[test-case][class]")
} }
{ {
auto mmd = generate_class_mermaid(diagram, *model); auto mmd = generate_class_mermaid(diagram, *model);
mermaid::AliasMatcher _A(mmd);
REQUIRE_THAT(mmd, IsClass(_A("A")));
REQUIRE_THAT(mmd, !IsDependency(_A("A"), _A("A")));
REQUIRE_THAT(mmd, (mermaid::IsMethod<Public, Default>("A")));
REQUIRE_THAT(
mmd, (mermaid::IsMethod<Public, Default>("A", "void", "A &&")));
REQUIRE_THAT(mmd,
(mermaid::IsMethod<Public, Deleted>("A", "void", "const A &")));
REQUIRE_THAT(mmd, (mermaid::IsMethod<Public, Default>("~A")));
REQUIRE_THAT(mmd, (mermaid::IsMethod<Public>("basic_method")));
REQUIRE_THAT(
mmd, (mermaid::IsMethod<Public, Static>("static_method", "int")));
REQUIRE_THAT(mmd, (mermaid::IsMethod<Public, Const>("const_method")));
REQUIRE_THAT(mmd,
(mermaid::IsMethod<Public>("default_int", "int", "int i = 12")));
REQUIRE_THAT(mmd,
(mermaid::IsMethod<Public>("default_string", "std::string",
"int i, std::string s = \"abc\"")));
REQUIRE_THAT(mmd,
(mermaid::IsMethod<Public, Const, Constexpr>(
"size", "std::size_t")));
REQUIRE_THAT(mmd, (mermaid::IsMethod<Protected>("protected_method")));
REQUIRE_THAT(mmd, (mermaid::IsMethod<Private>("private_method")));
REQUIRE_THAT(mmd, (IsField<Public>("public_member", "int")));
REQUIRE_THAT(mmd, (IsField<Protected>("protected_member", "int")));
REQUIRE_THAT(mmd, (IsField<Private>("private_member", "int")));
REQUIRE_THAT(mmd,
(IsField<Public, Static>("auto_member", "const unsigned long")));
REQUIRE_THAT(mmd, (IsField<Private>("a_", "int")));
REQUIRE_THAT(mmd, (IsField<Private>("b_", "int")));
REQUIRE_THAT(mmd, (IsField<Private>("c_", "int")));
save_mermaid(config.output_directory(), diagram->name + ".mmd", mmd); save_mermaid(config.output_directory(), diagram->name + ".mmd", mmd);
} }

26
tests/t00004/test_case.h
View File

@@ -92,6 +92,32 @@ TEST_CASE("t00004", "[test-case][class]")
} }
{ {
auto mmd = generate_class_mermaid(diagram, *model); auto mmd = generate_class_mermaid(diagram, *model);
mermaid::AliasMatcher _A(mmd);
REQUIRE_THAT(mmd, IsClass(_A("A")));
REQUIRE_THAT(mmd, IsClass(_A("A::AA")));
REQUIRE_THAT(mmd, IsClass(_A("A::AA::AAA")));
REQUIRE_THAT(mmd, mermaid::IsEnum(_A("B::AA")));
REQUIRE_THAT(mmd, mermaid::IsEnum(_A("A::AA::Lights")));
REQUIRE_THAT(mmd, mermaid::IsInnerClass(_A("A"), _A("A::AA")));
REQUIRE_THAT(mmd, mermaid::IsInnerClass(_A("A::AA"), _A("A::AA::AAA")));
REQUIRE_THAT(
mmd, mermaid::IsInnerClass(_A("A::AA"), _A("A::AA::Lights")));
REQUIRE_THAT(mmd, IsClass(_A("C<T>")));
REQUIRE_THAT(mmd, mermaid::IsInnerClass(_A("C<T>"), _A("C::AA")));
REQUIRE_THAT(mmd, mermaid::IsInnerClass(_A("C::AA"), _A("C::AA::AAA")));
REQUIRE_THAT(mmd, mermaid::IsInnerClass(_A("C<T>"), _A("C::CC")));
REQUIRE_THAT(mmd, mermaid::IsInnerClass(_A("C::AA"), _A("C::AA::CCC")));
REQUIRE_THAT(mmd, mermaid::IsInnerClass(_A("C<T>"), _A("C::B<V>")));
REQUIRE_THAT(mmd, IsAggregation(_A("C<T>"), _A("C::B<int>"), "+b_int"));
REQUIRE_THAT(mmd, !mermaid::IsInnerClass(_A("C<T>"), _A("C::B")));
REQUIRE_THAT(mmd, IsInstantiation(_A("C::B<V>"), _A("C::B<int>")));
REQUIRE_THAT(mmd, IsClass(_A("detail::D")));
REQUIRE_THAT(mmd, IsClass(_A("detail::D::DD")));
REQUIRE_THAT(mmd, mermaid::IsEnum(_A("detail::D::AA")));
save_mermaid(config.output_directory(), diagram->name + ".mmd", mmd); save_mermaid(config.output_directory(), diagram->name + ".mmd", mmd);
} }

32
tests/t00005/test_case.h
View File

@@ -101,6 +101,38 @@ TEST_CASE("t00005", "[test-case][class]")
} }
{ {
auto mmd = generate_class_mermaid(diagram, *model); auto mmd = generate_class_mermaid(diagram, *model);
mermaid::AliasMatcher _A(mmd);
REQUIRE_THAT(mmd, StartsWith("classDiagram"));
REQUIRE_THAT(mmd, IsClass(_A("A")));
REQUIRE_THAT(mmd, IsClass(_A("B")));
REQUIRE_THAT(mmd, IsClass(_A("C")));
REQUIRE_THAT(mmd, IsClass(_A("D")));
REQUIRE_THAT(mmd, IsClass(_A("E")));
REQUIRE_THAT(mmd, IsClass(_A("F")));
REQUIRE_THAT(mmd, IsClass(_A("G")));
REQUIRE_THAT(mmd, IsClass(_A("H")));
REQUIRE_THAT(mmd, IsClass(_A("I")));
REQUIRE_THAT(mmd, IsClass(_A("J")));
REQUIRE_THAT(mmd, IsClass(_A("K")));
REQUIRE_THAT(mmd, IsClass(_A("R")));
REQUIRE_THAT(mmd, (IsField<Public>("some_int", "int")));
REQUIRE_THAT(mmd, (IsField<Public>("some_int_pointer", "int *")));
REQUIRE_THAT(
mmd, (IsField<Public>("some_int_pointer_pointer", "int **")));
REQUIRE_THAT(mmd, IsAggregation(_A("R"), _A("A"), "+a"));
REQUIRE_THAT(mmd, IsAssociation(_A("R"), _A("B"), "+b"));
REQUIRE_THAT(mmd, IsAssociation(_A("R"), _A("C"), "+c"));
REQUIRE_THAT(mmd, IsAssociation(_A("R"), _A("D"), "+d"));
REQUIRE_THAT(mmd, IsAssociation(_A("R"), _A("E"), "+e"));
REQUIRE_THAT(mmd, IsAggregation(_A("R"), _A("F"), "+f"));
REQUIRE_THAT(mmd, IsAssociation(_A("R"), _A("G"), "+g"));
REQUIRE_THAT(mmd, IsAssociation(_A("R"), _A("H"), "+h"));
REQUIRE_THAT(mmd, IsAssociation(_A("R"), _A("I"), "+i"));
REQUIRE_THAT(mmd, IsAssociation(_A("R"), _A("J"), "+j"));
REQUIRE_THAT(mmd, IsAssociation(_A("R"), _A("K"), "+k"));
save_mermaid(config.output_directory(), diagram->name + ".mmd", mmd); save_mermaid(config.output_directory(), diagram->name + ".mmd", mmd);
} }

122
tests/t00006/test_case.h
View File

@@ -29,51 +29,51 @@ TEST_CASE("t00006", "[test-case][class]")
REQUIRE(model->name() == "t00006_class"); REQUIRE(model->name() == "t00006_class");
{ {
auto puml = generate_class_puml(diagram, *model); auto src = generate_class_puml(diagram, *model);
AliasMatcher _A(puml); AliasMatcher _A(src);
REQUIRE_THAT(puml, StartsWith("@startuml")); REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(puml, EndsWith("@enduml\n")); REQUIRE_THAT(src, EndsWith("@enduml\n"));
REQUIRE_THAT(puml, IsClass(_A("A"))); REQUIRE_THAT(src, IsClass(_A("A")));
REQUIRE_THAT(puml, IsClass(_A("B"))); REQUIRE_THAT(src, IsClass(_A("B")));
REQUIRE_THAT(puml, IsClass(_A("C"))); REQUIRE_THAT(src, IsClass(_A("C")));
REQUIRE_THAT(puml, IsClass(_A("D"))); REQUIRE_THAT(src, IsClass(_A("D")));
REQUIRE_THAT(puml, IsClass(_A("E"))); REQUIRE_THAT(src, IsClass(_A("E")));
REQUIRE_THAT(puml, IsClass(_A("F"))); REQUIRE_THAT(src, IsClass(_A("F")));
REQUIRE_THAT(puml, IsClass(_A("G"))); REQUIRE_THAT(src, IsClass(_A("G")));
REQUIRE_THAT(puml, IsClass(_A("H"))); REQUIRE_THAT(src, IsClass(_A("H")));
REQUIRE_THAT(puml, IsClass(_A("I"))); REQUIRE_THAT(src, IsClass(_A("I")));
REQUIRE_THAT(puml, IsClass(_A("J"))); REQUIRE_THAT(src, IsClass(_A("J")));
REQUIRE_THAT(puml, IsClass(_A("K"))); REQUIRE_THAT(src, IsClass(_A("K")));
REQUIRE_THAT(puml, IsClass(_A("L"))); REQUIRE_THAT(src, IsClass(_A("L")));
REQUIRE_THAT(puml, IsClass(_A("M"))); REQUIRE_THAT(src, IsClass(_A("M")));
REQUIRE_THAT(puml, IsClass(_A("N"))); REQUIRE_THAT(src, IsClass(_A("N")));
REQUIRE_THAT(puml, IsClass(_A("NN"))); REQUIRE_THAT(src, IsClass(_A("NN")));
REQUIRE_THAT(puml, IsClass(_A("NNN"))); REQUIRE_THAT(src, IsClass(_A("NNN")));
REQUIRE_THAT(puml, REQUIRE_THAT(src,
IsInstantiation( IsInstantiation(
_A("custom_container<T>"), _A("custom_container<E>"))); _A("custom_container<T>"), _A("custom_container<E>")));
REQUIRE_THAT(puml, IsAggregation(_A("R"), _A("A"), "+a")); REQUIRE_THAT(src, IsAggregation(_A("R"), _A("A"), "+a"));
REQUIRE_THAT(puml, IsAssociation(_A("R"), _A("B"), "+b")); REQUIRE_THAT(src, IsAssociation(_A("R"), _A("B"), "+b"));
REQUIRE_THAT(puml, IsAggregation(_A("R"), _A("C"), "+c")); REQUIRE_THAT(src, IsAggregation(_A("R"), _A("C"), "+c"));
REQUIRE_THAT(puml, IsAssociation(_A("R"), _A("D"), "+d")); REQUIRE_THAT(src, IsAssociation(_A("R"), _A("D"), "+d"));
REQUIRE_THAT( REQUIRE_THAT(
puml, IsAggregation(_A("R"), _A("custom_container<E>"), "+e")); src, IsAggregation(_A("R"), _A("custom_container<E>"), "+e"));
REQUIRE_THAT(puml, IsAggregation(_A("R"), _A("F"), "+f")); REQUIRE_THAT(src, IsAggregation(_A("R"), _A("F"), "+f"));
REQUIRE_THAT(puml, IsAssociation(_A("R"), _A("G"), "+g")); REQUIRE_THAT(src, IsAssociation(_A("R"), _A("G"), "+g"));
REQUIRE_THAT(puml, IsAggregation(_A("R"), _A("H"), "+h")); REQUIRE_THAT(src, IsAggregation(_A("R"), _A("H"), "+h"));
REQUIRE_THAT(puml, IsAssociation(_A("R"), _A("I"), "+i")); REQUIRE_THAT(src, IsAssociation(_A("R"), _A("I"), "+i"));
REQUIRE_THAT(puml, IsAggregation(_A("R"), _A("J"), "+j")); REQUIRE_THAT(src, IsAggregation(_A("R"), _A("J"), "+j"));
REQUIRE_THAT(puml, IsAssociation(_A("R"), _A("K"), "+k")); REQUIRE_THAT(src, IsAssociation(_A("R"), _A("K"), "+k"));
REQUIRE_THAT(puml, IsAggregation(_A("R"), _A("L"), "+lm")); REQUIRE_THAT(src, IsAggregation(_A("R"), _A("L"), "+lm"));
REQUIRE_THAT(puml, IsAggregation(_A("R"), _A("M"), "+lm")); REQUIRE_THAT(src, IsAggregation(_A("R"), _A("M"), "+lm"));
REQUIRE_THAT(puml, IsAggregation(_A("R"), _A("N"), "+ns")); REQUIRE_THAT(src, IsAggregation(_A("R"), _A("N"), "+ns"));
REQUIRE_THAT(puml, IsAggregation(_A("R"), _A("NN"), "+ns")); REQUIRE_THAT(src, IsAggregation(_A("R"), _A("NN"), "+ns"));
REQUIRE_THAT(puml, IsAggregation(_A("R"), _A("NNN"), "+ns")); REQUIRE_THAT(src, IsAggregation(_A("R"), _A("NNN"), "+ns"));
save_puml(config.output_directory(), diagram->name + ".puml", puml); save_puml(config.output_directory(), diagram->name + ".puml", src);
} }
{ {
@@ -106,8 +106,50 @@ TEST_CASE("t00006", "[test-case][class]")
save_json(config.output_directory(), diagram->name + ".json", j); save_json(config.output_directory(), diagram->name + ".json", j);
} }
{ {
auto mmd = generate_class_mermaid(diagram, *model); auto src = generate_class_mermaid(diagram, *model);
using mermaid::AliasMatcher;
save_mermaid(config.output_directory(), diagram->name + ".mmd", mmd); AliasMatcher _A(src);
REQUIRE_THAT(src, IsClass(_A("A")));
REQUIRE_THAT(src, IsClass(_A("B")));
REQUIRE_THAT(src, IsClass(_A("C")));
REQUIRE_THAT(src, IsClass(_A("D")));
REQUIRE_THAT(src, IsClass(_A("E")));
REQUIRE_THAT(src, IsClass(_A("F")));
REQUIRE_THAT(src, IsClass(_A("G")));
REQUIRE_THAT(src, IsClass(_A("H")));
REQUIRE_THAT(src, IsClass(_A("I")));
REQUIRE_THAT(src, IsClass(_A("J")));
REQUIRE_THAT(src, IsClass(_A("K")));
REQUIRE_THAT(src, IsClass(_A("L")));
REQUIRE_THAT(src, IsClass(_A("M")));
REQUIRE_THAT(src, IsClass(_A("N")));
REQUIRE_THAT(src, IsClass(_A("NN")));
REQUIRE_THAT(src, IsClass(_A("NNN")));
REQUIRE_THAT(src,
IsInstantiation(
_A("custom_container<T>"), _A("custom_container<E>")));
REQUIRE_THAT(src, IsAggregation(_A("R"), _A("A"), "+a"));
REQUIRE_THAT(src, IsAssociation(_A("R"), _A("B"), "+b"));
REQUIRE_THAT(src, IsAggregation(_A("R"), _A("C"), "+c"));
REQUIRE_THAT(src, IsAssociation(_A("R"), _A("D"), "+d"));
REQUIRE_THAT(
src, IsAggregation(_A("R"), _A("custom_container<E>"), "+e"));
REQUIRE_THAT(src, IsAggregation(_A("R"), _A("F"), "+f"));
REQUIRE_THAT(src, IsAssociation(_A("R"), _A("G"), "+g"));
REQUIRE_THAT(src, IsAggregation(_A("R"), _A("H"), "+h"));
REQUIRE_THAT(src, IsAssociation(_A("R"), _A("I"), "+i"));
REQUIRE_THAT(src, IsAggregation(_A("R"), _A("J"), "+j"));
REQUIRE_THAT(src, IsAssociation(_A("R"), _A("K"), "+k"));
REQUIRE_THAT(src, IsAggregation(_A("R"), _A("L"), "+lm"));
REQUIRE_THAT(src, IsAggregation(_A("R"), _A("M"), "+lm"));
REQUIRE_THAT(src, IsAggregation(_A("R"), _A("N"), "+ns"));
REQUIRE_THAT(src, IsAggregation(_A("R"), _A("NN"), "+ns"));
REQUIRE_THAT(src, IsAggregation(_A("R"), _A("NNN"), "+ns"));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
} }
} }

39
tests/t00007/test_case.h
View File

@@ -29,21 +29,21 @@ TEST_CASE("t00007", "[test-case][class]")
REQUIRE(model->name() == "t00007_class"); REQUIRE(model->name() == "t00007_class");
{ {
auto puml = generate_class_puml(diagram, *model); auto src = generate_class_puml(diagram, *model);
AliasMatcher _A(puml); AliasMatcher _A(src);
REQUIRE_THAT(puml, StartsWith("@startuml")); REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(puml, EndsWith("@enduml\n")); REQUIRE_THAT(src, EndsWith("@enduml\n"));
REQUIRE_THAT(puml, IsClass(_A("A"))); REQUIRE_THAT(src, IsClass(_A("A")));
REQUIRE_THAT(puml, IsClass(_A("B"))); REQUIRE_THAT(src, IsClass(_A("B")));
REQUIRE_THAT(puml, IsClass(_A("C"))); REQUIRE_THAT(src, IsClass(_A("C")));
REQUIRE_THAT(puml, IsClass(_A("R"))); REQUIRE_THAT(src, IsClass(_A("R")));
REQUIRE_THAT(puml, IsAggregation(_A("R"), _A("A"), "+a")); REQUIRE_THAT(src, IsAggregation(_A("R"), _A("A"), "+a"));
REQUIRE_THAT(puml, IsAssociation(_A("R"), _A("B"), "+b")); REQUIRE_THAT(src, IsAssociation(_A("R"), _A("B"), "+b"));
REQUIRE_THAT(puml, IsAssociation(_A("R"), _A("C"), "+c")); REQUIRE_THAT(src, IsAssociation(_A("R"), _A("C"), "+c"));
save_puml(config.output_directory(), diagram->name + ".puml", puml); save_puml(config.output_directory(), diagram->name + ".puml", src);
} }
{ {
auto j = generate_class_json(diagram, *model); auto j = generate_class_json(diagram, *model);
@@ -61,8 +61,19 @@ TEST_CASE("t00007", "[test-case][class]")
save_json(config.output_directory(), diagram->name + ".json", j); save_json(config.output_directory(), diagram->name + ".json", j);
} }
{ {
auto mmd = generate_class_mermaid(diagram, *model); auto src = generate_class_mermaid(diagram, *model);
save_mermaid(config.output_directory(), diagram->name + ".mmd", mmd); mermaid::AliasMatcher _A(src);
REQUIRE_THAT(src, IsClass(_A("A")));
REQUIRE_THAT(src, IsClass(_A("B")));
REQUIRE_THAT(src, IsClass(_A("C")));
REQUIRE_THAT(src, IsClass(_A("R")));
REQUIRE_THAT(src, IsAggregation(_A("R"), _A("A"), "+a"));
REQUIRE_THAT(src, IsAssociation(_A("R"), _A("B"), "+b"));
REQUIRE_THAT(src, IsAssociation(_A("R"), _A("C"), "+c"));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
} }
} }

61
tests/t00008/test_case.h
View File

@@ -29,34 +29,34 @@ TEST_CASE("t00008", "[test-case][class]")
REQUIRE(model->name() == "t00008_class"); REQUIRE(model->name() == "t00008_class");
{ {
auto puml = generate_class_puml(diagram, *model); auto src = generate_class_puml(diagram, *model);
AliasMatcher _A(puml); AliasMatcher _A(src);
REQUIRE_THAT(puml, StartsWith("@startuml")); REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(puml, EndsWith("@enduml\n")); REQUIRE_THAT(src, EndsWith("@enduml\n"));
// TODO: add option to resolve using declared types // TODO: add option to resolve using declared types
// REQUIRE_THAT(puml, IsClassTemplate("A", "T, P, bool (*)(int, int), // REQUIRE_THAT(puml, IsClassTemplate("A", "T, P, bool (*)(int, int),
// int N")); // int N"));
REQUIRE_THAT(puml, IsClassTemplate("A", "T,P=T,CMP=nullptr,int N=3")); REQUIRE_THAT(src, IsClassTemplate("A", "T,P=T,CMP=nullptr,int N=3"));
REQUIRE_THAT(puml, IsClassTemplate("B", "T,C<>")); REQUIRE_THAT(src, IsClassTemplate("B", "T,C<>"));
REQUIRE_THAT(puml, (IsField<Public>("value", "T"))); REQUIRE_THAT(src, (IsField<Public>("value", "T")));
REQUIRE_THAT(puml, (IsField<Public>("pointer", "T *"))); REQUIRE_THAT(src, (IsField<Public>("pointer", "T *")));
REQUIRE_THAT(puml, (IsField<Public>("reference", "T &"))); REQUIRE_THAT(src, (IsField<Public>("reference", "T &")));
REQUIRE_THAT(puml, (IsField<Public>("values", "std::vector<P>"))); REQUIRE_THAT(src, (IsField<Public>("values", "std::vector<P>")));
REQUIRE_THAT(puml, (IsField<Public>("ints", "std::array<int,N>"))); REQUIRE_THAT(src, (IsField<Public>("ints", "std::array<int,N>")));
// TODO: add option to resolve using declared types // TODO: add option to resolve using declared types
// REQUIRE_THAT(puml, IsField(Public("bool (*)(int, int) comparator"))); // REQUIRE_THAT(puml, IsField(Public("bool (*)(int, int) comparator")));
REQUIRE_THAT(puml, (IsField<Public>("comparator", "CMP"))); REQUIRE_THAT(src, (IsField<Public>("comparator", "CMP")));
REQUIRE_THAT(puml, !IsClass(_A("E::nested_template"))); REQUIRE_THAT(src, !IsClass(_A("E::nested_template")));
REQUIRE_THAT(puml, IsClassTemplate("E::nested_template", "ET")); REQUIRE_THAT(src, IsClassTemplate("E::nested_template", "ET"));
REQUIRE_THAT(puml, IsClassTemplate("E::nested_template", "char")); REQUIRE_THAT(src, IsClassTemplate("E::nested_template", "char"));
REQUIRE_THAT(puml, REQUIRE_THAT(src,
IsInstantiation( IsInstantiation(
_A("E::nested_template<ET>"), _A("E::nested_template<char>"))); _A("E::nested_template<ET>"), _A("E::nested_template<char>")));
save_puml(config.output_directory(), diagram->name + ".puml", puml); save_puml(config.output_directory(), diagram->name + ".puml", src);
} }
{ {
auto j = generate_class_json(diagram, *model); auto j = generate_class_json(diagram, *model);
@@ -75,8 +75,31 @@ TEST_CASE("t00008", "[test-case][class]")
save_json(config.output_directory(), diagram->name + ".json", j); save_json(config.output_directory(), diagram->name + ".json", j);
} }
{ {
auto mmd = generate_class_mermaid(diagram, *model); auto src = generate_class_mermaid(diagram, *model);
save_mermaid(config.output_directory(), diagram->name + ".mmd", mmd); mermaid::AliasMatcher _A(src);
using mermaid::IsField;
REQUIRE_THAT(src, IsClass(_A("A<T,P=T,CMP=nullptr,int N=3>")));
REQUIRE_THAT(src, IsClass(_A("B<T,C<>>")));
REQUIRE_THAT(src, (IsField<Public>("value", "T")));
REQUIRE_THAT(src, (IsField<Public>("pointer", "T *")));
REQUIRE_THAT(src, (IsField<Public>("reference", "T &")));
REQUIRE_THAT(src, (IsField<Public>("values", "std::vector<P>")));
REQUIRE_THAT(src, (IsField<Public>("ints", "std::array<int,N>")));
// TODO: add option to resolve using declared types
// REQUIRE_THAT(puml, IsField(Public("bool (*)(int, int) comparator")));
REQUIRE_THAT(src, (IsField<Public>("comparator", "CMP")));
REQUIRE_THAT(src, !IsClass(_A("E::nested_template")));
REQUIRE_THAT(src, IsClass(_A("E::nested_template<ET>")));
REQUIRE_THAT(src, IsClass(_A("E::nested_template<char>")));
REQUIRE_THAT(src,
IsInstantiation(
_A("E::nested_template<ET>"), _A("E::nested_template<char>")));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
} }
} }

64
tests/t00009/test_case.h
View File

@@ -29,31 +29,31 @@ TEST_CASE("t00009", "[test-case][class]")
REQUIRE(model->name() == "t00009_class"); REQUIRE(model->name() == "t00009_class");
{ {
auto puml = generate_class_puml(diagram, *model); auto src = generate_class_puml(diagram, *model);
AliasMatcher _A(puml); AliasMatcher _A(src);
REQUIRE_THAT(puml, StartsWith("@startuml")); REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(puml, EndsWith("@enduml\n")); REQUIRE_THAT(src, EndsWith("@enduml\n"));
REQUIRE_THAT(puml, IsClassTemplate("A", "T")); REQUIRE_THAT(src, IsClassTemplate("A", "T"));
REQUIRE_THAT(puml, IsClass(_A("B"))); REQUIRE_THAT(src, IsClass(_A("B")));
REQUIRE_THAT(puml, (IsField<Public>("value", "T"))); REQUIRE_THAT(src, (IsField<Public>("value", "T")));
REQUIRE_THAT(puml, (IsField<Public>("aint", "A<int>"))); REQUIRE_THAT(src, (IsField<Public>("aint", "A<int>")));
REQUIRE_THAT(puml, (IsField<Public>("astring", "A<std::string> *"))); REQUIRE_THAT(src, (IsField<Public>("astring", "A<std::string> *")));
REQUIRE_THAT(puml,
(IsField<Public>("avector", "A<std::vector<std::string>> &")));
REQUIRE_THAT(puml, IsInstantiation(_A("A<T>"), _A("A<int>")));
REQUIRE_THAT(puml, IsInstantiation(_A("A<T>"), _A("A<std::string>")));
REQUIRE_THAT(puml, IsAggregation(_A("B"), _A("A<int>"), "+aint"));
REQUIRE_THAT( REQUIRE_THAT(
puml, IsAssociation(_A("B"), _A("A<std::string>"), "+astring")); src, (IsField<Public>("avector", "A<std::vector<std::string>> &")));
REQUIRE_THAT(puml,
REQUIRE_THAT(src, IsInstantiation(_A("A<T>"), _A("A<int>")));
REQUIRE_THAT(src, IsInstantiation(_A("A<T>"), _A("A<std::string>")));
REQUIRE_THAT(src, IsAggregation(_A("B"), _A("A<int>"), "+aint"));
REQUIRE_THAT(
src, IsAssociation(_A("B"), _A("A<std::string>"), "+astring"));
REQUIRE_THAT(src,
IsAssociation( IsAssociation(
_A("B"), _A("A<std::vector<std::string>>"), "+avector")); _A("B"), _A("A<std::vector<std::string>>"), "+avector"));
save_puml(config.output_directory(), diagram->name + ".puml", puml); save_puml(config.output_directory(), diagram->name + ".puml", src);
} }
{ {
auto j = generate_class_json(diagram, *model); auto j = generate_class_json(diagram, *model);
@@ -73,8 +73,30 @@ TEST_CASE("t00009", "[test-case][class]")
save_json(config.output_directory(), diagram->name + ".json", j); save_json(config.output_directory(), diagram->name + ".json", j);
} }
{ {
auto mmd = generate_class_mermaid(diagram, *model); auto src = generate_class_mermaid(diagram, *model);
save_mermaid(config.output_directory(), diagram->name + ".mmd", mmd); mermaid::AliasMatcher _A(src);
using mermaid::IsField;
REQUIRE_THAT(src, IsClass(_A("A<T>")));
REQUIRE_THAT(src, IsClass(_A("B")));
REQUIRE_THAT(src, (IsField<Public>("value", "T")));
REQUIRE_THAT(src, (IsField<Public>("aint", "A<int>")));
REQUIRE_THAT(src, (IsField<Public>("astring", "A<std::string> *")));
REQUIRE_THAT(
src, (IsField<Public>("avector", "A<std::vector<std::string>> &")));
REQUIRE_THAT(src, IsInstantiation(_A("A<T>"), _A("A<int>")));
REQUIRE_THAT(src, IsInstantiation(_A("A<T>"), _A("A<std::string>")));
REQUIRE_THAT(src, IsAggregation(_A("B"), _A("A<int>"), "+aint"));
REQUIRE_THAT(
src, IsAssociation(_A("B"), _A("A<std::string>"), "+astring"));
REQUIRE_THAT(src,
IsAssociation(
_A("B"), _A("A<std::vector<std::string>>"), "+avector"));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
} }
} }

49
tests/t00010/test_case.h
View File

@@ -29,26 +29,26 @@ TEST_CASE("t00010", "[test-case][class]")
REQUIRE(model->name() == "t00010_class"); REQUIRE(model->name() == "t00010_class");
{ {
auto puml = generate_class_puml(diagram, *model); auto src = generate_class_puml(diagram, *model);
AliasMatcher _A(puml); AliasMatcher _A(src);
REQUIRE_THAT(puml, StartsWith("@startuml")); REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(puml, EndsWith("@enduml\n")); REQUIRE_THAT(src, EndsWith("@enduml\n"));
REQUIRE_THAT(puml, IsClassTemplate("A", "T,P")); REQUIRE_THAT(src, IsClassTemplate("A", "T,P"));
REQUIRE_THAT(puml, IsClassTemplate("B", "T")); REQUIRE_THAT(src, IsClassTemplate("B", "T"));
REQUIRE_THAT(puml, (IsField<Public>("astring", "A<T,std::string>"))); REQUIRE_THAT(src, (IsField<Public>("astring", "A<T,std::string>")));
REQUIRE_THAT(puml, (IsField<Public>("aintstring", "B<int>"))); REQUIRE_THAT(src, (IsField<Public>("aintstring", "B<int>")));
REQUIRE_THAT( REQUIRE_THAT(
puml, IsInstantiation(_A("A<T,P>"), _A("A<T,std::string>"))); src, IsInstantiation(_A("A<T,P>"), _A("A<T,std::string>")));
REQUIRE_THAT(puml, IsInstantiation(_A("B<T>"), _A("B<int>"))); REQUIRE_THAT(src, IsInstantiation(_A("B<T>"), _A("B<int>")));
REQUIRE_THAT(puml, REQUIRE_THAT(
IsAggregation(_A("B<T>"), _A("A<T,std::string>"), "+astring")); src, IsAggregation(_A("B<T>"), _A("A<T,std::string>"), "+astring"));
REQUIRE_THAT(puml, IsAggregation(_A("C"), _A("B<int>"), "+aintstring")); REQUIRE_THAT(src, IsAggregation(_A("C"), _A("B<int>"), "+aintstring"));
save_puml(config.output_directory(), diagram->name + ".puml", puml); save_puml(config.output_directory(), diagram->name + ".puml", src);
} }
{ {
auto j = generate_class_json(diagram, *model); auto j = generate_class_json(diagram, *model);
@@ -66,8 +66,25 @@ TEST_CASE("t00010", "[test-case][class]")
save_json(config.output_directory(), diagram->name + ".json", j); save_json(config.output_directory(), diagram->name + ".json", j);
} }
{ {
auto mmd = generate_class_mermaid(diagram, *model); auto src = generate_class_mermaid(diagram, *model);
save_mermaid(config.output_directory(), diagram->name + ".mmd", mmd); mermaid::AliasMatcher _A(src);
using mermaid::IsField;
REQUIRE_THAT(src, IsClass(_A("A<T,P>")));
REQUIRE_THAT(src, IsClass(_A("B<T>")));
REQUIRE_THAT(src, (IsField<Public>("astring", "A<T,std::string>")));
REQUIRE_THAT(src, (IsField<Public>("aintstring", "B<int>")));
REQUIRE_THAT(
src, IsInstantiation(_A("A<T,P>"), _A("A<T,std::string>")));
REQUIRE_THAT(src, IsInstantiation(_A("B<T>"), _A("B<int>")));
REQUIRE_THAT(
src, IsAggregation(_A("B<T>"), _A("A<T,std::string>"), "+astring"));
REQUIRE_THAT(src, IsAggregation(_A("C"), _A("B<int>"), "+aintstring"));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
} }
} }

35
tests/t00011/test_case.h
View File

@@ -29,21 +29,19 @@ TEST_CASE("t00011", "[test-case][class]")
REQUIRE(model->name() == "t00011_class"); REQUIRE(model->name() == "t00011_class");
{ {
auto puml = generate_class_puml(diagram, *model); auto src = generate_class_puml(diagram, *model);
AliasMatcher _A(puml); AliasMatcher _A(src);
REQUIRE_THAT(puml, StartsWith("@startuml")); REQUIRE_THAT(src, IsClass(_A("A")));
REQUIRE_THAT(puml, EndsWith("@enduml\n")); REQUIRE_THAT(src, IsClass(_A("B")));
REQUIRE_THAT(puml, IsClass(_A("A"))); REQUIRE_THAT(src, !IsClass(_A("external::C")));
REQUIRE_THAT(puml, IsClass(_A("B"))); REQUIRE_THAT(src, IsClass(_A("D<T>")));
REQUIRE_THAT(puml, !IsClass(_A("external::C")));
REQUIRE_THAT(puml, IsClass(_A("D<T>")));
REQUIRE_THAT(puml, IsAssociation(_A("B"), _A("A"))); REQUIRE_THAT(src, IsAssociation(_A("B"), _A("A")));
REQUIRE_THAT(puml, IsFriend<Public>(_A("A"), _A("B"))); REQUIRE_THAT(src, IsFriend<Public>(_A("A"), _A("B")));
// REQUIRE_THAT(puml, IsFriend(_A("A"), _A("D<T>"))); // REQUIRE_THAT(puml, IsFriend(_A("A"), _A("D<T>")));
save_puml(config.output_directory(), diagram->name + ".puml", puml); save_puml(config.output_directory(), diagram->name + ".puml", src);
} }
{ {
auto j = generate_class_json(diagram, *model); auto j = generate_class_json(diagram, *model);
@@ -58,8 +56,19 @@ TEST_CASE("t00011", "[test-case][class]")
save_json(config.output_directory(), diagram->name + ".json", j); save_json(config.output_directory(), diagram->name + ".json", j);
} }
{ {
auto mmd = generate_class_mermaid(diagram, *model); auto src = generate_class_mermaid(diagram, *model);
save_mermaid(config.output_directory(), diagram->name + ".mmd", mmd); mermaid::AliasMatcher _A(src);
REQUIRE_THAT(src, IsClass(_A("A")));
REQUIRE_THAT(src, IsClass(_A("B")));
REQUIRE_THAT(src, !IsClass(_A("external::C")));
REQUIRE_THAT(src, IsClass(_A("D<T>")));
REQUIRE_THAT(src, IsAssociation(_A("B"), _A("A")));
REQUIRE_THAT(src, IsFriend<Public>(_A("A"), _A("B")));
// REQUIRE_THAT(puml, IsFriend(_A("A"), _A("D<T>")));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
} }
} }

38
tests/t00012/test_case.h
View File

@@ -29,24 +29,24 @@ TEST_CASE("t00012", "[test-case][class]")
REQUIRE(model->name() == "t00012_class"); REQUIRE(model->name() == "t00012_class");
{ {
auto puml = generate_class_puml(diagram, *model); auto src = generate_class_puml(diagram, *model);
AliasMatcher _A(puml); AliasMatcher _A(src);
REQUIRE_THAT(puml, StartsWith("@startuml")); REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(puml, EndsWith("@enduml\n")); REQUIRE_THAT(src, EndsWith("@enduml\n"));
REQUIRE_THAT(puml, IsClassTemplate("A", "T,Ts...")); REQUIRE_THAT(src, IsClassTemplate("A", "T,Ts..."));
REQUIRE_THAT(puml, IsClassTemplate("B", "int... Is")); REQUIRE_THAT(src, IsClassTemplate("B", "int... Is"));
REQUIRE_THAT(puml, IsInstantiation(_A("B<int... Is>"), _A("B<3,2,1>"))); REQUIRE_THAT(src, IsInstantiation(_A("B<int... Is>"), _A("B<3,2,1>")));
REQUIRE_THAT( REQUIRE_THAT(
puml, IsInstantiation(_A("B<int... Is>"), _A("B<1,1,1,1>"))); src, IsInstantiation(_A("B<int... Is>"), _A("B<1,1,1,1>")));
REQUIRE_THAT(puml, REQUIRE_THAT(src,
IsInstantiation(_A("C<T,int... Is>"), IsInstantiation(_A("C<T,int... Is>"),
_A("C<std::map<int," _A("C<std::map<int,"
"std::vector<std::vector<std::vector<std::string>>>>,3,3," "std::vector<std::vector<std::vector<std::string>>>>,3,3,"
"3>"))); "3>")));
save_puml(config.output_directory(), diagram->name + ".puml", puml); save_puml(config.output_directory(), diagram->name + ".puml", src);
} }
{ {
auto j = generate_class_json(diagram, *model); auto j = generate_class_json(diagram, *model);
@@ -64,8 +64,22 @@ TEST_CASE("t00012", "[test-case][class]")
save_json(config.output_directory(), diagram->name + ".json", j); save_json(config.output_directory(), diagram->name + ".json", j);
} }
{ {
auto mmd = generate_class_mermaid(diagram, *model); auto src = generate_class_mermaid(diagram, *model);
save_mermaid(config.output_directory(), diagram->name + ".mmd", mmd); mermaid::AliasMatcher _A(src);
REQUIRE_THAT(src, IsClass(_A("A<T,Ts...>")));
REQUIRE_THAT(src, IsClass(_A("B<int... Is>")));
REQUIRE_THAT(src, IsInstantiation(_A("B<int... Is>"), _A("B<3,2,1>")));
REQUIRE_THAT(
src, IsInstantiation(_A("B<int... Is>"), _A("B<1,1,1,1>")));
REQUIRE_THAT(src,
IsInstantiation(_A("C<T,int... Is>"),
_A("C<std::map<int,"
"std::vector<std::vector<std::vector<std::string>>>>,3,3,"
"3>")));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
} }
} }

86
tests/t00013/test_case.h
View File

@@ -29,40 +29,40 @@ TEST_CASE("t00013", "[test-case][class]")
REQUIRE(model->name() == "t00013_class"); REQUIRE(model->name() == "t00013_class");
{ {
auto puml = generate_class_puml(diagram, *model); auto src = generate_class_puml(diagram, *model);
AliasMatcher _A(puml); AliasMatcher _A(src);
REQUIRE_THAT(puml, StartsWith("@startuml")); REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(puml, EndsWith("@enduml\n")); REQUIRE_THAT(src, EndsWith("@enduml\n"));
REQUIRE_THAT(puml, IsClass(_A("A"))); REQUIRE_THAT(src, IsClass(_A("A")));
REQUIRE_THAT(puml, IsClass(_A("B"))); REQUIRE_THAT(src, IsClass(_A("B")));
REQUIRE_THAT(puml, IsClass(_A("C"))); REQUIRE_THAT(src, IsClass(_A("C")));
REQUIRE_THAT(puml, IsClass(_A("D"))); REQUIRE_THAT(src, IsClass(_A("D")));
REQUIRE_THAT(puml, IsClassTemplate("E", "T")); REQUIRE_THAT(src, IsClassTemplate("E", "T"));
REQUIRE_THAT(puml, IsClassTemplate("G", "T,Args...")); REQUIRE_THAT(src, IsClassTemplate("G", "T,Args..."));
REQUIRE_THAT(puml, !IsDependency(_A("R"), _A("R"))); REQUIRE_THAT(src, !IsDependency(_A("R"), _A("R")));
REQUIRE_THAT(puml, IsDependency(_A("R"), _A("A"))); REQUIRE_THAT(src, IsDependency(_A("R"), _A("A")));
REQUIRE_THAT(puml, IsDependency(_A("R"), _A("B"))); REQUIRE_THAT(src, IsDependency(_A("R"), _A("B")));
REQUIRE_THAT(puml, IsDependency(_A("R"), _A("C"))); REQUIRE_THAT(src, IsDependency(_A("R"), _A("C")));
REQUIRE_THAT(puml, IsDependency(_A("R"), _A("D"))); REQUIRE_THAT(src, IsDependency(_A("R"), _A("D")));
REQUIRE_THAT(puml, IsDependency(_A("D"), _A("R"))); REQUIRE_THAT(src, IsDependency(_A("D"), _A("R")));
REQUIRE_THAT(puml, IsDependency(_A("R"), _A("E<T>"))); REQUIRE_THAT(src, IsDependency(_A("R"), _A("E<T>")));
REQUIRE_THAT(puml, IsDependency(_A("R"), _A("E<int>"))); REQUIRE_THAT(src, IsDependency(_A("R"), _A("E<int>")));
REQUIRE_THAT(puml, IsInstantiation(_A("E<T>"), _A("E<int>"))); REQUIRE_THAT(src, IsInstantiation(_A("E<T>"), _A("E<int>")));
REQUIRE_THAT(puml, IsInstantiation(_A("E<T>"), _A("E<std::string>"))); REQUIRE_THAT(src, IsInstantiation(_A("E<T>"), _A("E<std::string>")));
REQUIRE_THAT( REQUIRE_THAT(
puml, IsAggregation(_A("R"), _A("E<std::string>"), "-estring")); src, IsAggregation(_A("R"), _A("E<std::string>"), "-estring"));
REQUIRE_THAT(puml, IsDependency(_A("R"), _A("ABCD::F<T>"))); REQUIRE_THAT(src, IsDependency(_A("R"), _A("ABCD::F<T>")));
REQUIRE_THAT( REQUIRE_THAT(
puml, IsInstantiation(_A("ABCD::F<T>"), _A("ABCD::F<int>"))); src, IsInstantiation(_A("ABCD::F<T>"), _A("ABCD::F<int>")));
REQUIRE_THAT(puml, IsDependency(_A("R"), _A("ABCD::F<int>"))); REQUIRE_THAT(src, IsDependency(_A("R"), _A("ABCD::F<int>")));
REQUIRE_THAT(puml, REQUIRE_THAT(src,
IsInstantiation( IsInstantiation(
_A("G<T,Args...>"), _A("G<int,float,std::string>"))); _A("G<T,Args...>"), _A("G<int,float,std::string>")));
save_puml(config.output_directory(), diagram->name + ".puml", puml); save_puml(config.output_directory(), diagram->name + ".puml", src);
} }
{ {
auto j = generate_class_json(diagram, *model); auto j = generate_class_json(diagram, *model);
@@ -85,8 +85,38 @@ TEST_CASE("t00013", "[test-case][class]")
save_json(config.output_directory(), diagram->name + ".json", j); save_json(config.output_directory(), diagram->name + ".json", j);
} }
{ {
auto mmd = generate_class_mermaid(diagram, *model); auto src = generate_class_mermaid(diagram, *model);
save_mermaid(config.output_directory(), diagram->name + ".mmd", mmd); mermaid::AliasMatcher _A(src);
REQUIRE_THAT(src, IsClass(_A("A")));
REQUIRE_THAT(src, IsClass(_A("B")));
REQUIRE_THAT(src, IsClass(_A("C")));
REQUIRE_THAT(src, IsClass(_A("D")));
REQUIRE_THAT(src, IsClass(_A("E<T>")));
REQUIRE_THAT(src, IsClass(_A("G<T,Args...>")));
REQUIRE_THAT(src, !IsDependency(_A("R"), _A("R")));
REQUIRE_THAT(src, IsDependency(_A("R"), _A("A")));
REQUIRE_THAT(src, IsDependency(_A("R"), _A("B")));
REQUIRE_THAT(src, IsDependency(_A("R"), _A("C")));
REQUIRE_THAT(src, IsDependency(_A("R"), _A("D")));
REQUIRE_THAT(src, IsDependency(_A("D"), _A("R")));
REQUIRE_THAT(src, IsDependency(_A("R"), _A("E<T>")));
REQUIRE_THAT(src, IsDependency(_A("R"), _A("E<int>")));
REQUIRE_THAT(src, IsInstantiation(_A("E<T>"), _A("E<int>")));
REQUIRE_THAT(src, IsInstantiation(_A("E<T>"), _A("E<std::string>")));
REQUIRE_THAT(
src, IsAggregation(_A("R"), _A("E<std::string>"), "-estring"));
REQUIRE_THAT(src, IsDependency(_A("R"), _A("ABCD::F<T>")));
REQUIRE_THAT(
src, IsInstantiation(_A("ABCD::F<T>"), _A("ABCD::F<int>")));
REQUIRE_THAT(src, IsDependency(_A("R"), _A("ABCD::F<int>")));
REQUIRE_THAT(src,
IsInstantiation(
_A("G<T,Args...>"), _A("G<int,float,std::string>")));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
} }
} }

247
tests/t00014/test_case.h
View File

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

32
tests/t00015/test_case.h
View File

@@ -29,18 +29,18 @@ TEST_CASE("t00015", "[test-case][class]")
REQUIRE(model->name() == "t00015_class"); REQUIRE(model->name() == "t00015_class");
{ {
auto puml = generate_class_puml(diagram, *model); auto src = generate_class_puml(diagram, *model);
AliasMatcher _A(puml); AliasMatcher _A(src);
REQUIRE_THAT(puml, StartsWith("@startuml")); REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(puml, EndsWith("@enduml\n")); REQUIRE_THAT(src, EndsWith("@enduml\n"));
REQUIRE_THAT(puml, IsClass(_A("ns1::A"))); REQUIRE_THAT(src, IsClass(_A("ns1::A")));
REQUIRE_THAT(puml, IsClass(_A("ns1::ns2_v0_9_0::A"))); REQUIRE_THAT(src, IsClass(_A("ns1::ns2_v0_9_0::A")));
REQUIRE_THAT(puml, IsClass(_A("ns1::Anon"))); REQUIRE_THAT(src, IsClass(_A("ns1::Anon")));
REQUIRE_THAT(puml, IsClass(_A("ns3::ns1::ns2::Anon"))); REQUIRE_THAT(src, IsClass(_A("ns3::ns1::ns2::Anon")));
REQUIRE_THAT(puml, IsClass(_A("ns3::B"))); REQUIRE_THAT(src, IsClass(_A("ns3::B")));
save_puml(config.output_directory(), diagram->name + ".puml", puml); save_puml(config.output_directory(), diagram->name + ".puml", src);
} }
{ {
auto j = generate_class_json(diagram, *model); auto j = generate_class_json(diagram, *model);
@@ -56,8 +56,16 @@ TEST_CASE("t00015", "[test-case][class]")
save_json(config.output_directory(), diagram->name + ".json", j); save_json(config.output_directory(), diagram->name + ".json", j);
} }
{ {
auto mmd = generate_class_mermaid(diagram, *model); auto src = generate_class_mermaid(diagram, *model);
save_mermaid(config.output_directory(), diagram->name + ".mmd", mmd); mermaid::AliasMatcher _A(src);
REQUIRE_THAT(src, IsClass(_A("ns1::A")));
REQUIRE_THAT(src, IsClass(_A("ns1::ns2_v0_9_0::A")));
REQUIRE_THAT(src, IsClass(_A("ns1::Anon")));
REQUIRE_THAT(src, IsClass(_A("ns3::ns1::ns2::Anon")));
REQUIRE_THAT(src, IsClass(_A("ns3::B")));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
} }
} }

52
tests/t00016/test_case.h
View File

@@ -29,30 +29,30 @@ TEST_CASE("t00016", "[test-case][class]")
REQUIRE(model->name() == "t00016_class"); REQUIRE(model->name() == "t00016_class");
{ {
auto puml = generate_class_puml(diagram, *model); auto src = generate_class_puml(diagram, *model);
AliasMatcher _A(puml); AliasMatcher _A(src);
REQUIRE_THAT(puml, StartsWith("@startuml")); REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(puml, EndsWith("@enduml\n")); REQUIRE_THAT(src, EndsWith("@enduml\n"));
REQUIRE_THAT(puml, IsClassTemplate("is_numeric", "typename")); REQUIRE_THAT(src, IsClassTemplate("is_numeric", "typename"));
REQUIRE_THAT(puml, IsClassTemplate("is_numeric", "int")); REQUIRE_THAT(src, IsClassTemplate("is_numeric", "int"));
REQUIRE_THAT(puml, IsClassTemplate("is_numeric", "bool")); REQUIRE_THAT(src, IsClassTemplate("is_numeric", "bool"));
REQUIRE_THAT(puml, IsClassTemplate("is_numeric", "char")); REQUIRE_THAT(src, IsClassTemplate("is_numeric", "char"));
REQUIRE_THAT(puml, IsClassTemplate("is_numeric", "float")); REQUIRE_THAT(src, IsClassTemplate("is_numeric", "float"));
REQUIRE_THAT(puml, REQUIRE_THAT(src,
IsInstantiation(_A("is_numeric<typename>"), _A("is_numeric<int>"))); IsInstantiation(_A("is_numeric<typename>"), _A("is_numeric<int>")));
REQUIRE_THAT(puml, REQUIRE_THAT(src,
IsInstantiation( IsInstantiation(
_A("is_numeric<typename>"), _A("is_numeric<bool>"))); _A("is_numeric<typename>"), _A("is_numeric<bool>")));
REQUIRE_THAT(puml, REQUIRE_THAT(src,
IsInstantiation( IsInstantiation(
_A("is_numeric<typename>"), _A("is_numeric<char>"))); _A("is_numeric<typename>"), _A("is_numeric<char>")));
REQUIRE_THAT(puml, REQUIRE_THAT(src,
IsInstantiation( IsInstantiation(
_A("is_numeric<typename>"), _A("is_numeric<float>"))); _A("is_numeric<typename>"), _A("is_numeric<float>")));
save_puml(config.output_directory(), diagram->name + ".puml", puml); save_puml(config.output_directory(), diagram->name + ".puml", src);
} }
{ {
auto j = generate_class_json(diagram, *model); auto j = generate_class_json(diagram, *model);
@@ -68,8 +68,28 @@ TEST_CASE("t00016", "[test-case][class]")
save_json(config.output_directory(), diagram->name + ".json", j); save_json(config.output_directory(), diagram->name + ".json", j);
} }
{ {
auto mmd = generate_class_mermaid(diagram, *model); auto src = generate_class_mermaid(diagram, *model);
save_mermaid(config.output_directory(), diagram->name + ".mmd", mmd); mermaid::AliasMatcher _A(src);
REQUIRE_THAT(src, IsClass(_A("is_numeric<typename>")));
REQUIRE_THAT(src, IsClass(_A("is_numeric<int>")));
REQUIRE_THAT(src, IsClass(_A("is_numeric<bool>")));
REQUIRE_THAT(src, IsClass(_A("is_numeric<char>")));
REQUIRE_THAT(src, IsClass(_A("is_numeric<float>")));
REQUIRE_THAT(src,
IsInstantiation(_A("is_numeric<typename>"), _A("is_numeric<int>")));
REQUIRE_THAT(src,
IsInstantiation(
_A("is_numeric<typename>"), _A("is_numeric<bool>")));
REQUIRE_THAT(src,
IsInstantiation(
_A("is_numeric<typename>"), _A("is_numeric<char>")));
REQUIRE_THAT(src,
IsInstantiation(
_A("is_numeric<typename>"), _A("is_numeric<float>")));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
} }
} }

106
tests/t00017/test_case.h
View File

@@ -29,46 +29,46 @@ TEST_CASE("t00017", "[test-case][class]")
REQUIRE(model->name() == "t00017_class"); REQUIRE(model->name() == "t00017_class");
{ {
auto puml = generate_class_puml(diagram, *model); auto src = generate_class_puml(diagram, *model);
AliasMatcher _A(puml); AliasMatcher _A(src);
REQUIRE_THAT(puml, StartsWith("@startuml")); REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(puml, EndsWith("@enduml\n")); REQUIRE_THAT(src, EndsWith("@enduml\n"));
REQUIRE_THAT(puml, IsClass(_A("A"))); REQUIRE_THAT(src, IsClass(_A("A")));
REQUIRE_THAT(puml, IsClass(_A("B"))); REQUIRE_THAT(src, IsClass(_A("B")));
REQUIRE_THAT(puml, IsClass(_A("C"))); REQUIRE_THAT(src, IsClass(_A("C")));
REQUIRE_THAT(puml, IsClass(_A("D"))); REQUIRE_THAT(src, IsClass(_A("D")));
REQUIRE_THAT(puml, IsClass(_A("E"))); REQUIRE_THAT(src, IsClass(_A("E")));
REQUIRE_THAT(puml, IsClass(_A("F"))); REQUIRE_THAT(src, IsClass(_A("F")));
REQUIRE_THAT(puml, IsClass(_A("G"))); REQUIRE_THAT(src, IsClass(_A("G")));
REQUIRE_THAT(puml, IsClass(_A("H"))); REQUIRE_THAT(src, IsClass(_A("H")));
REQUIRE_THAT(puml, IsClass(_A("I"))); REQUIRE_THAT(src, IsClass(_A("I")));
REQUIRE_THAT(puml, IsClass(_A("J"))); REQUIRE_THAT(src, IsClass(_A("J")));
REQUIRE_THAT(puml, IsClass(_A("K"))); REQUIRE_THAT(src, IsClass(_A("K")));
REQUIRE_THAT(puml, IsClass(_A("R"))); REQUIRE_THAT(src, IsClass(_A("R")));
REQUIRE_THAT(puml, (IsField<Private>("some_int", "int"))); REQUIRE_THAT(src, (IsField<Private>("some_int", "int")));
REQUIRE_THAT(puml, (IsField<Private>("some_int_pointer", "int *"))); REQUIRE_THAT(src, (IsField<Private>("some_int_pointer", "int *")));
REQUIRE_THAT( REQUIRE_THAT(
puml, (IsField<Private>("some_int_pointer_pointer", "int **"))); src, (IsField<Private>("some_int_pointer_pointer", "int **")));
// Relationship members should not be rendered as part of this testcase // Relationship members should not be rendered as part of this testcase
REQUIRE_THAT(puml, !(IsField<Private>("a", _A("A")))); REQUIRE_THAT(src, !(IsField<Private>("a", _A("A"))));
REQUIRE_THAT(puml, !(IsField<Private>("b", _A("B")))); REQUIRE_THAT(src, !(IsField<Private>("b", _A("B"))));
REQUIRE_THAT(puml, IsAggregation(_A("R"), _A("A"), "-a")); REQUIRE_THAT(src, IsAggregation(_A("R"), _A("A"), "-a"));
REQUIRE_THAT(puml, IsAssociation(_A("R"), _A("B"), "-b")); REQUIRE_THAT(src, IsAssociation(_A("R"), _A("B"), "-b"));
REQUIRE_THAT(puml, IsAssociation(_A("R"), _A("C"), "-c")); REQUIRE_THAT(src, IsAssociation(_A("R"), _A("C"), "-c"));
REQUIRE_THAT(puml, IsAssociation(_A("R"), _A("D"), "-d")); REQUIRE_THAT(src, IsAssociation(_A("R"), _A("D"), "-d"));
REQUIRE_THAT(puml, IsAssociation(_A("R"), _A("E"), "-e")); REQUIRE_THAT(src, IsAssociation(_A("R"), _A("E"), "-e"));
REQUIRE_THAT(puml, IsAggregation(_A("R"), _A("F"), "-f")); REQUIRE_THAT(src, IsAggregation(_A("R"), _A("F"), "-f"));
REQUIRE_THAT(puml, IsAssociation(_A("R"), _A("G"), "-g")); REQUIRE_THAT(src, IsAssociation(_A("R"), _A("G"), "-g"));
REQUIRE_THAT(puml, IsAssociation(_A("R"), _A("H"), "-h")); REQUIRE_THAT(src, IsAssociation(_A("R"), _A("H"), "-h"));
REQUIRE_THAT(puml, IsAssociation(_A("R"), _A("I"), "-i")); REQUIRE_THAT(src, IsAssociation(_A("R"), _A("I"), "-i"));
REQUIRE_THAT(puml, IsAssociation(_A("R"), _A("J"), "-j")); REQUIRE_THAT(src, IsAssociation(_A("R"), _A("J"), "-j"));
REQUIRE_THAT(puml, IsAssociation(_A("R"), _A("K"), "-k")); REQUIRE_THAT(src, IsAssociation(_A("R"), _A("K"), "-k"));
save_puml(config.output_directory(), diagram->name + ".puml", puml); save_puml(config.output_directory(), diagram->name + ".puml", src);
} }
{ {
auto j = generate_class_json(diagram, *model); auto j = generate_class_json(diagram, *model);
@@ -91,8 +91,44 @@ TEST_CASE("t00017", "[test-case][class]")
save_json(config.output_directory(), diagram->name + ".json", j); save_json(config.output_directory(), diagram->name + ".json", j);
} }
{ {
auto mmd = generate_class_mermaid(diagram, *model); auto src = generate_class_mermaid(diagram, *model);
mermaid::AliasMatcher _A(src);
using mermaid::IsField;
save_mermaid(config.output_directory(), diagram->name + ".mmd", mmd); REQUIRE_THAT(src, IsClass(_A("A")));
REQUIRE_THAT(src, IsClass(_A("B")));
REQUIRE_THAT(src, IsClass(_A("C")));
REQUIRE_THAT(src, IsClass(_A("D")));
REQUIRE_THAT(src, IsClass(_A("E")));
REQUIRE_THAT(src, IsClass(_A("F")));
REQUIRE_THAT(src, IsClass(_A("G")));
REQUIRE_THAT(src, IsClass(_A("H")));
REQUIRE_THAT(src, IsClass(_A("I")));
REQUIRE_THAT(src, IsClass(_A("J")));
REQUIRE_THAT(src, IsClass(_A("K")));
REQUIRE_THAT(src, IsClass(_A("R")));
REQUIRE_THAT(src, (IsField<Private>("some_int", "int")));
REQUIRE_THAT(src, (IsField<Private>("some_int_pointer", "int *")));
REQUIRE_THAT(
src, (IsField<Private>("some_int_pointer_pointer", "int **")));
// Relationship members should not be rendered as part of this testcase
REQUIRE_THAT(src, !(IsField<Private>("a", _A("A"))));
REQUIRE_THAT(src, !(IsField<Private>("b", _A("B"))));
REQUIRE_THAT(src, IsAggregation(_A("R"), _A("A"), "-a"));
REQUIRE_THAT(src, IsAssociation(_A("R"), _A("B"), "-b"));
REQUIRE_THAT(src, IsAssociation(_A("R"), _A("C"), "-c"));
REQUIRE_THAT(src, IsAssociation(_A("R"), _A("D"), "-d"));
REQUIRE_THAT(src, IsAssociation(_A("R"), _A("E"), "-e"));
REQUIRE_THAT(src, IsAggregation(_A("R"), _A("F"), "-f"));
REQUIRE_THAT(src, IsAssociation(_A("R"), _A("G"), "-g"));
REQUIRE_THAT(src, IsAssociation(_A("R"), _A("H"), "-h"));
REQUIRE_THAT(src, IsAssociation(_A("R"), _A("I"), "-i"));
REQUIRE_THAT(src, IsAssociation(_A("R"), _A("J"), "-j"));
REQUIRE_THAT(src, IsAssociation(_A("R"), _A("K"), "-k"));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
} }
} }

33
tests/t00018/test_case.h
View File

@@ -29,20 +29,20 @@ TEST_CASE("t00018", "[test-case][class]")
REQUIRE(model->name() == "t00018_class"); REQUIRE(model->name() == "t00018_class");
{ {
auto puml = generate_class_puml(diagram, *model); auto src = generate_class_puml(diagram, *model);
AliasMatcher _A(puml); AliasMatcher _A(src);
REQUIRE_THAT(puml, StartsWith("@startuml")); REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(puml, EndsWith("@enduml\n")); REQUIRE_THAT(src, EndsWith("@enduml\n"));
REQUIRE_THAT(puml, IsClass(_A("widget"))); REQUIRE_THAT(src, IsClass(_A("widget")));
REQUIRE_THAT(puml, IsClass(_A("impl::widget"))); REQUIRE_THAT(src, IsClass(_A("impl::widget")));
REQUIRE_THAT( REQUIRE_THAT(
puml, IsAggregation(_A("widget"), _A("impl::widget"), "-pImpl")); src, IsAggregation(_A("widget"), _A("impl::widget"), "-pImpl"));
REQUIRE_THAT(puml, IsDependency(_A("impl::widget"), _A("widget"))); REQUIRE_THAT(src, IsDependency(_A("impl::widget"), _A("widget")));
REQUIRE_THAT(puml, !IsDependency(_A("widget"), _A("widget"))); REQUIRE_THAT(src, !IsDependency(_A("widget"), _A("widget")));
save_puml(config.output_directory(), diagram->name + ".puml", puml); save_puml(config.output_directory(), diagram->name + ".puml", src);
} }
{ {
auto j = generate_class_json(diagram, *model); auto j = generate_class_json(diagram, *model);
@@ -56,8 +56,17 @@ TEST_CASE("t00018", "[test-case][class]")
save_json(config.output_directory(), diagram->name + ".json", j); save_json(config.output_directory(), diagram->name + ".json", j);
} }
{ {
auto mmd = generate_class_mermaid(diagram, *model); auto src = generate_class_mermaid(diagram, *model);
mermaid::AliasMatcher _A(src);
save_mermaid(config.output_directory(), diagram->name + ".mmd", mmd); REQUIRE_THAT(src, IsClass(_A("widget")));
REQUIRE_THAT(src, IsClass(_A("impl::widget")));
REQUIRE_THAT(
src, IsAggregation(_A("widget"), _A("impl::widget"), "-pImpl"));
REQUIRE_THAT(src, IsDependency(_A("impl::widget"), _A("widget")));
REQUIRE_THAT(src, !IsDependency(_A("widget"), _A("widget")));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
} }
} }

83
tests/t00019/test_case.h
View File

@@ -29,47 +29,47 @@ TEST_CASE("t00019", "[test-case][class]")
REQUIRE(model->name() == "t00019_class"); REQUIRE(model->name() == "t00019_class");
{ {
auto puml = generate_class_puml(diagram, *model); auto src = generate_class_puml(diagram, *model);
AliasMatcher _A(puml); AliasMatcher _A(src);
REQUIRE_THAT(puml, StartsWith("@startuml")); REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(puml, EndsWith("@enduml\n")); REQUIRE_THAT(src, EndsWith("@enduml\n"));
REQUIRE_THAT(puml, IsClass(_A("Base"))); REQUIRE_THAT(src, IsClass(_A("Base")));
REQUIRE_THAT(puml, IsClassTemplate("Layer1", "LowerLayer")); REQUIRE_THAT(src, IsClassTemplate("Layer1", "LowerLayer"));
REQUIRE_THAT(puml, IsClassTemplate("Layer2", "LowerLayer")); REQUIRE_THAT(src, IsClassTemplate("Layer2", "LowerLayer"));
REQUIRE_THAT(puml, IsClassTemplate("Layer3", "LowerLayer")); REQUIRE_THAT(src, IsClassTemplate("Layer3", "LowerLayer"));
REQUIRE_THAT(puml, IsBaseClass(_A("Base"), _A("Layer3<Base>"))); REQUIRE_THAT(src, IsBaseClass(_A("Base"), _A("Layer3<Base>")));
REQUIRE_THAT(puml, !IsDependency(_A("Base"), _A("Layer3<Base>"))); REQUIRE_THAT(src, !IsDependency(_A("Base"), _A("Layer3<Base>")));
REQUIRE_THAT( REQUIRE_THAT(
puml, IsBaseClass(_A("Layer3<Base>"), _A("Layer2<Layer3<Base>>"))); src, IsBaseClass(_A("Layer3<Base>"), _A("Layer2<Layer3<Base>>")));
REQUIRE_THAT(puml, REQUIRE_THAT(
!IsDependency(_A("Layer3<Base>"), _A("Layer2<Layer3<Base>>"))); src, !IsDependency(_A("Layer3<Base>"), _A("Layer2<Layer3<Base>>")));
REQUIRE_THAT(puml, REQUIRE_THAT(src,
IsBaseClass(_A("Layer2<Layer3<Base>>"), IsBaseClass(_A("Layer2<Layer3<Base>>"),
_A("Layer1<Layer2<Layer3<Base>>>"))); _A("Layer1<Layer2<Layer3<Base>>>")));
REQUIRE_THAT(puml, REQUIRE_THAT(src,
!IsDependency(_A("Layer2<Layer3<Base>>"), !IsDependency(_A("Layer2<Layer3<Base>>"),
_A("Layer1<Layer2<Layer3<Base>>>"))); _A("Layer1<Layer2<Layer3<Base>>>")));
REQUIRE_THAT(puml, REQUIRE_THAT(src,
IsAggregation( IsAggregation(
_A("A"), _A("Layer1<Layer2<Layer3<Base>>>"), "+layers")); _A("A"), _A("Layer1<Layer2<Layer3<Base>>>"), "+layers"));
REQUIRE_THAT( REQUIRE_THAT(
puml, !IsDependency(_A("A"), _A("Layer1<Layer2<Layer3<Base>>>"))); src, !IsDependency(_A("A"), _A("Layer1<Layer2<Layer3<Base>>>")));
REQUIRE_THAT(puml, REQUIRE_THAT(src,
!IsAggregation(_A("A"), _A("Layer2<Layer3<Base>>"), "+layers")); !IsAggregation(_A("A"), _A("Layer2<Layer3<Base>>"), "+layers"));
REQUIRE_THAT( REQUIRE_THAT(
puml, !IsAggregation(_A("A"), _A("Layer3<Base>"), "+layers")); src, !IsAggregation(_A("A"), _A("Layer3<Base>"), "+layers"));
REQUIRE_THAT(puml, !IsAggregation(_A("A"), _A("Base"), "+layers")); REQUIRE_THAT(src, !IsAggregation(_A("A"), _A("Base"), "+layers"));
save_puml(config.output_directory(), diagram->name + ".puml", puml); save_puml(config.output_directory(), diagram->name + ".puml", src);
} }
{ {
auto j = generate_class_json(diagram, *model); auto j = generate_class_json(diagram, *model);
@@ -84,8 +84,45 @@ TEST_CASE("t00019", "[test-case][class]")
save_json(config.output_directory(), diagram->name + ".json", j); save_json(config.output_directory(), diagram->name + ".json", j);
} }
{ {
auto mmd = generate_class_mermaid(diagram, *model); auto src = generate_class_mermaid(diagram, *model);
save_mermaid(config.output_directory(), diagram->name + ".mmd", mmd); mermaid::AliasMatcher _A(src);
REQUIRE_THAT(src, IsClass(_A("Base")));
REQUIRE_THAT(src, IsClass(_A("Layer1<LowerLayer>")));
REQUIRE_THAT(src, IsClass(_A("Layer2<LowerLayer>")));
REQUIRE_THAT(src, IsClass(_A("Layer3<LowerLayer>")));
REQUIRE_THAT(src, IsBaseClass(_A("Base"), _A("Layer3<Base>")));
REQUIRE_THAT(src, !IsDependency(_A("Base"), _A("Layer3<Base>")));
REQUIRE_THAT(
src, IsBaseClass(_A("Layer3<Base>"), _A("Layer2<Layer3<Base>>")));
REQUIRE_THAT(
src, !IsDependency(_A("Layer3<Base>"), _A("Layer2<Layer3<Base>>")));
REQUIRE_THAT(src,
IsBaseClass(_A("Layer2<Layer3<Base>>"),
_A("Layer1<Layer2<Layer3<Base>>>")));
REQUIRE_THAT(src,
!IsDependency(_A("Layer2<Layer3<Base>>"),
_A("Layer1<Layer2<Layer3<Base>>>")));
REQUIRE_THAT(src,
IsAggregation(
_A("A"), _A("Layer1<Layer2<Layer3<Base>>>"), "+layers"));
REQUIRE_THAT(
src, !IsDependency(_A("A"), _A("Layer1<Layer2<Layer3<Base>>>")));
REQUIRE_THAT(src,
!IsAggregation(_A("A"), _A("Layer2<Layer3<Base>>"), "+layers"));
REQUIRE_THAT(
src, !IsAggregation(_A("A"), _A("Layer3<Base>"), "+layers"));
REQUIRE_THAT(src, !IsAggregation(_A("A"), _A("Base"), "+layers"));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
} }
} }

45
tests/t00020/test_case.h
View File

@@ -29,22 +29,22 @@ TEST_CASE("t00020", "[test-case][class]")
REQUIRE(model->name() == "t00020_class"); REQUIRE(model->name() == "t00020_class");
{ {
auto puml = generate_class_puml(diagram, *model); auto src = generate_class_puml(diagram, *model);
AliasMatcher _A(puml); AliasMatcher _A(src);
REQUIRE_THAT(puml, StartsWith("@startuml")); REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(puml, EndsWith("@enduml\n")); REQUIRE_THAT(src, EndsWith("@enduml\n"));
REQUIRE_THAT(puml, IsAbstractClass(_A("ProductA"))); REQUIRE_THAT(src, IsAbstractClass(_A("ProductA")));
REQUIRE_THAT(puml, IsAbstractClass(_A("ProductB"))); REQUIRE_THAT(src, IsAbstractClass(_A("ProductB")));
REQUIRE_THAT(puml, IsClass(_A("ProductA1"))); REQUIRE_THAT(src, IsClass(_A("ProductA1")));
REQUIRE_THAT(puml, IsClass(_A("ProductA2"))); REQUIRE_THAT(src, IsClass(_A("ProductA2")));
REQUIRE_THAT(puml, IsClass(_A("ProductB1"))); REQUIRE_THAT(src, IsClass(_A("ProductB1")));
REQUIRE_THAT(puml, IsClass(_A("ProductB2"))); REQUIRE_THAT(src, IsClass(_A("ProductB2")));
REQUIRE_THAT(puml, IsAbstractClass(_A("AbstractFactory"))); REQUIRE_THAT(src, IsAbstractClass(_A("AbstractFactory")));
REQUIRE_THAT(puml, IsClass(_A("Factory1"))); REQUIRE_THAT(src, IsClass(_A("Factory1")));
REQUIRE_THAT(puml, IsClass(_A("Factory2"))); REQUIRE_THAT(src, IsClass(_A("Factory2")));
save_puml(config.output_directory(), diagram->name + ".puml", puml); save_puml(config.output_directory(), diagram->name + ".puml", src);
} }
{ {
auto j = generate_class_json(diagram, *model); auto j = generate_class_json(diagram, *model);
@@ -60,8 +60,21 @@ TEST_CASE("t00020", "[test-case][class]")
save_json(config.output_directory(), diagram->name + ".json", j); save_json(config.output_directory(), diagram->name + ".json", j);
} }
{ {
auto mmd = generate_class_mermaid(diagram, *model); auto src = generate_class_mermaid(diagram, *model);
save_mermaid(config.output_directory(), diagram->name + ".mmd", mmd); 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);
} }
} }

39
tests/t00021/test_case.h
View File

@@ -29,20 +29,20 @@ TEST_CASE("t00021", "[test-case][class]")
REQUIRE(model->name() == "t00021_class"); REQUIRE(model->name() == "t00021_class");
{ {
auto puml = generate_class_puml(diagram, *model); auto src = generate_class_puml(diagram, *model);
AliasMatcher _A(puml); AliasMatcher _A(src);
REQUIRE_THAT(puml, StartsWith("@startuml")); REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(puml, EndsWith("@enduml\n")); REQUIRE_THAT(src, EndsWith("@enduml\n"));
REQUIRE_THAT(puml, IsAbstractClass(_A("Item"))); REQUIRE_THAT(src, IsAbstractClass(_A("Item")));
REQUIRE_THAT(puml, IsAbstractClass(_A("Visitor"))); REQUIRE_THAT(src, IsAbstractClass(_A("Visitor")));
REQUIRE_THAT(puml, IsClass(_A("A"))); REQUIRE_THAT(src, IsClass(_A("A")));
REQUIRE_THAT(puml, IsClass(_A("B"))); REQUIRE_THAT(src, IsClass(_A("B")));
REQUIRE_THAT(puml, IsClass(_A("Visitor1"))); REQUIRE_THAT(src, IsClass(_A("Visitor1")));
REQUIRE_THAT(puml, IsClass(_A("Visitor2"))); REQUIRE_THAT(src, IsClass(_A("Visitor2")));
REQUIRE_THAT(puml, IsClass(_A("Visitor3"))); REQUIRE_THAT(src, IsClass(_A("Visitor3")));
save_puml(config.output_directory(), diagram->name + ".puml", puml); save_puml(config.output_directory(), diagram->name + ".puml", src);
} }
{ {
auto j = generate_class_json(diagram, *model); auto j = generate_class_json(diagram, *model);
@@ -56,8 +56,19 @@ TEST_CASE("t00021", "[test-case][class]")
save_json(config.output_directory(), diagram->name + ".json", j); save_json(config.output_directory(), diagram->name + ".json", j);
} }
{ {
auto mmd = generate_class_mermaid(diagram, *model); auto src = generate_class_mermaid(diagram, *model);
save_mermaid(config.output_directory(), diagram->name + ".mmd", mmd); mermaid::AliasMatcher _A(src);
using mermaid::IsAbstractClass;
REQUIRE_THAT(src, IsAbstractClass(_A("Item")));
REQUIRE_THAT(src, IsAbstractClass(_A("Visitor")));
REQUIRE_THAT(src, IsClass(_A("A")));
REQUIRE_THAT(src, IsClass(_A("B")));
REQUIRE_THAT(src, IsClass(_A("Visitor1")));
REQUIRE_THAT(src, IsClass(_A("Visitor2")));
REQUIRE_THAT(src, IsClass(_A("Visitor3")));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
} }
} }

26
tests/t00022/test_case.h
View File

@@ -29,16 +29,16 @@ TEST_CASE("t00022", "[test-case][class]")
REQUIRE(model->name() == "t00022_class"); REQUIRE(model->name() == "t00022_class");
{ {
auto puml = generate_class_puml(diagram, *model); auto src = generate_class_puml(diagram, *model);
AliasMatcher _A(puml); AliasMatcher _A(src);
REQUIRE_THAT(puml, StartsWith("@startuml")); REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(puml, EndsWith("@enduml\n")); REQUIRE_THAT(src, EndsWith("@enduml\n"));
REQUIRE_THAT(puml, IsAbstractClass(_A("A"))); REQUIRE_THAT(src, IsAbstractClass(_A("A")));
REQUIRE_THAT(puml, IsClass(_A("A1"))); REQUIRE_THAT(src, IsClass(_A("A1")));
REQUIRE_THAT(puml, IsClass(_A("A2"))); REQUIRE_THAT(src, IsClass(_A("A2")));
save_puml(config.output_directory(), diagram->name + ".puml", puml); save_puml(config.output_directory(), diagram->name + ".puml", src);
} }
{ {
auto j = generate_class_json(diagram, *model); auto j = generate_class_json(diagram, *model);
@@ -52,8 +52,14 @@ TEST_CASE("t00022", "[test-case][class]")
save_json(config.output_directory(), diagram->name + ".json", j); save_json(config.output_directory(), diagram->name + ".json", j);
} }
{ {
auto mmd = generate_class_mermaid(diagram, *model); auto src = generate_class_mermaid(diagram, *model);
mermaid::AliasMatcher _A(src);
using mermaid::IsAbstractClass;
save_mermaid(config.output_directory(), diagram->name + ".mmd", mmd); REQUIRE_THAT(src, IsAbstractClass(_A("A")));
REQUIRE_THAT(src, IsClass(_A("A1")));
REQUIRE_THAT(src, IsClass(_A("A2")));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
} }
} }

27
tests/t00023/test_case.h
View File

@@ -29,16 +29,16 @@ TEST_CASE("t00023", "[test-case][class]")
REQUIRE(model->name() == "t00023_class"); REQUIRE(model->name() == "t00023_class");
{ {
auto puml = generate_class_puml(diagram, *model); auto src = generate_class_puml(diagram, *model);
AliasMatcher _A(puml); AliasMatcher _A(src);
REQUIRE_THAT(puml, StartsWith("@startuml")); REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(puml, EndsWith("@enduml\n")); REQUIRE_THAT(src, EndsWith("@enduml\n"));
REQUIRE_THAT(puml, IsAbstractClass(_A("Strategy"))); REQUIRE_THAT(src, IsAbstractClass(_A("Strategy")));
REQUIRE_THAT(puml, IsClass(_A("StrategyA"))); REQUIRE_THAT(src, IsClass(_A("StrategyA")));
REQUIRE_THAT(puml, IsClass(_A("StrategyB"))); REQUIRE_THAT(src, IsClass(_A("StrategyB")));
save_puml(config.output_directory(), diagram->name + ".puml", puml); save_puml(config.output_directory(), diagram->name + ".puml", src);
} }
{ {
auto j = generate_class_json(diagram, *model); auto j = generate_class_json(diagram, *model);
@@ -52,8 +52,15 @@ TEST_CASE("t00023", "[test-case][class]")
save_json(config.output_directory(), diagram->name + ".json", j); save_json(config.output_directory(), diagram->name + ".json", j);
} }
{ {
auto mmd = generate_class_mermaid(diagram, *model); auto src = generate_class_mermaid(diagram, *model);
save_mermaid(config.output_directory(), diagram->name + ".mmd", mmd); mermaid::AliasMatcher _A(src);
using mermaid::IsAbstractClass;
REQUIRE_THAT(src, IsAbstractClass(_A("Strategy")));
REQUIRE_THAT(src, IsClass(_A("StrategyA")));
REQUIRE_THAT(src, IsClass(_A("StrategyB")));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
} }
} }

39
tests/t00024/test_case.h
View File

@@ -29,20 +29,20 @@ TEST_CASE("t00024", "[test-case][class]")
REQUIRE(model->name() == "t00024_class"); REQUIRE(model->name() == "t00024_class");
{ {
auto puml = generate_class_puml(diagram, *model); auto src = generate_class_puml(diagram, *model);
AliasMatcher _A(puml); AliasMatcher _A(src);
REQUIRE_THAT(puml, StartsWith("@startuml")); REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(puml, EndsWith("@enduml\n")); REQUIRE_THAT(src, EndsWith("@enduml\n"));
REQUIRE_THAT(puml, IsAbstractClass(_A("Target"))); REQUIRE_THAT(src, IsAbstractClass(_A("Target")));
REQUIRE_THAT(puml, IsClass(_A("Target1"))); REQUIRE_THAT(src, IsClass(_A("Target1")));
REQUIRE_THAT(puml, IsClass(_A("Target2"))); REQUIRE_THAT(src, IsClass(_A("Target2")));
REQUIRE_THAT(puml, IsClass(_A("Proxy"))); REQUIRE_THAT(src, IsClass(_A("Proxy")));
REQUIRE_THAT(puml, IsBaseClass(_A("Target"), _A("Target1"))); REQUIRE_THAT(src, IsBaseClass(_A("Target"), _A("Target1")));
REQUIRE_THAT(puml, IsBaseClass(_A("Target"), _A("Target2"))); REQUIRE_THAT(src, IsBaseClass(_A("Target"), _A("Target2")));
REQUIRE_THAT(puml, IsBaseClass(_A("Target"), _A("Proxy"))); REQUIRE_THAT(src, IsBaseClass(_A("Target"), _A("Proxy")));
save_puml(config.output_directory(), diagram->name + ".puml", puml); save_puml(config.output_directory(), diagram->name + ".puml", src);
} }
{ {
auto j = generate_class_json(diagram, *model); auto j = generate_class_json(diagram, *model);
@@ -59,8 +59,19 @@ TEST_CASE("t00024", "[test-case][class]")
save_json(config.output_directory(), diagram->name + ".json", j); save_json(config.output_directory(), diagram->name + ".json", j);
} }
{ {
auto mmd = generate_class_mermaid(diagram, *model); auto src = generate_class_mermaid(diagram, *model);
save_mermaid(config.output_directory(), diagram->name + ".mmd", mmd); mermaid::AliasMatcher _A(src);
using mermaid::IsAbstractClass;
REQUIRE_THAT(src, IsAbstractClass(_A("Target")));
REQUIRE_THAT(src, IsClass(_A("Target1")));
REQUIRE_THAT(src, IsClass(_A("Target2")));
REQUIRE_THAT(src, IsClass(_A("Proxy")));
REQUIRE_THAT(src, IsBaseClass(_A("Target"), _A("Target1")));
REQUIRE_THAT(src, IsBaseClass(_A("Target"), _A("Target2")));
REQUIRE_THAT(src, IsBaseClass(_A("Target"), _A("Proxy")));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
} }
} }

56
tests/t00025/test_case.h
View File

@@ -29,30 +29,30 @@ TEST_CASE("t00025", "[test-case][class]")
REQUIRE(model->name() == "t00025_class"); REQUIRE(model->name() == "t00025_class");
{ {
auto puml = generate_class_puml(diagram, *model); auto src = generate_class_puml(diagram, *model);
AliasMatcher _A(puml); AliasMatcher _A(src);
REQUIRE_THAT(puml, StartsWith("@startuml")); REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(puml, EndsWith("@enduml\n")); REQUIRE_THAT(src, EndsWith("@enduml\n"));
REQUIRE_THAT(puml, IsClass(_A("Target1"))); REQUIRE_THAT(src, IsClass(_A("Target1")));
REQUIRE_THAT(puml, IsClass(_A("Target2"))); REQUIRE_THAT(src, IsClass(_A("Target2")));
REQUIRE_THAT(puml, IsClassTemplate("Proxy", "T")); REQUIRE_THAT(src, IsClassTemplate("Proxy", "T"));
REQUIRE_THAT( REQUIRE_THAT(
puml, IsInstantiation(_A("Proxy<T>"), _A("Proxy<Target1>"))); src, IsInstantiation(_A("Proxy<T>"), _A("Proxy<Target1>")));
REQUIRE_THAT( REQUIRE_THAT(
puml, IsInstantiation(_A("Proxy<T>"), _A("Proxy<Target2>"))); src, IsInstantiation(_A("Proxy<T>"), _A("Proxy<Target2>")));
REQUIRE_THAT(puml, REQUIRE_THAT(src,
IsAggregation(_A("ProxyHolder"), _A("Proxy<Target1>"), "+proxy1")); IsAggregation(_A("ProxyHolder"), _A("Proxy<Target1>"), "+proxy1"));
REQUIRE_THAT(puml, REQUIRE_THAT(src,
IsAggregation(_A("ProxyHolder"), _A("Proxy<Target2>"), "+proxy2")); IsAggregation(_A("ProxyHolder"), _A("Proxy<Target2>"), "+proxy2"));
REQUIRE_THAT( REQUIRE_THAT(
puml, !IsAggregation(_A("ProxyHolder"), _A("Target1"), "+proxy1")); src, !IsAggregation(_A("ProxyHolder"), _A("Target1"), "+proxy1"));
REQUIRE_THAT( REQUIRE_THAT(
puml, !IsAggregation(_A("ProxyHolder"), _A("Target2"), "+proxy2")); src, !IsAggregation(_A("ProxyHolder"), _A("Target2"), "+proxy2"));
REQUIRE_THAT(puml, IsDependency(_A("Proxy<Target1>"), _A("Target1"))); REQUIRE_THAT(src, IsDependency(_A("Proxy<Target1>"), _A("Target1")));
REQUIRE_THAT(puml, IsDependency(_A("Proxy<Target2>"), _A("Target2"))); REQUIRE_THAT(src, IsDependency(_A("Proxy<Target2>"), _A("Target2")));
save_puml(config.output_directory(), diagram->name + ".puml", puml); save_puml(config.output_directory(), diagram->name + ".puml", src);
} }
{ {
auto j = generate_class_json(diagram, *model); auto j = generate_class_json(diagram, *model);
@@ -68,8 +68,28 @@ TEST_CASE("t00025", "[test-case][class]")
save_json(config.output_directory(), diagram->name + ".json", j); save_json(config.output_directory(), diagram->name + ".json", j);
} }
{ {
auto mmd = generate_class_mermaid(diagram, *model); auto src = generate_class_mermaid(diagram, *model);
save_mermaid(config.output_directory(), diagram->name + ".mmd", mmd); mermaid::AliasMatcher _A(src);
REQUIRE_THAT(src, IsClass(_A("Target1")));
REQUIRE_THAT(src, IsClass(_A("Target2")));
REQUIRE_THAT(src, IsClass(_A("Proxy<T>")));
REQUIRE_THAT(
src, IsInstantiation(_A("Proxy<T>"), _A("Proxy<Target1>")));
REQUIRE_THAT(
src, IsInstantiation(_A("Proxy<T>"), _A("Proxy<Target2>")));
REQUIRE_THAT(src,
IsAggregation(_A("ProxyHolder"), _A("Proxy<Target1>"), "+proxy1"));
REQUIRE_THAT(src,
IsAggregation(_A("ProxyHolder"), _A("Proxy<Target2>"), "+proxy2"));
REQUIRE_THAT(
src, !IsAggregation(_A("ProxyHolder"), _A("Target1"), "+proxy1"));
REQUIRE_THAT(
src, !IsAggregation(_A("ProxyHolder"), _A("Target2"), "+proxy2"));
REQUIRE_THAT(src, IsDependency(_A("Proxy<Target1>"), _A("Target1")));
REQUIRE_THAT(src, IsDependency(_A("Proxy<Target2>"), _A("Target2")));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
} }
} }

35
tests/t00026/test_case.h
View File

@@ -29,21 +29,21 @@ TEST_CASE("t00026", "[test-case][class]")
REQUIRE(model->name() == "t00026_class"); REQUIRE(model->name() == "t00026_class");
{ {
auto puml = generate_class_puml(diagram, *model); auto src = generate_class_puml(diagram, *model);
AliasMatcher _A(puml); AliasMatcher _A(src);
REQUIRE_THAT(puml, StartsWith("@startuml")); REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(puml, EndsWith("@enduml\n")); REQUIRE_THAT(src, EndsWith("@enduml\n"));
REQUIRE_THAT(puml, IsClassTemplate("Memento", "T")); REQUIRE_THAT(src, IsClassTemplate("Memento", "T"));
REQUIRE_THAT(puml, IsClassTemplate("Originator", "T")); REQUIRE_THAT(src, IsClassTemplate("Originator", "T"));
REQUIRE_THAT(puml, IsClassTemplate("Caretaker", "T")); REQUIRE_THAT(src, IsClassTemplate("Caretaker", "T"));
REQUIRE_THAT(puml, REQUIRE_THAT(src,
IsInstantiation( IsInstantiation(
_A("Originator<T>"), _A("Originator<std::string>"))); _A("Originator<T>"), _A("Originator<std::string>")));
REQUIRE_THAT(puml, REQUIRE_THAT(src,
IsInstantiation(_A("Caretaker<T>"), _A("Caretaker<std::string>"))); IsInstantiation(_A("Caretaker<T>"), _A("Caretaker<std::string>")));
save_puml(config.output_directory(), diagram->name + ".puml", puml); save_puml(config.output_directory(), diagram->name + ".puml", src);
} }
{ {
auto j = generate_class_json(diagram, *model); auto j = generate_class_json(diagram, *model);
@@ -57,8 +57,19 @@ TEST_CASE("t00026", "[test-case][class]")
save_json(config.output_directory(), diagram->name + ".json", j); save_json(config.output_directory(), diagram->name + ".json", j);
} }
{ {
auto mmd = generate_class_mermaid(diagram, *model); auto src = generate_class_mermaid(diagram, *model);
save_mermaid(config.output_directory(), diagram->name + ".mmd", mmd); mermaid::AliasMatcher _A(src);
REQUIRE_THAT(src, IsClass(_A("Memento<T>")));
REQUIRE_THAT(src, IsClass(_A("Originator<T>")));
REQUIRE_THAT(src, IsClass(_A("Caretaker<T>")));
REQUIRE_THAT(src,
IsInstantiation(
_A("Originator<T>"), _A("Originator<std::string>")));
REQUIRE_THAT(src,
IsInstantiation(_A("Caretaker<T>"), _A("Caretaker<std::string>")));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
} }
} }

67
tests/t00027/test_case.h
View File

@@ -29,34 +29,34 @@ TEST_CASE("t00027", "[test-case][class]")
REQUIRE(model->name() == "t00027_class"); REQUIRE(model->name() == "t00027_class");
{ {
auto puml = generate_class_puml(diagram, *model); auto src = generate_class_puml(diagram, *model);
AliasMatcher _A(puml); AliasMatcher _A(src);
REQUIRE_THAT(puml, StartsWith("@startuml")); REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(puml, EndsWith("@enduml\n")); REQUIRE_THAT(src, EndsWith("@enduml\n"));
REQUIRE_THAT(puml, IsAbstractClass(_A("Shape"))); REQUIRE_THAT(src, IsAbstractClass(_A("Shape")));
REQUIRE_THAT(puml, IsAbstractClass(_A("ShapeDecorator"))); REQUIRE_THAT(src, IsAbstractClass(_A("ShapeDecorator")));
REQUIRE_THAT(puml, IsClassTemplate("Line", "T<>...")); REQUIRE_THAT(src, IsClassTemplate("Line", "T<>..."));
REQUIRE_THAT(puml, IsClassTemplate("Text", "T<>...")); REQUIRE_THAT(src, IsClassTemplate("Text", "T<>..."));
REQUIRE_THAT( REQUIRE_THAT(
puml, IsInstantiation(_A("Line<T<>...>"), _A("Line<Color>"))); src, IsInstantiation(_A("Line<T<>...>"), _A("Line<Color>")));
REQUIRE_THAT(puml,
IsInstantiation(_A("Line<T<>...>"), _A("Line<Color,Weight>")));
REQUIRE_THAT( REQUIRE_THAT(
puml, IsInstantiation(_A("Text<T<>...>"), _A("Text<Color>"))); src, IsInstantiation(_A("Line<T<>...>"), _A("Line<Color,Weight>")));
REQUIRE_THAT(puml, REQUIRE_THAT(
IsInstantiation(_A("Text<T<>...>"), _A("Text<Color,Weight>"))); src, IsInstantiation(_A("Text<T<>...>"), _A("Text<Color>")));
REQUIRE_THAT(
src, IsInstantiation(_A("Text<T<>...>"), _A("Text<Color,Weight>")));
REQUIRE_THAT(puml, REQUIRE_THAT(src,
IsAggregation(_A("Window"), _A("Line<Color,Weight>"), "+border")); IsAggregation(_A("Window"), _A("Line<Color,Weight>"), "+border"));
REQUIRE_THAT( REQUIRE_THAT(
puml, IsAggregation(_A("Window"), _A("Line<Color>"), "+divider")); src, IsAggregation(_A("Window"), _A("Line<Color>"), "+divider"));
REQUIRE_THAT(puml, REQUIRE_THAT(src,
IsAggregation(_A("Window"), _A("Text<Color,Weight>"), "+title")); IsAggregation(_A("Window"), _A("Text<Color,Weight>"), "+title"));
REQUIRE_THAT(puml, REQUIRE_THAT(src,
IsAggregation(_A("Window"), _A("Text<Color>"), "+description")); IsAggregation(_A("Window"), _A("Text<Color>"), "+description"));
save_puml(config.output_directory(), diagram->name + ".puml", puml); save_puml(config.output_directory(), diagram->name + ".puml", src);
} }
{ {
auto j = generate_class_json(diagram, *model); auto j = generate_class_json(diagram, *model);
@@ -77,8 +77,33 @@ TEST_CASE("t00027", "[test-case][class]")
save_json(config.output_directory(), diagram->name + ".json", j); save_json(config.output_directory(), diagram->name + ".json", j);
} }
{ {
auto mmd = generate_class_mermaid(diagram, *model); auto src = generate_class_mermaid(diagram, *model);
save_mermaid(config.output_directory(), diagram->name + ".mmd", mmd); 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);
} }
} }

65
tests/t00028/test_case.h
View File

@@ -29,41 +29,41 @@ TEST_CASE("t00028", "[test-case][class]")
REQUIRE(model->name() == "t00028_class"); REQUIRE(model->name() == "t00028_class");
{ {
auto puml = generate_class_puml(diagram, *model); auto src = generate_class_puml(diagram, *model);
AliasMatcher _A(puml); AliasMatcher _A(src);
REQUIRE_THAT(puml, StartsWith("@startuml")); REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(puml, EndsWith("@enduml\n")); REQUIRE_THAT(src, EndsWith("@enduml\n"));
REQUIRE_THAT(puml, IsClass(_A("A"))); REQUIRE_THAT(src, IsClass(_A("A")));
REQUIRE_THAT(puml, IsClass(_A("B"))); REQUIRE_THAT(src, IsClass(_A("B")));
REQUIRE_THAT(puml, IsClass(_A("C"))); REQUIRE_THAT(src, IsClass(_A("C")));
REQUIRE_THAT(puml, IsClass(_A("D"))); REQUIRE_THAT(src, IsClass(_A("D")));
REQUIRE_THAT(puml, IsClassTemplate("E", "T")); REQUIRE_THAT(src, IsClassTemplate("E", "T"));
REQUIRE_THAT(puml, IsEnum(_A("F"))); REQUIRE_THAT(src, IsEnum(_A("F")));
REQUIRE_THAT(puml, IsClass(_A("R"))); REQUIRE_THAT(src, IsClass(_A("R")));
REQUIRE_THAT(puml, HasNote(_A("A"), "top", "A class note.")); REQUIRE_THAT(src, HasNote(_A("A"), "top", "A class note."));
REQUIRE_THAT(puml, HasNote(_A("B"), "left", "B class note.")); REQUIRE_THAT(src, HasNote(_A("B"), "left", "B class note."));
REQUIRE_THAT(puml, HasNote(_A("C"), "bottom", "C class note.")); REQUIRE_THAT(src, HasNote(_A("C"), "bottom", "C class note."));
const auto d_note = R"( const auto d_note = R"(
D D
class class
note.)"; note.)";
REQUIRE_THAT(puml, HasNote(_A("D"), "left", d_note)); REQUIRE_THAT(src, HasNote(_A("D"), "left", d_note));
REQUIRE_THAT( REQUIRE_THAT(
puml, HasNote(_A("E<T>"), "left", "E template class note.")); src, HasNote(_A("E<T>"), "left", "E template class note."));
REQUIRE_THAT(puml, HasNote(_A("F"), "bottom", "F enum note.")); REQUIRE_THAT(src, HasNote(_A("F"), "bottom", "F enum note."));
REQUIRE_THAT(puml, !HasNote(_A("G"), "left", "G class note.")); REQUIRE_THAT(src, !HasNote(_A("G"), "left", "G class note."));
REQUIRE_THAT(puml, HasNote(_A("R"), "right", "R class note.")); REQUIRE_THAT(src, HasNote(_A("R"), "right", "R class note."));
REQUIRE_THAT(puml, REQUIRE_THAT(src,
HasMemberNote( HasMemberNote(
_A("R"), "aaa", "left", "R contains an instance of A.")); _A("R"), "aaa", "left", "R contains an instance of A."));
REQUIRE_THAT( REQUIRE_THAT(
puml, !HasMemberNote(_A("R"), "bbb", "right", "R class note.")); src, !HasMemberNote(_A("R"), "bbb", "right", "R class note."));
REQUIRE_THAT( REQUIRE_THAT(
puml, HasMemberNote(_A("R"), "ccc", "left", "Reference to C.")); src, HasMemberNote(_A("R"), "ccc", "left", "Reference to C."));
save_puml(config.output_directory(), diagram->name + ".puml", puml); save_puml(config.output_directory(), diagram->name + ".puml", src);
} }
{ {
auto j = generate_class_json(diagram, *model); auto j = generate_class_json(diagram, *model);
@@ -73,8 +73,23 @@ note.)";
save_json(config.output_directory(), diagram->name + ".json", j); save_json(config.output_directory(), diagram->name + ".json", j);
} }
{ {
auto mmd = generate_class_mermaid(diagram, *model); auto src = generate_class_mermaid(diagram, *model);
save_mermaid(config.output_directory(), diagram->name + ".mmd", mmd); mermaid::AliasMatcher _A(src);
using mermaid::IsEnum;
REQUIRE_THAT(src, IsClass(_A("A")));
REQUIRE_THAT(src, IsClass(_A("B")));
REQUIRE_THAT(src, IsClass(_A("C")));
REQUIRE_THAT(src, IsClass(_A("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."));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
} }
} }

65
tests/t00029/test_case.h
View File

@@ -29,31 +29,31 @@ TEST_CASE("t00029", "[test-case][class]")
REQUIRE(model->name() == "t00029_class"); REQUIRE(model->name() == "t00029_class");
{ {
auto puml = generate_class_puml(diagram, *model); auto src = generate_class_puml(diagram, *model);
AliasMatcher _A(puml); AliasMatcher _A(src);
REQUIRE_THAT(puml, StartsWith("@startuml")); REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(puml, EndsWith("@enduml\n")); REQUIRE_THAT(src, EndsWith("@enduml\n"));
REQUIRE_THAT(puml, IsClass(_A("A"))); REQUIRE_THAT(src, IsClass(_A("A")));
REQUIRE_THAT(puml, !IsClass(_A("B"))); REQUIRE_THAT(src, !IsClass(_A("B")));
REQUIRE_THAT(puml, IsClassTemplate("C", "T")); REQUIRE_THAT(src, IsClassTemplate("C", "T"));
REQUIRE_THAT(puml, !IsClassTemplate("D", "T")); REQUIRE_THAT(src, !IsClassTemplate("D", "T"));
REQUIRE_THAT(puml, IsEnum(_A("E"))); REQUIRE_THAT(src, IsEnum(_A("E")));
REQUIRE_THAT(puml, !IsEnum(_A("F"))); REQUIRE_THAT(src, !IsEnum(_A("F")));
REQUIRE_THAT(puml, IsClass(_A("G1"))); REQUIRE_THAT(src, IsClass(_A("G1")));
REQUIRE_THAT(puml, IsClass(_A("G2"))); REQUIRE_THAT(src, IsClass(_A("G2")));
REQUIRE_THAT(puml, IsClass(_A("G3"))); REQUIRE_THAT(src, IsClass(_A("G3")));
REQUIRE_THAT(puml, IsClass(_A("G4"))); REQUIRE_THAT(src, IsClass(_A("G4")));
REQUIRE_THAT(puml, IsClass(_A("R"))); REQUIRE_THAT(src, IsClass(_A("R")));
REQUIRE_THAT(puml, IsAggregation(_A("R"), _A("G1"), "+g1")); REQUIRE_THAT(src, IsAggregation(_A("R"), _A("G1"), "+g1"));
REQUIRE_THAT(puml, !IsAggregation(_A("R"), _A("G2"), "+g2")); REQUIRE_THAT(src, !IsAggregation(_A("R"), _A("G2"), "+g2"));
REQUIRE_THAT(puml, !IsAggregation(_A("R"), _A("G3"), "+g3")); REQUIRE_THAT(src, !IsAggregation(_A("R"), _A("G3"), "+g3"));
REQUIRE_THAT(puml, IsAssociation(_A("R"), _A("G4"), "+g4")); REQUIRE_THAT(src, IsAssociation(_A("R"), _A("G4"), "+g4"));
save_puml(config.output_directory(), diagram->name + ".puml", puml); save_puml(config.output_directory(), diagram->name + ".puml", src);
} }
{ {
auto j = generate_class_json(diagram, *model); auto j = generate_class_json(diagram, *model);
@@ -65,8 +65,29 @@ TEST_CASE("t00029", "[test-case][class]")
save_json(config.output_directory(), diagram->name + ".json", j); save_json(config.output_directory(), diagram->name + ".json", j);
} }
{ {
auto mmd = generate_class_mermaid(diagram, *model); auto src = generate_class_mermaid(diagram, *model);
save_mermaid(config.output_directory(), diagram->name + ".mmd", mmd); mermaid::AliasMatcher _A(src);
using mermaid::IsEnum;
REQUIRE_THAT(src, IsClass(_A("A")));
REQUIRE_THAT(src, !IsClass(_A("B")));
REQUIRE_THAT(src, IsClass(_A("C<T>")));
REQUIRE_THAT(src, !IsClass(_A("D<T>")));
REQUIRE_THAT(src, IsEnum(_A("E")));
REQUIRE_THAT(src, !IsEnum(_A("F")));
REQUIRE_THAT(src, IsClass(_A("G1")));
REQUIRE_THAT(src, IsClass(_A("G2")));
REQUIRE_THAT(src, IsClass(_A("G3")));
REQUIRE_THAT(src, IsClass(_A("G4")));
REQUIRE_THAT(src, IsClass(_A("R")));
REQUIRE_THAT(src, IsAggregation(_A("R"), _A("G1"), "+g1"));
REQUIRE_THAT(src, !IsAggregation(_A("R"), _A("G2"), "+g2"));
REQUIRE_THAT(src, !IsAggregation(_A("R"), _A("G3"), "+g3"));
REQUIRE_THAT(src, IsAssociation(_A("R"), _A("G4"), "+g4"));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
} }
} }

47
tests/t00030/test_case.h
View File

@@ -29,26 +29,26 @@ TEST_CASE("t00030", "[test-case][class]")
REQUIRE(model->name() == "t00030_class"); REQUIRE(model->name() == "t00030_class");
{ {
auto puml = generate_class_puml(diagram, *model); auto src = generate_class_puml(diagram, *model);
AliasMatcher _A(puml); AliasMatcher _A(src);
REQUIRE_THAT(puml, StartsWith("@startuml")); REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(puml, EndsWith("@enduml\n")); REQUIRE_THAT(src, EndsWith("@enduml\n"));
REQUIRE_THAT(puml, IsClass(_A("A"))); REQUIRE_THAT(src, IsClass(_A("A")));
REQUIRE_THAT(puml, IsClass(_A("B"))); REQUIRE_THAT(src, IsClass(_A("B")));
REQUIRE_THAT(puml, IsClass(_A("C"))); REQUIRE_THAT(src, IsClass(_A("C")));
REQUIRE_THAT(puml, IsClass(_A("D"))); REQUIRE_THAT(src, IsClass(_A("D")));
REQUIRE_THAT(puml, IsAssociation(_A("R"), _A("A"), "+aaa")); REQUIRE_THAT(src, IsAssociation(_A("R"), _A("A"), "+aaa"));
REQUIRE_THAT( REQUIRE_THAT(
puml, IsComposition(_A("R"), _A("B"), "+bbb", "0..1", "1..*")); src, IsComposition(_A("R"), _A("B"), "+bbb", "0..1", "1..*"));
REQUIRE_THAT( REQUIRE_THAT(
puml, IsAggregation(_A("R"), _A("C"), "+ccc", "0..1", "1..5")); src, IsAggregation(_A("R"), _A("C"), "+ccc", "0..1", "1..5"));
REQUIRE_THAT(puml, IsAssociation(_A("R"), _A("D"), "+ddd", "", "1")); REQUIRE_THAT(src, IsAssociation(_A("R"), _A("D"), "+ddd", "", "1"));
REQUIRE_THAT(puml, IsAggregation(_A("R"), _A("E"), "+eee", "", "1")); REQUIRE_THAT(src, IsAggregation(_A("R"), _A("E"), "+eee", "", "1"));
save_puml(config.output_directory(), diagram->name + ".puml", puml); save_puml(config.output_directory(), diagram->name + ".puml", src);
} }
{ {
auto j = generate_class_json(diagram, *model); auto j = generate_class_json(diagram, *model);
@@ -60,8 +60,23 @@ TEST_CASE("t00030", "[test-case][class]")
save_json(config.output_directory(), diagram->name + ".json", j); save_json(config.output_directory(), diagram->name + ".json", j);
} }
{ {
auto mmd = generate_class_mermaid(diagram, *model); auto src = generate_class_mermaid(diagram, *model);
save_mermaid(config.output_directory(), diagram->name + ".mmd", mmd); mermaid::AliasMatcher _A(src);
REQUIRE_THAT(src, IsClass(_A("A")));
REQUIRE_THAT(src, IsClass(_A("B")));
REQUIRE_THAT(src, IsClass(_A("C")));
REQUIRE_THAT(src, IsClass(_A("D")));
REQUIRE_THAT(src, IsAssociation(_A("R"), _A("A"), "+aaa"));
REQUIRE_THAT(
src, IsComposition(_A("R"), _A("B"), "+bbb", "0..1", "1..*"));
REQUIRE_THAT(
src, IsAggregation(_A("R"), _A("C"), "+ccc", "0..1", "1..5"));
REQUIRE_THAT(src, IsAssociation(_A("R"), _A("D"), "+ddd", "", "1"));
REQUIRE_THAT(src, IsAggregation(_A("R"), _A("E"), "+eee", "", "1"));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
} }
} }

40
tests/t00031/test_case.h
View File

@@ -29,32 +29,32 @@ TEST_CASE("t00031", "[test-case][class]")
REQUIRE(model->name() == "t00031_class"); REQUIRE(model->name() == "t00031_class");
{ {
auto puml = generate_class_puml(diagram, *model); auto src = generate_class_puml(diagram, *model);
AliasMatcher _A(puml); AliasMatcher _A(src);
REQUIRE_THAT(puml, StartsWith("@startuml")); REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(puml, EndsWith("@enduml\n")); REQUIRE_THAT(src, EndsWith("@enduml\n"));
REQUIRE_THAT(puml, IsClass(_A("A"))); REQUIRE_THAT(src, IsClass(_A("A")));
REQUIRE_THAT(puml, IsEnum(_A("B"))); REQUIRE_THAT(src, IsEnum(_A("B")));
REQUIRE_THAT(puml, IsClassTemplate("C", "T")); REQUIRE_THAT(src, IsClassTemplate("C", "T"));
REQUIRE_THAT(puml, IsClass(_A("D"))); REQUIRE_THAT(src, IsClass(_A("D")));
REQUIRE_THAT(puml, REQUIRE_THAT(src,
IsAssociationWithStyle( IsAssociationWithStyle(
_A("R"), _A("A"), "+aaa", "#red,dashed,thickness=2")); _A("R"), _A("A"), "+aaa", "#red,dashed,thickness=2"));
REQUIRE_THAT(puml, REQUIRE_THAT(src,
IsCompositionWithStyle( IsCompositionWithStyle(
_A("R"), _A("B"), "+bbb", "#green,dashed,thickness=4")); _A("R"), _A("B"), "+bbb", "#green,dashed,thickness=4"));
REQUIRE_THAT(puml, IsDependency(_A("R"), _A("B"))); REQUIRE_THAT(src, IsDependency(_A("R"), _A("B")));
REQUIRE_THAT(puml, REQUIRE_THAT(src,
IsAggregationWithStyle( IsAggregationWithStyle(
_A("R"), _A("C<int>"), "+ccc", "#blue,dotted,thickness=8")); _A("R"), _A("C<int>"), "+ccc", "#blue,dotted,thickness=8"));
REQUIRE_THAT(puml, REQUIRE_THAT(src,
IsAssociationWithStyle( IsAssociationWithStyle(
_A("R"), _A("D"), "+ddd", "#blue,plain,thickness=16")); _A("R"), _A("D"), "+ddd", "#blue,plain,thickness=16"));
save_puml(config.output_directory(), diagram->name + ".puml", puml); save_puml(config.output_directory(), diagram->name + ".puml", src);
} }
{ {
auto j = generate_class_json(diagram, *model); auto j = generate_class_json(diagram, *model);
@@ -67,8 +67,16 @@ TEST_CASE("t00031", "[test-case][class]")
save_json(config.output_directory(), diagram->name + ".json", j); save_json(config.output_directory(), diagram->name + ".json", j);
} }
{ {
auto mmd = generate_class_mermaid(diagram, *model); auto src = generate_class_mermaid(diagram, *model);
save_mermaid(config.output_directory(), diagram->name + ".mmd", mmd); mermaid::AliasMatcher _A(src);
using mermaid::IsEnum;
REQUIRE_THAT(src, IsClass(_A("A")));
REQUIRE_THAT(src, IsEnum(_A("B")));
REQUIRE_THAT(src, IsClass(_A("C<T>")));
REQUIRE_THAT(src, IsClass(_A("D")));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
} }
} }

75
tests/t00032/test_case.h
View File

@@ -29,40 +29,40 @@ TEST_CASE("t00032", "[test-case][class]")
REQUIRE(model->name() == "t00032_class"); REQUIRE(model->name() == "t00032_class");
{ {
auto puml = generate_class_puml(diagram, *model); auto src = generate_class_puml(diagram, *model);
AliasMatcher _A(puml); AliasMatcher _A(src);
REQUIRE_THAT(puml, StartsWith("@startuml")); REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(puml, EndsWith("@enduml\n")); REQUIRE_THAT(src, EndsWith("@enduml\n"));
REQUIRE_THAT(puml, IsClass(_A("Base"))); REQUIRE_THAT(src, IsClass(_A("Base")));
REQUIRE_THAT(puml, IsClass(_A("TBase"))); REQUIRE_THAT(src, IsClass(_A("TBase")));
REQUIRE_THAT(puml, IsClass(_A("A"))); REQUIRE_THAT(src, IsClass(_A("A")));
REQUIRE_THAT(puml, IsClass(_A("B"))); REQUIRE_THAT(src, IsClass(_A("B")));
REQUIRE_THAT(puml, IsClass(_A("C"))); REQUIRE_THAT(src, IsClass(_A("C")));
REQUIRE_THAT(puml, IsClass(_A("R"))); REQUIRE_THAT(src, IsClass(_A("R")));
REQUIRE_THAT(puml, IsClassTemplate("Overload", "T,L,Ts...")); REQUIRE_THAT(src, IsClassTemplate("Overload", "T,L,Ts..."));
REQUIRE_THAT(puml, IsBaseClass(_A("Base"), _A("Overload<T,L,Ts...>"))); REQUIRE_THAT(src, IsBaseClass(_A("Base"), _A("Overload<T,L,Ts...>")));
REQUIRE_THAT( REQUIRE_THAT(
puml, IsBaseClass(_A("TBase"), _A("Overload<TBase,int,A,B,C>"))); src, IsBaseClass(_A("TBase"), _A("Overload<TBase,int,A,B,C>")));
REQUIRE_THAT( REQUIRE_THAT(
puml, IsBaseClass(_A("A"), _A("Overload<TBase,int,A,B,C>"))); src, IsBaseClass(_A("A"), _A("Overload<TBase,int,A,B,C>")));
REQUIRE_THAT( REQUIRE_THAT(
puml, IsBaseClass(_A("B"), _A("Overload<TBase,int,A,B,C>"))); src, IsBaseClass(_A("B"), _A("Overload<TBase,int,A,B,C>")));
REQUIRE_THAT( REQUIRE_THAT(
puml, IsBaseClass(_A("C"), _A("Overload<TBase,int,A,B,C>"))); src, IsBaseClass(_A("C"), _A("Overload<TBase,int,A,B,C>")));
REQUIRE_THAT( REQUIRE_THAT(
puml, !IsDependency(_A("Overload<TBase,int,A,B,C>"), _A("TBase"))); src, !IsDependency(_A("Overload<TBase,int,A,B,C>"), _A("TBase")));
REQUIRE_THAT( REQUIRE_THAT(
puml, !IsDependency(_A("Overload<TBase,int,A,B,C>"), _A("A"))); src, !IsDependency(_A("Overload<TBase,int,A,B,C>"), _A("A")));
REQUIRE_THAT( REQUIRE_THAT(
puml, !IsDependency(_A("Overload<TBase,int,A,B,C>"), _A("B"))); src, !IsDependency(_A("Overload<TBase,int,A,B,C>"), _A("B")));
REQUIRE_THAT( REQUIRE_THAT(
puml, !IsDependency(_A("Overload<TBase,int,A,B,C>"), _A("C"))); src, !IsDependency(_A("Overload<TBase,int,A,B,C>"), _A("C")));
save_puml(config.output_directory(), diagram->name + ".puml", puml); save_puml(config.output_directory(), diagram->name + ".puml", src);
} }
{ {
auto j = generate_class_json(diagram, *model); auto j = generate_class_json(diagram, *model);
@@ -76,8 +76,37 @@ TEST_CASE("t00032", "[test-case][class]")
save_json(config.output_directory(), diagram->name + ".json", j); save_json(config.output_directory(), diagram->name + ".json", j);
} }
{ {
auto mmd = generate_class_mermaid(diagram, *model); auto src = generate_class_mermaid(diagram, *model);
save_mermaid(config.output_directory(), diagram->name + ".mmd", mmd); mermaid::AliasMatcher _A(src);
REQUIRE_THAT(src, IsClass(_A("Base")));
REQUIRE_THAT(src, IsClass(_A("TBase")));
REQUIRE_THAT(src, IsClass(_A("A")));
REQUIRE_THAT(src, IsClass(_A("B")));
REQUIRE_THAT(src, IsClass(_A("C")));
REQUIRE_THAT(src, IsClass(_A("R")));
REQUIRE_THAT(src, IsClass(_A("Overload<T,L,Ts...>")));
REQUIRE_THAT(src, IsBaseClass(_A("Base"), _A("Overload<T,L,Ts...>")));
REQUIRE_THAT(
src, IsBaseClass(_A("TBase"), _A("Overload<TBase,int,A,B,C>")));
REQUIRE_THAT(
src, IsBaseClass(_A("A"), _A("Overload<TBase,int,A,B,C>")));
REQUIRE_THAT(
src, IsBaseClass(_A("B"), _A("Overload<TBase,int,A,B,C>")));
REQUIRE_THAT(
src, IsBaseClass(_A("C"), _A("Overload<TBase,int,A,B,C>")));
REQUIRE_THAT(
src, !IsDependency(_A("Overload<TBase,int,A,B,C>"), _A("TBase")));
REQUIRE_THAT(
src, !IsDependency(_A("Overload<TBase,int,A,B,C>"), _A("A")));
REQUIRE_THAT(
src, !IsDependency(_A("Overload<TBase,int,A,B,C>"), _A("B")));
REQUIRE_THAT(
src, !IsDependency(_A("Overload<TBase,int,A,B,C>"), _A("C")));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
} }
} }

57
tests/t00033/test_case.h
View File

@@ -29,32 +29,32 @@ TEST_CASE("t00033", "[test-case][class]")
REQUIRE(model->name() == "t00033_class"); REQUIRE(model->name() == "t00033_class");
{ {
auto puml = generate_class_puml(diagram, *model); auto src = generate_class_puml(diagram, *model);
AliasMatcher _A(puml); AliasMatcher _A(src);
REQUIRE_THAT(puml, StartsWith("@startuml")); REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(puml, EndsWith("@enduml\n")); REQUIRE_THAT(src, EndsWith("@enduml\n"));
REQUIRE_THAT(puml, IsClassTemplate("A", "T")); REQUIRE_THAT(src, IsClassTemplate("A", "T"));
REQUIRE_THAT(puml, IsClassTemplate("B", "T")); REQUIRE_THAT(src, IsClassTemplate("B", "T"));
REQUIRE_THAT(puml, IsClassTemplate("C", "T")); REQUIRE_THAT(src, IsClassTemplate("C", "T"));
REQUIRE_THAT(puml, IsClass(_A("D"))); REQUIRE_THAT(src, IsClass(_A("D")));
REQUIRE_THAT(puml, IsClass(_A("R"))); REQUIRE_THAT(src, IsClass(_A("R")));
REQUIRE_THAT(puml, REQUIRE_THAT(src,
IsDependency(_A("A<B<std::unique_ptr<C<D>>>>"), IsDependency(_A("A<B<std::unique_ptr<C<D>>>>"),
_A("B<std::unique_ptr<C<D>>>"))); _A("B<std::unique_ptr<C<D>>>")));
REQUIRE_THAT( REQUIRE_THAT(
puml, IsDependency(_A("B<std::unique_ptr<C<D>>>"), _A("C<D>"))); src, IsDependency(_A("B<std::unique_ptr<C<D>>>"), _A("C<D>")));
REQUIRE_THAT(puml, IsDependency(_A("C<D>"), _A("D"))); REQUIRE_THAT(src, IsDependency(_A("C<D>"), _A("D")));
REQUIRE_THAT(puml, IsInstantiation(_A("C<T>"), _A("C<D>"))); REQUIRE_THAT(src, IsInstantiation(_A("C<T>"), _A("C<D>")));
REQUIRE_THAT( REQUIRE_THAT(
puml, IsInstantiation(_A("B<T>"), _A("B<std::unique_ptr<C<D>>>"))); src, IsInstantiation(_A("B<T>"), _A("B<std::unique_ptr<C<D>>>")));
REQUIRE_THAT(puml, REQUIRE_THAT(src,
IsInstantiation(_A("A<T>"), _A("A<B<std::unique_ptr<C<D>>>>"))); IsInstantiation(_A("A<T>"), _A("A<B<std::unique_ptr<C<D>>>>")));
save_puml(config.output_directory(), diagram->name + ".puml", puml); save_puml(config.output_directory(), diagram->name + ".puml", src);
} }
{ {
auto j = generate_class_json(diagram, *model); auto j = generate_class_json(diagram, *model);
@@ -72,8 +72,29 @@ TEST_CASE("t00033", "[test-case][class]")
save_json(config.output_directory(), diagram->name + ".json", j); save_json(config.output_directory(), diagram->name + ".json", j);
} }
{ {
auto mmd = generate_class_mermaid(diagram, *model); auto src = generate_class_mermaid(diagram, *model);
save_mermaid(config.output_directory(), diagram->name + ".mmd", mmd); mermaid::AliasMatcher _A(src);
REQUIRE_THAT(src, IsClass(_A("A<T>")));
REQUIRE_THAT(src, IsClass(_A("B<T>")));
REQUIRE_THAT(src, IsClass(_A("C<T>")));
REQUIRE_THAT(src, IsClass(_A("D")));
REQUIRE_THAT(src, IsClass(_A("R")));
REQUIRE_THAT(src,
IsDependency(_A("A<B<std::unique_ptr<C<D>>>>"),
_A("B<std::unique_ptr<C<D>>>")));
REQUIRE_THAT(
src, IsDependency(_A("B<std::unique_ptr<C<D>>>"), _A("C<D>")));
REQUIRE_THAT(src, IsDependency(_A("C<D>"), _A("D")));
REQUIRE_THAT(src, IsInstantiation(_A("C<T>"), _A("C<D>")));
REQUIRE_THAT(
src, IsInstantiation(_A("B<T>"), _A("B<std::unique_ptr<C<D>>>")));
REQUIRE_THAT(src,
IsInstantiation(_A("A<T>"), _A("A<B<std::unique_ptr<C<D>>>>")));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
} }
} }

41
tests/t00034/test_case.h
View File

@@ -29,24 +29,24 @@ TEST_CASE("t00034", "[test-case][class]")
REQUIRE(model->name() == "t00034_class"); REQUIRE(model->name() == "t00034_class");
{ {
auto puml = generate_class_puml(diagram, *model); auto src = generate_class_puml(diagram, *model);
AliasMatcher _A(puml); AliasMatcher _A(src);
REQUIRE_THAT(puml, StartsWith("@startuml")); REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(puml, EndsWith("@enduml\n")); REQUIRE_THAT(src, EndsWith("@enduml\n"));
REQUIRE_THAT(puml, IsClassTemplate("lift_void", "T")); REQUIRE_THAT(src, IsClassTemplate("lift_void", "T"));
REQUIRE_THAT(puml, IsClassTemplate("drop_void", "T")); REQUIRE_THAT(src, IsClassTemplate("drop_void", "T"));
REQUIRE_THAT(puml, IsClass(_A("Void"))); REQUIRE_THAT(src, IsClass(_A("Void")));
REQUIRE_THAT(puml, IsClass(_A("A"))); REQUIRE_THAT(src, IsClass(_A("A")));
REQUIRE_THAT(puml, IsClass(_A("R"))); REQUIRE_THAT(src, IsClass(_A("R")));
REQUIRE_THAT( REQUIRE_THAT(
puml, IsInstantiation(_A("lift_void<T>"), _A("lift_void<void>"))); src, IsInstantiation(_A("lift_void<T>"), _A("lift_void<void>")));
REQUIRE_THAT( REQUIRE_THAT(
puml, IsInstantiation(_A("drop_void<T>"), _A("drop_void<Void>"))); src, IsInstantiation(_A("drop_void<T>"), _A("drop_void<Void>")));
save_puml(config.output_directory(), diagram->name + ".puml", puml); save_puml(config.output_directory(), diagram->name + ".puml", src);
} }
{ {
auto j = generate_class_json(diagram, *model); auto j = generate_class_json(diagram, *model);
@@ -59,8 +59,21 @@ TEST_CASE("t00034", "[test-case][class]")
save_json(config.output_directory(), diagram->name + ".json", j); save_json(config.output_directory(), diagram->name + ".json", j);
} }
{ {
auto mmd = generate_class_mermaid(diagram, *model); auto src = generate_class_mermaid(diagram, *model);
save_mermaid(config.output_directory(), diagram->name + ".mmd", mmd); mermaid::AliasMatcher _A(src);
REQUIRE_THAT(src, IsClass(_A("lift_void<T>")));
REQUIRE_THAT(src, IsClass(_A("drop_void<T>")));
REQUIRE_THAT(src, IsClass(_A("Void")));
REQUIRE_THAT(src, IsClass(_A("A")));
REQUIRE_THAT(src, IsClass(_A("R")));
REQUIRE_THAT(
src, IsInstantiation(_A("lift_void<T>"), _A("lift_void<void>")));
REQUIRE_THAT(
src, IsInstantiation(_A("drop_void<T>"), _A("drop_void<Void>")));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
} }
} }

40
tests/t00035/test_case.h
View File

@@ -29,24 +29,24 @@ TEST_CASE("t00035", "[test-case][class]")
REQUIRE(model->name() == "t00035_class"); REQUIRE(model->name() == "t00035_class");
{ {
auto puml = generate_class_puml(diagram, *model); auto src = generate_class_puml(diagram, *model);
AliasMatcher _A(puml); AliasMatcher _A(src);
REQUIRE_THAT(puml, StartsWith("@startuml")); REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(puml, EndsWith("@enduml\n")); REQUIRE_THAT(src, EndsWith("@enduml\n"));
REQUIRE_THAT(puml, IsClass(_A("Top"))); REQUIRE_THAT(src, IsClass(_A("Top")));
REQUIRE_THAT(puml, IsClass(_A("Bottom"))); REQUIRE_THAT(src, IsClass(_A("Bottom")));
REQUIRE_THAT(puml, IsClass(_A("Center"))); REQUIRE_THAT(src, IsClass(_A("Center")));
REQUIRE_THAT(puml, IsClass(_A("Left"))); REQUIRE_THAT(src, IsClass(_A("Left")));
REQUIRE_THAT(puml, IsClass(_A("Right"))); REQUIRE_THAT(src, IsClass(_A("Right")));
REQUIRE_THAT(puml, IsLayoutHint(_A("Center"), "up", _A("Top"))); REQUIRE_THAT(src, IsLayoutHint(_A("Center"), "up", _A("Top")));
REQUIRE_THAT(puml, IsLayoutHint(_A("Center"), "left", _A("Left"))); REQUIRE_THAT(src, IsLayoutHint(_A("Center"), "left", _A("Left")));
REQUIRE_THAT(puml, IsLayoutHint(_A("Center"), "right", _A("Right"))); REQUIRE_THAT(src, IsLayoutHint(_A("Center"), "right", _A("Right")));
REQUIRE_THAT(puml, IsLayoutHint(_A("Center"), "down", _A("Bottom"))); REQUIRE_THAT(src, IsLayoutHint(_A("Center"), "down", _A("Bottom")));
save_puml(config.output_directory(), diagram->name + ".puml", puml); save_puml(config.output_directory(), diagram->name + ".puml", src);
} }
{ {
auto j = generate_class_json(diagram, *model); auto j = generate_class_json(diagram, *model);
@@ -62,8 +62,16 @@ TEST_CASE("t00035", "[test-case][class]")
save_json(config.output_directory(), diagram->name + ".json", j); save_json(config.output_directory(), diagram->name + ".json", j);
} }
{ {
auto mmd = generate_class_mermaid(diagram, *model); auto src = generate_class_mermaid(diagram, *model);
save_mermaid(config.output_directory(), diagram->name + ".mmd", mmd); mermaid::AliasMatcher _A(src);
REQUIRE_THAT(src, IsClass(_A("Top")));
REQUIRE_THAT(src, IsClass(_A("Bottom")));
REQUIRE_THAT(src, IsClass(_A("Center")));
REQUIRE_THAT(src, IsClass(_A("Left")));
REQUIRE_THAT(src, IsClass(_A("Right")));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
} }
} }

50
tests/t00036/test_case.h
View File

@@ -30,26 +30,26 @@ TEST_CASE("t00036", "[test-case][class]")
REQUIRE(model->name() == "t00036_class"); REQUIRE(model->name() == "t00036_class");
{ {
auto puml = generate_class_puml(diagram, *model); auto src = generate_class_puml(diagram, *model);
AliasMatcher _A(puml); AliasMatcher _A(src);
REQUIRE_THAT(puml, StartsWith("@startuml")); REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(puml, EndsWith("@enduml\n")); REQUIRE_THAT(src, EndsWith("@enduml\n"));
REQUIRE_THAT(puml, IsClassTemplate("A", "T")); REQUIRE_THAT(src, IsClassTemplate("A", "T"));
REQUIRE_THAT(puml, IsClassTemplate("A", "int")); REQUIRE_THAT(src, IsClassTemplate("A", "int"));
REQUIRE_THAT(puml, IsEnum(_A("E"))); REQUIRE_THAT(src, IsEnum(_A("E")));
REQUIRE_THAT(puml, IsClass(_A("B"))); REQUIRE_THAT(src, IsClass(_A("B")));
REQUIRE_THAT(puml, IsClass(_A("C"))); REQUIRE_THAT(src, IsClass(_A("C")));
REQUIRE_THAT(puml, !IsClass(_A("DImpl"))); REQUIRE_THAT(src, !IsClass(_A("DImpl")));
REQUIRE_THAT(puml, IsPackage("ns111")); REQUIRE_THAT(src, IsPackage("ns111"));
REQUIRE_THAT(puml, IsPackage("ns22")); REQUIRE_THAT(src, IsPackage("ns22"));
REQUIRE_THAT(puml, !IsPackage("ns3")); REQUIRE_THAT(src, !IsPackage("ns3"));
REQUIRE_THAT(puml, !IsPackage("ns33")); REQUIRE_THAT(src, !IsPackage("ns33"));
REQUIRE_THAT(puml, IsAggregation(_A("B"), _A("A<int>"), "+a_int")); REQUIRE_THAT(src, IsAggregation(_A("B"), _A("A<int>"), "+a_int"));
save_puml(config.output_directory(), diagram->name + ".puml", puml); save_puml(config.output_directory(), diagram->name + ".puml", src);
} }
{ {
auto j = generate_class_json(diagram, *model); auto j = generate_class_json(diagram, *model);
@@ -69,8 +69,22 @@ TEST_CASE("t00036", "[test-case][class]")
save_json(config.output_directory(), diagram->name + ".json", j); save_json(config.output_directory(), diagram->name + ".json", j);
} }
{ {
auto mmd = generate_class_mermaid(diagram, *model); auto src = generate_class_mermaid(diagram, *model);
save_mermaid(config.output_directory(), diagram->name + ".mmd", mmd); mermaid::AliasMatcher _A(src);
using mermaid::IsEnum;
REQUIRE_THAT(src, IsClass(_A("ns1::ns11::A<T>")));
REQUIRE_THAT(src, IsClass(_A("ns1::ns11::A<int>")));
REQUIRE_THAT(src, IsEnum(_A("ns1::E")));
REQUIRE_THAT(src, IsClass(_A("ns1::ns11::ns111::B")));
REQUIRE_THAT(src, IsClass(_A("ns2::ns22::C")));
REQUIRE_THAT(src, !IsClass(_A("DImpl")));
REQUIRE_THAT(src,
IsAggregation(
_A("ns1::ns11::ns111::B"), _A("ns1::ns11::A<int>"), "+a_int"));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
} }
} }

37
tests/t00037/test_case.h
View File

@@ -30,22 +30,21 @@ TEST_CASE("t00037", "[test-case][class]")
REQUIRE(model->name() == "t00037_class"); REQUIRE(model->name() == "t00037_class");
{ {
auto puml = generate_class_puml(diagram, *model); auto src = generate_class_puml(diagram, *model);
AliasMatcher _A(puml); AliasMatcher _A(src);
REQUIRE_THAT(puml, StartsWith("@startuml")); REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(puml, EndsWith("@enduml\n")); REQUIRE_THAT(src, EndsWith("@enduml\n"));
REQUIRE_THAT(puml, IsClass(_A("ST"))); REQUIRE_THAT(src, IsClass(_A("ST")));
REQUIRE_THAT(puml, IsClass(_A("A"))); REQUIRE_THAT(src, IsClass(_A("A")));
REQUIRE_THAT(puml, IsClass(_A("ST::(units)"))); REQUIRE_THAT(src, IsClass(_A("ST::(units)")));
REQUIRE_THAT(puml, IsClass(_A("ST::(dimensions)"))); REQUIRE_THAT(src, IsClass(_A("ST::(dimensions)")));
REQUIRE_THAT(puml, REQUIRE_THAT(src,
IsAggregation(_A("ST"), _A("ST::(dimensions)"), "+dimensions")); IsAggregation(_A("ST"), _A("ST::(dimensions)"), "+dimensions"));
REQUIRE_THAT( REQUIRE_THAT(src, IsAggregation(_A("ST"), _A("ST::(units)"), "-units"));
puml, IsAggregation(_A("ST"), _A("ST::(units)"), "-units"));
save_puml(config.output_directory(), diagram->name + ".puml", puml); save_puml(config.output_directory(), diagram->name + ".puml", src);
} }
{ {
auto j = generate_class_json(diagram, *model); auto j = generate_class_json(diagram, *model);
@@ -61,8 +60,18 @@ TEST_CASE("t00037", "[test-case][class]")
save_json(config.output_directory(), diagram->name + ".json", j); save_json(config.output_directory(), diagram->name + ".json", j);
} }
{ {
auto mmd = generate_class_mermaid(diagram, *model); auto src = generate_class_mermaid(diagram, *model);
save_mermaid(config.output_directory(), diagram->name + ".mmd", mmd); mermaid::AliasMatcher _A(src);
REQUIRE_THAT(src, IsClass(_A("ST")));
REQUIRE_THAT(src, IsClass(_A("A")));
REQUIRE_THAT(src, IsClass(_A("ST::(units)")));
REQUIRE_THAT(src, IsClass(_A("ST::(dimensions)")));
REQUIRE_THAT(src,
IsAggregation(_A("ST"), _A("ST::(dimensions)"), "+dimensions"));
REQUIRE_THAT(src, IsAggregation(_A("ST"), _A("ST::(units)"), "-units"));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
} }
} }

111
tests/t00038/test_case.h
View File

@@ -30,73 +30,73 @@ TEST_CASE("t00038", "[test-case][class]")
REQUIRE(model->name() == "t00038_class"); REQUIRE(model->name() == "t00038_class");
{ {
auto puml = generate_class_puml(diagram, *model); auto src = generate_class_puml(diagram, *model);
AliasMatcher _A(puml); AliasMatcher _A(src);
REQUIRE_THAT(puml, StartsWith("@startuml")); REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(puml, EndsWith("@enduml\n")); REQUIRE_THAT(src, EndsWith("@enduml\n"));
REQUIRE_THAT(puml, IsClass(_A("A"))); REQUIRE_THAT(src, IsClass(_A("A")));
REQUIRE_THAT(puml, IsClass(_A("B"))); REQUIRE_THAT(src, IsClass(_A("B")));
REQUIRE_THAT(puml, IsClass(_A("C"))); REQUIRE_THAT(src, IsClass(_A("C")));
REQUIRE_THAT(puml, IsClass(_A("thirdparty::ns1::E"))); REQUIRE_THAT(src, IsClass(_A("thirdparty::ns1::E")));
REQUIRE_THAT(puml, IsClass(_A("key_t"))); REQUIRE_THAT(src, IsClass(_A("key_t")));
REQUIRE_THAT(puml, IsClassTemplate("map", "T")); REQUIRE_THAT(src, IsClassTemplate("map", "T"));
REQUIRE_THAT(puml, REQUIRE_THAT(src,
IsClassTemplate("map", IsClassTemplate("map",
"std::integral_constant<property_t,property_t::property_a>")); "std::integral_constant<property_t,property_t::property_a>"));
REQUIRE_THAT(puml, REQUIRE_THAT(src,
IsClassTemplate("map", IsClassTemplate("map",
"std::vector<std::integral_constant<property_t,property_t::" "std::vector<std::integral_constant<property_t,property_t::"
"property_b>>")); "property_b>>"));
REQUIRE_THAT(puml, REQUIRE_THAT(src,
IsClassTemplate("map", IsClassTemplate("map",
"std::map<key_t,std::vector<std::integral_constant<property_t," "std::map<key_t,std::vector<std::integral_constant<property_t,"
"property_t::property_c>>>")); "property_t::property_c>>>"));
REQUIRE_THAT(puml, IsEnum(_A("property_t"))); REQUIRE_THAT(src, IsEnum(_A("property_t")));
REQUIRE_THAT(puml, REQUIRE_THAT(src,
IsInstantiation(_A("map<T>"), IsInstantiation(_A("map<T>"),
_A("map<std::map<key_t,std::vector<std::integral_constant<" _A("map<std::map<key_t,std::vector<std::integral_constant<"
"property_" "property_"
"t,property_t::property_c>>>>"))); "t,property_t::property_c>>>>")));
REQUIRE_THAT(puml, REQUIRE_THAT(src,
IsDependency(_A("map<std::integral_constant<property_t,property_t::" IsDependency(_A("map<std::integral_constant<property_t,property_t::"
"property_a>>"), "property_a>>"),
_A("property_t"))); _A("property_t")));
REQUIRE_THAT(puml, REQUIRE_THAT(src,
IsDependency(_A("map<" IsDependency(_A("map<"
"std::vector<std::integral_constant<property_t," "std::vector<std::integral_constant<property_t,"
"property_t::property_b>>>"), "property_t::property_b>>>"),
_A("property_t"))); _A("property_t")));
REQUIRE_THAT(puml, REQUIRE_THAT(src,
IsDependency( IsDependency(
_A("map<std::map<key_t,std::vector<std::integral_constant<" _A("map<std::map<key_t,std::vector<std::integral_constant<"
"property_t,property_t::property_c>>>>"), "property_t,property_t::property_c>>>>"),
_A("property_t"))); _A("property_t")));
REQUIRE_THAT(puml, REQUIRE_THAT(src,
IsDependency( IsDependency(
_A("map<std::map<key_t,std::vector<std::integral_constant<" _A("map<std::map<key_t,std::vector<std::integral_constant<"
"property_t,property_t::property_c>>>>"), "property_t,property_t::property_c>>>>"),
_A("key_t"))); _A("key_t")));
REQUIRE_THAT(puml, REQUIRE_THAT(src,
IsDependency( IsDependency(
_A("map<std::integral_constant<thirdparty::ns1::color_t," _A("map<std::integral_constant<thirdparty::ns1::color_t,"
"thirdparty::ns1::color_t::red>>"), "thirdparty::ns1::color_t::red>>"),
_A("thirdparty::ns1::color_t"))); _A("thirdparty::ns1::color_t")));
REQUIRE_THAT(puml, REQUIRE_THAT(src,
IsBaseClass(_A("thirdparty::ns1::E"), IsBaseClass(_A("thirdparty::ns1::E"),
_A("map<std::integral_constant<thirdparty::ns1::color_t," _A("map<std::integral_constant<thirdparty::ns1::color_t,"
"thirdparty::ns1::color_t::red>>"))); "thirdparty::ns1::color_t::red>>")));
save_puml(config.output_directory(), diagram->name + ".puml", puml); save_puml(config.output_directory(), diagram->name + ".puml", src);
} }
{ {
auto j = generate_class_json(diagram, *model); auto j = generate_class_json(diagram, *model);
@@ -110,8 +110,71 @@ TEST_CASE("t00038", "[test-case][class]")
save_json(config.output_directory(), diagram->name + ".json", j); save_json(config.output_directory(), diagram->name + ".json", j);
} }
{ {
auto mmd = generate_class_mermaid(diagram, *model); auto src = generate_class_mermaid(diagram, *model);
save_mermaid(config.output_directory(), diagram->name + ".mmd", mmd); mermaid::AliasMatcher _A(src);
using mermaid::IsEnum;
REQUIRE_THAT(src, IsClass(_A("A")));
REQUIRE_THAT(src, IsClass(_A("B")));
REQUIRE_THAT(src, IsClass(_A("C")));
REQUIRE_THAT(src, IsClass(_A("thirdparty::ns1::E")));
REQUIRE_THAT(src, IsClass(_A("key_t")));
REQUIRE_THAT(src, IsClass(_A("map<T>")));
REQUIRE_THAT(src,
IsClass(_A("map<std::integral_constant<property_t,property_t::"
"property_a>>")));
REQUIRE_THAT(src,
IsClass(_A(
"map<std::vector<std::integral_constant<property_t,property_t::"
"property_b>>>")));
REQUIRE_THAT(src,
IsClass(_A("map<std::map<key_t,std::vector<std::integral_constant<"
"property_t,"
"property_t::property_c>>>>")));
REQUIRE_THAT(src, IsEnum(_A("property_t")));
REQUIRE_THAT(src,
IsInstantiation(_A("map<T>"),
_A("map<std::map<key_t,std::vector<std::integral_constant<"
"property_"
"t,property_t::property_c>>>>")));
REQUIRE_THAT(src,
IsDependency(_A("map<std::integral_constant<property_t,property_t::"
"property_a>>"),
_A("property_t")));
REQUIRE_THAT(src,
IsDependency(_A("map<"
"std::vector<std::integral_constant<property_t,"
"property_t::property_b>>>"),
_A("property_t")));
REQUIRE_THAT(src,
IsDependency(
_A("map<std::map<key_t,std::vector<std::integral_constant<"
"property_t,property_t::property_c>>>>"),
_A("property_t")));
REQUIRE_THAT(src,
IsDependency(
_A("map<std::map<key_t,std::vector<std::integral_constant<"
"property_t,property_t::property_c>>>>"),
_A("key_t")));
REQUIRE_THAT(src,
IsDependency(
_A("map<std::integral_constant<thirdparty::ns1::color_t,"
"thirdparty::ns1::color_t::red>>"),
_A("thirdparty::ns1::color_t")));
REQUIRE_THAT(src,
IsBaseClass(_A("thirdparty::ns1::E"),
_A("map<std::integral_constant<thirdparty::ns1::color_t,"
"thirdparty::ns1::color_t::red>>")));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
} }
} }

92
tests/t00039/test_case.h
View File

@@ -29,41 +29,41 @@ TEST_CASE("t00039", "[test-case][class]")
REQUIRE(model->name() == "t00039_class"); REQUIRE(model->name() == "t00039_class");
{ {
auto puml = generate_class_puml(diagram, *model); auto src = generate_class_puml(diagram, *model);
AliasMatcher _A(puml); AliasMatcher _A(src);
REQUIRE_THAT(puml, StartsWith("@startuml")); REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(puml, EndsWith("@enduml\n")); REQUIRE_THAT(src, EndsWith("@enduml\n"));
REQUIRE_THAT(puml, IsClass(_A("A"))); REQUIRE_THAT(src, IsClass(_A("A")));
REQUIRE_THAT(puml, IsClass(_A("AA"))); REQUIRE_THAT(src, IsClass(_A("AA")));
REQUIRE_THAT(puml, IsClass(_A("AAA"))); REQUIRE_THAT(src, IsClass(_A("AAA")));
REQUIRE_THAT(puml, IsClass(_A("ns2::AAAA"))); REQUIRE_THAT(src, IsClass(_A("ns2::AAAA")));
REQUIRE_THAT(puml, IsBaseClass(_A("A"), _A("AA"))); REQUIRE_THAT(src, IsBaseClass(_A("A"), _A("AA")));
REQUIRE_THAT(puml, IsBaseClass(_A("AA"), _A("AAA"))); REQUIRE_THAT(src, IsBaseClass(_A("AA"), _A("AAA")));
REQUIRE_THAT(puml, IsBaseClass(_A("AAA"), _A("ns2::AAAA"))); REQUIRE_THAT(src, IsBaseClass(_A("AAA"), _A("ns2::AAAA")));
REQUIRE_THAT(puml, !IsClass(_A("detail::AA"))); REQUIRE_THAT(src, !IsClass(_A("detail::AA")));
REQUIRE_THAT(puml, !IsClass(_A("B"))); REQUIRE_THAT(src, !IsClass(_A("B")));
REQUIRE_THAT(puml, !IsClass(_A("ns1::BB"))); REQUIRE_THAT(src, !IsClass(_A("ns1::BB")));
REQUIRE_THAT(puml, IsClass(_A("C"))); REQUIRE_THAT(src, IsClass(_A("C")));
REQUIRE_THAT(puml, IsClass(_A("D"))); REQUIRE_THAT(src, IsClass(_A("D")));
REQUIRE_THAT(puml, IsClass(_A("E"))); REQUIRE_THAT(src, IsClass(_A("E")));
REQUIRE_THAT(puml, IsBaseClass(_A("C"), _A("CD"))); REQUIRE_THAT(src, IsBaseClass(_A("C"), _A("CD")));
REQUIRE_THAT(puml, IsBaseClass(_A("D"), _A("CD"))); REQUIRE_THAT(src, IsBaseClass(_A("D"), _A("CD")));
REQUIRE_THAT(puml, IsBaseClass(_A("D"), _A("DE"))); REQUIRE_THAT(src, IsBaseClass(_A("D"), _A("DE")));
REQUIRE_THAT(puml, IsBaseClass(_A("E"), _A("DE"))); REQUIRE_THAT(src, IsBaseClass(_A("E"), _A("DE")));
REQUIRE_THAT(puml, IsBaseClass(_A("C"), _A("CDE"))); REQUIRE_THAT(src, IsBaseClass(_A("C"), _A("CDE")));
REQUIRE_THAT(puml, IsBaseClass(_A("D"), _A("CDE"))); REQUIRE_THAT(src, IsBaseClass(_A("D"), _A("CDE")));
REQUIRE_THAT(puml, IsBaseClass(_A("E"), _A("CDE"))); REQUIRE_THAT(src, IsBaseClass(_A("E"), _A("CDE")));
REQUIRE_THAT(puml, IsClassTemplate("ns3::F", "T")); REQUIRE_THAT(src, IsClassTemplate("ns3::F", "T"));
REQUIRE_THAT(puml, IsClassTemplate("ns3::FF", "T,M")); REQUIRE_THAT(src, IsClassTemplate("ns3::FF", "T,M"));
REQUIRE_THAT(puml, IsClassTemplate("ns3::FE", "T,M")); REQUIRE_THAT(src, IsClassTemplate("ns3::FE", "T,M"));
REQUIRE_THAT(puml, IsClassTemplate("ns3::FFF", "T,M,N")); REQUIRE_THAT(src, IsClassTemplate("ns3::FFF", "T,M,N"));
save_puml(config.output_directory(), diagram->name + ".puml", puml); save_puml(config.output_directory(), diagram->name + ".puml", src);
} }
{ {
auto j = generate_class_json(diagram, *model); auto j = generate_class_json(diagram, *model);
@@ -86,8 +86,38 @@ TEST_CASE("t00039", "[test-case][class]")
save_json(config.output_directory(), diagram->name + ".json", j); save_json(config.output_directory(), diagram->name + ".json", j);
} }
{ {
auto mmd = generate_class_mermaid(diagram, *model); auto src = generate_class_mermaid(diagram, *model);
save_mermaid(config.output_directory(), diagram->name + ".mmd", mmd); mermaid::AliasMatcher _A(src);
REQUIRE_THAT(src, IsClass(_A("A")));
REQUIRE_THAT(src, IsClass(_A("AA")));
REQUIRE_THAT(src, IsClass(_A("AAA")));
REQUIRE_THAT(src, IsClass(_A("ns2::AAAA")));
REQUIRE_THAT(src, IsBaseClass(_A("A"), _A("AA")));
REQUIRE_THAT(src, IsBaseClass(_A("AA"), _A("AAA")));
REQUIRE_THAT(src, IsBaseClass(_A("AAA"), _A("ns2::AAAA")));
REQUIRE_THAT(src, !IsClass(_A("detail::AA")));
REQUIRE_THAT(src, !IsClass(_A("B")));
REQUIRE_THAT(src, !IsClass(_A("ns1::BB")));
REQUIRE_THAT(src, IsClass(_A("C")));
REQUIRE_THAT(src, IsClass(_A("D")));
REQUIRE_THAT(src, IsClass(_A("E")));
REQUIRE_THAT(src, IsBaseClass(_A("C"), _A("CD")));
REQUIRE_THAT(src, IsBaseClass(_A("D"), _A("CD")));
REQUIRE_THAT(src, IsBaseClass(_A("D"), _A("DE")));
REQUIRE_THAT(src, IsBaseClass(_A("E"), _A("DE")));
REQUIRE_THAT(src, IsBaseClass(_A("C"), _A("CDE")));
REQUIRE_THAT(src, IsBaseClass(_A("D"), _A("CDE")));
REQUIRE_THAT(src, IsBaseClass(_A("E"), _A("CDE")));
REQUIRE_THAT(src, IsClass(_A("ns3::F<T>")));
REQUIRE_THAT(src, IsClass(_A("ns3::FF<T,M>")));
REQUIRE_THAT(src, IsClass(_A("ns3::FE<T,M>")));
REQUIRE_THAT(src, IsClass(_A("ns3::FFF<T,M,N>")));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
} }
} }

40
tests/t00040/test_case.h
View File

@@ -29,23 +29,23 @@ TEST_CASE("t00040", "[test-case][class]")
REQUIRE(model->name() == "t00040_class"); REQUIRE(model->name() == "t00040_class");
{ {
auto puml = generate_class_puml(diagram, *model); auto src = generate_class_puml(diagram, *model);
AliasMatcher _A(puml); AliasMatcher _A(src);
REQUIRE_THAT(puml, StartsWith("@startuml")); REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(puml, EndsWith("@enduml\n")); REQUIRE_THAT(src, EndsWith("@enduml\n"));
REQUIRE_THAT(puml, IsClass(_A("A"))); REQUIRE_THAT(src, IsClass(_A("A")));
REQUIRE_THAT(puml, IsClass(_A("AA"))); REQUIRE_THAT(src, IsClass(_A("AA")));
REQUIRE_THAT(puml, IsClass(_A("AAA"))); REQUIRE_THAT(src, IsClass(_A("AAA")));
REQUIRE_THAT(puml, IsBaseClass(_A("A"), _A("AA"))); REQUIRE_THAT(src, IsBaseClass(_A("A"), _A("AA")));
REQUIRE_THAT(puml, IsBaseClass(_A("AA"), _A("AAA"))); REQUIRE_THAT(src, IsBaseClass(_A("AA"), _A("AAA")));
REQUIRE_THAT(puml, !IsClass(_A("B"))); REQUIRE_THAT(src, !IsClass(_A("B")));
REQUIRE_THAT(puml, !IsDependency(_A("R"), _A("A"))); REQUIRE_THAT(src, !IsDependency(_A("R"), _A("A")));
save_puml(config.output_directory(), diagram->name + ".puml", puml); save_puml(config.output_directory(), diagram->name + ".puml", src);
} }
{ {
auto j = generate_class_json(diagram, *model); auto j = generate_class_json(diagram, *model);
@@ -59,8 +59,20 @@ TEST_CASE("t00040", "[test-case][class]")
save_json(config.output_directory(), diagram->name + ".json", j); save_json(config.output_directory(), diagram->name + ".json", j);
} }
{ {
auto mmd = generate_class_mermaid(diagram, *model); auto src = generate_class_mermaid(diagram, *model);
save_mermaid(config.output_directory(), diagram->name + ".mmd", mmd); mermaid::AliasMatcher _A(src);
REQUIRE_THAT(src, IsClass(_A("A")));
REQUIRE_THAT(src, IsClass(_A("AA")));
REQUIRE_THAT(src, IsClass(_A("AAA")));
REQUIRE_THAT(src, IsBaseClass(_A("A"), _A("AA")));
REQUIRE_THAT(src, IsBaseClass(_A("AA"), _A("AAA")));
REQUIRE_THAT(src, !IsClass(_A("B")));
REQUIRE_THAT(src, !IsDependency(_A("R"), _A("A")));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
} }
} }

91
tests/t00041/test_case.h
View File

@@ -30,42 +30,42 @@ TEST_CASE("t00041", "[test-case][class]")
REQUIRE(model->name() == "t00041_class"); REQUIRE(model->name() == "t00041_class");
{ {
auto puml = generate_class_puml(diagram, *model); auto src = generate_class_puml(diagram, *model);
AliasMatcher _A(puml); AliasMatcher _A(src);
REQUIRE_THAT(puml, StartsWith("@startuml")); REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(puml, EndsWith("@enduml\n")); REQUIRE_THAT(src, EndsWith("@enduml\n"));
REQUIRE_THAT(puml, !IsClass(_A("A"))); REQUIRE_THAT(src, !IsClass(_A("A")));
REQUIRE_THAT(puml, !IsClass(_A("AA"))); REQUIRE_THAT(src, !IsClass(_A("AA")));
REQUIRE_THAT(puml, !IsClass(_A("AAA"))); REQUIRE_THAT(src, !IsClass(_A("AAA")));
REQUIRE_THAT(puml, !IsClass(_A("B"))); REQUIRE_THAT(src, !IsClass(_A("B")));
REQUIRE_THAT(puml, IsClass(_A("D"))); REQUIRE_THAT(src, IsClass(_A("D")));
REQUIRE_THAT(puml, IsClass(_A("E"))); REQUIRE_THAT(src, IsClass(_A("E")));
REQUIRE_THAT(puml, IsClass(_A("F"))); REQUIRE_THAT(src, IsClass(_A("F")));
REQUIRE_THAT(puml, IsClass(_A("R"))); REQUIRE_THAT(src, IsClass(_A("R")));
REQUIRE_THAT(puml, IsClass(_A("RR"))); REQUIRE_THAT(src, IsClass(_A("RR")));
REQUIRE_THAT(puml, IsClass(_A("RRR"))); REQUIRE_THAT(src, IsClass(_A("RRR")));
REQUIRE_THAT(puml, !IsClass(_A("detail::G"))); REQUIRE_THAT(src, !IsClass(_A("detail::G")));
REQUIRE_THAT(puml, !IsClass(_A("H"))); REQUIRE_THAT(src, !IsClass(_A("H")));
REQUIRE_THAT(puml, IsBaseClass(_A("R"), _A("RR"))); REQUIRE_THAT(src, IsBaseClass(_A("R"), _A("RR")));
REQUIRE_THAT(puml, IsBaseClass(_A("RR"), _A("RRR"))); REQUIRE_THAT(src, IsBaseClass(_A("RR"), _A("RRR")));
REQUIRE_THAT(puml, IsAssociation(_A("D"), _A("RR"), "+rr")); REQUIRE_THAT(src, IsAssociation(_A("D"), _A("RR"), "+rr"));
REQUIRE_THAT(puml, IsAssociation(_A("RR"), _A("E"), "+e")); REQUIRE_THAT(src, IsAssociation(_A("RR"), _A("E"), "+e"));
REQUIRE_THAT(puml, IsAssociation(_A("RR"), _A("F"), "+f")); REQUIRE_THAT(src, IsAssociation(_A("RR"), _A("F"), "+f"));
REQUIRE_THAT(puml, !IsDependency(_A("RR"), _A("H"))); REQUIRE_THAT(src, !IsDependency(_A("RR"), _A("H")));
REQUIRE_THAT(puml, IsClass(_A("ns1::N"))); REQUIRE_THAT(src, IsClass(_A("ns1::N")));
REQUIRE_THAT(puml, IsClass(_A("ns1::NN"))); REQUIRE_THAT(src, IsClass(_A("ns1::NN")));
REQUIRE_THAT(puml, IsClass(_A("ns1::NM"))); REQUIRE_THAT(src, IsClass(_A("ns1::NM")));
REQUIRE_THAT(puml, IsBaseClass(_A("ns1::N"), _A("ns1::NN"))); REQUIRE_THAT(src, IsBaseClass(_A("ns1::N"), _A("ns1::NN")));
REQUIRE_THAT(puml, IsBaseClass(_A("ns1::N"), _A("ns1::NM"))); REQUIRE_THAT(src, IsBaseClass(_A("ns1::N"), _A("ns1::NM")));
save_puml(config.output_directory(), diagram->name + ".puml", puml); save_puml(config.output_directory(), diagram->name + ".puml", src);
} }
{ {
auto j = generate_class_json(diagram, *model); auto j = generate_class_json(diagram, *model);
@@ -85,8 +85,39 @@ TEST_CASE("t00041", "[test-case][class]")
save_json(config.output_directory(), diagram->name + ".json", j); save_json(config.output_directory(), diagram->name + ".json", j);
} }
{ {
auto mmd = generate_class_mermaid(diagram, *model); auto src = generate_class_mermaid(diagram, *model);
save_mermaid(config.output_directory(), diagram->name + ".mmd", mmd); mermaid::AliasMatcher _A(src);
REQUIRE_THAT(src, !IsClass(_A("A")));
REQUIRE_THAT(src, !IsClass(_A("AA")));
REQUIRE_THAT(src, !IsClass(_A("AAA")));
REQUIRE_THAT(src, !IsClass(_A("B")));
REQUIRE_THAT(src, IsClass(_A("D")));
REQUIRE_THAT(src, IsClass(_A("E")));
REQUIRE_THAT(src, IsClass(_A("F")));
REQUIRE_THAT(src, IsClass(_A("R")));
REQUIRE_THAT(src, IsClass(_A("RR")));
REQUIRE_THAT(src, IsClass(_A("RRR")));
REQUIRE_THAT(src, !IsClass(_A("detail::G")));
REQUIRE_THAT(src, !IsClass(_A("H")));
REQUIRE_THAT(src, IsBaseClass(_A("R"), _A("RR")));
REQUIRE_THAT(src, IsBaseClass(_A("RR"), _A("RRR")));
REQUIRE_THAT(src, IsAssociation(_A("D"), _A("RR"), "+rr"));
REQUIRE_THAT(src, IsAssociation(_A("RR"), _A("E"), "+e"));
REQUIRE_THAT(src, IsAssociation(_A("RR"), _A("F"), "+f"));
REQUIRE_THAT(src, !IsDependency(_A("RR"), _A("H")));
REQUIRE_THAT(src, IsClass(_A("ns1::N")));
REQUIRE_THAT(src, IsClass(_A("ns1::NN")));
REQUIRE_THAT(src, IsClass(_A("ns1::NM")));
REQUIRE_THAT(src, IsBaseClass(_A("ns1::N"), _A("ns1::NN")));
REQUIRE_THAT(src, IsBaseClass(_A("ns1::N"), _A("ns1::NM")));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
} }
} }

26
tests/t00042/test_case.h
View File

@@ -30,17 +30,17 @@ TEST_CASE("t00042", "[test-case][class]")
REQUIRE(model->name() == "t00042_class"); REQUIRE(model->name() == "t00042_class");
{ {
auto puml = generate_class_puml(diagram, *model); auto src = generate_class_puml(diagram, *model);
AliasMatcher _A(puml); AliasMatcher _A(src);
REQUIRE_THAT(puml, StartsWith("@startuml")); REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(puml, EndsWith("@enduml\n")); REQUIRE_THAT(src, EndsWith("@enduml\n"));
REQUIRE_THAT(puml, IsClassTemplate("A", "T")); REQUIRE_THAT(src, IsClassTemplate("A", "T"));
REQUIRE_THAT(puml, IsClassTemplate("B", "T,K")); REQUIRE_THAT(src, IsClassTemplate("B", "T,K"));
REQUIRE_THAT(puml, !IsClassTemplate("C", "T")); REQUIRE_THAT(src, !IsClassTemplate("C", "T"));
save_puml(config.output_directory(), diagram->name + ".puml", puml); save_puml(config.output_directory(), diagram->name + ".puml", src);
} }
{ {
auto j = generate_class_json(diagram, *model); auto j = generate_class_json(diagram, *model);
@@ -53,8 +53,14 @@ TEST_CASE("t00042", "[test-case][class]")
save_json(config.output_directory(), diagram->name + ".json", j); save_json(config.output_directory(), diagram->name + ".json", j);
} }
{ {
auto mmd = generate_class_mermaid(diagram, *model); auto src = generate_class_mermaid(diagram, *model);
save_mermaid(config.output_directory(), diagram->name + ".mmd", mmd); mermaid::AliasMatcher _A(src);
REQUIRE_THAT(src, IsClass(_A("A<T>")));
REQUIRE_THAT(src, IsClass(_A("B<T,K>")));
REQUIRE_THAT(src, !IsClass(_A("C<T>")));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
} }
} }

94
tests/t00043/test_case.h
View File

@@ -30,40 +30,40 @@ TEST_CASE("t00043", "[test-case][class]")
REQUIRE(model->name() == "t00043_class"); REQUIRE(model->name() == "t00043_class");
{ {
auto puml = generate_class_puml(diagram, *model); auto src = generate_class_puml(diagram, *model);
AliasMatcher _A(puml); AliasMatcher _A(src);
REQUIRE_THAT(puml, StartsWith("@startuml")); REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(puml, EndsWith("@enduml\n")); REQUIRE_THAT(src, EndsWith("@enduml\n"));
// Check dependants filter // Check dependants filter
REQUIRE_THAT(puml, IsClass(_A("A"))); REQUIRE_THAT(src, IsClass(_A("A")));
REQUIRE_THAT(puml, IsClass(_A("B"))); REQUIRE_THAT(src, IsClass(_A("B")));
REQUIRE_THAT(puml, IsClass(_A("BB"))); REQUIRE_THAT(src, IsClass(_A("BB")));
REQUIRE_THAT(puml, IsClass(_A("D"))); REQUIRE_THAT(src, IsClass(_A("D")));
REQUIRE_THAT(puml, IsClass(_A("E"))); REQUIRE_THAT(src, IsClass(_A("E")));
REQUIRE_THAT(puml, !IsClass(_A("F"))); REQUIRE_THAT(src, !IsClass(_A("F")));
REQUIRE_THAT(puml, IsDependency(_A("B"), _A("A"))); REQUIRE_THAT(src, IsDependency(_A("B"), _A("A")));
REQUIRE_THAT(puml, IsDependency(_A("BB"), _A("A"))); REQUIRE_THAT(src, IsDependency(_A("BB"), _A("A")));
REQUIRE_THAT(puml, IsDependency(_A("C"), _A("B"))); REQUIRE_THAT(src, IsDependency(_A("C"), _A("B")));
REQUIRE_THAT(puml, IsDependency(_A("D"), _A("C"))); REQUIRE_THAT(src, IsDependency(_A("D"), _A("C")));
REQUIRE_THAT(puml, IsDependency(_A("E"), _A("D"))); REQUIRE_THAT(src, IsDependency(_A("E"), _A("D")));
// Check dependencies filter // Check dependencies filter
REQUIRE_THAT(puml, IsClass(_A("G"))); REQUIRE_THAT(src, IsClass(_A("G")));
REQUIRE_THAT(puml, IsClass(_A("GG"))); REQUIRE_THAT(src, IsClass(_A("GG")));
REQUIRE_THAT(puml, IsClass(_A("H"))); REQUIRE_THAT(src, IsClass(_A("H")));
REQUIRE_THAT(puml, !IsClass(_A("HH"))); REQUIRE_THAT(src, !IsClass(_A("HH")));
REQUIRE_THAT(puml, IsClass(_A("I"))); REQUIRE_THAT(src, IsClass(_A("I")));
REQUIRE_THAT(puml, IsClass(_A("J"))); REQUIRE_THAT(src, IsClass(_A("J")));
REQUIRE_THAT(puml, IsDependency(_A("H"), _A("G"))); REQUIRE_THAT(src, IsDependency(_A("H"), _A("G")));
REQUIRE_THAT(puml, IsDependency(_A("H"), _A("GG"))); REQUIRE_THAT(src, IsDependency(_A("H"), _A("GG")));
REQUIRE_THAT(puml, IsDependency(_A("I"), _A("H"))); REQUIRE_THAT(src, IsDependency(_A("I"), _A("H")));
REQUIRE_THAT(puml, IsDependency(_A("J"), _A("I"))); REQUIRE_THAT(src, IsDependency(_A("J"), _A("I")));
save_puml(config.output_directory(), diagram->name + ".puml", puml); save_puml(config.output_directory(), diagram->name + ".puml", src);
} }
{ {
auto j = generate_class_json(diagram, *model); auto j = generate_class_json(diagram, *model);
@@ -87,8 +87,46 @@ TEST_CASE("t00043", "[test-case][class]")
save_json(config.output_directory(), diagram->name + ".json", j); save_json(config.output_directory(), diagram->name + ".json", j);
} }
{ {
auto mmd = generate_class_mermaid(diagram, *model); auto src = generate_class_mermaid(diagram, *model);
save_mermaid(config.output_directory(), diagram->name + ".mmd", mmd); mermaid::AliasMatcher _A(src);
// Check dependants filter
REQUIRE_THAT(src, IsClass(_A("dependants::A")));
REQUIRE_THAT(src, IsClass(_A("dependants::B")));
REQUIRE_THAT(src, IsClass(_A("dependants::BB")));
REQUIRE_THAT(src, IsClass(_A("dependants::D")));
REQUIRE_THAT(src, IsClass(_A("dependants::E")));
REQUIRE_THAT(src, !IsClass(_A("dependants::F")));
REQUIRE_THAT(
src, IsDependency(_A("dependants::B"), _A("dependants::A")));
REQUIRE_THAT(
src, IsDependency(_A("dependants::BB"), _A("dependants::A")));
REQUIRE_THAT(
src, IsDependency(_A("dependants::C"), _A("dependants::B")));
REQUIRE_THAT(
src, IsDependency(_A("dependants::D"), _A("dependants::C")));
REQUIRE_THAT(
src, IsDependency(_A("dependants::E"), _A("dependants::D")));
// Check dependencies filter
REQUIRE_THAT(src, IsClass(_A("dependencies::G")));
REQUIRE_THAT(src, IsClass(_A("dependencies::GG")));
REQUIRE_THAT(src, IsClass(_A("dependencies::H")));
REQUIRE_THAT(src, !IsClass(_A("dependencies::HH")));
REQUIRE_THAT(src, IsClass(_A("dependencies::I")));
REQUIRE_THAT(src, IsClass(_A("dependencies::J")));
REQUIRE_THAT(
src, IsDependency(_A("dependencies::H"), _A("dependencies::G")));
REQUIRE_THAT(
src, IsDependency(_A("dependencies::H"), _A("dependencies::GG")));
REQUIRE_THAT(
src, IsDependency(_A("dependencies::I"), _A("dependencies::H")));
REQUIRE_THAT(
src, IsDependency(_A("dependencies::J"), _A("dependencies::I")));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
} }
} }

65
tests/t00044/test_case.h
View File

@@ -30,41 +30,41 @@ TEST_CASE("t00044", "[test-case][class]")
REQUIRE(model->name() == "t00044_class"); REQUIRE(model->name() == "t00044_class");
{ {
auto puml = generate_class_puml(diagram, *model); auto src = generate_class_puml(diagram, *model);
AliasMatcher _A(puml); AliasMatcher _A(src);
REQUIRE_THAT(puml, StartsWith("@startuml")); REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(puml, EndsWith("@enduml\n")); REQUIRE_THAT(src, EndsWith("@enduml\n"));
REQUIRE_THAT(puml, !Contains("type-parameter-")); REQUIRE_THAT(src, !Contains("type-parameter-"));
REQUIRE_THAT(puml, IsClassTemplate("sink", "T")); REQUIRE_THAT(src, IsClassTemplate("sink", "T"));
REQUIRE_THAT(puml, IsClassTemplate("signal_handler", "T,A")); REQUIRE_THAT(src, IsClassTemplate("signal_handler", "T,A"));
REQUIRE_THAT(puml, IsClassTemplate("signal_handler", "Ret(Args...),A")); REQUIRE_THAT(src, IsClassTemplate("signal_handler", "Ret(Args...),A"));
REQUIRE_THAT(puml, IsClassTemplate("signal_handler", "void(int),bool")); REQUIRE_THAT(src, IsClassTemplate("signal_handler", "void(int),bool"));
REQUIRE_THAT( REQUIRE_THAT(
puml, IsClassTemplate("sink", "signal_handler<Ret(Args...),A>")); src, IsClassTemplate("sink", "signal_handler<Ret(Args...),A>"));
REQUIRE_THAT(puml, REQUIRE_THAT(src,
IsInstantiation( IsInstantiation(
_A("sink<T>"), _A("sink<signal_handler<Ret(Args...),A>>"))); _A("sink<T>"), _A("sink<signal_handler<Ret(Args...),A>>")));
REQUIRE_THAT(puml, REQUIRE_THAT(src,
IsInstantiation(_A("sink<signal_handler<Ret(Args...),A>>"), IsInstantiation(_A("sink<signal_handler<Ret(Args...),A>>"),
_A("sink<signal_handler<void(int),bool>>"))); _A("sink<signal_handler<void(int),bool>>")));
REQUIRE_THAT(puml, IsClassTemplate("signal_handler", "T,A")); REQUIRE_THAT(src, IsClassTemplate("signal_handler", "T,A"));
REQUIRE_THAT(puml, REQUIRE_THAT(src,
IsInstantiation(_A("signal_handler<T,A>"), IsInstantiation(_A("signal_handler<T,A>"),
_A("signal_handler<Ret(Args...),A>"))); _A("signal_handler<Ret(Args...),A>")));
REQUIRE_THAT(puml, REQUIRE_THAT(src,
IsInstantiation(_A("signal_handler<Ret(Args...),A>"), IsInstantiation(_A("signal_handler<Ret(Args...),A>"),
_A("signal_handler<void(int),bool>"))); _A("signal_handler<void(int),bool>")));
save_puml(config.output_directory(), diagram->name + ".puml", puml); save_puml(config.output_directory(), diagram->name + ".puml", src);
} }
{ {
auto j = generate_class_json(diagram, *model); auto j = generate_class_json(diagram, *model);
@@ -82,8 +82,37 @@ TEST_CASE("t00044", "[test-case][class]")
save_json(config.output_directory(), diagram->name + ".json", j); save_json(config.output_directory(), diagram->name + ".json", j);
} }
{ {
auto mmd = generate_class_mermaid(diagram, *model); auto src = generate_class_mermaid(diagram, *model);
save_mermaid(config.output_directory(), diagram->name + ".mmd", mmd); mermaid::AliasMatcher _A(src);
REQUIRE_THAT(src, !Contains("type-parameter-"));
REQUIRE_THAT(src, IsClass(_A("sink<T>")));
REQUIRE_THAT(src, IsClass(_A("signal_handler<T,A>")));
REQUIRE_THAT(src, IsClass(_A("signal_handler<Ret(Args...),A>")));
REQUIRE_THAT(src, IsClass(_A("signal_handler<void(int),bool>")));
REQUIRE_THAT(src, IsClass(_A("sink<signal_handler<Ret(Args...),A>>")));
REQUIRE_THAT(src,
IsInstantiation(
_A("sink<T>"), _A("sink<signal_handler<Ret(Args...),A>>")));
REQUIRE_THAT(src,
IsInstantiation(_A("sink<signal_handler<Ret(Args...),A>>"),
_A("sink<signal_handler<void(int),bool>>")));
REQUIRE_THAT(src, IsClass(_A("signal_handler<T,A>")));
REQUIRE_THAT(src,
IsInstantiation(_A("signal_handler<T,A>"),
_A("signal_handler<Ret(Args...),A>")));
REQUIRE_THAT(src,
IsInstantiation(_A("signal_handler<Ret(Args...),A>"),
_A("signal_handler<void(int),bool>")));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
} }
} }

83
tests/t00045/test_case.h
View File

@@ -29,44 +29,43 @@ TEST_CASE("t00045", "[test-case][class]")
REQUIRE(model->name() == "t00045_class"); REQUIRE(model->name() == "t00045_class");
{ {
auto puml = generate_class_puml(diagram, *model); auto src = generate_class_puml(diagram, *model);
AliasMatcher _A(puml); AliasMatcher _A(src);
REQUIRE_THAT(puml, StartsWith("@startuml")); REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(puml, EndsWith("@enduml\n")); REQUIRE_THAT(src, EndsWith("@enduml\n"));
REQUIRE_THAT(puml, IsClass(_A("A"))); REQUIRE_THAT(src, IsClass(_A("A")));
REQUIRE_THAT(puml, IsClass(_A("ns1::A"))); REQUIRE_THAT(src, IsClass(_A("ns1::A")));
REQUIRE_THAT(puml, IsClass(_A("ns1::ns2::A"))); REQUIRE_THAT(src, IsClass(_A("ns1::ns2::A")));
REQUIRE_THAT(puml, IsClass(_A("ns1::ns2::B"))); REQUIRE_THAT(src, IsClass(_A("ns1::ns2::B")));
REQUIRE_THAT(puml, IsClass(_A("ns1::ns2::C"))); REQUIRE_THAT(src, IsClass(_A("ns1::ns2::C")));
REQUIRE_THAT(puml, IsClass(_A("ns1::ns2::D"))); REQUIRE_THAT(src, IsClass(_A("ns1::ns2::D")));
REQUIRE_THAT(puml, IsClass(_A("ns1::ns2::E"))); REQUIRE_THAT(src, IsClass(_A("ns1::ns2::E")));
REQUIRE_THAT(puml, IsClass(_A("ns1::ns2::R"))); REQUIRE_THAT(src, IsClass(_A("ns1::ns2::R")));
REQUIRE_THAT(puml, IsBaseClass(_A("ns1::ns2::A"), _A("ns1::ns2::B"))); REQUIRE_THAT(src, IsBaseClass(_A("ns1::ns2::A"), _A("ns1::ns2::B")));
REQUIRE_THAT(puml, IsBaseClass(_A("ns1::A"), _A("ns1::ns2::C"))); REQUIRE_THAT(src, IsBaseClass(_A("ns1::A"), _A("ns1::ns2::C")));
REQUIRE_THAT(puml, IsBaseClass(_A("ns1::ns2::A"), _A("ns1::ns2::D"))); REQUIRE_THAT(src, IsBaseClass(_A("ns1::ns2::A"), _A("ns1::ns2::D")));
REQUIRE_THAT(puml, IsBaseClass(_A("A"), _A("ns1::ns2::E"))); REQUIRE_THAT(src, IsBaseClass(_A("A"), _A("ns1::ns2::E")));
REQUIRE_THAT( REQUIRE_THAT(
puml, IsAssociation(_A("ns1::ns2::R"), _A("ns1::ns2::A"), "+a")); src, IsAssociation(_A("ns1::ns2::R"), _A("ns1::ns2::A"), "+a"));
REQUIRE_THAT( REQUIRE_THAT(
puml, IsAssociation(_A("ns1::ns2::R"), _A("ns1::A"), "+ns1_a")); src, IsAssociation(_A("ns1::ns2::R"), _A("ns1::A"), "+ns1_a"));
REQUIRE_THAT(puml, REQUIRE_THAT(src,
IsAssociation(_A("ns1::ns2::R"), _A("ns1::ns2::A"), "+ns1_ns2_a")); IsAssociation(_A("ns1::ns2::R"), _A("ns1::ns2::A"), "+ns1_ns2_a"));
REQUIRE_THAT( REQUIRE_THAT(src, IsAssociation(_A("ns1::ns2::R"), _A("A"), "+root_a"));
puml, IsAssociation(_A("ns1::ns2::R"), _A("A"), "+root_a"));
REQUIRE_THAT(puml, IsDependency(_A("ns1::ns2::R"), _A("AA"))); REQUIRE_THAT(src, IsDependency(_A("ns1::ns2::R"), _A("AA")));
REQUIRE_THAT(puml, IsFriend<Public>(_A("ns1::ns2::R"), _A("AAA"))); REQUIRE_THAT(src, IsFriend<Public>(_A("ns1::ns2::R"), _A("AAA")));
REQUIRE_THAT( REQUIRE_THAT(
puml, !IsFriend<Public>(_A("ns1::ns2::R"), _A("ns1::ns2::AAA"))); src, !IsFriend<Public>(_A("ns1::ns2::R"), _A("ns1::ns2::AAA")));
// TODO: // TODO:
// REQUIRE_THAT(puml, IsFriend<Public>(_A("ns1::ns2::R"), // REQUIRE_THAT(puml, IsFriend<Public>(_A("ns1::ns2::R"),
// _A("AAAA<T>"))); // _A("AAAA<T>")));
save_puml(config.output_directory(), diagram->name + ".puml", puml); save_puml(config.output_directory(), diagram->name + ".puml", src);
} }
{ {
auto j = generate_class_json(diagram, *model); auto j = generate_class_json(diagram, *model);
@@ -87,8 +86,38 @@ TEST_CASE("t00045", "[test-case][class]")
save_json(config.output_directory(), diagram->name + ".json", j); save_json(config.output_directory(), diagram->name + ".json", j);
} }
{ {
auto mmd = generate_class_mermaid(diagram, *model); auto src = generate_class_mermaid(diagram, *model);
save_mermaid(config.output_directory(), diagram->name + ".mmd", mmd); mermaid::AliasMatcher _A(src);
REQUIRE_THAT(src, IsClass(_A("A")));
REQUIRE_THAT(src, IsClass(_A("ns1::A")));
REQUIRE_THAT(src, IsClass(_A("ns1::ns2::A")));
REQUIRE_THAT(src, IsClass(_A("ns1::ns2::B")));
REQUIRE_THAT(src, IsClass(_A("ns1::ns2::C")));
REQUIRE_THAT(src, IsClass(_A("ns1::ns2::D")));
REQUIRE_THAT(src, IsClass(_A("ns1::ns2::E")));
REQUIRE_THAT(src, IsClass(_A("ns1::ns2::R")));
REQUIRE_THAT(src, IsBaseClass(_A("ns1::ns2::A"), _A("ns1::ns2::B")));
REQUIRE_THAT(src, IsBaseClass(_A("ns1::A"), _A("ns1::ns2::C")));
REQUIRE_THAT(src, IsBaseClass(_A("ns1::ns2::A"), _A("ns1::ns2::D")));
REQUIRE_THAT(src, IsBaseClass(_A("A"), _A("ns1::ns2::E")));
REQUIRE_THAT(
src, IsAssociation(_A("ns1::ns2::R"), _A("ns1::ns2::A"), "+a"));
REQUIRE_THAT(
src, IsAssociation(_A("ns1::ns2::R"), _A("ns1::A"), "+ns1_a"));
REQUIRE_THAT(src,
IsAssociation(_A("ns1::ns2::R"), _A("ns1::ns2::A"), "+ns1_ns2_a"));
REQUIRE_THAT(src, IsAssociation(_A("ns1::ns2::R"), _A("A"), "+root_a"));
REQUIRE_THAT(src, IsDependency(_A("ns1::ns2::R"), _A("AA")));
REQUIRE_THAT(src, IsFriend<Public>(_A("ns1::ns2::R"), _A("AAA")));
REQUIRE_THAT(
src, !IsFriend<Public>(_A("ns1::ns2::R"), _A("ns1::ns2::AAA")));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
} }
} }

41
tests/t00046/test_case.h
View File

@@ -29,21 +29,21 @@ TEST_CASE("t00046", "[test-case][class]")
REQUIRE(model->name() == "t00046_class"); REQUIRE(model->name() == "t00046_class");
{ {
auto puml = generate_class_puml(diagram, *model); auto src = generate_class_puml(diagram, *model);
AliasMatcher _A(puml); AliasMatcher _A(src);
REQUIRE_THAT(puml, StartsWith("@startuml")); REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(puml, EndsWith("@enduml\n")); REQUIRE_THAT(src, EndsWith("@enduml\n"));
REQUIRE_THAT(puml, IsClass(_A("A"))); REQUIRE_THAT(src, IsClass(_A("A")));
REQUIRE_THAT(puml, IsClass(_A("B"))); REQUIRE_THAT(src, IsClass(_A("B")));
REQUIRE_THAT(puml, IsClass(_A("C"))); REQUIRE_THAT(src, IsClass(_A("C")));
REQUIRE_THAT(puml, IsClass(_A("D"))); REQUIRE_THAT(src, IsClass(_A("D")));
REQUIRE_THAT(puml, IsClass(_A("E"))); REQUIRE_THAT(src, IsClass(_A("E")));
REQUIRE_THAT(puml, IsClass(_A("R"))); REQUIRE_THAT(src, IsClass(_A("R")));
REQUIRE_THAT(puml, IsField<Public>("i", "std::vector<std::uint8_t>")); REQUIRE_THAT(src, IsField<Public>("i", "std::vector<std::uint8_t>"));
save_puml(config.output_directory(), diagram->name + ".puml", puml); save_puml(config.output_directory(), diagram->name + ".puml", src);
} }
{ {
auto j = generate_class_json(diagram, *model); auto j = generate_class_json(diagram, *model);
@@ -58,8 +58,21 @@ TEST_CASE("t00046", "[test-case][class]")
save_json(config.output_directory(), diagram->name + ".json", j); save_json(config.output_directory(), diagram->name + ".json", j);
} }
{ {
auto mmd = generate_class_mermaid(diagram, *model); auto src = generate_class_mermaid(diagram, *model);
save_mermaid(config.output_directory(), diagram->name + ".mmd", mmd); mermaid::AliasMatcher _A(src);
using mermaid::IsField;
REQUIRE_THAT(src, IsClass(_A("A")));
REQUIRE_THAT(src, IsClass(_A("AA")));
REQUIRE_THAT(src, IsClass(_A("ns1::ns2::B")));
REQUIRE_THAT(src, IsClass(_A("ns1::ns2::C")));
REQUIRE_THAT(src, IsClass(_A("ns1::ns2::D")));
REQUIRE_THAT(src, IsClass(_A("ns1::ns2::E")));
REQUIRE_THAT(src, IsClass(_A("ns1::ns2::R")));
REQUIRE_THAT(src, IsField<Public>("i", "std::vector<std::uint8_t>"));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
} }
} }

32
tests/t00047/test_case.h
View File

@@ -29,21 +29,21 @@ TEST_CASE("t00047", "[test-case][class]")
REQUIRE(model->name() == "t00047_class"); REQUIRE(model->name() == "t00047_class");
{ {
auto puml = generate_class_puml(diagram, *model); auto src = generate_class_puml(diagram, *model);
AliasMatcher _A(puml); AliasMatcher _A(src);
REQUIRE_THAT(puml, StartsWith("@startuml")); REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(puml, EndsWith("@enduml\n")); REQUIRE_THAT(src, EndsWith("@enduml\n"));
// Check if class templates exist // Check if class templates exist
REQUIRE_THAT(puml, IsClassTemplate("conditional_t", "Ts...")); REQUIRE_THAT(src, IsClassTemplate("conditional_t", "Ts..."));
REQUIRE_THAT(puml, IsClassTemplate("conditional_t", "Else")); REQUIRE_THAT(src, IsClassTemplate("conditional_t", "Else"));
REQUIRE_THAT(puml, REQUIRE_THAT(src,
IsClassTemplate("conditional_t", "std::true_type,Result,Tail...")); IsClassTemplate("conditional_t", "std::true_type,Result,Tail..."));
REQUIRE_THAT(puml, REQUIRE_THAT(src,
IsClassTemplate("conditional_t", "std::false_type,Result,Tail...")); IsClassTemplate("conditional_t", "std::false_type,Result,Tail..."));
save_puml(config.output_directory(), diagram->name + ".puml", puml); save_puml(config.output_directory(), diagram->name + ".puml", src);
} }
{ {
auto j = generate_class_json(diagram, *model); auto j = generate_class_json(diagram, *model);
@@ -58,8 +58,18 @@ TEST_CASE("t00047", "[test-case][class]")
save_json(config.output_directory(), diagram->name + ".json", j); save_json(config.output_directory(), diagram->name + ".json", j);
} }
{ {
auto mmd = generate_class_mermaid(diagram, *model); auto src = generate_class_mermaid(diagram, *model);
save_mermaid(config.output_directory(), diagram->name + ".mmd", mmd); mermaid::AliasMatcher _A(src);
// Check if class templates exist
REQUIRE_THAT(src, IsClass(_A("conditional_t<Ts...>")));
REQUIRE_THAT(src, IsClass(_A("conditional_t<Else>")));
REQUIRE_THAT(
src, IsClass(_A("conditional_t<std::true_type,Result,Tail...>")));
REQUIRE_THAT(
src, IsClass(_A("conditional_t<std::false_type,Result,Tail...>")));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
} }
} }

47
tests/t00048/test_case.h
View File

@@ -29,27 +29,27 @@ TEST_CASE("t00048", "[test-case][class]")
REQUIRE(model->name() == "t00048_class"); REQUIRE(model->name() == "t00048_class");
{ {
auto puml = generate_class_puml(diagram, *model); auto src = generate_class_puml(diagram, *model);
AliasMatcher _A(puml); AliasMatcher _A(src);
REQUIRE_THAT(puml, StartsWith("@startuml")); REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(puml, EndsWith("@enduml\n")); REQUIRE_THAT(src, EndsWith("@enduml\n"));
// Check if all classes exist // Check if all classes exist
REQUIRE_THAT(puml, IsAbstractClass(_A("Base"))); REQUIRE_THAT(src, IsAbstractClass(_A("Base")));
REQUIRE_THAT(puml, IsClass(_A("A"))); REQUIRE_THAT(src, IsClass(_A("A")));
REQUIRE_THAT(puml, IsClass(_A("B"))); REQUIRE_THAT(src, IsClass(_A("B")));
// Check if class templates exist // Check if class templates exist
REQUIRE_THAT(puml, IsAbstractClassTemplate("BaseTemplate", "T")); REQUIRE_THAT(src, IsAbstractClassTemplate("BaseTemplate", "T"));
REQUIRE_THAT(puml, IsClassTemplate("ATemplate", "T")); REQUIRE_THAT(src, IsClassTemplate("ATemplate", "T"));
REQUIRE_THAT(puml, IsClassTemplate("BTemplate", "T")); REQUIRE_THAT(src, IsClassTemplate("BTemplate", "T"));
// Check if all inheritance relationships exist // Check if all inheritance relationships exist
REQUIRE_THAT(puml, IsBaseClass(_A("Base"), _A("A"))); REQUIRE_THAT(src, IsBaseClass(_A("Base"), _A("A")));
REQUIRE_THAT(puml, IsBaseClass(_A("Base"), _A("B"))); REQUIRE_THAT(src, IsBaseClass(_A("Base"), _A("B")));
save_puml(config.output_directory(), diagram->name + ".puml", puml); save_puml(config.output_directory(), diagram->name + ".puml", src);
} }
{ {
auto j = generate_class_json(diagram, *model); auto j = generate_class_json(diagram, *model);
@@ -66,8 +66,25 @@ TEST_CASE("t00048", "[test-case][class]")
save_json(config.output_directory(), diagram->name + ".json", j); save_json(config.output_directory(), diagram->name + ".json", j);
} }
{ {
auto mmd = generate_class_mermaid(diagram, *model); auto src = generate_class_mermaid(diagram, *model);
save_mermaid(config.output_directory(), diagram->name + ".mmd", mmd); mermaid::AliasMatcher _A(src);
using mermaid::IsAbstractClass;
// Check if all classes exist
REQUIRE_THAT(src, IsAbstractClass(_A("Base")));
REQUIRE_THAT(src, IsClass(_A("A")));
REQUIRE_THAT(src, IsClass(_A("B")));
// Check if class templates exist
REQUIRE_THAT(src, IsAbstractClass(_A("BaseTemplate<T>")));
REQUIRE_THAT(src, IsClass(_A("ATemplate<T>")));
REQUIRE_THAT(src, IsClass(_A("BTemplate<T>")));
// Check if all inheritance relationships exist
REQUIRE_THAT(src, IsBaseClass(_A("Base"), _A("A")));
REQUIRE_THAT(src, IsBaseClass(_A("Base"), _A("B")));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
} }
} }

60
tests/t00049/test_case.h
View File

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

56
tests/t00050/test_case.h
View File

@@ -29,32 +29,32 @@ TEST_CASE("t00050", "[test-case][class]")
REQUIRE(model->name() == "t00050_class"); REQUIRE(model->name() == "t00050_class");
{ {
auto puml = generate_class_puml(diagram, *model); auto src = generate_class_puml(diagram, *model);
AliasMatcher _A(puml); AliasMatcher _A(src);
REQUIRE_THAT(puml, StartsWith("@startuml")); REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(puml, EndsWith("@enduml\n")); REQUIRE_THAT(src, EndsWith("@enduml\n"));
// Check if all classes exist // Check if all classes exist
REQUIRE_THAT(puml, IsClass(_A("A"))); REQUIRE_THAT(src, IsClass(_A("A")));
REQUIRE_THAT(puml, IsClass(_A("B"))); REQUIRE_THAT(src, IsClass(_A("B")));
REQUIRE_THAT(puml, IsClass(_A("C"))); REQUIRE_THAT(src, IsClass(_A("C")));
REQUIRE_THAT(puml, IsClass(_A("utils::D"))); REQUIRE_THAT(src, IsClass(_A("utils::D")));
REQUIRE_THAT(puml, IsEnum(_A("E"))); REQUIRE_THAT(src, IsEnum(_A("E")));
REQUIRE_THAT(puml, HasNote(_A("A"), "left")); REQUIRE_THAT(src, HasNote(_A("A"), "left"));
REQUIRE_THAT(puml, HasNote(_A("A"), "right")); REQUIRE_THAT(src, HasNote(_A("A"), "right"));
REQUIRE_THAT(puml, HasNote(_A("B"), "top")); REQUIRE_THAT(src, HasNote(_A("B"), "top"));
REQUIRE_THAT(puml, HasNote(_A("C"), "top")); REQUIRE_THAT(src, HasNote(_A("C"), "top"));
REQUIRE_THAT(puml, HasNote(_A("utils::D"), "top")); REQUIRE_THAT(src, HasNote(_A("utils::D"), "top"));
REQUIRE_THAT(puml, !HasNote(_A("E"), "bottom")); REQUIRE_THAT(src, !HasNote(_A("E"), "bottom"));
REQUIRE_THAT(puml, !HasNote(_A("NoComment"), "top")); REQUIRE_THAT(src, !HasNote(_A("NoComment"), "top"));
REQUIRE_THAT(puml, HasNote(_A("F<T,V,int N>"), "top")); REQUIRE_THAT(src, HasNote(_A("F<T,V,int N>"), "top"));
REQUIRE_THAT(puml, HasNote(_A("G"), "top")); REQUIRE_THAT(src, HasNote(_A("G"), "top"));
REQUIRE_THAT(puml, HasNote(_A("G"), "bottom")); REQUIRE_THAT(src, HasNote(_A("G"), "bottom"));
REQUIRE_THAT(puml, HasNote(_A("G"), "right")); REQUIRE_THAT(src, HasNote(_A("G"), "right"));
save_puml(config.output_directory(), diagram->name + ".puml", puml); save_puml(config.output_directory(), diagram->name + ".puml", src);
} }
{ {
auto j = generate_class_json(diagram, *model); auto j = generate_class_json(diagram, *model);
@@ -70,8 +70,18 @@ TEST_CASE("t00050", "[test-case][class]")
save_json(config.output_directory(), diagram->name + ".json", j); save_json(config.output_directory(), diagram->name + ".json", j);
} }
{ {
auto mmd = generate_class_mermaid(diagram, *model); auto src = generate_class_mermaid(diagram, *model);
save_mermaid(config.output_directory(), diagram->name + ".mmd", mmd); 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("C")));
REQUIRE_THAT(src, IsClass(_A("utils::D")));
REQUIRE_THAT(src, IsEnum(_A("E")));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
} }
} }

82
tests/t00051/test_case.h
View File

@@ -29,51 +29,51 @@ TEST_CASE("t00051", "[test-case][class]")
REQUIRE(model->name() == "t00051_class"); REQUIRE(model->name() == "t00051_class");
{ {
auto puml = generate_class_puml(diagram, *model); auto src = generate_class_puml(diagram, *model);
AliasMatcher _A(puml); AliasMatcher _A(src);
REQUIRE_THAT(puml, StartsWith("@startuml")); REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(puml, EndsWith("@enduml\n")); REQUIRE_THAT(src, EndsWith("@enduml\n"));
// Check if all classes exist // Check if all classes exist
REQUIRE_THAT(puml, IsClass(_A("A"))); REQUIRE_THAT(src, IsClass(_A("A")));
REQUIRE_THAT(puml, IsInnerClass(_A("A"), _A("A::custom_thread1"))); REQUIRE_THAT(src, IsInnerClass(_A("A"), _A("A::custom_thread1")));
REQUIRE_THAT(puml, IsInnerClass(_A("A"), _A("A::custom_thread2"))); REQUIRE_THAT(src, IsInnerClass(_A("A"), _A("A::custom_thread2")));
REQUIRE_THAT(puml, REQUIRE_THAT(src,
(IsMethod<Public>("custom_thread1<Function,Args...>", "void", (IsMethod<Public>("custom_thread1<Function,Args...>", "void",
"Function && f, Args &&... args"))); "Function && f, Args &&... args")));
REQUIRE_THAT(puml, REQUIRE_THAT(src,
(IsMethod<Public>("thread", "void", (IsMethod<Public>("thread", "void",
"(lambda at ../../tests/t00051/t00051.cc:59:27) &&"))); "(lambda at ../../tests/t00051/t00051.cc:59:27) &&")));
REQUIRE_THAT(puml, REQUIRE_THAT(src,
(IsMethod<Private>("start_thread3", (IsMethod<Private>("start_thread3",
"B<(lambda at ../../tests/t00051/t00051.cc:43:18),(lambda at " "B<(lambda at ../../tests/t00051/t00051.cc:43:18),(lambda at "
"../../tests/t00051/t00051.cc:43:27)>"))); "../../tests/t00051/t00051.cc:43:27)>")));
REQUIRE_THAT(puml, REQUIRE_THAT(src,
(IsMethod<Private>("get_function", (IsMethod<Private>("get_function",
"(lambda at ../../tests/t00051/t00051.cc:48:16)"))); "(lambda at ../../tests/t00051/t00051.cc:48:16)")));
REQUIRE_THAT(puml, IsClassTemplate("B", "F,FF=F")); REQUIRE_THAT(src, IsClassTemplate("B", "F,FF=F"));
REQUIRE_THAT(puml, (IsMethod<Public>("f", "void"))); REQUIRE_THAT(src, (IsMethod<Public>("f", "void")));
REQUIRE_THAT(puml, (IsMethod<Public>("ff", "void"))); REQUIRE_THAT(src, (IsMethod<Public>("ff", "void")));
REQUIRE_THAT(puml, REQUIRE_THAT(src,
IsClassTemplate("B", IsClassTemplate("B",
"(lambda at ../../tests/t00051/t00051.cc:43:18),(lambda at " "(lambda at ../../tests/t00051/t00051.cc:43:18),(lambda at "
"../../tests/t00051/t00051.cc:43:27)")); "../../tests/t00051/t00051.cc:43:27)"));
REQUIRE_THAT(puml, REQUIRE_THAT(src,
IsInstantiation(_A("B<F,FF=F>"), IsInstantiation(_A("B<F,FF=F>"),
_A("B<(lambda at ../../tests/t00051/t00051.cc:43:18),(lambda " _A("B<(lambda at ../../tests/t00051/t00051.cc:43:18),(lambda "
"at ../../tests/t00051/t00051.cc:43:27)>"))); "at ../../tests/t00051/t00051.cc:43:27)>")));
REQUIRE_THAT(puml, REQUIRE_THAT(src,
IsDependency(_A("A"), IsDependency(_A("A"),
_A("B<(lambda at ../../tests/t00051/t00051.cc:43:18),(lambda " _A("B<(lambda at ../../tests/t00051/t00051.cc:43:18),(lambda "
"at ../../tests/t00051/t00051.cc:43:27)>"))); "at ../../tests/t00051/t00051.cc:43:27)>")));
save_puml(config.output_directory(), diagram->name + ".puml", puml); save_puml(config.output_directory(), diagram->name + ".puml", src);
} }
{ {
auto j = generate_class_json(diagram, *model); auto j = generate_class_json(diagram, *model);
@@ -87,8 +87,50 @@ TEST_CASE("t00051", "[test-case][class]")
save_json(config.output_directory(), diagram->name + ".json", j); save_json(config.output_directory(), diagram->name + ".json", j);
} }
{ {
auto mmd = generate_class_mermaid(diagram, *model); auto src = generate_class_mermaid(diagram, *model);
save_mermaid(config.output_directory(), diagram->name + ".mmd", mmd); 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 ../../tests/t00051/t00051.cc:59:27) &&")));
REQUIRE_THAT(src,
(IsMethod<Private>("start_thread3",
"B<(lambda at ../../tests/t00051/t00051.cc:43:18),(lambda at "
"../../tests/t00051/t00051.cc:43:27)>")));
REQUIRE_THAT(src,
(IsMethod<Private>("get_function",
"(lambda at ../../tests/t00051/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 ../../tests/t00051/t00051.cc:43:18),(lambda at "
"../../tests/t00051/t00051.cc:43:27)>")));
REQUIRE_THAT(src,
IsInstantiation(_A("B<F,FF=F>"),
_A("B<(lambda at ../../tests/t00051/t00051.cc:43:18),(lambda "
"at ../../tests/t00051/t00051.cc:43:27)>")));
REQUIRE_THAT(src,
IsDependency(_A("A"),
_A("B<(lambda at ../../tests/t00051/t00051.cc:43:18),(lambda "
"at ../../tests/t00051/t00051.cc:43:27)>")));
save_mermaid(config.output_directory(), diagram->name + ".mmd", src);
} }
} }

42
tests/t00052/test_case.h
View File

@@ -29,26 +29,25 @@ TEST_CASE("t00052", "[test-case][class]")
REQUIRE(model->name() == "t00052_class"); REQUIRE(model->name() == "t00052_class");
{ {
auto puml = generate_class_puml(diagram, *model); auto src = generate_class_puml(diagram, *model);
AliasMatcher _A(puml); AliasMatcher _A(src);
REQUIRE_THAT(puml, StartsWith("@startuml")); REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(puml, EndsWith("@enduml\n")); REQUIRE_THAT(src, EndsWith("@enduml\n"));
// Check if all classes exist // Check if all classes exist
REQUIRE_THAT(puml, IsClass(_A("A"))); REQUIRE_THAT(src, IsClass(_A("A")));
// Check if class templates exist // Check if class templates exist
REQUIRE_THAT(puml, IsClassTemplate("B", "T")); REQUIRE_THAT(src, IsClassTemplate("B", "T"));
// Check if all methods exist // Check if all methods exist
REQUIRE_THAT(puml, (IsMethod<Public>("a<T>", "T", "T p"))); REQUIRE_THAT(src, (IsMethod<Public>("a<T>", "T", "T p")));
REQUIRE_THAT( REQUIRE_THAT(src, (IsMethod<Public>("aa<F,Q>", "void", "F && f, Q q")));
puml, (IsMethod<Public>("aa<F,Q>", "void", "F && f, Q q"))); REQUIRE_THAT(src, (IsMethod<Public>("b", "T", "T t")));
REQUIRE_THAT(puml, (IsMethod<Public>("b", "T", "T t"))); REQUIRE_THAT(src, (IsMethod<Public>("bb<F>", "T", "F && f, T t")));
REQUIRE_THAT(puml, (IsMethod<Public>("bb<F>", "T", "F && f, T t")));
save_puml(config.output_directory(), diagram->name + ".puml", puml); save_puml(config.output_directory(), diagram->name + ".puml", src);
} }
{ {
auto j = generate_class_json(diagram, *model); auto j = generate_class_json(diagram, *model);
@@ -61,8 +60,23 @@ TEST_CASE("t00052", "[test-case][class]")
save_json(config.output_directory(), diagram->name + ".json", j); save_json(config.output_directory(), diagram->name + ".json", j);
} }
{ {
auto mmd = generate_class_mermaid(diagram, *model); auto src = generate_class_mermaid(diagram, *model);
save_mermaid(config.output_directory(), diagram->name + ".mmd", mmd); 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);
} }
} }

61
tests/t00053/test_case.h
View File

@@ -29,30 +29,30 @@ TEST_CASE("t00053", "[test-case][class]")
REQUIRE(model->name() == "t00053_class"); REQUIRE(model->name() == "t00053_class");
{ {
auto puml = generate_class_puml(diagram, *model); auto src = generate_class_puml(diagram, *model);
AliasMatcher _A(puml); AliasMatcher _A(src);
REQUIRE_THAT(puml, StartsWith("@startuml")); REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(puml, EndsWith("@enduml\n")); REQUIRE_THAT(src, EndsWith("@enduml\n"));
// Check if all classes exist // Check if all classes exist
REQUIRE_THAT(puml, IsClass(_A("a"))); REQUIRE_THAT(src, IsClass(_A("a")));
REQUIRE_THAT(puml, IsClass(_A("b"))); REQUIRE_THAT(src, IsClass(_A("b")));
REQUIRE_THAT(puml, IsClass(_A("c"))); REQUIRE_THAT(src, IsClass(_A("c")));
REQUIRE_THAT(puml, IsClass(_A("d"))); REQUIRE_THAT(src, IsClass(_A("d")));
REQUIRE_THAT(puml, IsClass(_A("e"))); REQUIRE_THAT(src, IsClass(_A("e")));
REQUIRE_THAT(puml, IsClass(_A("f"))); REQUIRE_THAT(src, IsClass(_A("f")));
REQUIRE_THAT(puml, IsClass(_A("g"))); REQUIRE_THAT(src, IsClass(_A("g")));
REQUIRE_THAT(puml, IsClass(_A("A"))); REQUIRE_THAT(src, IsClass(_A("A")));
REQUIRE_THAT(puml, IsClass(_A("B"))); REQUIRE_THAT(src, IsClass(_A("B")));
REQUIRE_THAT(puml, IsClass(_A("C"))); REQUIRE_THAT(src, IsClass(_A("C")));
REQUIRE_THAT(puml, IsClass(_A("D"))); REQUIRE_THAT(src, IsClass(_A("D")));
REQUIRE_THAT(puml, IsClass(_A("E"))); REQUIRE_THAT(src, IsClass(_A("E")));
REQUIRE_THAT(puml, IsClass(_A("F"))); REQUIRE_THAT(src, IsClass(_A("F")));
REQUIRE_THAT(puml, IsClass(_A("G"))); REQUIRE_THAT(src, IsClass(_A("G")));
save_puml(config.output_directory(), diagram->name + ".puml", puml); save_puml(config.output_directory(), diagram->name + ".puml", src);
} }
{ {
@@ -79,8 +79,27 @@ TEST_CASE("t00053", "[test-case][class]")
save_json(config.output_directory(), diagram->name + ".json", j); save_json(config.output_directory(), diagram->name + ".json", j);
} }
{ {
auto mmd = generate_class_mermaid(diagram, *model); auto src = generate_class_mermaid(diagram, *model);
save_mermaid(config.output_directory(), diagram->name + ".mmd", mmd); 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);
} }
} }

72
tests/t00054/test_case.h
View File

@@ -29,34 +29,34 @@ TEST_CASE("t00054", "[test-case][class]")
REQUIRE(model->name() == "t00054_class"); REQUIRE(model->name() == "t00054_class");
{ {
auto puml = generate_class_puml(diagram, *model); auto src = generate_class_puml(diagram, *model);
AliasMatcher _A(puml); AliasMatcher _A(src);
REQUIRE_THAT(puml, StartsWith("@startuml")); REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(puml, EndsWith("@enduml\n")); REQUIRE_THAT(src, EndsWith("@enduml\n"));
// Check if all classes exist // Check if all classes exist
REQUIRE_THAT(puml, IsClass(_A("a"))); REQUIRE_THAT(src, IsClass(_A("a")));
REQUIRE_THAT(puml, IsClass(_A("b"))); REQUIRE_THAT(src, IsClass(_A("b")));
REQUIRE_THAT(puml, IsClass(_A("c"))); REQUIRE_THAT(src, IsClass(_A("c")));
REQUIRE_THAT(puml, IsClass(_A("d"))); REQUIRE_THAT(src, IsClass(_A("d")));
REQUIRE_THAT(puml, IsClass(_A("e"))); REQUIRE_THAT(src, IsClass(_A("e")));
REQUIRE_THAT(puml, IsClass(_A("f"))); REQUIRE_THAT(src, IsClass(_A("f")));
REQUIRE_THAT(puml, IsClass(_A("g"))); REQUIRE_THAT(src, IsClass(_A("g")));
REQUIRE_THAT(puml, IsClass(_A("A"))); REQUIRE_THAT(src, IsClass(_A("A")));
REQUIRE_THAT(puml, IsClass(_A("B"))); REQUIRE_THAT(src, IsClass(_A("B")));
REQUIRE_THAT(puml, IsClass(_A("C"))); REQUIRE_THAT(src, IsClass(_A("C")));
REQUIRE_THAT(puml, IsClass(_A("D"))); REQUIRE_THAT(src, IsClass(_A("D")));
REQUIRE_THAT(puml, IsClass(_A("E"))); REQUIRE_THAT(src, IsClass(_A("E")));
REQUIRE_THAT(puml, IsClass(_A("F"))); REQUIRE_THAT(src, IsClass(_A("F")));
REQUIRE_THAT(puml, IsClass(_A("G"))); REQUIRE_THAT(src, IsClass(_A("G")));
REQUIRE_THAT(puml, IsEnum(_A("i"))); REQUIRE_THAT(src, IsEnum(_A("i")));
REQUIRE_THAT(puml, IsEnum(_A("h"))); REQUIRE_THAT(src, IsEnum(_A("h")));
REQUIRE_THAT(puml, IsEnum(_A("j"))); REQUIRE_THAT(src, IsEnum(_A("j")));
save_puml(config.output_directory(), diagram->name + ".puml", puml); save_puml(config.output_directory(), diagram->name + ".puml", src);
} }
{ {
@@ -87,8 +87,32 @@ TEST_CASE("t00054", "[test-case][class]")
save_json(config.output_directory(), diagram->name + ".json", j); save_json(config.output_directory(), diagram->name + ".json", j);
} }
{ {
auto mmd = generate_class_mermaid(diagram, *model); auto src = generate_class_mermaid(diagram, *model);
save_mermaid(config.output_directory(), diagram->name + ".mmd", mmd); 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);
} }
} }

64
tests/t00055/test_case.h
View File

@@ -29,35 +29,35 @@ TEST_CASE("t00055", "[test-case][class]")
REQUIRE(model->name() == "t00055_class"); REQUIRE(model->name() == "t00055_class");
{ {
auto puml = generate_class_puml(diagram, *model); auto src = generate_class_puml(diagram, *model);
AliasMatcher _A(puml); AliasMatcher _A(src);
REQUIRE_THAT(puml, StartsWith("@startuml")); REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(puml, EndsWith("@enduml\n")); REQUIRE_THAT(src, EndsWith("@enduml\n"));
// Check if all classes exist // Check if all classes exist
REQUIRE_THAT(puml, IsClass(_A("A"))); REQUIRE_THAT(src, IsClass(_A("A")));
REQUIRE_THAT(puml, IsClass(_A("B"))); REQUIRE_THAT(src, IsClass(_A("B")));
REQUIRE_THAT(puml, IsClass(_A("C"))); REQUIRE_THAT(src, IsClass(_A("C")));
REQUIRE_THAT(puml, IsClass(_A("D"))); REQUIRE_THAT(src, IsClass(_A("D")));
REQUIRE_THAT(puml, IsClass(_A("E"))); REQUIRE_THAT(src, IsClass(_A("E")));
REQUIRE_THAT(puml, IsClass(_A("F"))); REQUIRE_THAT(src, IsClass(_A("F")));
REQUIRE_THAT(puml, IsClass(_A("G"))); REQUIRE_THAT(src, IsClass(_A("G")));
REQUIRE_THAT(puml, IsClass(_A("H"))); REQUIRE_THAT(src, IsClass(_A("H")));
REQUIRE_THAT(puml, IsClass(_A("I"))); REQUIRE_THAT(src, IsClass(_A("I")));
REQUIRE_THAT(puml, IsClass(_A("J"))); REQUIRE_THAT(src, IsClass(_A("J")));
REQUIRE_THAT(puml, IsLayoutHint(_A("A"), "right", _A("C"))); REQUIRE_THAT(src, IsLayoutHint(_A("A"), "right", _A("C")));
REQUIRE_THAT(puml, IsLayoutHint(_A("C"), "right", _A("E"))); REQUIRE_THAT(src, IsLayoutHint(_A("C"), "right", _A("E")));
REQUIRE_THAT(puml, IsLayoutHint(_A("E"), "right", _A("G"))); REQUIRE_THAT(src, IsLayoutHint(_A("E"), "right", _A("G")));
REQUIRE_THAT(puml, IsLayoutHint(_A("G"), "right", _A("I"))); REQUIRE_THAT(src, IsLayoutHint(_A("G"), "right", _A("I")));
REQUIRE_THAT(puml, IsLayoutHint(_A("B"), "down", _A("D"))); REQUIRE_THAT(src, IsLayoutHint(_A("B"), "down", _A("D")));
REQUIRE_THAT(puml, IsLayoutHint(_A("D"), "down", _A("F"))); REQUIRE_THAT(src, IsLayoutHint(_A("D"), "down", _A("F")));
REQUIRE_THAT(puml, IsLayoutHint(_A("F"), "down", _A("H"))); REQUIRE_THAT(src, IsLayoutHint(_A("F"), "down", _A("H")));
REQUIRE_THAT(puml, IsLayoutHint(_A("H"), "down", _A("J"))); REQUIRE_THAT(src, IsLayoutHint(_A("H"), "down", _A("J")));
save_puml(config.output_directory(), diagram->name + ".puml", puml); save_puml(config.output_directory(), diagram->name + ".puml", src);
} }
{ {
@@ -79,8 +79,22 @@ TEST_CASE("t00055", "[test-case][class]")
save_json(config.output_directory(), diagram->name + ".json", j); save_json(config.output_directory(), diagram->name + ".json", j);
} }
{ {
auto mmd = generate_class_mermaid(diagram, *model); auto src = generate_class_mermaid(diagram, *model);
save_mermaid(config.output_directory(), diagram->name + ".mmd", mmd); 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);
} }
} }

159
tests/t00056/test_case.h
View File

@@ -29,94 +29,94 @@ TEST_CASE("t00056", "[test-case][class]")
REQUIRE(model->name() == "t00056_class"); REQUIRE(model->name() == "t00056_class");
{ {
auto puml = generate_class_puml(diagram, *model); auto src = generate_class_puml(diagram, *model);
AliasMatcher _A(puml); AliasMatcher _A(src);
REQUIRE_THAT(puml, StartsWith("@startuml")); REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(puml, EndsWith("@enduml\n")); REQUIRE_THAT(src, EndsWith("@enduml\n"));
// Check if all classes exist // Check if all classes exist
REQUIRE_THAT(puml, IsConcept(_A("greater_than_simple<T,L>"))); REQUIRE_THAT(src, IsConcept(_A("greater_than_simple<T,L>")));
REQUIRE_THAT(puml, IsConcept(_A("greater_than_with_requires<T,P>"))); REQUIRE_THAT(src, IsConcept(_A("greater_than_with_requires<T,P>")));
REQUIRE_THAT(puml, IsConcept(_A("max_four_bytes<T>"))); REQUIRE_THAT(src, IsConcept(_A("max_four_bytes<T>")));
REQUIRE_THAT(puml, IsConcept(_A("iterable<T>"))); REQUIRE_THAT(src, IsConcept(_A("iterable<T>")));
REQUIRE_THAT(puml, IsConcept(_A("has_value_type<T>"))); REQUIRE_THAT(src, IsConcept(_A("has_value_type<T>")));
REQUIRE_THAT(puml, IsConcept(_A("convertible_to_string<T>"))); REQUIRE_THAT(src, IsConcept(_A("convertible_to_string<T>")));
REQUIRE_THAT(puml, IsConcept(_A("iterable_with_value_type<T>"))); REQUIRE_THAT(src, IsConcept(_A("iterable_with_value_type<T>")));
REQUIRE_THAT(puml, IsConcept(_A("iterable_or_small_value_type<T>"))); REQUIRE_THAT(src, IsConcept(_A("iterable_or_small_value_type<T>")));
REQUIRE_THAT(puml, REQUIRE_THAT(src,
IsConceptRequirement(_A("greater_than_with_requires<T,P>"), IsConceptRequirement(_A("greater_than_with_requires<T,P>"),
"sizeof (l) > sizeof (r)")); "sizeof (l) > sizeof (r)"));
REQUIRE_THAT( REQUIRE_THAT(
puml, IsConceptRequirement(_A("iterable<T>"), "container.begin()")); src, IsConceptRequirement(_A("iterable<T>"), "container.begin()"));
REQUIRE_THAT( REQUIRE_THAT(
puml, IsConceptRequirement(_A("iterable<T>"), "container.end()")); src, IsConceptRequirement(_A("iterable<T>"), "container.end()"));
#ifdef _MSC_VER #ifdef _MSC_VER
REQUIRE_THAT(puml, REQUIRE_THAT(puml,
IsConceptRequirement( IsConceptRequirement(
_A("convertible_to_string<T>"), "std::string{s}")); _A("convertible_to_string<T>"), "std::string{s}"));
#else #else
REQUIRE_THAT(puml, REQUIRE_THAT(src,
IsConceptRequirement( IsConceptRequirement(
_A("convertible_to_string<T>"), "std::string{s}")); _A("convertible_to_string<T>"), "std::string{s}"));
#endif #endif
REQUIRE_THAT(puml, REQUIRE_THAT(src,
IsConceptRequirement(_A("convertible_to_string<T>"), IsConceptRequirement(_A("convertible_to_string<T>"),
"{std::to_string(s)} noexcept")); "{std::to_string(s)} noexcept"));
REQUIRE_THAT(puml, REQUIRE_THAT(src,
IsConceptRequirement(_A("convertible_to_string<T>"), IsConceptRequirement(_A("convertible_to_string<T>"),
"{std::to_string(s)} -> std::same_as<std::string>")); "{std::to_string(s)} -> std::same_as<std::string>"));
// Check if class templates exist // Check if class templates exist
REQUIRE_THAT(puml, IsClassTemplate("A", "max_four_bytes T")); REQUIRE_THAT(src, IsClassTemplate("A", "max_four_bytes T"));
REQUIRE_THAT(puml, IsClassTemplate("B", "T")); REQUIRE_THAT(src, IsClassTemplate("B", "T"));
REQUIRE_THAT(puml, IsClassTemplate("C", "convertible_to_string T")); REQUIRE_THAT(src, IsClassTemplate("C", "convertible_to_string T"));
REQUIRE_THAT( REQUIRE_THAT(
puml, IsClassTemplate("D", "iterable T1,T2,iterable T3,T4,T5")); src, IsClassTemplate("D", "iterable T1,T2,iterable T3,T4,T5"));
REQUIRE_THAT(puml, IsClassTemplate("E", "T1,T2,T3")); REQUIRE_THAT(src, IsClassTemplate("E", "T1,T2,T3"));
REQUIRE_THAT(puml, IsClassTemplate("F", "T1,T2,T3")); REQUIRE_THAT(src, IsClassTemplate("F", "T1,T2,T3"));
// Check if all relationships exist // Check if all relationships exist
REQUIRE_THAT(puml, REQUIRE_THAT(src,
IsConstraint( IsConstraint(
_A("A<max_four_bytes T>"), _A("max_four_bytes<T>"), "T")); _A("A<max_four_bytes T>"), _A("max_four_bytes<T>"), "T"));
REQUIRE_THAT(puml, REQUIRE_THAT(src,
IsConstraint(_A("D<iterable T1,T2,iterable T3,T4,T5>"), IsConstraint(_A("D<iterable T1,T2,iterable T3,T4,T5>"),
_A("max_four_bytes<T>"), "T2")); _A("max_four_bytes<T>"), "T2"));
REQUIRE_THAT(puml, REQUIRE_THAT(src,
IsConstraint(_A("D<iterable T1,T2,iterable T3,T4,T5>"), IsConstraint(_A("D<iterable T1,T2,iterable T3,T4,T5>"),
_A("max_four_bytes<T>"), "T5")); _A("max_four_bytes<T>"), "T5"));
REQUIRE_THAT(puml, REQUIRE_THAT(src,
IsConstraint(_A("D<iterable T1,T2,iterable T3,T4,T5>"), IsConstraint(_A("D<iterable T1,T2,iterable T3,T4,T5>"),
_A("iterable<T>"), "T1")); _A("iterable<T>"), "T1"));
REQUIRE_THAT(puml, REQUIRE_THAT(src,
IsConstraint(_A("D<iterable T1,T2,iterable T3,T4,T5>"), IsConstraint(_A("D<iterable T1,T2,iterable T3,T4,T5>"),
_A("iterable<T>"), "T3")); _A("iterable<T>"), "T3"));
REQUIRE_THAT(puml, REQUIRE_THAT(src,
IsConstraint(_A("iterable_with_value_type<T>"), IsConstraint(_A("iterable_with_value_type<T>"),
_A("has_value_type<T>"), "T")); _A("has_value_type<T>"), "T"));
REQUIRE_THAT(puml, REQUIRE_THAT(src,
IsConstraint(_A("iterable_or_small_value_type<T>"), IsConstraint(_A("iterable_or_small_value_type<T>"),
_A("max_four_bytes<T>"), "T")); _A("max_four_bytes<T>"), "T"));
REQUIRE_THAT(puml, REQUIRE_THAT(src,
IsConstraint(_A("iterable_or_small_value_type<T>"), IsConstraint(_A("iterable_or_small_value_type<T>"),
_A("iterable_with_value_type<T>"), "T")); _A("iterable_with_value_type<T>"), "T"));
REQUIRE_THAT(puml, REQUIRE_THAT(src,
IsConstraint(_A("E<T1,T2,T3>"), IsConstraint(_A("E<T1,T2,T3>"),
_A("greater_than_with_requires<T,P>"), "T1,T3")); _A("greater_than_with_requires<T,P>"), "T1,T3"));
REQUIRE_THAT(puml, REQUIRE_THAT(src,
IsConstraint( IsConstraint(
_A("F<T1,T2,T3>"), _A("greater_than_simple<T,L>"), "T1,T3")); _A("F<T1,T2,T3>"), _A("greater_than_simple<T,L>"), "T1,T3"));
save_puml(config.output_directory(), diagram->name + ".puml", puml); save_puml(config.output_directory(), diagram->name + ".puml", src);
} }
{ {
auto j = generate_class_json(diagram, *model); auto j = generate_class_json(diagram, *model);
@@ -135,8 +135,93 @@ TEST_CASE("t00056", "[test-case][class]")
save_json(config.output_directory(), diagram->name + ".json", j); save_json(config.output_directory(), diagram->name + ".json", j);
} }
{ {
auto mmd = generate_class_mermaid(diagram, *model); auto src = generate_class_mermaid(diagram, *model);
save_mermaid(config.output_directory(), diagram->name + ".mmd", mmd); 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()"));
#ifdef _MSC_VER
REQUIRE_THAT(puml,
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);
} }
} }

75
tests/t00057/test_case.h
View File

@@ -29,37 +29,37 @@ TEST_CASE("t00057", "[test-case][class]")
REQUIRE(model->name() == "t00057_class"); REQUIRE(model->name() == "t00057_class");
{ {
auto puml = generate_class_puml(diagram, *model); auto src = generate_class_puml(diagram, *model);
AliasMatcher _A(puml); AliasMatcher _A(src);
REQUIRE_THAT(puml, StartsWith("@startuml")); REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(puml, EndsWith("@enduml\n")); REQUIRE_THAT(src, EndsWith("@enduml\n"));
// Check if all classes exist // Check if all classes exist
REQUIRE_THAT(puml, IsClass(_A("t00057_A"))); REQUIRE_THAT(src, IsClass(_A("t00057_A")));
REQUIRE_THAT(puml, IsClass(_A("t00057_B"))); REQUIRE_THAT(src, IsClass(_A("t00057_B")));
REQUIRE_THAT(puml, IsClass(_A("t00057_C"))); REQUIRE_THAT(src, IsClass(_A("t00057_C")));
REQUIRE_THAT(puml, IsUnion(_A("t00057_D"))); REQUIRE_THAT(src, IsUnion(_A("t00057_D")));
REQUIRE_THAT(puml, IsClass(_A("t00057_E"))); REQUIRE_THAT(src, IsClass(_A("t00057_E")));
REQUIRE_THAT(puml, IsClass(_A("t00057_F"))); REQUIRE_THAT(src, IsClass(_A("t00057_F")));
REQUIRE_THAT(puml, IsClass(_A("t00057_G"))); REQUIRE_THAT(src, IsClass(_A("t00057_G")));
REQUIRE_THAT(puml, !IsClass(_A("(anonymous)"))); REQUIRE_THAT(src, !IsClass(_A("(anonymous)")));
REQUIRE_THAT(puml, IsClass(_A("t00057_R"))); REQUIRE_THAT(src, IsClass(_A("t00057_R")));
// Check if all relationships exist // Check if all relationships exist
REQUIRE_THAT(puml, IsAggregation(_A("t00057_R"), _A("t00057_A"), "+a")); REQUIRE_THAT(src, IsAggregation(_A("t00057_R"), _A("t00057_A"), "+a"));
REQUIRE_THAT(puml, IsAggregation(_A("t00057_R"), _A("t00057_B"), "+b")); REQUIRE_THAT(src, IsAggregation(_A("t00057_R"), _A("t00057_B"), "+b"));
REQUIRE_THAT(puml, IsAssociation(_A("t00057_R"), _A("t00057_C"), "+c")); REQUIRE_THAT(src, IsAssociation(_A("t00057_R"), _A("t00057_C"), "+c"));
REQUIRE_THAT(puml, IsAggregation(_A("t00057_R"), _A("t00057_D"), "+d")); REQUIRE_THAT(src, IsAggregation(_A("t00057_R"), _A("t00057_D"), "+d"));
REQUIRE_THAT(puml, IsAssociation(_A("t00057_R"), _A("t00057_E"), "+e")); REQUIRE_THAT(src, IsAssociation(_A("t00057_R"), _A("t00057_E"), "+e"));
REQUIRE_THAT(puml, IsAssociation(_A("t00057_R"), _A("t00057_F"), "+f")); REQUIRE_THAT(src, IsAssociation(_A("t00057_R"), _A("t00057_F"), "+f"));
REQUIRE_THAT(puml, REQUIRE_THAT(src,
IsAggregation( IsAggregation(
_A("t00057_E"), _A("t00057_E::(coordinates)"), "+coordinates")); _A("t00057_E"), _A("t00057_E::(coordinates)"), "+coordinates"));
REQUIRE_THAT(puml, REQUIRE_THAT(src,
IsAggregation(_A("t00057_E"), _A("t00057_E::(height)"), "+height")); IsAggregation(_A("t00057_E"), _A("t00057_E::(height)"), "+height"));
save_puml(config.output_directory(), diagram->name + ".puml", puml); save_puml(config.output_directory(), diagram->name + ".puml", src);
} }
{ {
@@ -79,8 +79,35 @@ TEST_CASE("t00057", "[test-case][class]")
save_json(config.output_directory(), diagram->name + ".json", j); save_json(config.output_directory(), diagram->name + ".json", j);
} }
{ {
auto mmd = generate_class_mermaid(diagram, *model); auto src = generate_class_mermaid(diagram, *model);
save_mermaid(config.output_directory(), diagram->name + ".mmd", mmd); 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);
} }
} }

72
tests/t00058/test_case.h
View File

@@ -29,44 +29,44 @@ TEST_CASE("t00058", "[test-case][class]")
REQUIRE(model->name() == "t00058_class"); REQUIRE(model->name() == "t00058_class");
{ {
auto puml = generate_class_puml(diagram, *model); auto src = generate_class_puml(diagram, *model);
AliasMatcher _A(puml); AliasMatcher _A(src);
REQUIRE_THAT(puml, StartsWith("@startuml")); REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(puml, EndsWith("@enduml\n")); REQUIRE_THAT(src, EndsWith("@enduml\n"));
REQUIRE_THAT(puml, IsClassTemplate("A", "int,int,double,std::string")); REQUIRE_THAT(src, IsClassTemplate("A", "int,int,double,std::string"));
REQUIRE_THAT(puml, REQUIRE_THAT(
IsClassTemplate("B", "int,std::string,int,double,A<int,int>")); src, IsClassTemplate("B", "int,std::string,int,double,A<int,int>"));
REQUIRE_THAT(puml, IsConcept(_A("same_as_first_type<T,Args...>"))); REQUIRE_THAT(src, IsConcept(_A("same_as_first_type<T,Args...>")));
REQUIRE_THAT(puml, REQUIRE_THAT(src,
IsConstraint(_A("A<T,Args...>"), IsConstraint(_A("A<T,Args...>"),
_A("same_as_first_type<T,Args...>"), "T,Args...")); _A("same_as_first_type<T,Args...>"), "T,Args..."));
REQUIRE_THAT(puml, REQUIRE_THAT(src,
IsConstraint(_A("B<T,P,Args...>"), IsConstraint(_A("B<T,P,Args...>"),
_A("same_as_first_type<T,Args...>"), "T,Args...")); _A("same_as_first_type<T,Args...>"), "T,Args..."));
REQUIRE_THAT(puml, REQUIRE_THAT(src,
IsAggregation(_A("R"), _A("A<int,int,double,std::string>"), "+aa")); IsAggregation(_A("R"), _A("A<int,int,double,std::string>"), "+aa"));
REQUIRE_THAT(puml, REQUIRE_THAT(src,
IsAggregation(_A("R"), IsAggregation(_A("R"),
_A("B<int,std::string,int,double,A<int,int>>"), "+bb")); _A("B<int,std::string,int,double,A<int,int>>"), "+bb"));
REQUIRE_THAT(puml, REQUIRE_THAT(src,
IsInstantiation( IsInstantiation(
_A("A<T,Args...>"), _A("A<int,int,double,std::string>"))); _A("A<T,Args...>"), _A("A<int,int,double,std::string>")));
REQUIRE_THAT(puml, REQUIRE_THAT(src,
IsInstantiation(_A("B<T,P,Args...>"), IsInstantiation(_A("B<T,P,Args...>"),
_A("B<int,std::string,int,double,A<int,int>>"))); _A("B<int,std::string,int,double,A<int,int>>")));
REQUIRE_THAT(puml, REQUIRE_THAT(src,
IsDependency(_A("same_as_first_type<T,Args...>"), IsDependency(_A("same_as_first_type<T,Args...>"),
_A("first_type<T,Args...>"))); _A("first_type<T,Args...>")));
save_puml(config.output_directory(), diagram->name + ".puml", puml); save_puml(config.output_directory(), diagram->name + ".puml", src);
} }
{ {
@@ -81,8 +81,44 @@ TEST_CASE("t00058", "[test-case][class]")
save_json(config.output_directory(), diagram->name + ".json", j); save_json(config.output_directory(), diagram->name + ".json", j);
} }
{ {
auto mmd = generate_class_mermaid(diagram, *model); auto src = generate_class_mermaid(diagram, *model);
save_mermaid(config.output_directory(), diagram->name + ".mmd", mmd); 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);
} }
} }

111
tests/t00059/test_case.h
View File

@@ -29,64 +29,64 @@ TEST_CASE("t00059", "[test-case][class]")
REQUIRE(model->name() == "t00059_class"); REQUIRE(model->name() == "t00059_class");
{ {
auto puml = generate_class_puml(diagram, *model); auto src = generate_class_puml(diagram, *model);
AliasMatcher _A(puml); AliasMatcher _A(src);
REQUIRE_THAT(puml, StartsWith("@startuml")); REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(puml, EndsWith("@enduml\n")); REQUIRE_THAT(src, EndsWith("@enduml\n"));
REQUIRE_THAT(puml, IsConcept(_A("fruit_c<T>"))); REQUIRE_THAT(src, IsConcept(_A("fruit_c<T>")));
REQUIRE_THAT(puml, IsConcept(_A("apple_c<T>"))); REQUIRE_THAT(src, IsConcept(_A("apple_c<T>")));
REQUIRE_THAT(puml, IsConcept(_A("orange_c<T>"))); REQUIRE_THAT(src, IsConcept(_A("orange_c<T>")));
REQUIRE_THAT( REQUIRE_THAT(
puml, IsConstraint(_A("apple_c<T>"), _A("fruit_c<T>"), "T")); src, IsConstraint(_A("apple_c<T>"), _A("fruit_c<T>"), "T"));
REQUIRE_THAT( REQUIRE_THAT(
puml, IsConstraint(_A("orange_c<T>"), _A("fruit_c<T>"), "T")); src, IsConstraint(_A("orange_c<T>"), _A("fruit_c<T>"), "T"));
REQUIRE_THAT( REQUIRE_THAT(
puml, IsConceptRequirement(_A("apple_c<T>"), "t.get_sweetness()")); src, IsConceptRequirement(_A("apple_c<T>"), "t.get_sweetness()"));
REQUIRE_THAT( REQUIRE_THAT(
puml, IsConceptRequirement(_A("apple_c<T>"), "t.get_bitterness()")); src, IsConceptRequirement(_A("apple_c<T>"), "t.get_bitterness()"));
REQUIRE_THAT(puml, IsClass(_A("gala_apple"))); REQUIRE_THAT(src, IsClass(_A("gala_apple")));
REQUIRE_THAT(puml, IsClass(_A("empire_apple"))); REQUIRE_THAT(src, IsClass(_A("empire_apple")));
REQUIRE_THAT(puml, IsClass(_A("valencia_orange"))); REQUIRE_THAT(src, IsClass(_A("valencia_orange")));
REQUIRE_THAT(puml, IsClass(_A("lima_orange"))); REQUIRE_THAT(src, IsClass(_A("lima_orange")));
REQUIRE_THAT(puml, IsClass(_A("R"))); REQUIRE_THAT(src, IsClass(_A("R")));
REQUIRE_THAT( REQUIRE_THAT(
puml, IsClassTemplate("fruit_factory", "apple_c TA,orange_c TO")); src, IsClassTemplate("fruit_factory", "apple_c TA,orange_c TO"));
REQUIRE_THAT(puml, REQUIRE_THAT(src,
IsDependency(_A("fruit_factory<gala_apple,valencia_orange>"), IsDependency(_A("fruit_factory<gala_apple,valencia_orange>"),
_A("gala_apple"))); _A("gala_apple")));
REQUIRE_THAT(puml, REQUIRE_THAT(src,
IsDependency(_A("fruit_factory<gala_apple,valencia_orange>"), IsDependency(_A("fruit_factory<gala_apple,valencia_orange>"),
_A("valencia_orange"))); _A("valencia_orange")));
REQUIRE_THAT(puml, REQUIRE_THAT(src,
IsDependency(_A("fruit_factory<empire_apple,lima_orange>"), IsDependency(_A("fruit_factory<empire_apple,lima_orange>"),
_A("empire_apple"))); _A("empire_apple")));
REQUIRE_THAT(puml, REQUIRE_THAT(src,
IsDependency(_A("fruit_factory<empire_apple,lima_orange>"), IsDependency(_A("fruit_factory<empire_apple,lima_orange>"),
_A("lima_orange"))); _A("lima_orange")));
REQUIRE_THAT(puml, REQUIRE_THAT(src,
IsAggregation(_A("R"), IsAggregation(_A("R"),
_A("fruit_factory<gala_apple,valencia_orange>"), "+factory_1")); _A("fruit_factory<gala_apple,valencia_orange>"), "+factory_1"));
REQUIRE_THAT(puml, REQUIRE_THAT(src,
IsAggregation(_A("R"), IsAggregation(_A("R"),
_A("fruit_factory<empire_apple,lima_orange>"), "+factory_2")); _A("fruit_factory<empire_apple,lima_orange>"), "+factory_2"));
REQUIRE_THAT(puml, REQUIRE_THAT(src,
IsInstantiation(_A("fruit_factory<apple_c TA,orange_c TO>"), IsInstantiation(_A("fruit_factory<apple_c TA,orange_c TO>"),
_A("fruit_factory<gala_apple,valencia_orange>"))); _A("fruit_factory<gala_apple,valencia_orange>")));
REQUIRE_THAT(puml, REQUIRE_THAT(src,
IsInstantiation(_A("fruit_factory<apple_c TA,orange_c TO>"), IsInstantiation(_A("fruit_factory<apple_c TA,orange_c TO>"),
_A("fruit_factory<empire_apple,lima_orange>"))); _A("fruit_factory<empire_apple,lima_orange>")));
save_puml(config.output_directory(), diagram->name + ".puml", puml); save_puml(config.output_directory(), diagram->name + ".puml", src);
} }
{ {
@@ -101,8 +101,63 @@ TEST_CASE("t00059", "[test-case][class]")
save_json(config.output_directory(), diagram->name + ".json", j); save_json(config.output_directory(), diagram->name + ".json", j);
} }
{ {
auto mmd = generate_class_mermaid(diagram, *model); auto src = generate_class_mermaid(diagram, *model);
save_mermaid(config.output_directory(), diagram->name + ".mmd", mmd); 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);
} }
} }

44
tests/t00060/test_case.h
View File

@@ -29,25 +29,25 @@ TEST_CASE("t00060", "[test-case][class]")
REQUIRE(model->name() == "t00060_class"); REQUIRE(model->name() == "t00060_class");
{ {
auto puml = generate_class_puml(diagram, *model); auto src = generate_class_puml(diagram, *model);
AliasMatcher _A(puml); AliasMatcher _A(src);
REQUIRE_THAT(puml, StartsWith("@startuml")); REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(puml, EndsWith("@enduml\n")); REQUIRE_THAT(src, EndsWith("@enduml\n"));
// Check if all classes exist // Check if all classes exist
REQUIRE_THAT(puml, IsClass(_A("A"))); REQUIRE_THAT(src, IsClass(_A("A")));
REQUIRE_THAT(puml, IsClass(_A("B"))); REQUIRE_THAT(src, IsClass(_A("B")));
REQUIRE_THAT(puml, IsClass(_A("C"))); REQUIRE_THAT(src, IsClass(_A("C")));
REQUIRE_THAT(puml, IsClass(_A("D"))); REQUIRE_THAT(src, IsClass(_A("D")));
REQUIRE_THAT(puml, !IsClass(_A("E"))); REQUIRE_THAT(src, !IsClass(_A("E")));
REQUIRE_THAT(puml, !IsClass(_A("F"))); REQUIRE_THAT(src, !IsClass(_A("F")));
// Check if class templates exist // Check if class templates exist
REQUIRE_THAT(puml, IsClassTemplate("G", "T")); REQUIRE_THAT(src, IsClassTemplate("G", "T"));
REQUIRE_THAT(puml, IsClassTemplate("H", "T,P")); REQUIRE_THAT(src, IsClassTemplate("H", "T,P"));
save_puml(config.output_directory(), diagram->name + ".puml", puml); save_puml(config.output_directory(), diagram->name + ".puml", src);
} }
{ {
@@ -65,8 +65,22 @@ TEST_CASE("t00060", "[test-case][class]")
save_json(config.output_directory(), diagram->name + ".json", j); save_json(config.output_directory(), diagram->name + ".json", j);
} }
{ {
auto mmd = generate_class_mermaid(diagram, *model); auto src = generate_class_mermaid(diagram, *model);
save_mermaid(config.output_directory(), diagram->name + ".mmd", mmd); 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);
} }
} }

27
tests/t00061/test_case.h
View File

@@ -29,18 +29,18 @@ TEST_CASE("t00061", "[test-case][class]")
REQUIRE(model->name() == "t00061_class"); REQUIRE(model->name() == "t00061_class");
{ {
auto puml = generate_class_puml(diagram, *model); auto src = generate_class_puml(diagram, *model);
AliasMatcher _A(puml); AliasMatcher _A(src);
REQUIRE_THAT(puml, StartsWith("@startuml")); REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(puml, EndsWith("@enduml\n")); REQUIRE_THAT(src, EndsWith("@enduml\n"));
// Check if all classes exist // Check if all classes exist
REQUIRE_THAT(puml, IsClass(_A("A"))); REQUIRE_THAT(src, IsClass(_A("A")));
REQUIRE_THAT(puml, !IsClass(_A("B"))); REQUIRE_THAT(src, !IsClass(_A("B")));
REQUIRE_THAT(puml, !IsClass(_A("C"))); REQUIRE_THAT(src, !IsClass(_A("C")));
save_puml(config.output_directory(), diagram->name + ".puml", puml); save_puml(config.output_directory(), diagram->name + ".puml", src);
} }
{ {
@@ -55,8 +55,15 @@ TEST_CASE("t00061", "[test-case][class]")
save_json(config.output_directory(), diagram->name + ".json", j); save_json(config.output_directory(), diagram->name + ".json", j);
} }
{ {
auto mmd = generate_class_mermaid(diagram, *model); auto src = generate_class_mermaid(diagram, *model);
save_mermaid(config.output_directory(), diagram->name + ".mmd", mmd); 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);
} }
} }

137
tests/t00062/test_case.h
View File

@@ -29,61 +29,61 @@ TEST_CASE("t00062", "[test-case][class]")
REQUIRE(model->name() == "t00062_class"); REQUIRE(model->name() == "t00062_class");
{ {
auto puml = generate_class_puml(diagram, *model); auto src = generate_class_puml(diagram, *model);
AliasMatcher _A(puml); AliasMatcher _A(src);
REQUIRE_THAT(puml, StartsWith("@startuml")); REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(puml, EndsWith("@enduml\n")); REQUIRE_THAT(src, EndsWith("@enduml\n"));
REQUIRE_THAT(puml, !Contains("type-parameter-")); REQUIRE_THAT(src, !Contains("type-parameter-"));
// Check if all classes exist // Check if all classes exist
REQUIRE_THAT(puml, IsClassTemplate("A", "T")); REQUIRE_THAT(src, IsClassTemplate("A", "T"));
REQUIRE_THAT(puml, IsClassTemplate("A", "U &")); REQUIRE_THAT(src, IsClassTemplate("A", "U &"));
REQUIRE_THAT(puml, IsClassTemplate("A", "U &&")); REQUIRE_THAT(src, IsClassTemplate("A", "U &&"));
REQUIRE_THAT(puml, IsClassTemplate("A", "U const&")); REQUIRE_THAT(src, IsClassTemplate("A", "U const&"));
REQUIRE_THAT(puml, IsClassTemplate("A", "M C::*")); REQUIRE_THAT(src, IsClassTemplate("A", "M C::*"));
REQUIRE_THAT(puml, IsClassTemplate("A", "M C::* &&")); REQUIRE_THAT(src, IsClassTemplate("A", "M C::* &&"));
REQUIRE_THAT(puml, IsClassTemplate("A", "M (C::*)(Arg)")); REQUIRE_THAT(src, IsClassTemplate("A", "M (C::*)(Arg)"));
REQUIRE_THAT(puml, IsClassTemplate("A", "int (C::*)(bool)")); REQUIRE_THAT(src, IsClassTemplate("A", "int (C::*)(bool)"));
REQUIRE_THAT(puml, IsClassTemplate("A", "M (C::*)(Arg) &&")); REQUIRE_THAT(src, IsClassTemplate("A", "M (C::*)(Arg) &&"));
REQUIRE_THAT(puml, IsClassTemplate("A", "M (C::*)(Arg1,Arg2,Arg3)")); REQUIRE_THAT(src, IsClassTemplate("A", "M (C::*)(Arg1,Arg2,Arg3)"));
REQUIRE_THAT(puml, IsClassTemplate("A", "float (C::*)(int) &&")); REQUIRE_THAT(src, IsClassTemplate("A", "float (C::*)(int) &&"));
REQUIRE_THAT(puml, IsClassTemplate("A", "char[N]")); REQUIRE_THAT(src, IsClassTemplate("A", "char[N]"));
REQUIRE_THAT(puml, IsClassTemplate("A", "char[1000]")); REQUIRE_THAT(src, IsClassTemplate("A", "char[1000]"));
REQUIRE_THAT(puml, IsClassTemplate("A", "U(...)")); REQUIRE_THAT(src, IsClassTemplate("A", "U(...)"));
REQUIRE_THAT(puml, IsClassTemplate("A", "C<T>")); REQUIRE_THAT(src, IsClassTemplate("A", "C<T>"));
REQUIRE_THAT(puml, IsClassTemplate("A", "C<T,Args...>")); REQUIRE_THAT(src, IsClassTemplate("A", "C<T,Args...>"));
REQUIRE_THAT(puml, (IsField<Public>("u", "U &"))); REQUIRE_THAT(src, (IsField<Public>("u", "U &")));
REQUIRE_THAT(puml, (IsField<Public>("u", "U **"))); REQUIRE_THAT(src, (IsField<Public>("u", "U **")));
REQUIRE_THAT(puml, (IsField<Public>("u", "U ***"))); REQUIRE_THAT(src, (IsField<Public>("u", "U ***")));
REQUIRE_THAT(puml, (IsField<Public>("u", "U &&"))); REQUIRE_THAT(src, (IsField<Public>("u", "U &&")));
REQUIRE_THAT(puml, (IsField<Public>("u", "const U &"))); REQUIRE_THAT(src, (IsField<Public>("u", "const U &")));
REQUIRE_THAT(puml, (IsField<Public>("c", "C &"))); REQUIRE_THAT(src, (IsField<Public>("c", "C &")));
REQUIRE_THAT(puml, (IsField<Public>("m", "M C::*"))); REQUIRE_THAT(src, (IsField<Public>("m", "M C::*")));
REQUIRE_THAT(puml, IsInstantiation(_A("A<T>"), _A("A<U &>"))); REQUIRE_THAT(src, IsInstantiation(_A("A<T>"), _A("A<U &>")));
REQUIRE_THAT(puml, IsInstantiation(_A("A<T>"), _A("A<U &&>"))); REQUIRE_THAT(src, IsInstantiation(_A("A<T>"), _A("A<U &&>")));
REQUIRE_THAT(puml, IsInstantiation(_A("A<T>"), _A("A<M C::*>"))); REQUIRE_THAT(src, IsInstantiation(_A("A<T>"), _A("A<M C::*>")));
REQUIRE_THAT(puml, IsInstantiation(_A("A<U &&>"), _A("A<M C::* &&>"))); REQUIRE_THAT(src, IsInstantiation(_A("A<U &&>"), _A("A<M C::* &&>")));
REQUIRE_THAT(puml, IsInstantiation(_A("A<T>"), _A("A<M (C::*)(Arg)>"))); REQUIRE_THAT(src, IsInstantiation(_A("A<T>"), _A("A<M (C::*)(Arg)>")));
REQUIRE_THAT(puml, REQUIRE_THAT(src,
IsInstantiation(_A("A<M (C::*)(Arg)>"), _A("A<int (C::*)(bool)>"))); IsInstantiation(_A("A<M (C::*)(Arg)>"), _A("A<int (C::*)(bool)>")));
REQUIRE_THAT(puml, IsInstantiation(_A("A<T>"), _A("A<char[N]>"))); REQUIRE_THAT(src, IsInstantiation(_A("A<T>"), _A("A<char[N]>")));
REQUIRE_THAT( REQUIRE_THAT(
puml, IsInstantiation(_A("A<char[N]>"), _A("A<char[1000]>"))); src, IsInstantiation(_A("A<char[N]>"), _A("A<char[1000]>")));
REQUIRE_THAT(puml, IsInstantiation(_A("A<T>"), _A("A<U(...)>"))); REQUIRE_THAT(src, IsInstantiation(_A("A<T>"), _A("A<U(...)>")));
REQUIRE_THAT(puml, IsInstantiation(_A("A<T>"), _A("A<U(...)>"))); REQUIRE_THAT(src, IsInstantiation(_A("A<T>"), _A("A<U(...)>")));
REQUIRE_THAT(puml, IsInstantiation(_A("A<T>"), _A("A<C<T>>"))); REQUIRE_THAT(src, IsInstantiation(_A("A<T>"), _A("A<C<T>>")));
REQUIRE_THAT(puml, IsInstantiation(_A("A<T>"), _A("A<C<T,Args...>>"))); REQUIRE_THAT(src, IsInstantiation(_A("A<T>"), _A("A<C<T,Args...>>")));
save_puml(config.output_directory(), diagram->name + ".puml", puml); save_puml(config.output_directory(), diagram->name + ".puml", src);
} }
{ {
@@ -94,8 +94,59 @@ TEST_CASE("t00062", "[test-case][class]")
save_json(config.output_directory(), diagram->name + ".json", j); save_json(config.output_directory(), diagram->name + ".json", j);
} }
{ {
auto mmd = generate_class_mermaid(diagram, *model); auto src = generate_class_mermaid(diagram, *model);
save_mermaid(config.output_directory(), diagram->name + ".mmd", mmd); 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);
} }
} }

27
tests/t00063/test_case.h
View File

@@ -29,17 +29,17 @@ TEST_CASE("t00063", "[test-case][class]")
REQUIRE(model->name() == "t00063_class"); REQUIRE(model->name() == "t00063_class");
{ {
auto puml = generate_class_puml(diagram, *model); auto src = generate_class_puml(diagram, *model);
AliasMatcher _A(puml); AliasMatcher _A(src);
REQUIRE_THAT(puml, StartsWith("@startuml")); REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(puml, EndsWith("@enduml\n")); REQUIRE_THAT(src, EndsWith("@enduml\n"));
REQUIRE_THAT(puml, IsClass(_A("A"))); REQUIRE_THAT(src, IsClass(_A("A")));
REQUIRE_THAT(puml, !IsEnum(_A("B"))); REQUIRE_THAT(src, !IsEnum(_A("B")));
REQUIRE_THAT(puml, !IsEnum(_A("C"))); REQUIRE_THAT(src, !IsEnum(_A("C")));
save_puml(config.output_directory(), diagram->name + ".puml", puml); save_puml(config.output_directory(), diagram->name + ".puml", src);
} }
{ {
@@ -54,8 +54,15 @@ TEST_CASE("t00063", "[test-case][class]")
save_json(config.output_directory(), diagram->name + ".json", j); save_json(config.output_directory(), diagram->name + ".json", j);
} }
{ {
auto mmd = generate_class_mermaid(diagram, *model); auto src = generate_class_mermaid(diagram, *model);
save_mermaid(config.output_directory(), diagram->name + ".mmd", mmd); 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);
} }
} }

100
tests/t00064/test_case.h
View File

@@ -29,56 +29,55 @@ TEST_CASE("t00064", "[test-case][class]")
REQUIRE(model->name() == "t00064_class"); REQUIRE(model->name() == "t00064_class");
{ {
auto puml = generate_class_puml(diagram, *model); auto src = generate_class_puml(diagram, *model);
AliasMatcher _A(puml); AliasMatcher _A(src);
REQUIRE_THAT(puml, StartsWith("@startuml")); REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(puml, EndsWith("@enduml\n")); REQUIRE_THAT(src, EndsWith("@enduml\n"));
REQUIRE_THAT(puml, !Contains("type-parameter-")); REQUIRE_THAT(src, !Contains("type-parameter-"));
REQUIRE_THAT(puml, IsClass(_A("A"))); REQUIRE_THAT(src, IsClass(_A("A")));
REQUIRE_THAT(puml, IsClass(_A("B"))); REQUIRE_THAT(src, IsClass(_A("B")));
REQUIRE_THAT(puml, IsClass(_A("C"))); REQUIRE_THAT(src, IsClass(_A("C")));
REQUIRE_THAT(puml, IsClass(_A("R"))); REQUIRE_THAT(src, IsClass(_A("R")));
REQUIRE_THAT(puml, IsClassTemplate("type_list", "Ts...")); REQUIRE_THAT(src, IsClassTemplate("type_list", "Ts..."));
REQUIRE_THAT(puml, IsClassTemplate("type_list", "Ret(Arg &&),Ts...")); REQUIRE_THAT(src, IsClassTemplate("type_list", "Ret(Arg &&),Ts..."));
REQUIRE_THAT(puml, IsClassTemplate("type_list", "T const,Ts...")); REQUIRE_THAT(src, IsClassTemplate("type_list", "T const,Ts..."));
REQUIRE_THAT(puml, IsClassTemplate("head", "typename")); REQUIRE_THAT(src, IsClassTemplate("head", "typename"));
REQUIRE_THAT(puml, IsClassTemplate("head", "type_list<Head,Tail...>")); REQUIRE_THAT(src, IsClassTemplate("head", "type_list<Head,Tail...>"));
REQUIRE_THAT( REQUIRE_THAT(
puml, IsClassTemplate("type_group_pair", "typename,typename")); src, IsClassTemplate("type_group_pair", "typename,typename"));
REQUIRE_THAT(puml, REQUIRE_THAT(src,
IsClassTemplate( IsClassTemplate(
"type_group_pair", "type_list<First...>,type_list<Second...>")); "type_group_pair", "type_list<First...>,type_list<Second...>"));
REQUIRE_THAT(puml, REQUIRE_THAT(src,
IsClassTemplate( IsClassTemplate(
"type_group_pair", "type_list<float,double>,type_list<A,B,C>")); "type_group_pair", "type_list<float,double>,type_list<A,B,C>"));
REQUIRE_THAT(puml, IsClassTemplate("optional_ref", "T")); REQUIRE_THAT(src, IsClassTemplate("optional_ref", "T"));
REQUIRE_THAT(puml, REQUIRE_THAT(src,
IsClassTemplate("type_group_pair_it", IsClassTemplate("type_group_pair_it",
"It,type_list<First...>,type_list<Second...>")); "It,type_list<First...>,type_list<Second...>"));
REQUIRE_THAT( REQUIRE_THAT(src, (IsMethod<Public>("get", "ref_t", "unsigned int i")));
puml, (IsMethod<Public>("get", "ref_t", "unsigned int i")));
#if LLVM_VERSION_MAJOR < 16 #if LLVM_VERSION_MAJOR < 16
REQUIRE_THAT(puml, REQUIRE_THAT(src,
(IsMethod<Public>("getp", "value_type const*", "unsigned int i"))); (IsMethod<Public>("getp", "value_type const*", "unsigned int i")));
REQUIRE_THAT(puml, REQUIRE_THAT(src,
(IsMethod<Public, Constexpr>( (IsMethod<Public, Constexpr>(
"find", "unsigned int", "value_type const& v"))); "find", "unsigned int", "value_type const& v")));
#else #else
REQUIRE_THAT(puml, REQUIRE_THAT(src,
(IsMethod<Public>("getp", "const value_type *", "unsigned int i"))); (IsMethod<Public>("getp", "const value_type *", "unsigned int i")));
REQUIRE_THAT(puml, REQUIRE_THAT(src,
(IsMethod<Public, Constexpr>( (IsMethod<Public, Constexpr>(
"find", "unsigned int", "const value_type & v"))); "find", "unsigned int", "const value_type & v")));
#endif #endif
save_puml(config.output_directory(), diagram->name + ".puml", puml); save_puml(config.output_directory(), diagram->name + ".puml", src);
} }
{ {
@@ -89,8 +88,53 @@ TEST_CASE("t00064", "[test-case][class]")
save_json(config.output_directory(), diagram->name + ".json", j); save_json(config.output_directory(), diagram->name + ".json", j);
} }
{ {
auto mmd = generate_class_mermaid(diagram, *model); auto src = generate_class_mermaid(diagram, *model);
save_mermaid(config.output_directory(), diagram->name + ".mmd", mmd); 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);
} }
} }

42
tests/t00065/test_case.h
View File

@@ -29,25 +29,25 @@ TEST_CASE("t00065", "[test-case][class]")
REQUIRE(model->name() == "t00065_class"); REQUIRE(model->name() == "t00065_class");
{ {
auto puml = generate_class_puml(diagram, *model); auto src = generate_class_puml(diagram, *model);
AliasMatcher _A(puml); AliasMatcher _A(src);
REQUIRE_THAT(puml, StartsWith("@startuml")); REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(puml, EndsWith("@enduml\n")); REQUIRE_THAT(src, EndsWith("@enduml\n"));
// Check if all classes exist // Check if all classes exist
REQUIRE_THAT(puml, IsClass(_A("R"))); REQUIRE_THAT(src, IsClass(_A("R")));
REQUIRE_THAT(puml, IsClass(_A("A"))); REQUIRE_THAT(src, IsClass(_A("A")));
REQUIRE_THAT(puml, IsClass(_A("AImpl"))); REQUIRE_THAT(src, IsClass(_A("AImpl")));
REQUIRE_THAT(puml, IsEnum(_A("XYZ"))); REQUIRE_THAT(src, IsEnum(_A("XYZ")));
REQUIRE_THAT(puml, IsEnum(_A("ABC"))); REQUIRE_THAT(src, IsEnum(_A("ABC")));
REQUIRE_THAT(puml, IsPackage("module1")); REQUIRE_THAT(src, IsPackage("module1"));
REQUIRE_THAT(puml, IsPackage("module2")); REQUIRE_THAT(src, IsPackage("module2"));
REQUIRE_THAT(puml, IsPackage("submodule1a")); REQUIRE_THAT(src, IsPackage("submodule1a"));
REQUIRE_THAT(puml, IsPackage("concepts")); REQUIRE_THAT(src, IsPackage("concepts"));
save_puml(config.output_directory(), diagram->name + ".puml", puml); save_puml(config.output_directory(), diagram->name + ".puml", src);
} }
{ {
@@ -58,8 +58,18 @@ TEST_CASE("t00065", "[test-case][class]")
save_json(config.output_directory(), diagram->name + ".json", j); save_json(config.output_directory(), diagram->name + ".json", j);
} }
{ {
auto mmd = generate_class_mermaid(diagram, *model); auto src = generate_class_mermaid(diagram, *model);
save_mermaid(config.output_directory(), diagram->name + ".mmd", mmd); 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);
} }
} }

94
tests/t00066/test_case.h
View File

@@ -29,47 +29,47 @@ TEST_CASE("t00066", "[test-case][class]")
REQUIRE(model->name() == "t00066_class"); REQUIRE(model->name() == "t00066_class");
{ {
auto puml = generate_class_puml(diagram, *model); auto src = generate_class_puml(diagram, *model);
AliasMatcher _A(puml); AliasMatcher _A(src);
REQUIRE_THAT(puml, StartsWith("@startuml")); REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(puml, EndsWith("@enduml\n")); REQUIRE_THAT(src, EndsWith("@enduml\n"));
REQUIRE_THAT(puml, IsClass(_A("A"))); REQUIRE_THAT(src, IsClass(_A("A")));
REQUIRE_THAT(puml, !IsDependency(_A("A"), _A("A"))); REQUIRE_THAT(src, !IsDependency(_A("A"), _A("A")));
REQUIRE_THAT(puml, (IsMethod<Public, Default>("A"))); REQUIRE_THAT(src, (IsMethod<Public, Default>("A")));
REQUIRE_THAT(puml, (IsMethod<Public, Default>("A", "void", "A &&"))); REQUIRE_THAT(src, (IsMethod<Public, Default>("A", "void", "A &&")));
REQUIRE_THAT( REQUIRE_THAT(
puml, (IsMethod<Public, Deleted>("A", "void", "const A &"))); src, (IsMethod<Public, Deleted>("A", "void", "const A &")));
REQUIRE_THAT(puml, (IsMethod<Public, Default>("~A"))); REQUIRE_THAT(src, (IsMethod<Public, Default>("~A")));
REQUIRE_THAT(puml, (IsMethod<Public>("basic_method"))); REQUIRE_THAT(src, (IsMethod<Public>("basic_method")));
REQUIRE_THAT(puml, (IsMethod<Public, Static>("static_method", "int"))); REQUIRE_THAT(src, (IsMethod<Public, Static>("static_method", "int")));
REQUIRE_THAT(puml, (IsMethod<Public, Const>("const_method"))); REQUIRE_THAT(src, (IsMethod<Public, Const>("const_method")));
REQUIRE_THAT( REQUIRE_THAT(
puml, (IsMethod<Public>("default_int", "int", "int i = 12"))); src, (IsMethod<Public>("default_int", "int", "int i = 12")));
REQUIRE_THAT(puml, REQUIRE_THAT(src,
(IsMethod<Public>("default_string", "std::string", (IsMethod<Public>("default_string", "std::string",
"int i, std::string s = \"abc\""))); "int i, std::string s = \"abc\"")));
REQUIRE_THAT(puml, (IsMethod<Public, Const>("size", "std::size_t"))); REQUIRE_THAT(src, (IsMethod<Public, Const>("size", "std::size_t")));
REQUIRE_THAT(puml, (IsMethod<Protected>("protected_method"))); REQUIRE_THAT(src, (IsMethod<Protected>("protected_method")));
REQUIRE_THAT(puml, (IsMethod<Private>("private_method"))); REQUIRE_THAT(src, (IsMethod<Private>("private_method")));
REQUIRE_THAT(puml, (IsField<Public>("public_member", "int"))); REQUIRE_THAT(src, (IsField<Public>("public_member", "int")));
REQUIRE_THAT(puml, (IsField<Protected>("protected_member", "int"))); REQUIRE_THAT(src, (IsField<Protected>("protected_member", "int")));
REQUIRE_THAT(puml, (IsField<Private>("private_member", "int"))); REQUIRE_THAT(src, (IsField<Private>("private_member", "int")));
REQUIRE_THAT(puml, REQUIRE_THAT(src,
(IsField<Public, Static>("auto_member", "const unsigned long"))); (IsField<Public, Static>("auto_member", "const unsigned long")));
REQUIRE_THAT(puml, (IsField<Private>("a_", "int"))); REQUIRE_THAT(src, (IsField<Private>("a_", "int")));
REQUIRE_THAT(puml, (IsField<Private>("b_", "int"))); REQUIRE_THAT(src, (IsField<Private>("b_", "int")));
REQUIRE_THAT(puml, (IsField<Private>("c_", "int"))); REQUIRE_THAT(src, (IsField<Private>("c_", "int")));
save_puml(config.output_directory(), diagram->name + ".puml", puml); save_puml(config.output_directory(), diagram->name + ".puml", src);
} }
{ {
@@ -80,8 +80,46 @@ TEST_CASE("t00066", "[test-case][class]")
save_json(config.output_directory(), diagram->name + ".json", j); save_json(config.output_directory(), diagram->name + ".json", j);
} }
{ {
auto mmd = generate_class_mermaid(diagram, *model); auto src = generate_class_mermaid(diagram, *model);
save_mermaid(config.output_directory(), diagram->name + ".mmd", mmd); 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);
} }
} }

39
tests/t00067/test_case.h
View File

@@ -29,22 +29,22 @@ TEST_CASE("t00067", "[test-case][class]")
REQUIRE(model->name() == "t00067_class"); REQUIRE(model->name() == "t00067_class");
{ {
auto puml = generate_class_puml(diagram, *model); auto src = generate_class_puml(diagram, *model);
AliasMatcher _A(puml); AliasMatcher _A(src);
REQUIRE_THAT(puml, StartsWith("@startuml")); REQUIRE_THAT(src, StartsWith("@startuml"));
REQUIRE_THAT(puml, EndsWith("@enduml\n")); REQUIRE_THAT(src, EndsWith("@enduml\n"));
REQUIRE_THAT(puml, !(IsMethod<Public, Default>("A"))); REQUIRE_THAT(src, !(IsMethod<Public, Default>("A")));
REQUIRE_THAT(puml, !(IsMethod<Public, Default>("A", "void", "A &&"))); REQUIRE_THAT(src, !(IsMethod<Public, Default>("A", "void", "A &&")));
REQUIRE_THAT( REQUIRE_THAT(
puml, !(IsMethod<Public, Deleted>("A", "void", "const A &"))); src, !(IsMethod<Public, Deleted>("A", "void", "const A &")));
REQUIRE_THAT(puml, !(IsMethod<Public, Default>("~A"))); REQUIRE_THAT(src, !(IsMethod<Public, Default>("~A")));
REQUIRE_THAT(puml, !(IsMethod<Public, Default>("~A"))); REQUIRE_THAT(src, !(IsMethod<Public, Default>("~A")));
save_puml(config.output_directory(), diagram->name + ".puml", puml); save_puml(config.output_directory(), diagram->name + ".puml", src);
} }
{ {
@@ -54,9 +54,22 @@ TEST_CASE("t00067", "[test-case][class]")
save_json(config.output_directory(), diagram->name + ".json", j); save_json(config.output_directory(), diagram->name + ".json", j);
} }
{
auto mmd = generate_class_mermaid(diagram, *model);
save_mermaid(config.output_directory(), diagram->name + ".mmd", mmd); {
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);
} }
} }

266
tests/test_cases.h
View File

@@ -302,12 +302,86 @@ struct AliasMatcher {
const std::vector<std::string> puml; const std::vector<std::string> puml;
}; };
namespace mermaid {
struct AliasMatcher {
AliasMatcher(const std::string &mmd_)
: mmd{split(mmd_, "\n")}
{
}
std::string operator()(std::string name)
{
std::vector<std::regex> patterns;
const std::string alias_regex("([A-Z]_[0-9]+)");
util::replace_all(name, "(", "&lpar;");
util::replace_all(name, ")", "&rpar;");
util::replace_all(name, " ", "\\s");
util::replace_all(name, "*", "\\*");
util::replace_all(name, "[", "\\[");
util::replace_all(name, "]", "\\]");
util::replace_all(name, "<", "&lt;");
util::replace_all(name, ">", "&gt;");
patterns.push_back(
std::regex{"class\\s" + alias_regex + "\\[\"" + name + "\"\\]"});
// patterns.push_back(
// std::regex{"abstract\\s\"" + name + "\"\\sas\\s" +
// alias_regex});
// patterns.push_back(
// std::regex{"enum\\s\"" + name + "\"\\sas\\s" +
// alias_regex});
// patterns.push_back(
// std::regex{"package\\s\"" + name + "\"\\sas\\s" +
// alias_regex});
// patterns.push_back(
// std::regex{"package\\s\\[" + name + "\\]\\sas\\s" +
// alias_regex});
// patterns.push_back(
// std::regex{"file\\s\"" + name + "\"\\sas\\s" +
// alias_regex});
// patterns.push_back(
// std::regex{"folder\\s\"" + name + "\"\\sas\\s" +
// alias_regex});
// patterns.push_back(
// std::regex{"participant\\s\"" + name + "\"\\sas\\s" +
// alias_regex});
std::smatch base_match;
for (const auto &line : mmd) {
for (const auto &pattern : patterns) {
if (std::regex_search(line, base_match, pattern) &&
base_match.size() == 2) {
std::ssub_match base_sub_match = base_match[1];
std::string alias = base_sub_match.str();
return trim(alias);
}
}
}
return "__INVALID__ALIAS__";
}
const std::vector<std::string> mmd;
};
}
ContainsMatcher IsClass(std::string const &str, ContainsMatcher IsClass(std::string const &str,
CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes) CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes)
{ {
return ContainsMatcher(CasedString("class " + str, caseSensitivity)); return ContainsMatcher(CasedString("class " + str, caseSensitivity));
} }
namespace mermaid {
auto IsClass(std::string const &str,
CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes)
{
return ContainsMatcher(CasedString("class " + str, caseSensitivity));
}
}
ContainsMatcher IsUnion(std::string const &str, ContainsMatcher IsUnion(std::string const &str,
CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes) CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes)
{ {
@@ -315,6 +389,16 @@ ContainsMatcher IsUnion(std::string const &str,
CasedString("class " + str + " <<union>>", caseSensitivity)); CasedString("class " + str + " <<union>>", caseSensitivity));
} }
namespace mermaid {
auto IsUnion(std::string const &alias,
CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes)
{
return Catch::Matchers::Matches(
std::string("class ") + alias + " \\{\\n\\s+<<union>>",
caseSensitivity);
}
}
ContainsMatcher IsClassTemplate(std::string const &str, ContainsMatcher IsClassTemplate(std::string const &str,
std::string const &tmplt, std::string const &tmplt,
CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes) CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes)
@@ -330,18 +414,48 @@ ContainsMatcher IsConcept(std::string const &str,
CasedString("class " + str + " <<concept>>", caseSensitivity)); CasedString("class " + str + " <<concept>>", caseSensitivity));
} }
namespace mermaid {
auto IsConcept(std::string const &alias,
CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes)
{
return Catch::Matchers::Matches(
std::string("class ") + alias + " \\{\\n\\s+<<concept>>",
caseSensitivity);
}
}
ContainsMatcher IsEnum(std::string const &str, ContainsMatcher IsEnum(std::string const &str,
CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes) CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes)
{ {
return ContainsMatcher(CasedString("enum " + str, caseSensitivity)); return ContainsMatcher(CasedString("enum " + str, caseSensitivity));
} }
namespace mermaid {
auto IsEnum(std::string const &alias,
CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes)
{
return Catch::Matchers::Matches(
std::string("class ") + alias + " \\{\\n\\s+<<enumeration>>",
caseSensitivity);
}
}
ContainsMatcher IsAbstractClass(std::string const &str, ContainsMatcher IsAbstractClass(std::string const &str,
CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes) CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes)
{ {
return ContainsMatcher(CasedString("abstract " + str, caseSensitivity)); return ContainsMatcher(CasedString("abstract " + str, caseSensitivity));
} }
namespace mermaid {
auto IsAbstractClass(std::string const &alias,
CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes)
{
return Catch::Matchers::Matches(
std::string("class ") + alias + " \\{\\n\\s+<<abstract>>",
caseSensitivity);
}
}
ContainsMatcher IsAbstractClassTemplate(std::string const &str, ContainsMatcher IsAbstractClassTemplate(std::string const &str,
std::string const &tmplt, std::string const &tmplt,
CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes) CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes)
@@ -356,6 +470,14 @@ ContainsMatcher IsBaseClass(std::string const &base, std::string const &sub,
return ContainsMatcher(CasedString(base + " <|-- " + sub, caseSensitivity)); return ContainsMatcher(CasedString(base + " <|-- " + sub, caseSensitivity));
} }
namespace mermaid {
ContainsMatcher IsBaseClass(std::string const &base, std::string const &sub,
CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes)
{
return ContainsMatcher(CasedString(base + " <|-- " + sub, caseSensitivity));
}
}
ContainsMatcher IsInnerClass(std::string const &parent, ContainsMatcher IsInnerClass(std::string const &parent,
std::string const &inner, std::string const &inner,
CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes) CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes)
@@ -364,6 +486,16 @@ ContainsMatcher IsInnerClass(std::string const &parent,
CasedString(inner + " --+ " + parent, caseSensitivity)); CasedString(inner + " --+ " + parent, caseSensitivity));
} }
namespace mermaid {
ContainsMatcher IsInnerClass(std::string const &parent,
std::string const &inner,
CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes)
{
return ContainsMatcher(
CasedString(parent + " ()-- " + inner + " : ", caseSensitivity));
}
}
ContainsMatcher IsAssociation(std::string const &from, std::string const &to, ContainsMatcher IsAssociation(std::string const &from, std::string const &to,
std::string const &label = "", std::string multiplicity_source = "", std::string const &label = "", std::string multiplicity_source = "",
std::string multiplicity_dest = "", std::string multiplicity_dest = "",
@@ -494,6 +626,43 @@ ContainsMatcher IsConceptRequirement(std::string const &cpt,
return ContainsMatcher(CasedString(requirement, caseSensitivity)); return ContainsMatcher(CasedString(requirement, caseSensitivity));
} }
namespace mermaid {
ContainsMatcher IsConstraint(std::string const &from, std::string const &to,
std::string label = {},
CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes)
{
util::replace_all(label, "<", "&lt;");
util::replace_all(label, ">", "&gt;");
util::replace_all(label, "(", "&lpar;");
util::replace_all(label, ")", "&rpar;");
util::replace_all(label, "##", "::");
util::replace_all(label, "{", "&lbrace;");
util::replace_all(label, "}", "&rbrace;");
if (label.empty())
return ContainsMatcher(
CasedString(fmt::format("{} ..> {}", from, to), caseSensitivity));
else
return ContainsMatcher(CasedString(
fmt::format("{} ..> {} : {}", from, to, label), caseSensitivity));
}
ContainsMatcher IsConceptRequirement(std::string const &cpt,
std::string requirement,
CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes)
{
util::replace_all(requirement, "<", "&lt;");
util::replace_all(requirement, ">", "&gt;");
util::replace_all(requirement, "(", "&lpar;");
util::replace_all(requirement, ")", "&rpar;");
util::replace_all(requirement, "##", "::");
util::replace_all(requirement, "{", "&lbrace;");
util::replace_all(requirement, "}", "&rbrace;");
return ContainsMatcher(CasedString(requirement, caseSensitivity));
}
}
ContainsMatcher IsLayoutHint(std::string const &from, std::string const &hint, ContainsMatcher IsLayoutHint(std::string const &from, std::string const &hint,
std::string const &to, std::string const &to,
CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes) CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes)
@@ -534,6 +703,17 @@ ContainsMatcher HasLink(std::string const &alias, std::string const &link,
fmt::format("{} [[{}{{{}}}]]", alias, link, tooltip), caseSensitivity)); fmt::format("{} [[{}{{{}}}]]", alias, link, tooltip), caseSensitivity));
} }
namespace mermaid {
ContainsMatcher HasLink(std::string const &alias, std::string const &link,
std::string const &tooltip,
CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes)
{
return ContainsMatcher(CasedString(
fmt::format("click {} href \"{}\" \"{}\"", alias, link, tooltip),
caseSensitivity));
}
}
ContainsMatcher HasMemberLink(std::string const &method, ContainsMatcher HasMemberLink(std::string const &method,
std::string const &link, std::string const &tooltip, std::string const &link, std::string const &tooltip,
CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes) CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes)
@@ -589,6 +769,61 @@ ContainsMatcher IsMethod(std::string const &name,
return ContainsMatcher(CasedString(pattern, caseSensitivity)); return ContainsMatcher(CasedString(pattern, caseSensitivity));
} }
namespace mermaid {
template <typename... Ts>
ContainsMatcher IsMethod(std::string const &name, std::string type = "void",
std::string const &params = "",
CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes)
{
std::string pattern;
if constexpr (has_type<Public, Ts...>())
pattern = "+";
else if constexpr (has_type<Protected, Ts...>())
pattern = "#";
else
pattern = "-";
pattern += name;
pattern += "(" + params + ")";
std::vector<std::string> method_mods;
if constexpr (has_type<Default, Ts...>())
method_mods.push_back("default");
if constexpr (has_type<Const, Ts...>())
method_mods.push_back("const");
if constexpr (has_type<Constexpr, Ts...>())
method_mods.push_back("constexpr");
if constexpr (has_type<Consteval, Ts...>())
method_mods.push_back("consteval");
pattern += " : ";
if (!method_mods.empty()) {
pattern += fmt::format("[{}] ", fmt::join(method_mods, ","));
}
util::replace_all(type, "<", "&lt;");
util::replace_all(type, ">", "&gt;");
util::replace_all(type, "(", "&lpar;");
util::replace_all(type, ")", "&rpar;");
util::replace_all(type, "##", "::");
util::replace_all(type, "{", "&lbrace;");
util::replace_all(type, "}", "&rbrace;");
pattern += type;
if constexpr (has_type<Abstract, Ts...>())
pattern += "*";
if constexpr (has_type<Static, Ts...>())
pattern += "$";
return ContainsMatcher(CasedString(pattern, caseSensitivity));
}
}
template <typename... Ts> template <typename... Ts>
ContainsMatcher IsField(std::string const &name, ContainsMatcher IsField(std::string const &name,
std::string const &type = "void", std::string const &type = "void",
@@ -611,6 +846,37 @@ ContainsMatcher IsField(std::string const &name,
CasedString(pattern + " : " + type, caseSensitivity)); CasedString(pattern + " : " + type, caseSensitivity));
} }
namespace mermaid {
template <typename... Ts>
ContainsMatcher IsField(std::string const &name, std::string type = "void",
CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes)
{
std::string pattern;
if constexpr (has_type<Static, Ts...>())
pattern += "{static} ";
if constexpr (has_type<Public, Ts...>())
pattern = "+";
else if constexpr (has_type<Protected, Ts...>())
pattern = "#";
else
pattern = "-";
pattern += name;
util::replace_all(type, "<", "&lt;");
util::replace_all(type, ">", "&gt;");
util::replace_all(type, "(", "&lpar;");
util::replace_all(type, ")", "&rpar;");
util::replace_all(type, "##", "::");
util::replace_all(type, "{", "&lbrace;");
util::replace_all(type, "}", "&rbrace;");
return ContainsMatcher(
CasedString(pattern + " : " + type, caseSensitivity));
}
}
template <typename... Ts> template <typename... Ts>
ContainsMatcher IsFriend(std::string const &from, std::string const &to, ContainsMatcher IsFriend(std::string const &from, std::string const &to,
CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes) CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes)