Added custom catch matchers for test cases

tests/t00002/test_case.h

@@ -43,10 +43,16 @@ TEST_CASE("Test t00002", "[unit-test]")
 
     REQUIRE_THAT(puml, StartsWith("@startuml"));
     REQUIRE_THAT(puml, EndsWith("@enduml\n"));
-    REQUIRE_THAT(puml, Contains("abstract A"));
-    REQUIRE_THAT(puml, Contains("class B"));
-    REQUIRE_THAT(puml, Contains("class C"));
-    REQUIRE_THAT(puml, Contains("class D"));
+    REQUIRE_THAT(puml, IsAbstractClass("A"));
+    REQUIRE_THAT(puml, IsClass("B"));
+    REQUIRE_THAT(puml, IsClass("C"));
+    REQUIRE_THAT(puml, IsClass("D"));
+    REQUIRE_THAT(puml, IsBaseClass("A", "B"));
+    REQUIRE_THAT(puml, IsBaseClass("A", "C"));
+    REQUIRE_THAT(puml, IsBaseClass("B", "D"));
+    REQUIRE_THAT(puml, IsBaseClass("C", "D"));
+    REQUIRE_THAT(puml, IsMethod(Abstract(Public("foo_a"))));
+    REQUIRE_THAT(puml, IsMethod(Abstract(Public("foo_c"))));
 
     save_puml(
         "./" + config.output_directory + "/" + diagram->name + ".puml", puml);

tests/t00003/test_case.h

@@ -44,21 +44,21 @@ TEST_CASE("Test t00003", "[unit-test]")
     REQUIRE_THAT(puml, EndsWith("@enduml\n"));
     REQUIRE_THAT(puml, Contains("class A"));
 
-    REQUIRE_THAT(puml, Contains("+ A() = default"));
-    REQUIRE_THAT(puml, Contains("+ A() = default"));
-    REQUIRE_THAT(puml, Contains("+ A() = default"));
-    REQUIRE_THAT(puml, Contains("+ ~A() = default"));
-    REQUIRE_THAT(puml, Contains("+ basic_method()"));
-    REQUIRE_THAT(puml, Contains("{static} +int static_method()"));
-    REQUIRE_THAT(puml, Contains("+ const_method() const"));
-    REQUIRE_THAT(puml, Contains("# protected_method()"));
-    REQUIRE_THAT(puml, Contains("- private_method()"));
-    REQUIRE_THAT(puml, Contains("+int public_member"));
-    REQUIRE_THAT(puml, Contains("#int protected_member"));
-    REQUIRE_THAT(puml, Contains("-int private_member"));
-    REQUIRE_THAT(puml, Contains("-int a"));
-    REQUIRE_THAT(puml, Contains("-int b"));
-    REQUIRE_THAT(puml, Contains("-int c"));
+    REQUIRE_THAT(puml, IsMethod(Default(Public("A"))));
+    REQUIRE_THAT(puml, IsMethod(Default(Public("~A"))));
+
+    REQUIRE_THAT(puml, IsMethod(Public("basic_method")));
+    REQUIRE_THAT(puml, IsMethod(Static(Public("int static_method"))));
+    REQUIRE_THAT(puml, IsMethod(Const(Public("const_method"))));
+    REQUIRE_THAT(puml, IsMethod(Protected("protected_method")));
+    REQUIRE_THAT(puml, IsMethod(Private("private_method")));
+    REQUIRE_THAT(puml, IsField(Public("int public_member")));
+    REQUIRE_THAT(puml, IsField(Protected("int protected_member")));
+    REQUIRE_THAT(puml, IsField(Private("int private_member")));
+
+    REQUIRE_THAT(puml, IsField(Private("int a")));
+    REQUIRE_THAT(puml, IsField(Private("int b")));
+    REQUIRE_THAT(puml, IsField(Private("int c")));
 
     save_puml(
         "./" + config.output_directory + "/" + diagram->name + ".puml", puml);

tests/t00004/test_case.h

@@ -44,12 +44,15 @@ TEST_CASE("Test t00004", "[unit-test]")
 
     REQUIRE_THAT(puml, StartsWith("@startuml"));
     REQUIRE_THAT(puml, EndsWith("@enduml\n"));
