diff --git a/src/puml/class_diagram_generator.h b/src/puml/class_diagram_generator.h
index 94a7fbfb..69251c20 100644
--- a/src/puml/class_diagram_generator.h
+++ b/src/puml/class_diagram_generator.h
@@ -153,12 +153,9 @@ public:
             if (m.is_static)
                 ostr << "{static} ";
 
-            std::string type{};
-            if (m.type != "void")
-                type = m.type + " ";
+            std::string type{m.type};
 
-            ostr << to_string(m.scope)
-                 << ns_relative(m_config.using_namespace, type) << m.name;
+            ostr << to_string(m.scope) << m.name;
 
             ostr << "(";
             if (true) { // TODO: add option to disable parameter generation
@@ -182,6 +179,8 @@ public:
             if (m.is_defaulted)
                 ostr << " = default";
 
+            ostr << " : " << ns_relative(m_config.using_namespace, type);
+
             ostr << std::endl;
         }
 
@@ -192,9 +191,8 @@ public:
             if (m.is_static)
                 ostr << "{static} ";
 
-            ostr << to_string(m.scope)
-                 << ns_relative(m_config.using_namespace, m.type) << " "
-                 << m.name << std::endl;
+            ostr << to_string(m.scope) << m.name << " : "
+                 << ns_relative(m_config.using_namespace, m.type) << std::endl;
         }
 
         ostr << "}" << std::endl;
@@ -356,31 +354,6 @@ clanguml::model::class_diagram::diagram generate(
     for (auto &file : parser.files())
         ctx(file);
 
-    /*
-    for (const auto &tu_path : translation_units) {
-        spdlog::debug("Processing translation unit: {}",
-            std::filesystem::canonical(tu_path).c_str());
-
-        auto cursor = clang_getTranslationUnitCursor(tu);
-
-        if (clang_Cursor_isNull(cursor)) {
-            spdlog::debug("CURSOR IS NULL");
-        }
-
-        spdlog::debug("Cursor kind: {}",
-            clang_getCString(clang_getCursorKindSpelling(cursor.kind)));
-        spdlog::debug("Cursor name: {}",
-            clang_getCString(clang_getCursorDisplayName(cursor)));
-
-        clanguml::visitor::class_diagram::tu_context ctx(d, diagram);
-        auto res = clang_visitChildren(cursor,
-            clanguml::visitor::class_diagram::translation_unit_visitor, &ctx);
-        spdlog::debug("Processing result: {}", res);
-
-        clang_suspendTranslationUnit(tu);
-    }
-    */
-
     return d;
 }
 }
diff --git a/tests/t00002/test_case.h b/tests/t00002/test_case.h
index 6e5eb07f..b2c637f5 100644
--- a/tests/t00002/test_case.h
+++ b/tests/t00002/test_case.h
@@ -50,8 +50,8 @@ TEST_CASE("t00002", "[test-case][class]")
     REQUIRE_THAT(puml, IsBaseClass(_A("A"), _A("C")));
     REQUIRE_THAT(puml, IsBaseClass(_A("B"), _A("D")));
     REQUIRE_THAT(puml, IsBaseClass(_A("C"), _A("D")));
-    REQUIRE_THAT(puml, IsMethod(Abstract(Public("foo_a"))));
-    REQUIRE_THAT(puml, IsMethod(Abstract(Public("foo_c"))));
+    REQUIRE_THAT(puml, (IsMethod<Public, Abstract>("foo_a")));
+    REQUIRE_THAT(puml, (IsMethod<Public, Abstract>("foo_c")));
 
     REQUIRE_THAT(puml, IsAssociation(_A("D"), _A("A"), "as"));
 
diff --git a/tests/t00003/test_case.h b/tests/t00003/test_case.h
index c0251992..d8c04d41 100644
--- a/tests/t00003/test_case.h
+++ b/tests/t00003/test_case.h
@@ -45,23 +45,23 @@ TEST_CASE("t00003", "[test-case][class]")
 
     REQUIRE_THAT(puml, !IsDependency(_A("A"), _A("A")));
 
