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

Added basic config option inheritance

Browse Source
This commit is contained in:
Bartek Kryza
2022-02-06 00:02:42 +01:00
parent bf64a59d0d
commit 8117dfefab
55 changed files with 375 additions and 399 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -119,7 +119,7 @@ void generator::generate_alias(const enum_ &e, std::ostream &ostr) const
void generator::generate(const class_ &c, std::ostream &ostr) const
{
const auto &uns = m_config.using_namespace;
const auto &uns = m_config.using_namespace();
std::string class_type{"class"};
if (c.is_abstract())
@@ -154,7 +154,7 @@ void generator::generate(const class_ &c, std::ostream &ostr) const
std::vector<std::string> params;
std::transform(m.parameters().cbegin(), m.parameters().cend(),
std::back_inserter(params), [this](const auto &mp) {
return mp.to_string(m_config.using_namespace);
return mp.to_string(m_config.using_namespace());
});
ostr << fmt::format("{}", fmt::join(params, ", "));
}
@@ -238,7 +238,7 @@ void generator::generate(const class_ &c, std::ostream &ostr) const
if (!m_config.should_include(m.scope()))
continue;
if (!m_config.include_relations_also_as_members &&
if (!m_config.include_relations_also_as_members() &&
rendered_relations.find(m.name()) != rendered_relations.end())
continue;
@@ -310,10 +310,10 @@ void generator::generate(const enum_ &e, std::ostream &ostr) const
destination = r.destination();
relstr << m_model.to_alias(
ns_relative(m_config.using_namespace, e.name()))
ns_relative(m_config.using_namespace(), e.name()))
<< " " << to_string(r.type()) << " "
<< m_model.to_alias(
ns_relative(m_config.using_namespace, destination));
ns_relative(m_config.using_namespace(), destination));
if (!r.label().empty())
relstr << " : " << r.label();
@@ -346,12 +346,12 @@ void generator::generate(std::ostream &ostr) const
{
ostr << "@startuml" << '\n';
for (const auto &b : m_config.puml.before) {
for (const auto &b : m_config.puml().before) {
std::string note{b};
std::tuple<std::string, size_t, size_t> alias_match;
while (util::find_element_alias(note, alias_match)) {
auto alias = m_model.to_alias(ns_relative(
m_config.using_namespace, std::get<0>(alias_match)));
m_config.using_namespace(), std::get<0>(alias_match)));
note.replace(
std::get<1>(alias_match), std::get<2>(alias_match), alias);
}
@@ -388,12 +388,12 @@ void generator::generate(std::ostream &ostr) const
}
// Process aliases in any of the puml directives
for (const auto &b : m_config.puml.after) {
for (const auto &b : m_config.puml().after) {
std::string note{b};
std::tuple<std::string, size_t, size_t> alias_match;
while (util::find_element_alias(note, alias_match)) {
auto alias = m_model.to_alias(ns_relative(
m_config.using_namespace, std::get<0>(alias_match)));
m_config.using_namespace(), std::get<0>(alias_match)));
note.replace(
std::get<1>(alias_match), std::get<2>(alias_match), alias);
}
@@ -419,7 +419,7 @@ clanguml::class_diagram::model::diagram generate(
// Get all translation units matching the glob from diagram
// configuration
std::vector<std::string> translation_units{};
for (const auto &g : diagram.glob) {
for (const auto &g : diagram.glob()) {
LOG_DBG("Processing glob: {}", g);
const auto matches = glob::rglob(g);
std::copy(matches.begin(), matches.end(),

6
src/class_diagram/visitor/translation_unit_visitor.cc
View File

@@ -202,7 +202,7 @@ void translation_unit_visitor::process_enum_declaration(
return;
}
enum_ e{ctx.config().using_namespace};
enum_ e{ctx.config().using_namespace()};
e.set_name(cx::util::full_name(ctx.get_namespace(), enm));
if (enm.comment().has_value())
@@ -242,7 +242,7 @@ void translation_unit_visitor::process_class_declaration(
const cppast::cpp_class &cls,
type_safe::optional_ref<const cppast::cpp_template_specialization> tspec)
{
class_ c{ctx.config().using_namespace};
class_ c{ctx.config().using_namespace()};
c.is_struct(cls.class_kind() == cppast::cpp_class_kind::struct_t);
c.set_name(cx::util::full_name(ctx.get_namespace(), cls));
@@ -1201,7 +1201,7 @@ class_ translation_unit_visitor::build_template_instantiation(
const cppast::cpp_template_instantiation_type &t,
std::optional<clanguml::class_diagram::model::class_ *> parent)
{
class_ tinst{ctx.config().using_namespace};
class_ tinst{ctx.config().using_namespace()};
std::string full_template_name;
std::deque<std::tuple<std::string, int, bool>> template_base_params{};

151
src/config/config.cc
View File

@@ -53,15 +53,15 @@ std::string to_string(const diagram_type t)
bool diagram::should_include_entities(const std::string &ent)
{
for (const auto &ex : exclude.entity_types) {
for (const auto &ex : exclude().entity_types) {
if (ent == ex)
return false;
}
if (include.entity_types.empty())
if (include().entity_types.empty())
return true;
for (const auto &in : include.entity_types) {
for (const auto &in : include().entity_types) {
if (ent == in)
return true;
}
@@ -71,15 +71,15 @@ bool diagram::should_include_entities(const std::string &ent)
bool diagram::should_include_relationship(const std::string &rel)
{
for (const auto &ex : exclude.relationships) {
for (const auto &ex : exclude().relationships) {
if (rel == ex)
return false;
}
if (include.relationships.empty())
if (include().relationships.empty())
return true;
for (const auto &in : include.relationships) {
for (const auto &in : include().relationships) {
if (rel == in)
return true;
}
@@ -91,7 +91,7 @@ bool diagram::should_include(const std::string &name_) const
{
auto name = clanguml::util::unqualify(name_);
for (const auto &ex : exclude.namespaces) {
for (const auto &ex : exclude().namespaces) {
if (name.find(ex) == 0) {
LOG_DBG("Skipping from diagram: {}", name);
return false;
@@ -100,10 +100,10 @@ bool diagram::should_include(const std::string &name_) const
// If no inclusive namespaces are provided,
// allow all
if (include.namespaces.empty())
if (include().namespaces.empty())
return true;
for (const auto &in : include.namespaces) {
for (const auto &in : include().namespaces) {
if (name.find(in) == 0)
return true;
}
@@ -115,15 +115,15 @@ bool diagram::should_include(const std::string &name_) const
bool diagram::should_include(const clanguml::common::model::scope_t scope) const
{
for (const auto &s : exclude.scopes) {
for (const auto &s : exclude().scopes) {
if (s == scope)
return false;
}
if (include.scopes.empty())
if (include().scopes.empty())
return true;
for (const auto &s : include.scopes) {
for (const auto &s : include().scopes) {
if (s == scope)
return true;
}
@@ -135,8 +135,8 @@ diagram_type class_diagram::type() const { return diagram_type::class_diagram; }
bool class_diagram::has_class(std::string clazz)
{
for (const auto &c : classes) {
for (const auto &ns : using_namespace) {
for (const auto &c : classes()) {
for (const auto &ns : using_namespace()) {
std::string prefix{};
if (!ns.empty()) {
prefix = ns + "::";
@@ -159,6 +159,16 @@ diagram_type package_diagram::type() const
return diagram_type::package_diagram;
}
template <>
void append_value<std::vector<std::string>>(
std::vector<std::string> &l, const std::vector<std::string> &r)
{
l.insert(l.end(), r.begin(), r.end());
}
template <> void append_value<plantuml>(plantuml &l, const plantuml &r)
{
l.append(r);
}
}
}
@@ -171,6 +181,42 @@ using clanguml::config::package_diagram;
using clanguml::config::plantuml;
using clanguml::config::sequence_diagram;
using clanguml::config::source_location;
inline bool has_key(const YAML::Node &n, const std::string &key)
{
assert(n.Type() == NodeType::Map);
return std::count_if(n.begin(), n.end(), [&key](auto &&n) {
return n.first.template as<std::string>() == key;
}) > 0;
}
template <typename T>
void get_option(const Node &node, clanguml::config::option<T> &option)
{
if (node[option.name])
option.append(node[option.name].template as<T>());
}
std::shared_ptr<clanguml::config::diagram> parse_diagram_config(const Node &d)
{
const auto diagram_type = d["type"].as<std::string>();
if (diagram_type == "class") {
return std::make_shared<class_diagram>(d.as<class_diagram>());
}
else if (diagram_type == "sequence") {
return std::make_shared<sequence_diagram>(d.as<sequence_diagram>());
}
else if (diagram_type == "package") {
return std::make_shared<package_diagram>(d.as<package_diagram>());
}
LOG_WARN("Diagrams of type {} are not supported... ", diagram_type);
return {};
}
template <> struct convert<scope_t> {
static bool decode(const Node &node, scope_t &rhs)
{
@@ -264,21 +310,11 @@ template <> struct convert<filter> {
template <typename T> bool decode_diagram(const Node &node, T &rhs)
{
if (node["using_namespace"])
rhs.using_namespace =
node["using_namespace"].as<std::vector<std::string>>();
if (node["glob"])
rhs.glob = node["glob"].as<std::vector<std::string>>();
if (node["include"])
rhs.include = node["include"].as<decltype(rhs.include)>();
if (node["exclude"])
rhs.exclude = node["exclude"].as<decltype(rhs.exclude)>();
if (node["plantuml"])
rhs.puml = node["plantuml"].as<plantuml>();
get_option(node, rhs.glob);
get_option(node, rhs.using_namespace);
get_option(node, rhs.include);
get_option(node, rhs.exclude);
get_option(node, rhs.puml);
return true;
}
@@ -292,10 +328,8 @@ template <> struct convert<class_diagram> {
if (!decode_diagram(node, rhs))
return false;
if (node["include_relations_also_as_members"])
rhs.include_relations_also_as_members =
node["include_relations_also_as_members"]
.as<decltype(rhs.include_relations_also_as_members)>();
get_option(node, rhs.classes);
get_option(node, rhs.include_relations_also_as_members);
return true;
}
@@ -310,9 +344,7 @@ template <> struct convert<sequence_diagram> {
if (!decode_diagram(node, rhs))
return false;
if (node["start_from"])
rhs.start_from =
node["start_from"].as<std::vector<source_location>>();
get_option(node, rhs.start_from);
return true;
}
@@ -331,49 +363,19 @@ template <> struct convert<package_diagram> {
}
};
std::shared_ptr<clanguml::config::diagram> parse_diagram_config(const Node &d)
{
const auto diagram_type = d["type"].as<std::string>();
if (diagram_type == "class") {
return std::make_shared<class_diagram>(d.as<class_diagram>());
}
else if (diagram_type == "sequence") {
return std::make_shared<sequence_diagram>(d.as<sequence_diagram>());
}
else if (diagram_type == "package") {
return std::make_shared<package_diagram>(d.as<package_diagram>());
}
LOG_WARN("Diagrams of type {} are not supported... ", diagram_type);
return {};
}
inline bool has_key(const YAML::Node &n, const std::string &key)
{
assert(n.Type() == NodeType::Map);
return std::count_if(n.begin(), n.end(), [&key](auto &&n) {
return n.first.template as<std::string>() == key;
}) > 0;
}
//
// config Yaml decoder
//
template <> struct convert<config> {
static bool decode(const Node &node, config &rhs)
{
if (node["glob"])
rhs.glob = node["glob"].as<std::vector<std::string>>();
if (node["output_directory"])
rhs.output_directory = node["output_directory"].as<std::string>();
if (node["compilation_database_dir"])
rhs.compilation_database_dir =
node["compilation_database_dir"].as<std::string>();
get_option(node, rhs.glob);
get_option(node, rhs.using_namespace);
get_option(node, rhs.output_directory);
get_option(node, rhs.compilation_database_dir);
get_option(node, rhs.include_relations_also_as_members);
get_option(node, rhs.puml);
auto diagrams = node["diagrams"];
@@ -381,7 +383,7 @@ template <> struct convert<config> {
for (const auto &d : diagrams) {
auto name = d.first.as<std::string>();
std::shared_ptr<clanguml::config::diagram> diagram_config;
std::shared_ptr<clanguml::config::diagram> diagram_config{};
if (has_key(d.second, "include!")) {
YAML::Node node =
@@ -395,6 +397,7 @@ template <> struct convert<config> {
if (diagram_config) {
diagram_config->name = name;
diagram_config->inherit(rhs);
rhs.diagrams[name] = diagram_config;
}
}

101
src/config/config.h
View File

@@ -37,6 +37,12 @@ namespace config {
struct plantuml {
std::vector<std::string> before;
std::vector<std::string> after;
void append(const plantuml &r)
{
before.insert(before.end(), r.before.begin(), r.before.end());
after.insert(after.end(), r.after.begin(), r.after.end());
}
};
struct filter {
@@ -63,19 +69,84 @@ enum class diagram_type { class_diagram, sequence_diagram, package_diagram };
std::string to_string(const diagram_type t);
struct diagram {
template <typename T> void append_value(T &l, const T &r) { l = r; }
// template<> void append_value<bool>(bool &l, const bool&r) {l = r;}
template <typename T> struct option {
option(const std::string &name_)
: name{name_}
{
}
option(const std::string &name_, const T &initial_value)
: name{name_}
, value{initial_value}
, has_value{true}
{
}
std::string name;
T value;
bool has_value{false};
void append(const T &r)
{
append_value(value, r);
has_value = true;
}
option<T> &operator+=(const T &r)
{
append_value(value, r);
has_value = true;
return *this;
}
T &operator()() { return value; }
const T &operator()() const { return value; }
};
struct inheritable_diagram_options {
option<std::vector<std::string>> glob{"glob"};
option<std::vector<std::string>> using_namespace{"using_namespace"};
option<bool> include_relations_also_as_members{
"include_relations_also_as_members", true};
option<filter> include{"include"};
option<filter> exclude{"exclude"};
option<plantuml> puml{"plantuml"};
void inherit(const inheritable_diagram_options &parent)
{
if (!glob.has_value && parent.glob.has_value)
glob.append(parent.glob());
if (!using_namespace.has_value && parent.using_namespace.has_value)
using_namespace.append(parent.using_namespace());
if (!include_relations_also_as_members.has_value &&
parent.include_relations_also_as_members.has_value)
include_relations_also_as_members.append(
parent.include_relations_also_as_members());
if (!include.has_value && parent.include.has_value)
include.append(parent.include());
if (!exclude.has_value && parent.exclude.has_value)
exclude.append(parent.exclude());
if (!puml.has_value && parent.puml.has_value)
puml.append(parent.puml());
}
};
struct diagram : public inheritable_diagram_options {
virtual ~diagram() = default;
virtual diagram_type type() const = 0;
std::string name;
std::vector<std::string> glob;
std::vector<std::string> using_namespace;
filter include;
filter exclude;
plantuml puml;
bool should_include_entities(const std::string &ent);
@@ -97,8 +168,7 @@ struct class_diagram : public diagram {
diagram_type type() const override;
std::vector<std::string> classes;
bool include_relations_also_as_members{true};
option<std::vector<std::string>> classes{"classes"};
bool has_class(std::string clazz);
};
@@ -108,7 +178,7 @@ struct sequence_diagram : public diagram {
diagram_type type() const override;
std::vector<source_location> start_from;
option<std::vector<source_location>> start_from{"start_from"};
};
struct package_diagram : public diagram {
@@ -117,12 +187,13 @@ struct package_diagram : public diagram {
diagram_type type() const override;
};
struct config {
struct config : public inheritable_diagram_options {
// the glob list is additive and relative to the current
// directory
std::vector<std::string> glob;
std::string compilation_database_dir{"."};
std::string output_directory{};
option<std::string> compilation_database_dir{
"compilation_database_dir", "."};
option<std::string> output_directory{"output_directory"};
std::map<std::string, std::shared_ptr<diagram>> diagrams;
};

6
src/main.cc
View File

@@ -89,11 +89,11 @@ int main(int argc, const char *argv[])
LOG_INFO("Loaded clang-uml config from {}", config_path);
LOG_INFO("Loading compilation database from {} directory",
config.compilation_database_dir);
config.compilation_database_dir());
cppast::libclang_compilation_database db(config.compilation_database_dir);
cppast::libclang_compilation_database db(config.compilation_database_dir());
std::string od = config.output_directory;
auto od = config.output_directory();
if (output_directory)
od = output_directory.value();

14
src/package_diagram/generators/plantuml/package_diagram_generator.cc
View File

@@ -82,7 +82,7 @@ std::string generator::name(relationship_t r) const
void generator::generate_relationships(
const package &p, std::ostream &ostr) const
{
const auto &uns = m_config.using_namespace;
const auto &uns = m_config.using_namespace();
// Generate this packages relationship
if (m_config.should_include_relationship("dependency")) {
@@ -111,7 +111,7 @@ void generator::generate_relationships(
void generator::generate(const package &p, std::ostream &ostr) const
{
const auto uns = m_config.using_namespace;
const auto &uns = m_config.using_namespace();
ostr << "package [" << p.name() << "] ";
ostr << "as " << p.alias();
@@ -150,12 +150,12 @@ void generator::generate(std::ostream &ostr) const
ostr << "@startuml" << '\n';
// Process aliases in any of the puml directives
for (const auto &b : m_config.puml.before) {
for (const auto &b : m_config.puml().before) {
std::string note{b};
std::tuple<std::string, size_t, size_t> alias_match;
while (util::find_element_alias(note, alias_match)) {
auto alias = m_model.to_alias(ns_relative(
m_config.using_namespace, std::get<0>(alias_match)));
m_config.using_namespace(), std::get<0>(alias_match)));
note.replace(
std::get<1>(alias_match), std::get<2>(alias_match), alias);
}
@@ -176,12 +176,12 @@ void generator::generate(std::ostream &ostr) const
}
// Process aliases in any of the puml directives
for (const auto &b : m_config.puml.after) {
for (const auto &b : m_config.puml().after) {
std::string note{b};
std::tuple<std::string, size_t, size_t> alias_match;
while (util::find_element_alias(note, alias_match)) {
auto alias = m_model.to_alias(ns_relative(
m_config.using_namespace, std::get<0>(alias_match)));
m_config.using_namespace(), std::get<0>(alias_match)));
note.replace(
std::get<1>(alias_match), std::get<2>(alias_match), alias);
}
@@ -208,7 +208,7 @@ clanguml::package_diagram::model::diagram generate(
// Get all translation units matching the glob from diagram
// configuration
std::vector<std::string> translation_units{};
for (const auto &g : diagram.glob) {
for (const auto &g : diagram.glob()) {
LOG_DBG("Processing glob: {}", g);
const auto matches = glob::rglob(g);
std::copy(matches.begin(), matches.end(),

6
src/package_diagram/visitor/translation_unit_visitor.cc
View File

@@ -94,12 +94,12 @@ void translation_unit_visitor::operator()(const cppast::cpp_entity &file)
auto package_path = package_parent;
package_path.push_back(e.name());
auto usn =
util::split(ctx.config().using_namespace[0], "::");
auto usn = util::split(
ctx.config().using_namespace()[0], "::");
if (!util::starts_with(usn, package_path)) {
auto p = std::make_unique<package>(
ctx.config().using_namespace);
ctx.config().using_namespace());
util::remove_prefix(package_path, usn);
util::remove_prefix(package_parent, usn);

18
src/sequence_diagram/generators/plantuml/sequence_diagram_generator.cc
View File

@@ -59,8 +59,8 @@ std::string generator::to_string(message_t r) const
void generator::generate_call(const message &m, std::ostream &ostr) const
{
const auto from = ns_relative(m_config.using_namespace, m.from);
const auto to = ns_relative(m_config.using_namespace, m.to);
const auto from = ns_relative(m_config.using_namespace(), m.from);
const auto to = ns_relative(m_config.using_namespace(), m.to);
ostr << '"' << from << "\" "
<< "->"
@@ -72,8 +72,8 @@ void generator::generate_return(const message &m, std::ostream &ostr) const
// Add return activity only for messages between different actors and
// only if the return type is different than void
if ((m.from != m.to) && (m.return_type != "void")) {
const auto from = ns_relative(m_config.using_namespace, m.from);
const auto to = ns_relative(m_config.using_namespace, m.to);
const auto from = ns_relative(m_config.using_namespace(), m.from);
const auto to = ns_relative(m_config.using_namespace(), m.to);
ostr << '"' << to << "\" "
<< "-->"
@@ -84,7 +84,7 @@ void generator::generate_return(const message &m, std::ostream &ostr) const
void generator::generate_activity(const activity &a, std::ostream &ostr) const
{
for (const auto &m : a.messages) {
const auto to = ns_relative(m_config.using_namespace, m.to);
const auto to = ns_relative(m_config.using_namespace(), m.to);
generate_call(m, ostr);
ostr << "activate " << '"' << to << '"' << std::endl;
if (m_model.sequences.find(m.to_usr) != m_model.sequences.end())
@@ -98,10 +98,10 @@ void generator::generate(std::ostream &ostr) const
{
ostr << "@startuml" << std::endl;
for (const auto &b : m_config.puml.before)
for (const auto &b : m_config.puml().before)
ostr << b << std::endl;
for (const auto &sf : m_config.start_from) {
for (const auto &sf : m_config.start_from()) {
if (sf.location_type == source_location::location_t::function) {
std::uint_least64_t start_from;
for (const auto &[k, v] : m_model.sequences) {
@@ -117,7 +117,7 @@ void generator::generate(std::ostream &ostr) const
continue;
}
}
for (const auto &a : m_config.puml.after)
for (const auto &a : m_config.puml().after)
ostr << a << std::endl;
ostr << "@enduml" << std::endl;
@@ -147,7 +147,7 @@ clanguml::sequence_diagram::model::diagram generate(
// Get all translation units matching the glob from diagram
// configuration
std::vector<std::string> translation_units{};
for (const auto &g : diagram.glob) {
for (const auto &g : diagram.glob()) {
spdlog::debug("Processing glob: {}", g);
const auto matches = glob::rglob(g);
std::copy(matches.begin(), matches.end(),

32
tests/CMakeLists.txt
View File

@@ -6,6 +6,7 @@ set(CMAKE_CXX_STANDARD 17)
file(GLOB_RECURSE TEST_CASE_SOURCES t*/*.cc)
file(GLOB_RECURSE TEST_CASE_CONFIGS t*/.clang-uml)
file(GLOB_RECURSE TEST_CONFIG_YMLS test_config_data/*.yml)
set(CLANG_UML_TEST_UTIL_SRC
test_util.cc
@@ -31,6 +32,14 @@ set(CLANG_UML_TEST_DECORATOR_PARSER_HEADER
catch.h
)
set(CLANG_UML_TEST_CONFIG_SRC
test_config.cc
${TEST_UTIL_SOURCES}
)
set(CLANG_UML_TEST_CONFIG_HEADER
catch.h
)
add_executable(test_util
${CLANG_UML_TEST_UTIL_SRC}
${CLANG_UML_TEST_UTIL_HEADER})
@@ -51,6 +60,16 @@ target_link_libraries(test_decorator_parser
${YAML_CPP_LIBRARIES}
spdlog::spdlog clang-umllib cppast)
add_executable(test_config
${CLANG_UML_TEST_CONFIG_SRC}
${CLANG_UML_TEST_CONFIG_HEADER})
target_link_libraries(test_config
PRIVATE
${LIBCLANG_LIBRARIES}
${YAML_CPP_LIBRARIES}
spdlog::spdlog clang-umllib cppast)
add_executable(test_cases
${CLANG_UML_TEST_CASES_SRC}
${CLANG_UML_TEST_CASES_HEADER})
@@ -73,6 +92,19 @@ foreach(TEST_CASE_CONFIG ${TEST_CASE_CONFIGS})
COPYONLY)
endforeach()
foreach(TEST_CONFIG_YML ${TEST_CONFIG_YMLS})
file(RELATIVE_PATH
TEST_CONFIG_YML_RELATIVE
${CMAKE_CURRENT_SOURCE_DIR}
${TEST_CONFIG_YML})
message(${TEST_CONFIG_YML_RELATIVE})
configure_file(
${TEST_CONFIG_YML_RELATIVE}
${TEST_CONFIG_YML_RELATIVE}
COPYONLY)
endforeach()
add_test(NAME test_util COMMAND test_util)
add_test(NAME test_decorator_parser COMMAND test_decorator_parser)
add_test(NAME test_config COMMAND test_config)
add_test(NAME test_cases COMMAND test_cases)

8
tests/t00002/test_case.h
View File

@@ -24,11 +24,11 @@ TEST_CASE("t00002", "[test-case][class]")
REQUIRE(diagram->name == "t00002_class");
REQUIRE(diagram->include.namespaces.size() == 1);
REQUIRE_THAT(diagram->include.namespaces,
REQUIRE(diagram->include().namespaces.size() == 1);
REQUIRE_THAT(diagram->include().namespaces,
VectorContains(std::string{"clanguml::t00002"}));
REQUIRE(diagram->exclude.namespaces.size() == 0);
REQUIRE(diagram->exclude().namespaces.size() == 0);
REQUIRE(diagram->should_include("clanguml::t00002::A"));
REQUIRE(!diagram->should_include("std::vector"));
@@ -56,5 +56,5 @@ TEST_CASE("t00002", "[test-case][class]")
REQUIRE_THAT(puml, IsAssociation(_A("D"), _A("A"), "-as"));
save_puml(
"./" + config.output_directory + "/" + diagram->name + ".puml", puml);
"./" + config.output_directory() + "/" + diagram->name + ".puml", puml);
}

8
tests/t00003/test_case.h
View File

@@ -24,11 +24,11 @@ TEST_CASE("t00003", "[test-case][class]")
REQUIRE(diagram->name == "t00003_class");
REQUIRE(diagram->include.namespaces.size() == 1);
REQUIRE_THAT(diagram->include.namespaces,
REQUIRE(diagram->include().namespaces.size() == 1);
REQUIRE_THAT(diagram->include().namespaces,
VectorContains(std::string{"clanguml::t00003"}));
REQUIRE(diagram->exclude.namespaces.size() == 0);
REQUIRE(diagram->exclude().namespaces.size() == 0);
REQUIRE(diagram->should_include("clanguml::t00003::A"));
@@ -64,5 +64,5 @@ TEST_CASE("t00003", "[test-case][class]")
REQUIRE_THAT(puml, (IsField<Private>("c", "int")));
save_puml(
"./" + config.output_directory + "/" + diagram->name + ".puml", puml);
"./" + config.output_directory() + "/" + diagram->name + ".puml", puml);
}

8
tests/t00004/test_case.h
View File

@@ -24,11 +24,11 @@ TEST_CASE("t00004", "[test-case][class]")
REQUIRE(diagram->name == "t00004_class");
REQUIRE(diagram->include.namespaces.size() == 1);
REQUIRE_THAT(diagram->include.namespaces,
REQUIRE(diagram->include().namespaces.size() == 1);
REQUIRE_THAT(diagram->include().namespaces,
VectorContains(std::string{"clanguml::t00004"}));
REQUIRE(diagram->exclude.namespaces.size() == 0);
REQUIRE(diagram->exclude().namespaces.size() == 0);
REQUIRE(diagram->should_include("clanguml::t00004::A"));
REQUIRE(diagram->should_include("clanguml::t00004::A::AA"));
@@ -54,5 +54,5 @@ TEST_CASE("t00004", "[test-case][class]")
REQUIRE_THAT(puml, (IsMethod<Public, Const>("foo2")));
save_puml(
"./" + config.output_directory + "/" + diagram->name + ".puml", puml);
"./" + config.output_directory() + "/" + diagram->name + ".puml", puml);
}

8
tests/t00005/test_case.h
View File

@@ -24,12 +24,6 @@ TEST_CASE("t00005", "[test-case][class]")
REQUIRE(diagram->name == "t00005_class");
REQUIRE(diagram->include.namespaces.size() == 1);
REQUIRE_THAT(diagram->include.namespaces,
VectorContains(std::string{"clanguml::t00005"}));
REQUIRE(diagram->exclude.namespaces.size() == 0);
REQUIRE(diagram->should_include("clanguml::t00005::A"));
REQUIRE(diagram->should_include("clanguml::t00005::B"));
REQUIRE(diagram->should_include("clanguml::t00005::C"));
@@ -74,5 +68,5 @@ TEST_CASE("t00005", "[test-case][class]")
REQUIRE_THAT(puml, IsAssociation(_A("R"), _A("K"), "+k"));
save_puml(
"./" + config.output_directory + "/" + diagram->name + ".puml", puml);
"./" + config.output_directory() + "/" + diagram->name + ".puml", puml);
}

8
tests/t00006/test_case.h
View File

@@ -24,12 +24,6 @@ TEST_CASE("t00006", "[test-case][class]")
REQUIRE(diagram->name == "t00006_class");
REQUIRE(diagram->include.namespaces.size() == 1);
REQUIRE_THAT(diagram->include.namespaces,
VectorContains(std::string{"clanguml::t00006"}));
REQUIRE(diagram->exclude.namespaces.size() == 0);
REQUIRE(diagram->should_include("clanguml::t00006::A"));
REQUIRE(diagram->should_include("clanguml::t00006::B"));
REQUIRE(diagram->should_include("clanguml::t00006::C"));
@@ -83,5 +77,5 @@ TEST_CASE("t00006", "[test-case][class]")
REQUIRE_THAT(puml, IsAggregation(_A("R"), _A("NNN"), "+ns"));
save_puml(
"./" + config.output_directory + "/" + diagram->name + ".puml", puml);
"./" + config.output_directory() + "/" + diagram->name + ".puml", puml);
}

8
tests/t00007/test_case.h
View File

@@ -24,12 +24,6 @@ TEST_CASE("t00007", "[test-case][class]")
REQUIRE(diagram->name == "t00007_class");
REQUIRE(diagram->include.namespaces.size() == 1);
REQUIRE_THAT(diagram->include.namespaces,
VectorContains(std::string{"clanguml::t00007"}));
REQUIRE(diagram->exclude.namespaces.size() == 0);
REQUIRE(diagram->should_include("clanguml::t00007::A"));
REQUIRE(diagram->should_include("clanguml::t00007::B"));
REQUIRE(diagram->should_include("clanguml::t00007::C"));
@@ -55,5 +49,5 @@ TEST_CASE("t00007", "[test-case][class]")
REQUIRE_THAT(puml, IsAssociation(_A("R"), _A("C"), "+c"));
save_puml(
"./" + config.output_directory + "/" + diagram->name + ".puml", puml);
"./" + config.output_directory() + "/" + diagram->name + ".puml", puml);
}

8
tests/t00008/test_case.h
View File

@@ -24,12 +24,6 @@ TEST_CASE("t00008", "[test-case][class]")
REQUIRE(diagram->name == "t00008_class");
REQUIRE(diagram->include.namespaces.size() == 1);
REQUIRE_THAT(diagram->include.namespaces,
VectorContains(std::string{"clanguml::t00008"}));
REQUIRE(diagram->exclude.namespaces.size() == 0);
REQUIRE(diagram->should_include("clanguml::t00008::A"));
REQUIRE(diagram->should_include("clanguml::t00008::B"));
@@ -58,5 +52,5 @@ TEST_CASE("t00008", "[test-case][class]")
REQUIRE_THAT(puml, (IsField<Public>("comparator", "CMP")));
save_puml(
"./" + config.output_directory + "/" + diagram->name + ".puml", puml);
"./" + config.output_directory() + "/" + diagram->name + ".puml", puml);
}

8
tests/t00009/test_case.h
View File

@@ -24,12 +24,6 @@ TEST_CASE("t00009", "[test-case][class]")
REQUIRE(diagram->name == "t00009_class");
REQUIRE(diagram->include.namespaces.size() == 1);
REQUIRE_THAT(diagram->include.namespaces,
VectorContains(std::string{"clanguml::t00009"}));
REQUIRE(diagram->exclude.namespaces.size() == 0);
REQUIRE(diagram->should_include("clanguml::t00009::A"));
REQUIRE(diagram->should_include("clanguml::t00009::B"));
@@ -61,5 +55,5 @@ TEST_CASE("t00009", "[test-case][class]")
IsAssociation(_A("B"), _A("A<std::vector<std::string>>"), "+avector"));
save_puml(
"./" + config.output_directory + "/" + diagram->name + ".puml", puml);
"./" + config.output_directory() + "/" + diagram->name + ".puml", puml);
}

8
tests/t00010/test_case.h
View File

@@ -24,12 +24,6 @@ TEST_CASE("t00010", "[test-case][class]")
REQUIRE(diagram->name == "t00010_class");
REQUIRE(diagram->include.namespaces.size() == 1);
REQUIRE_THAT(diagram->include.namespaces,
VectorContains(std::string{"clanguml::t00010"}));
REQUIRE(diagram->exclude.namespaces.size() == 0);
REQUIRE(diagram->should_include("clanguml::t00010::A"));
REQUIRE(diagram->should_include("clanguml::t00010::B"));
@@ -56,5 +50,5 @@ TEST_CASE("t00010", "[test-case][class]")
REQUIRE_THAT(puml, IsAggregation(_A("C"), _A("B<int>"), "+aintstring"));
save_puml(
"./" + config.output_directory + "/" + diagram->name + ".puml", puml);
"./" + config.output_directory() + "/" + diagram->name + ".puml", puml);
}

8
tests/t00011/test_case.h
View File

@@ -24,12 +24,6 @@ TEST_CASE("t00011", "[test-case][class]")
REQUIRE(diagram->name == "t00011_class");
REQUIRE(diagram->include.namespaces.size() == 1);
REQUIRE_THAT(diagram->include.namespaces,
VectorContains(std::string{"clanguml::t00011"}));
REQUIRE(diagram->exclude.namespaces.size() == 0);
REQUIRE(diagram->should_include("clanguml::t00011::A"));
REQUIRE(diagram->should_include("clanguml::t00011::B"));
@@ -50,5 +44,5 @@ TEST_CASE("t00011", "[test-case][class]")
// REQUIRE_THAT(puml, IsFriend(_A("A"), _A("D<T>")));
save_puml(
"./" + config.output_directory + "/" + diagram->name + ".puml", puml);
"./" + config.output_directory() + "/" + diagram->name + ".puml", puml);
}

8
tests/t00012/test_case.h
View File

@@ -24,12 +24,6 @@ TEST_CASE("t00012", "[test-case][class]")
REQUIRE(diagram->name == "t00012_class");
REQUIRE(diagram->include.namespaces.size() == 1);
REQUIRE_THAT(diagram->include.namespaces,
VectorContains(std::string{"clanguml::t00012"}));
REQUIRE(diagram->exclude.namespaces.size() == 0);
REQUIRE(diagram->should_include("clanguml::t00012::A"));
REQUIRE(diagram->should_include("clanguml::t00012::B"));
@@ -53,5 +47,5 @@ TEST_CASE("t00012", "[test-case][class]")
"std::vector<std::vector<std::vector<std::string>>>>,3,3,3>")));
save_puml(
"./" + config.output_directory + "/" + diagram->name + ".puml", puml);
"./" + config.output_directory() + "/" + diagram->name + ".puml", puml);
}

7
tests/t00013/test_case.h
View File

@@ -24,11 +24,6 @@ TEST_CASE("t00013", "[test-case][class]")
REQUIRE(diagram->name == "t00013_class");
REQUIRE_THAT(diagram->include.namespaces,
VectorContains(std::string{"clanguml::t00013"}));
REQUIRE(diagram->exclude.namespaces.size() == 0);
REQUIRE(diagram->should_include("clanguml::t00013::A"));
REQUIRE(diagram->should_include("clanguml::t00013::B"));
REQUIRE(diagram->should_include("ABCD::F"));
@@ -63,5 +58,5 @@ TEST_CASE("t00013", "[test-case][class]")
REQUIRE_THAT(puml, IsDependency(_A("R"), _A("F<int>")));
save_puml(
"./" + config.output_directory + "/" + diagram->name + ".puml", puml);
"./" + config.output_directory() + "/" + diagram->name + ".puml", puml);
}

7
tests/t00014/test_case.h
View File

@@ -24,11 +24,6 @@ TEST_CASE("t00014", "[test-case][class]")
REQUIRE(diagram->name == "t00014_class");
REQUIRE_THAT(diagram->include.namespaces,
VectorContains(std::string{"clanguml::t00014"}));
REQUIRE(diagram->exclude.namespaces.size() == 2);
REQUIRE(diagram->should_include("clanguml::t00014::S"));
auto model = generate_class_diagram(db, diagram);
@@ -58,5 +53,5 @@ TEST_CASE("t00014", "[test-case][class]")
REQUIRE_THAT(puml, IsAggregation(_A("R"), _A("B"), "+bs2"));
save_puml(
"./" + config.output_directory + "/" + diagram->name + ".puml", puml);
"./" + config.output_directory() + "/" + diagram->name + ".puml", puml);
}

8
tests/t00015/test_case.h
View File

@@ -24,12 +24,6 @@ TEST_CASE("t00015", "[test-case][class]")
REQUIRE(diagram->name == "t00015_class");
REQUIRE(diagram->include.namespaces.size() == 1);
REQUIRE_THAT(diagram->include.namespaces,
VectorContains(std::string{"clanguml::t00015"}));
REQUIRE(diagram->exclude.namespaces.size() == 0);
REQUIRE(diagram->should_include("clanguml::t00015::ns1::ns2::A"));
auto model = generate_class_diagram(db, diagram);
@@ -48,5 +42,5 @@ TEST_CASE("t00015", "[test-case][class]")
REQUIRE_THAT(puml, IsClass(_A("ns3::B")));
save_puml(
"./" + config.output_directory + "/" + diagram->name + ".puml", puml);
"./" + config.output_directory() + "/" + diagram->name + ".puml", puml);
}

8
tests/t00016/test_case.h
View File

@@ -24,12 +24,6 @@ TEST_CASE("t00016", "[test-case][class]")
REQUIRE(diagram->name == "t00016_class");
REQUIRE(diagram->include.namespaces.size() == 1);
REQUIRE_THAT(diagram->include.namespaces,
VectorContains(std::string{"clanguml::t00016"}));
REQUIRE(diagram->exclude.namespaces.size() == 0);
REQUIRE(diagram->should_include("clanguml::t00016::is_numeric"));
auto model = generate_class_diagram(db, diagram);
@@ -57,5 +51,5 @@ TEST_CASE("t00016", "[test-case][class]")
IsInstantiation(_A("is_numeric<>"), _A("is_numeric<unsigned char>")));
save_puml(
"./" + config.output_directory + "/" + diagram->name + ".puml", puml);
"./" + config.output_directory() + "/" + diagram->name + ".puml", puml);
}

8
tests/t00017/test_case.h
View File

@@ -24,12 +24,6 @@ TEST_CASE("t00017", "[test-case][class]")
REQUIRE(diagram->name == "t00017_class");
REQUIRE(diagram->include.namespaces.size() == 1);
REQUIRE_THAT(diagram->include.namespaces,
VectorContains(std::string{"clanguml::t00017"}));
REQUIRE(diagram->exclude.namespaces.size() == 0);
REQUIRE(diagram->should_include("clanguml::t00017::A"));
REQUIRE(diagram->should_include("clanguml::t00017::B"));
REQUIRE(diagram->should_include("clanguml::t00017::C"));
@@ -78,5 +72,5 @@ TEST_CASE("t00017", "[test-case][class]")
REQUIRE_THAT(puml, IsAssociation(_A("R"), _A("K"), "-k"));
save_puml(
"./" + config.output_directory + "/" + diagram->name + ".puml", puml);
"./" + config.output_directory() + "/" + diagram->name + ".puml", puml);
}

8
tests/t00018/test_case.h
View File

@@ -24,12 +24,6 @@ TEST_CASE("t00018", "[test-case][class]")
REQUIRE(diagram->name == "t00018_class");
REQUIRE(diagram->include.namespaces.size() == 1);
REQUIRE_THAT(diagram->include.namespaces,
VectorContains(std::string{"clanguml::t00018"}));
REQUIRE(diagram->exclude.namespaces.size() == 0);
REQUIRE(diagram->should_include("clanguml::t00018::widget"));
auto model = generate_class_diagram(db, diagram);
@@ -49,5 +43,5 @@ TEST_CASE("t00018", "[test-case][class]")
REQUIRE_THAT(puml, IsDependency(_A("impl::widget"), _A("widget")));
save_puml(
"./" + config.output_directory + "/" + diagram->name + ".puml", puml);
"./" + config.output_directory() + "/" + diagram->name + ".puml", puml);
}

8
tests/t00019/test_case.h
View File

@@ -24,12 +24,6 @@ TEST_CASE("t00019", "[test-case][class]")
REQUIRE(diagram->name == "t00019_class");
REQUIRE(diagram->include.namespaces.size() == 1);
REQUIRE_THAT(diagram->include.namespaces,
VectorContains(std::string{"clanguml::t00019"}));
REQUIRE(diagram->exclude.namespaces.size() == 0);
REQUIRE(diagram->should_include("clanguml::t00019::Layer1"));
REQUIRE(diagram->should_include("clanguml::t00019::Layer2"));
REQUIRE(diagram->should_include("clanguml::t00019::Layer3"));
@@ -56,5 +50,5 @@ TEST_CASE("t00019", "[test-case][class]")
_A("Layer2<Layer3<Base>>"), _A("Layer1<Layer2<Layer3<Base>>>")));
save_puml(
"./" + config.output_directory + "/" + diagram->name + ".puml", puml);
"./" + config.output_directory() + "/" + diagram->name + ".puml", puml);
}

8
tests/t00020/test_case.h
View File

@@ -24,12 +24,6 @@ TEST_CASE("t00020", "[test-case][class]")
REQUIRE(diagram->name == "t00020_class");
REQUIRE(diagram->include.namespaces.size() == 1);
REQUIRE_THAT(diagram->include.namespaces,
VectorContains(std::string{"clanguml::t00020"}));
REQUIRE(diagram->exclude.namespaces.size() == 0);
REQUIRE(diagram->should_include("clanguml::t00020::ProductA"));
auto model = generate_class_diagram(db, diagram);
@@ -52,5 +46,5 @@ TEST_CASE("t00020", "[test-case][class]")
REQUIRE_THAT(puml, IsClass(_A("Factory2")));
save_puml(
"./" + config.output_directory + "/" + diagram->name + ".puml", puml);
"./" + config.output_directory() + "/" + diagram->name + ".puml", puml);
}

8
tests/t00021/test_case.h
View File

@@ -24,12 +24,6 @@ TEST_CASE("t00021", "[test-case][class]")
REQUIRE(diagram->name == "t00021_class");
REQUIRE(diagram->include.namespaces.size() == 1);
REQUIRE_THAT(diagram->include.namespaces,
VectorContains(std::string{"clanguml::t00021"}));
REQUIRE(diagram->exclude.namespaces.size() == 0);
REQUIRE(diagram->should_include("clanguml::t00021::Visitor"));
auto model = generate_class_diagram(db, diagram);
@@ -50,5 +44,5 @@ TEST_CASE("t00021", "[test-case][class]")
REQUIRE_THAT(puml, IsClass(_A("Visitor3")));
save_puml(
"./" + config.output_directory + "/" + diagram->name + ".puml", puml);
"./" + config.output_directory() + "/" + diagram->name + ".puml", puml);
}

8
tests/t00022/test_case.h
View File

@@ -24,12 +24,6 @@ TEST_CASE("t00022", "[test-case][class]")
REQUIRE(diagram->name == "t00022_class");
REQUIRE(diagram->include.namespaces.size() == 1);
REQUIRE_THAT(diagram->include.namespaces,
VectorContains(std::string{"clanguml::t00022"}));
REQUIRE(diagram->exclude.namespaces.size() == 0);
REQUIRE(diagram->should_include("clanguml::t00022::A"));
auto model = generate_class_diagram(db, diagram);
@@ -46,5 +40,5 @@ TEST_CASE("t00022", "[test-case][class]")
REQUIRE_THAT(puml, IsClass(_A("A2")));
save_puml(
"./" + config.output_directory + "/" + diagram->name + ".puml", puml);
"./" + config.output_directory() + "/" + diagram->name + ".puml", puml);
}

8
tests/t00023/test_case.h
View File

@@ -24,12 +24,6 @@ TEST_CASE("t00023", "[test-case][class]")
REQUIRE(diagram->name == "t00023_class");
REQUIRE(diagram->include.namespaces.size() == 1);
REQUIRE_THAT(diagram->include.namespaces,
VectorContains(std::string{"clanguml::t00023"}));
REQUIRE(diagram->exclude.namespaces.size() == 0);
REQUIRE(diagram->should_include("clanguml::t00023::Visitor"));
auto model = generate_class_diagram(db, diagram);
@@ -46,5 +40,5 @@ TEST_CASE("t00023", "[test-case][class]")
REQUIRE_THAT(puml, IsClass(_A("StrategyB")));
save_puml(
"./" + config.output_directory + "/" + diagram->name + ".puml", puml);
"./" + config.output_directory() + "/" + diagram->name + ".puml", puml);
}

8
tests/t00024/test_case.h
View File

@@ -24,12 +24,6 @@ TEST_CASE("t00024", "[test-case][class]")
REQUIRE(diagram->name == "t00024_class");
REQUIRE(diagram->include.namespaces.size() == 1);
REQUIRE_THAT(diagram->include.namespaces,
VectorContains(std::string{"clanguml::t00024"}));
REQUIRE(diagram->exclude.namespaces.size() == 0);
REQUIRE(diagram->should_include("clanguml::t00024::A"));
auto model = generate_class_diagram(db, diagram);
@@ -50,5 +44,5 @@ TEST_CASE("t00024", "[test-case][class]")
REQUIRE_THAT(puml, IsBaseClass(_A("Target"), _A("Proxy")));
save_puml(
"./" + config.output_directory + "/" + diagram->name + ".puml", puml);
"./" + config.output_directory() + "/" + diagram->name + ".puml", puml);
}

8
tests/t00025/test_case.h
View File

@@ -24,12 +24,6 @@ TEST_CASE("t00025", "[test-case][class]")
REQUIRE(diagram->name == "t00025_class");
REQUIRE(diagram->include.namespaces.size() == 1);
REQUIRE_THAT(diagram->include.namespaces,
VectorContains(std::string{"clanguml::t00025"}));
REQUIRE(diagram->exclude.namespaces.size() == 0);
REQUIRE(diagram->should_include("clanguml::t00025::A"));
auto model = generate_class_diagram(db, diagram);
@@ -56,5 +50,5 @@ TEST_CASE("t00025", "[test-case][class]")
puml, !IsAggregation(_A("ProxyHolder"), _A("Target2"), "+proxy2"));
save_puml(
"./" + config.output_directory + "/" + diagram->name + ".puml", puml);
"./" + config.output_directory() + "/" + diagram->name + ".puml", puml);
}

8
tests/t00026/test_case.h
View File

@@ -24,12 +24,6 @@ TEST_CASE("t00026", "[test-case][class]")
REQUIRE(diagram->name == "t00026_class");
REQUIRE(diagram->include.namespaces.size() == 1);
REQUIRE_THAT(diagram->include.namespaces,
VectorContains(std::string{"clanguml::t00026"}));
REQUIRE(diagram->exclude.namespaces.size() == 0);
REQUIRE(diagram->should_include("clanguml::t00026::A"));
auto model = generate_class_diagram(db, diagram);
@@ -50,5 +44,5 @@ TEST_CASE("t00026", "[test-case][class]")
IsInstantiation(_A("Caretaker<T>"), _A("Caretaker<std::string>")));
save_puml(
"./" + config.output_directory + "/" + diagram->name + ".puml", puml);
"./" + config.output_directory() + "/" + diagram->name + ".puml", puml);
}

8
tests/t00027/test_case.h
View File

@@ -24,12 +24,6 @@ TEST_CASE("t00027", "[test-case][class]")
REQUIRE(diagram->name == "t00027_class");
REQUIRE(diagram->include.namespaces.size() == 1);
REQUIRE_THAT(diagram->include.namespaces,
VectorContains(std::string{"clanguml::t00027"}));
REQUIRE(diagram->exclude.namespaces.size() == 0);
REQUIRE(diagram->should_include("clanguml::t00027::A"));
auto model = generate_class_diagram(db, diagram);
@@ -62,5 +56,5 @@ TEST_CASE("t00027", "[test-case][class]")
puml, IsAggregation(_A("Window"), _A("Text<Color>"), "+description"));
save_puml(
"./" + config.output_directory + "/" + diagram->name + ".puml", puml);
"./" + config.output_directory() + "/" + diagram->name + ".puml", puml);
}

8
tests/t00028/test_case.h
View File

@@ -24,12 +24,6 @@ TEST_CASE("t00028", "[test-case][class]")
REQUIRE(diagram->name == "t00028_class");
REQUIRE(diagram->include.namespaces.size() == 1);
REQUIRE_THAT(diagram->include.namespaces,
VectorContains(std::string{"clanguml::t00028"}));
REQUIRE(diagram->exclude.namespaces.size() == 0);
REQUIRE(diagram->should_include("clanguml::t00028::A"));
auto model = generate_class_diagram(db, diagram);
@@ -63,5 +57,5 @@ note.)";
REQUIRE_THAT(puml, HasNote(_A("R"), "right", "R class note."));
save_puml(
"./" + config.output_directory + "/" + diagram->name + ".puml", puml);
"./" + config.output_directory() + "/" + diagram->name + ".puml", puml);
}

8
tests/t00029/test_case.h
View File

@@ -24,12 +24,6 @@ TEST_CASE("t00029", "[test-case][class]")
REQUIRE(diagram->name == "t00029_class");
REQUIRE(diagram->include.namespaces.size() == 1);
REQUIRE_THAT(diagram->include.namespaces,
VectorContains(std::string{"clanguml::t00029"}));
REQUIRE(diagram->exclude.namespaces.size() == 0);
REQUIRE(diagram->should_include("clanguml::t00029::A"));
auto model = generate_class_diagram(db, diagram);
@@ -61,5 +55,5 @@ TEST_CASE("t00029", "[test-case][class]")
REQUIRE_THAT(puml, IsAssociation(_A("R"), _A("G4"), "+g4"));
save_puml(
"./" + config.output_directory + "/" + diagram->name + ".puml", puml);
"./" + config.output_directory() + "/" + diagram->name + ".puml", puml);
}

8
tests/t00030/test_case.h
View File

@@ -24,12 +24,6 @@ TEST_CASE("t00030", "[test-case][class]")
REQUIRE(diagram->name == "t00030_class");
REQUIRE(diagram->include.namespaces.size() == 1);
REQUIRE_THAT(diagram->include.namespaces,
VectorContains(std::string{"clanguml::t00030"}));
REQUIRE(diagram->exclude.namespaces.size() == 0);
REQUIRE(diagram->should_include("clanguml::t00030::A"));
auto model = generate_class_diagram(db, diagram);
@@ -53,5 +47,5 @@ TEST_CASE("t00030", "[test-case][class]")
REQUIRE_THAT(puml, IsAssociation(_A("R"), _A("D"), "+ddd", "", "1"));
save_puml(
"./" + config.output_directory + "/" + diagram->name + ".puml", puml);
"./" + config.output_directory() + "/" + diagram->name + ".puml", puml);
}

8
tests/t00031/test_case.h
View File

@@ -24,12 +24,6 @@ TEST_CASE("t00031", "[test-case][class]")
REQUIRE(diagram->name == "t00031_class");
REQUIRE(diagram->include.namespaces.size() == 1);
REQUIRE_THAT(diagram->include.namespaces,
VectorContains(std::string{"clanguml::t00031"}));
REQUIRE(diagram->exclude.namespaces.size() == 0);
REQUIRE(diagram->should_include("clanguml::t00031::A"));
auto model = generate_class_diagram(db, diagram);
@@ -61,5 +55,5 @@ TEST_CASE("t00031", "[test-case][class]")
_A("R"), _A("D"), "+ddd", "#blue,plain,thickness=16"));
save_puml(
"./" + config.output_directory + "/" + diagram->name + ".puml", puml);
"./" + config.output_directory() + "/" + diagram->name + ".puml", puml);
}

8
tests/t00032/test_case.h
View File

@@ -24,12 +24,6 @@ TEST_CASE("t00032", "[test-case][class]")
REQUIRE(diagram->name == "t00032_class");
REQUIRE(diagram->include.namespaces.size() == 1);
REQUIRE_THAT(diagram->include.namespaces,
VectorContains(std::string{"clanguml::t00032"}));
REQUIRE(diagram->exclude.namespaces.size() == 0);
REQUIRE(diagram->should_include("clanguml::t00032::A"));
auto model = generate_class_diagram(db, diagram);
@@ -59,5 +53,5 @@ TEST_CASE("t00032", "[test-case][class]")
REQUIRE_THAT(puml, IsBaseClass(_A("C"), _A("Overload<TBase,int,A,B,C>")));
save_puml(
"./" + config.output_directory + "/" + diagram->name + ".puml", puml);
"./" + config.output_directory() + "/" + diagram->name + ".puml", puml);
}

8
tests/t00033/test_case.h
View File

@@ -24,12 +24,6 @@ TEST_CASE("t00033", "[test-case][class]")
REQUIRE(diagram->name == "t00033_class");
REQUIRE(diagram->include.namespaces.size() == 1);
REQUIRE_THAT(diagram->include.namespaces,
VectorContains(std::string{"clanguml::t00033"}));
REQUIRE(diagram->exclude.namespaces.size() == 0);
REQUIRE(diagram->should_include("clanguml::t00033::A"));
auto model = generate_class_diagram(db, diagram);
@@ -62,5 +56,5 @@ TEST_CASE("t00033", "[test-case][class]")
puml, IsInstantiation(_A("A<T>"), _A("A<B<std::unique_ptr<C<D>>>>")));
save_puml(
"./" + config.output_directory + "/" + diagram->name + ".puml", puml);
"./" + config.output_directory() + "/" + diagram->name + ".puml", puml);
}

8
tests/t00034/test_case.h
View File

@@ -24,12 +24,6 @@ TEST_CASE("t00034", "[test-case][class]")
REQUIRE(diagram->name == "t00034_class");
REQUIRE(diagram->include.namespaces.size() == 1);
REQUIRE_THAT(diagram->include.namespaces,
VectorContains(std::string{"clanguml::t00034"}));
REQUIRE(diagram->exclude.namespaces.size() == 0);
REQUIRE(diagram->should_include("clanguml::t00034::A"));
auto model = generate_class_diagram(db, diagram);
@@ -54,5 +48,5 @@ TEST_CASE("t00034", "[test-case][class]")
puml, IsInstantiation(_A("drop_void<T>"), _A("drop_void<Void>")));
save_puml(
"./" + config.output_directory + "/" + diagram->name + ".puml", puml);
"./" + config.output_directory() + "/" + diagram->name + ".puml", puml);
}

10
tests/t20001/test_case.h
View File

@@ -22,14 +22,6 @@ TEST_CASE("t20001", "[test-case][sequence]")
auto diagram = config.diagrams["t20001_sequence"];
REQUIRE(diagram->include.namespaces.size() == 1);
REQUIRE_THAT(diagram->include.namespaces,
VectorContains(std::string{"clanguml::t20001"}));
REQUIRE(diagram->exclude.namespaces.size() == 1);
REQUIRE_THAT(diagram->exclude.namespaces,
VectorContains(std::string{"clanguml::t20001::detail"}));
REQUIRE(diagram->should_include("clanguml::t20001::A"));
REQUIRE(!diagram->should_include("clanguml::t20001::detail::C"));
REQUIRE(!diagram->should_include("std::vector"));
@@ -52,5 +44,5 @@ TEST_CASE("t20001", "[test-case][sequence]")
REQUIRE_THAT(puml, !HasCall("A", "detail::C", "add"));
save_puml(
"./" + config.output_directory + "/" + diagram->name + ".puml", puml);
"./" + config.output_directory() + "/" + diagram->name + ".puml", puml);
}

6
tests/t20002/test_case.h
View File

@@ -22,10 +22,6 @@ TEST_CASE("t20002", "[test-case][sequence]")
auto diagram = config.diagrams["t20002_sequence"];
REQUIRE(diagram->include.namespaces.size() == 1);
REQUIRE_THAT(diagram->include.namespaces,
VectorContains(std::string{"clanguml::t20002"}));
REQUIRE(diagram->name == "t20002_sequence");
auto model = generate_sequence_diagram(db, diagram);
@@ -42,5 +38,5 @@ TEST_CASE("t20002", "[test-case][sequence]")
REQUIRE_THAT(puml, HasFunctionCall("m3", "m4"));
save_puml(
"./" + config.output_directory + "/" + diagram->name + ".puml", puml);
"./" + config.output_directory() + "/" + diagram->name + ".puml", puml);
}

10
tests/t30001/test_case.h
View File

@@ -22,14 +22,6 @@ TEST_CASE("t30001", "[test-case][package]")
auto diagram = config.diagrams["t30001_package"];
REQUIRE(diagram->include.namespaces.size() == 1);
REQUIRE_THAT(diagram->include.namespaces,
VectorContains(std::string{"clanguml::t30001"}));
REQUIRE(diagram->exclude.namespaces.size() == 1);
REQUIRE_THAT(diagram->exclude.namespaces,
VectorContains(std::string{"clanguml::t30001::detail"}));
REQUIRE(diagram->should_include("clanguml::t30001::A"));
REQUIRE(!diagram->should_include("clanguml::t30001::detail::C"));
REQUIRE(!diagram->should_include("std::vector"));
@@ -51,5 +43,5 @@ TEST_CASE("t30001", "[test-case][package]")
REQUIRE_THAT(puml, IsPackage("AAA"));
save_puml(
"./" + config.output_directory + "/" + diagram->name + ".puml", puml);
"./" + config.output_directory() + "/" + diagram->name + ".puml", puml);
}

10
tests/t30002/test_case.h
View File

@@ -22,14 +22,6 @@ TEST_CASE("t30002", "[test-case][package]")
auto diagram = config.diagrams["t30002_package"];
REQUIRE(diagram->include.namespaces.size() == 1);
REQUIRE_THAT(diagram->include.namespaces,
VectorContains(std::string{"clanguml::t30002"}));
REQUIRE(diagram->exclude.namespaces.size() == 1);
REQUIRE_THAT(diagram->exclude.namespaces,
VectorContains(std::string{"clanguml::t30002::detail"}));
REQUIRE(diagram->should_include("clanguml::t30002::A"));
REQUIRE(!diagram->should_include("clanguml::t30002::detail::C"));
REQUIRE(!diagram->should_include("std::vector"));
@@ -74,5 +66,5 @@ TEST_CASE("t30002", "[test-case][package]")
REQUIRE_THAT(puml, IsDependency(_A("BBB"), _A("A13")));
save_puml(
"./" + config.output_directory + "/" + diagram->name + ".puml", puml);
"./" + config.output_directory() + "/" + diagram->name + ".puml", puml);
}

6
tests/t30003/test_case.h
View File

@@ -22,10 +22,6 @@ TEST_CASE("t30003", "[test-case][package]")
auto diagram = config.diagrams["t30003_package"];
REQUIRE(diagram->include.namespaces.size() == 1);
REQUIRE_THAT(diagram->include.namespaces,
VectorContains(std::string{"clanguml::t30003"}));
REQUIRE(diagram->should_include("clanguml::t30003::A"));
REQUIRE(diagram->should_include("clanguml::t30003::C"));
REQUIRE(!diagram->should_include("std::vector"));
@@ -52,5 +48,5 @@ TEST_CASE("t30003", "[test-case][package]")
REQUIRE_THAT(puml, IsDeprecated(_A("ns3")));
save_puml(
"./" + config.output_directory + "/" + diagram->name + ".puml", puml);
"./" + config.output_directory() + "/" + diagram->name + ".puml", puml);
}

6
tests/t30004/test_case.h
View File

@@ -22,10 +22,6 @@ TEST_CASE("t30004", "[test-case][package]")
auto diagram = config.diagrams["t30004_package"];
REQUIRE(diagram->include.namespaces.size() == 1);
REQUIRE_THAT(diagram->include.namespaces,
VectorContains(std::string{"clanguml::t30004"}));
REQUIRE(diagram->should_include("clanguml::t30004::A"));
REQUIRE(diagram->should_include("clanguml::t30004::C"));
REQUIRE(!diagram->should_include("std::vector"));
@@ -49,5 +45,5 @@ TEST_CASE("t30004", "[test-case][package]")
REQUIRE_THAT(puml, IsPackage("EEE"));
save_puml(
"./" + config.output_directory + "/" + diagram->name + ".puml", puml);
"./" + config.output_directory() + "/" + diagram->name + ".puml", puml);
}

6
tests/t30005/test_case.h
View File

@@ -22,10 +22,6 @@ TEST_CASE("t30005", "[test-case][package]")
auto diagram = config.diagrams["t30005_package"];
REQUIRE(diagram->include.namespaces.size() == 1);
REQUIRE_THAT(diagram->include.namespaces,
VectorContains(std::string{"clanguml::t30005"}));
REQUIRE(diagram->should_include("clanguml::t30005::A"));
REQUIRE(diagram->should_include("clanguml::t30005::C"));
REQUIRE(!diagram->should_include("std::vector"));
@@ -50,5 +46,5 @@ TEST_CASE("t30005", "[test-case][package]")
REQUIRE_THAT(puml, IsDependency(_A("CCC"), _A("AAA")));
save_puml(
"./" + config.output_directory + "/" + diagram->name + ".puml", puml);
"./" + config.output_directory() + "/" + diagram->name + ".puml", puml);
}

6
tests/t30006/test_case.h
View File

@@ -22,10 +22,6 @@ TEST_CASE("t30006", "[test-case][package]")
auto diagram = config.diagrams["t30006_package"];
REQUIRE(diagram->include.namespaces.size() == 1);
REQUIRE_THAT(diagram->include.namespaces,
VectorContains(std::string{"clanguml::t30006"}));
REQUIRE(diagram->should_include("clanguml::t30006::A"));
REQUIRE(diagram->should_include("clanguml::t30006::C"));
REQUIRE(!diagram->should_include("std::vector"));
@@ -50,5 +46,5 @@ TEST_CASE("t30006", "[test-case][package]")
REQUIRE_THAT(puml, IsDependency(_A("A"), _A("C")));
save_puml(
"./" + config.output_directory + "/" + diagram->name + ".puml", puml);
"./" + config.output_directory() + "/" + diagram->name + ".puml", puml);
}

2
tests/t90000/test_case.h
View File

@@ -36,5 +36,5 @@ TEST_CASE("t90000", "[test-case][config]")
REQUIRE_THAT(puml, IsClass(_A("Boo")));
save_puml(
"./" + config.output_directory + "/" + diagram->name + ".puml", puml);
"./" + config.output_directory() + "/" + diagram->name + ".puml", puml);
}

4
tests/test_cases.cc
View File

@@ -24,7 +24,7 @@ load_config(const std::string &test_name)
{
auto config = clanguml::config::load(test_name + "/.clang-uml");
cppast::libclang_compilation_database db(config.compilation_database_dir);
cppast::libclang_compilation_database db(config.compilation_database_dir());
return std::make_pair(std::move(config), std::move(db));
}
@@ -35,7 +35,7 @@ std::pair<clanguml::config::config, compilation_database> load_config2(
auto config = clanguml::config::load(test_name + "/.clang-uml");
auto db = clanguml::cx::compilation_database::from_directory(
config.compilation_database_dir);
config.compilation_database_dir());
return std::make_pair(std::move(config), std::move(db));
}

54
tests/test_config.cc Normal file
View File

@@ -0,0 +1,54 @@
/**
* tests/test_config.cc
*
* Copyright (c) 2021-2022 Bartek Kryza <bkryza@gmail.com>
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#define CATCH_CONFIG_MAIN
#include "catch.h"
#include "config/config.h"
#include "util/util.h"
TEST_CASE("Test config simple", "[unit-test]")
{
auto cfg = clanguml::config::load("./test_config_data/simple.yml");
CHECK(cfg.diagrams.size() == 1);
auto &diagram = *cfg.diagrams["class_main"];
CHECK(diagram.type() == clanguml::config::diagram_type::class_diagram);
CHECK(diagram.glob().size() == 2);
CHECK(clanguml::util::contains(diagram.using_namespace(), "clanguml"));
}
TEST_CASE("Test config inherited", "[unit-test]")
{
auto cfg = clanguml::config::load("./test_config_data/inherited.yml");
CHECK(cfg.diagrams.size() == 2);
auto &def = *cfg.diagrams["class_default"];
CHECK(def.type() == clanguml::config::diagram_type::class_diagram);
CHECK(def.glob().size() == 2);
CHECK(def.glob()[0] == "src/**/*.cc");
CHECK(def.glob()[1] == "src/**/*.h");
CHECK(clanguml::util::contains(def.using_namespace(), "clanguml"));
auto &cus = *cfg.diagrams["class_custom"];
CHECK(cus.type() == clanguml::config::diagram_type::class_diagram);
CHECK(cus.glob().size() == 1);
CHECK(cus.glob()[0] == "src/main.cc");
CHECK(clanguml::util::contains(cus.using_namespace(), "clanguml::ns1"));
CHECK(cus.include_relations_also_as_members());
}

24
tests/test_config_data/inherited.yml Normal file
View File

@@ -0,0 +1,24 @@
compilation_database_dir: debug
output_directory: output
include_relations_also_as_members: false
using_namespace:
- clanguml
include:
namespaces:
- clanguml
- ABCD
glob:
- src/**/*.cc
- src/**/*.h
diagrams:
class_default:
type: class
class_custom:
type: class
using_namespace:
- clanguml::ns1
include_relations_also_as_members: true
glob:
- src/main.cc

14
tests/test_config_data/simple.yml Normal file
View File

@@ -0,0 +1,14 @@
compilation_database_dir: debug
output_directory: output
diagrams:
class_main:
type: class
glob:
- src/**/*.cc
- src/**/*.h
using_namespace:
- clanguml
include:
namespaces:
- clanguml
- ABCD