-    REQUIRE_THAT(puml, Contains("class A"));
-    REQUIRE_THAT(puml, Contains("A +-- AA"));
-    REQUIRE_THAT(puml, Contains("AA +-- AAA"));
-    REQUIRE_THAT(puml, Contains("AA +-- Lights"));
-    REQUIRE_THAT(puml, Contains("+ foo() const"));
-    REQUIRE_THAT(puml, Contains("+ foo2() const"));
+    REQUIRE_THAT(puml, IsClass("A"));
+    REQUIRE_THAT(puml, IsClass("AA"));
+    REQUIRE_THAT(puml, IsClass("AAA"));
+    REQUIRE_THAT(puml, IsEnum("Lights"));
+    REQUIRE_THAT(puml, IsInnerClass("A", "AA"));
+    REQUIRE_THAT(puml, IsInnerClass("AA", "AAA"));
+    REQUIRE_THAT(puml, IsInnerClass("AA", "Lights"));
+    REQUIRE_THAT(puml, IsMethod(Const(Public("foo"))));
+    REQUIRE_THAT(puml, IsMethod(Const(Public("foo2"))));
 
     save_puml(
         "./" + config.output_directory + "/" + diagram->name + ".puml", puml);

tests/test_cases.cc

@@ -84,14 +84,25 @@ void save_puml(const std::string &path, const std::string &puml)
 {
     std::filesystem::path p{path};
     std::filesystem::create_directory(p.parent_path());
-    spdlog::error("PWD: {}", std::filesystem::current_path().string());
-    spdlog::error("SAVING TEST PWD {} DIAGRAM: {}", p.string());
     std::ofstream ofs;
     ofs.open(p, std::ofstream::out | std::ofstream::trunc);
     ofs << puml;
     ofs.close();
 }
 
+using clanguml::test::matchers::Abstract;
+using clanguml::test::matchers::Const;
+using clanguml::test::matchers::Default;
+using clanguml::test::matchers::IsAbstractClass;
+using clanguml::test::matchers::IsBaseClass;
+using clanguml::test::matchers::IsClass;
+using clanguml::test::matchers::IsEnum;
+using clanguml::test::matchers::IsInnerClass;
+using clanguml::test::matchers::Private;
+using clanguml::test::matchers::Protected;
+using clanguml::test::matchers::Public;
+using clanguml::test::matchers::Static;
+
 #include "t00001/test_case.h"
 #include "t00002/test_case.h"
 #include "t00003/test_case.h"

tests/test_cases.h

@@ -57,3 +57,135 @@ std::string generate_class_puml(
     clanguml::model::class_diagram::diagram &model);
 
 void save_puml(const std::string &path, const std::string &puml);
+
+namespace clanguml {
+namespace test {
+namespace matchers {
+
+using Catch::CaseSensitive;
+using Catch::Matchers::StdString::CasedString;
+using Catch::Matchers::StdString::ContainsMatcher;
+
+struct Public {
+    Public(std::string const &method)
+        : m_method{method}
+    {
+    }
+
+    operator std::string() const { return "+" + m_method; }
+
+    std::string m_method;
+};
+
+struct Protected {
+    Protected(std::string const &method)
+        : m_method{method}
+    {
+    }
+
+    operator std::string() const { return "#" + m_method; }
+
+    std::string m_method;
+};
+
+struct Private {
+    Private(std::string const &method)
+        : m_method{method}
+    {
+    }
+
+    operator std::string() const { return "-" + m_method; }
+
+    std::string m_method;
+};
+
+struct Abstract {
+    Abstract(std::string const &method)
+        : m_method{method}
+    {
+    }
+
+    operator std::string() const { return "{abstract} " + m_method; }
+
+    std::string m_method;
+};
+
+struct Static {
+    Static(std::string const &method)
+        : m_method{method}
+    {
+    }
+
+    operator std::string() const { return "{static} " + m_method; }
+
+    std::string m_method;
+};
+
+struct Const {
+    Const(std::string const &method)
+        : m_method{method}
+    {
+    }
+
+    operator std::string() const { return m_method; }
+
+    std::string m_method;
+};
+
+struct Default {
+    Default(std::string const &method)
+        : m_method{method}
+    {
+    }
+
+    operator std::string() const { return m_method; }
+
+    std::string m_method;
+};
+
+ContainsMatcher IsClass(std::string const &str,
+    CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes)
+{
+    return ContainsMatcher(CasedString("class " + str, caseSensitivity));
+}
+
+ContainsMatcher IsEnum(std::string const &str,
+    CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes)
+{
+    return ContainsMatcher(CasedString("enum " + str, caseSensitivity));
+}
+
+ContainsMatcher IsAbstractClass(std::string const &str,
+    CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes)
+{
+    return ContainsMatcher(CasedString("abstract " + str, caseSensitivity));
+}
+
+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,
+    std::string const &inner,
+    CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes)
+{
+    return ContainsMatcher(
+        CasedString(parent + " +-- " + inner, caseSensitivity));
+}
+
+ContainsMatcher IsMethod(std::string const &name,
+    CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes)
+{
+    return ContainsMatcher(CasedString(name + "()", caseSensitivity));
+}
+
+ContainsMatcher IsField(std::string const &name,
+    CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes)
+{
+    return ContainsMatcher(CasedString(name, caseSensitivity));
+}
+}
+}
+}