-    REQUIRE_THAT(puml, IsMethod(Default(Public("A"))));
-    REQUIRE_THAT(puml, IsMethod(Default(Public("~A"))));
+    REQUIRE_THAT(puml, (IsMethod<Public, Default>("A")));
+    REQUIRE_THAT(puml, (IsMethod<Public, Default>("~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, (IsMethod<Public>("basic_method")));
+    REQUIRE_THAT(puml, (IsMethod<Public, Static>("static_method", "int")));
+    REQUIRE_THAT(puml, (IsMethod<Public, Const>("const_method")));
+    REQUIRE_THAT(puml, (IsMethod<Protected>("protected_method")));
+    REQUIRE_THAT(puml, (IsMethod<Private>("private_method")));
+    REQUIRE_THAT(puml, (IsField<Public>("public_member", "int")));
+    REQUIRE_THAT(puml, (IsField<Protected>("protected_member", "int")));
+    REQUIRE_THAT(puml, (IsField<Private>("private_member", "int")));
     REQUIRE_THAT(
-        puml, IsField(Static(Public("unsigned long const auto_member"))));
+        puml, (IsField<Public, Static>("auto_member", "unsigned long const")));
 
-    REQUIRE_THAT(puml, IsField(Private("int a")));
-    REQUIRE_THAT(puml, IsField(Private("int b")));
-    REQUIRE_THAT(puml, IsField(Private("int c")));
+    REQUIRE_THAT(puml, (IsField<Private>("a", "int")));
+    REQUIRE_THAT(puml, (IsField<Private>("b", "int")));
+    REQUIRE_THAT(puml, (IsField<Private>("c", "int")));
 
     save_puml(
         "./" + config.output_directory + "/" + diagram->name + ".puml", puml);
diff --git a/tests/t00004/test_case.h b/tests/t00004/test_case.h
index 0764aed8..399ea1be 100644
--- a/tests/t00004/test_case.h
+++ b/tests/t00004/test_case.h
@@ -50,8 +50,8 @@ TEST_CASE("t00004", "[test-case][class]")
     REQUIRE_THAT(puml, IsInnerClass(_A("A"), _A("AA")));
     REQUIRE_THAT(puml, IsInnerClass(_A("AA"), _A("AAA")));
     REQUIRE_THAT(puml, IsInnerClass(_A("AA"), "Lights"));
-    REQUIRE_THAT(puml, IsMethod(Const(Public("foo"))));
-    REQUIRE_THAT(puml, IsMethod(Const(Public("foo2"))));
+    REQUIRE_THAT(puml, (IsMethod<Public, Const>("foo")));
+    REQUIRE_THAT(puml, (IsMethod<Public, Const>("foo2")));
 
     save_puml(
         "./" + config.output_directory + "/" + diagram->name + ".puml", puml);
diff --git a/tests/t00005/test_case.h b/tests/t00005/test_case.h
index b13883aa..f8bfc865 100644
--- a/tests/t00005/test_case.h
+++ b/tests/t00005/test_case.h
@@ -57,9 +57,9 @@ TEST_CASE("t00005", "[test-case][class]")
     REQUIRE_THAT(puml, IsClass(_A("K")));
     REQUIRE_THAT(puml, IsClass(_A("R")));
 
-    REQUIRE_THAT(puml, IsField(Public("int some_int")));
-    REQUIRE_THAT(puml, IsField(Public("int* some_int_pointer")));
-    REQUIRE_THAT(puml, IsField(Public("int** some_int_pointer_pointer")));
+    REQUIRE_THAT(puml, (IsField<Public>("some_int", "int")));
+    REQUIRE_THAT(puml, (IsField<Public>("some_int_pointer", "int*")));
+    REQUIRE_THAT(puml, (IsField<Public>("some_int_pointer_pointer", "int**")));
 
     REQUIRE_THAT(puml, IsComposition(_A("R"), _A("A"), "a"));
     REQUIRE_THAT(puml, IsAssociation(_A("R"), _A("B"), "b"));
diff --git a/tests/t00008/test_case.h b/tests/t00008/test_case.h
index c7d876e1..d474b2af 100644
--- a/tests/t00008/test_case.h
+++ b/tests/t00008/test_case.h
@@ -48,14 +48,14 @@ TEST_CASE("t00008", "[test-case][class]")
     REQUIRE_THAT(puml, IsClassTemplate("A", "T,P,CMP,int N"));
     REQUIRE_THAT(puml, IsClassTemplate("B", "T,C<>"));
 
-    REQUIRE_THAT(puml, IsField(Public("T value")));
-    REQUIRE_THAT(puml, IsField(Public("T* pointer")));
-    REQUIRE_THAT(puml, IsField(Public("T& reference")));
-    REQUIRE_THAT(puml, IsField(Public("std::vector<P> values")));
-    REQUIRE_THAT(puml, IsField(Public("std::array<int,N> ints")));
+    REQUIRE_THAT(puml, (IsField<Public>("value", "T")));
+    REQUIRE_THAT(puml, (IsField<Public>("pointer", "T*")));
+    REQUIRE_THAT(puml, (IsField<Public>("reference", "T&")));
+    REQUIRE_THAT(puml, (IsField<Public>("values", "std::vector<P>")));
+    REQUIRE_THAT(puml, (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(puml, IsField(Public("CMP comparator")));
+    REQUIRE_THAT(puml, (IsField<Public>("comparator", "CMP")));
 
     save_puml(
         "./" + config.output_directory + "/" + diagram->name + ".puml", puml);
diff --git a/tests/t00009/test_case.h b/tests/t00009/test_case.h
index c5014cae..22d67ed0 100644
--- a/tests/t00009/test_case.h
+++ b/tests/t00009/test_case.h
@@ -45,10 +45,11 @@ TEST_CASE("t00009", "[test-case][class]")
     REQUIRE_THAT(puml, IsClassTemplate("A", "T"));
     REQUIRE_THAT(puml, IsClass(_A("B")));
 
-    REQUIRE_THAT(puml, IsField(Public("T value")));
-    REQUIRE_THAT(puml, IsField(Public("A<int> aint")));
-    REQUIRE_THAT(puml, IsField(Public("A<std::string>* astring")));
-    REQUIRE_THAT(puml, IsField(Public("A<std::vector<std::string>>& avector")));
+    REQUIRE_THAT(puml, (IsField<Public>("value", "T")));
+    REQUIRE_THAT(puml, (IsField<Public>("aint", "A<int>")));
+    REQUIRE_THAT(puml, (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>")));
diff --git a/tests/t00010/test_case.h b/tests/t00010/test_case.h
index ab249609..e699e378 100644
--- a/tests/t00010/test_case.h
+++ b/tests/t00010/test_case.h
@@ -45,8 +45,8 @@ TEST_CASE("t00010", "[test-case][class]")
     REQUIRE_THAT(puml, IsClassTemplate("A", "T,P"));
     REQUIRE_THAT(puml, IsClassTemplate("B", "T"));
 
-    REQUIRE_THAT(puml, IsField(Public("A<T,std::string> astring")));
-    REQUIRE_THAT(puml, IsField(Public("B<int> aintstring")));
+    REQUIRE_THAT(puml, (IsField<Public>("astring", "A<T,std::string>")));
+    REQUIRE_THAT(puml, (IsField<Public>("aintstring", "B<int>")));
 
     REQUIRE_THAT(puml, IsInstantiation(_A("A<T,P>"), _A("A<T,std::string>")));
     REQUIRE_THAT(puml, IsInstantiation(_A("B<T>"), _A("B<int>")));
diff --git a/tests/test_cases.cc b/tests/test_cases.cc
index ff3317d4..c39f2f71 100644
--- a/tests/test_cases.cc
+++ b/tests/test_cases.cc
@@ -100,29 +100,7 @@ void save_puml(const std::string &path, const std::string &puml)
     ofs.close();
 }
 
-using clanguml::test::matchers::Abstract;
-using clanguml::test::matchers::AliasMatcher;
-using clanguml::test::matchers::Const;
-using clanguml::test::matchers::Default;
-using clanguml::test::matchers::HasCall;
-using clanguml::test::matchers::HasCallWithResponse;
-using clanguml::test::matchers::IsAbstractClass;
-using clanguml::test::matchers::IsAggregation;
-using clanguml::test::matchers::IsAssociation;
-using clanguml::test::matchers::IsBaseClass;
-using clanguml::test::matchers::IsClass;
-using clanguml::test::matchers::IsClassTemplate;
-using clanguml::test::matchers::IsComposition;
-using clanguml::test::matchers::IsDependency;
-using clanguml::test::matchers::IsEnum;
-using clanguml::test::matchers::IsField;
-using clanguml::test::matchers::IsFriend;
-using clanguml::test::matchers::IsInnerClass;
-using clanguml::test::matchers::IsInstantiation;
-using clanguml::test::matchers::Private;
-using clanguml::test::matchers::Protected;
-using clanguml::test::matchers::Public;
-using clanguml::test::matchers::Static;
+using namespace clanguml::test::matchers;
 
 //
 // Class diagram tests
diff --git a/tests/test_cases.h b/tests/test_cases.h
index acf87f62..610d1178 100644
--- a/tests/test_cases.h
+++ b/tests/test_cases.h
@@ -74,81 +74,30 @@ using Catch::CaseSensitive;
 using Catch::Matchers::StdString::CasedString;
 using Catch::Matchers::StdString::ContainsMatcher;
 
+template <typename T, typename... Ts> constexpr bool has_type() noexcept
+{
+    return (std::is_same_v<T, Ts> || ... || false);
+}
+
 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;
 };
 
 struct HasCallWithResultMatcher : ContainsMatcher {
@@ -313,16 +262,60 @@ ContainsMatcher IsDependency(std::string const &from, std::string const &to,
         CasedString(fmt::format("{} ..> {}", from, to), caseSensitivity));
 }
 
+template <typename... Ts>
 ContainsMatcher IsMethod(std::string const &name,
+    std::string const &type = "void",
     CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes)
 {
-    return ContainsMatcher(CasedString(name + "()", caseSensitivity));
+    std::string pattern;
+    if constexpr (has_type<Static, Ts...>())
+        pattern += "{static} ";
+
+    if constexpr (has_type<Abstract, Ts...>())
+        pattern += "{abstract} ";
+
+    if constexpr (has_type<Public, Ts...>())
+        pattern = "+";
+    else if constexpr (has_type<Protected, Ts...>())
+        pattern = "#";
+    else
+        pattern = "-";
+
+    pattern += name;
+
+    pattern += "()";
+
+    if constexpr (has_type<Const, Ts...>())
+        pattern += " const";
+
+    if constexpr (has_type<Abstract, Ts...>())
+        pattern += " = 0";
+
+    pattern += " : " + type;
+
+    return ContainsMatcher(CasedString(pattern, caseSensitivity));
 }
 
+template <typename... Ts>
 ContainsMatcher IsField(std::string const &name,
+    std::string const &type = "void",
     CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes)
 {
-    return ContainsMatcher(CasedString(name, caseSensitivity));
+    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;
+
+    return ContainsMatcher(
+        CasedString(pattern + " : " + type, caseSensitivity));
 }
 }
 }