diff --git a/Makefile b/Makefile
index f429b8a7..8135a982 100644
--- a/Makefile
+++ b/Makefile
@@ -114,11 +114,11 @@ init_compile_commands: debug
 
 .PHONY: clang-format
 clang-format:
-	docker run --rm -v $(CURDIR):/root/sources bkryza/clang-format-check:1.3
+	docker run --rm -v $(CURDIR):/root/sources bkryza/clang-format-check:1.4
 
 .PHONY: format
 format:
-	docker run --rm -v $(CURDIR):/root/sources bkryza/clang-format-check:1.3
+	docker run --rm -v $(CURDIR):/root/sources bkryza/clang-format-check:1.4
 
 .PHONY: debug_tidy
 tidy: debug_tidy
diff --git a/tests/catch.h b/tests/catch.h
index 90d8fe9a..c3237aad 100644
--- a/tests/catch.h
+++ b/tests/catch.h
@@ -532,8 +532,7 @@ unsigned int rngSeed();
 
 // We need a dummy global operator<< so we can bring it into Catch namespace
 // later
-struct Catch_global_namespace_dummy {
-};
+struct Catch_global_namespace_dummy { };
 std::ostream &operator<<(std::ostream &, Catch_global_namespace_dummy);
 
 namespace Catch {
@@ -914,17 +913,15 @@ constexpr auto operator"" _catch_sr(
     N
 
 #define INTERNAL_CATCH_TYPE_GEN                                                \
-    template <typename...> struct TypeList {                                   \
-    };                                                                         \
+    template <typename...> struct TypeList { };                                \
     template <typename... Ts>                                                  \
-    constexpr auto get_wrapper() noexcept->TypeList<Ts...>                     \
+    constexpr auto get_wrapper() noexcept -> TypeList<Ts...>                   \
     {                                                                          \
         return {};                                                             \
     }                                                                          \
-    template <template <typename...> class...> struct TemplateTypeList {       \
-    };                                                                         \
+    template <template <typename...> class...> struct TemplateTypeList { };    \
     template <template <typename...> class... Cs>                              \
-    constexpr auto get_wrapper() noexcept->TemplateTypeList<Cs...>             \
+    constexpr auto get_wrapper() noexcept -> TemplateTypeList<Cs...>           \
     {                                                                          \
         return {};                                                             \
     }                                                                          \
@@ -976,18 +973,16 @@ constexpr auto operator"" _catch_sr(
     };
 
 #define INTERNAL_CATCH_NTTP_1(signature, ...)                                  \
-    template <INTERNAL_CATCH_REMOVE_PARENS(signature)> struct Nttp {           \
-    };                                                                         \
+    template <INTERNAL_CATCH_REMOVE_PARENS(signature)> struct Nttp { };        \
     template <INTERNAL_CATCH_REMOVE_PARENS(signature)>                         \
-    constexpr auto get_wrapper() noexcept->Nttp<__VA_ARGS__>                   \
+    constexpr auto get_wrapper() noexcept -> Nttp<__VA_ARGS__>                 \
     {                                                                          \
         return {};                                                             \
     }                                                                          \
     template <template <INTERNAL_CATCH_REMOVE_PARENS(signature)> class...>     \
-    struct NttpTemplateTypeList {                                              \
-    };                                                                         \
+    struct NttpTemplateTypeList { };                                           \
     template <template <INTERNAL_CATCH_REMOVE_PARENS(signature)> class... Cs>  \
-    constexpr auto get_wrapper() noexcept->NttpTemplateTypeList<Cs...>         \
+    constexpr auto get_wrapper() noexcept -> NttpTemplateTypeList<Cs...>       \
     {                                                                          \
         return {};                                                             \
     }                                                                          \
@@ -1283,11 +1278,9 @@ constexpr auto operator"" _catch_sr(
 #include <type_traits>
 
 namespace Catch {
-template <typename T> struct always_false : std::false_type {
-};
+template <typename T> struct always_false : std::false_type { };
 
-template <typename> struct true_given : std::true_type {
-};
+template <typename> struct true_given : std::true_type { };
 struct is_callable_tester {
     template <typename Fun, typename... Args>
     true_given<decltype(std::declval<Fun>()(
@@ -1299,8 +1292,7 @@ template <typename T> struct is_callable;
 
 template <typename Fun, typename... Args>
 struct is_callable<Fun(Args...)>
-    : decltype(is_callable_tester::test<Fun, Args...>(0)) {
-};
+    : decltype(is_callable_tester::test<Fun, Args...>(0)) { };
 
 #if defined(__cpp_lib_is_invocable) && __cpp_lib_is_invocable >= 201703
 // std::result_of is deprecated in C++17 and removed in C++20. Hence, it is
@@ -1383,10 +1375,9 @@ struct AutoReg : NonCopyable {
 #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION_2(            \
     TestNameClass, TestName, ClassName, Name, Tags, Signature, ...)            \
     namespace {                                                                \
-    namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName)                          \
-    {                                                                          \
-        INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD(                                \
-            TestName, ClassName, INTERNAL_CATCH_REMOVE_PARENS(Signature));     \
+    namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName) {                        \
+    INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD(                                    \
+        TestName, ClassName, INTERNAL_CATCH_REMOVE_PARENS(Signature));         \
     }                                                                          \
     }                                                                          \
     INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD(                                     \
@@ -1532,31 +1523,29 @@ struct AutoReg : NonCopyable {
     INTERNAL_CATCH_DECLARE_SIG_TEST(                                           \
         TestFunc, INTERNAL_CATCH_REMOVE_PARENS(Signature));                    \
     namespace {                                                                \
-    namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName)                          \
-    {                                                                          \
-        INTERNAL_CATCH_TYPE_GEN                                                \
-        INTERNAL_CATCH_NTTP_GEN(INTERNAL_CATCH_REMOVE_PARENS(Signature))       \
-        INTERNAL_CATCH_NTTP_REG_GEN(                                           \
-            TestFunc, INTERNAL_CATCH_REMOVE_PARENS(Signature))                 \
-        template <typename... Types> struct TestName {                         \
-            TestName()                                                         \
-            {                                                                  \
-                int index = 0;                                                 \
-                constexpr char const *tmpl_types[] = {CATCH_REC_LIST(          \
-                    INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, __VA_ARGS__)};    \
-                using expander = int[];                                        \
-                (void)expander{(reg_test(Types{},                              \
-                                    Catch::NameAndTags{Name " - " +            \
-                                            std::string(tmpl_types[index]),    \
-                                        Tags}),                                \
+    namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName) {                        \
+    INTERNAL_CATCH_TYPE_GEN                                                    \
+    INTERNAL_CATCH_NTTP_GEN(INTERNAL_CATCH_REMOVE_PARENS(Signature))           \
+    INTERNAL_CATCH_NTTP_REG_GEN(                                               \
+        TestFunc, INTERNAL_CATCH_REMOVE_PARENS(Signature))                     \
+    template <typename... Types> struct TestName {                             \
+        TestName()                                                             \
+        {                                                                      \
+            int index = 0;                                                     \
+            constexpr char const *tmpl_types[] = {CATCH_REC_LIST(              \
+                INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, __VA_ARGS__)};        \
+            using expander = int[];                                            \
+            (void)expander{                                                    \
+                (reg_test(Types{},                                             \
+                     Catch::NameAndTags{                                       \
+                         Name " - " + std::string(tmpl_types[index]), Tags}),  \
                     index++)...}; /* NOLINT */                                 \
-            }                                                                  \
-        };                                                                     \
-        static int INTERNAL_CATCH_UNIQUE_NAME(globalRegistrar) = []() {        \
-            TestName<INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES(                \
-                __VA_ARGS__)>();                                               \
-            return 0;                                                          \
-        }();                                                                   \
+        }                                                                      \
+    };                                                                         \
+    static int INTERNAL_CATCH_UNIQUE_NAME(globalRegistrar) = []() {            \
+        TestName<INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES(__VA_ARGS__)>();    \
+        return 0;                                                              \
+    }();                                                                       \
     }                                                                          \
     }                                                                          \
     CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION                                   \
@@ -1603,46 +1592,41 @@ struct AutoReg : NonCopyable {
     CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS                           \
     template <typename TestType> static void TestFuncName();                   \
     namespace {                                                                \
-    namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName)                          \
-    {                                                                          \
-        INTERNAL_CATCH_TYPE_GEN                                                \
-        INTERNAL_CATCH_NTTP_GEN(INTERNAL_CATCH_REMOVE_PARENS(Signature))       \
-        template <typename... Types> struct TestName {                         \
-            void reg_tests()                                                   \
-            {                                                                  \
-                int index = 0;                                                 \
-                using expander = int[];                                        \
-                constexpr char const *tmpl_types[] = {                         \
-                    CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS,    \
-                        INTERNAL_CATCH_REMOVE_PARENS(TmplTypes))};             \
-                constexpr char const *types_list[] = {                         \
-                    CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS,    \
-                        INTERNAL_CATCH_REMOVE_PARENS(TypesList))};             \
-                constexpr auto num_types =                                     \
-                    sizeof(types_list) / sizeof(types_list[0]);                \
-                (void)expander{                                                \
-                    (Catch::AutoReg(                                           \
-                         Catch::makeTestInvoker(&TestFuncName<Types>),         \
-                         CATCH_INTERNAL_LINEINFO, Catch::StringRef(),          \
-                         Catch::NameAndTags{Name " - " +                       \
-                                 std::string(tmpl_types[index / num_types]) +  \
-                                 "<" +                                         \
-                                 std::string(types_list[index % num_types]) +  \
-                                 ">",                                          \
-                             Tags}),                                           \
-                        index++)...}; /* NOLINT */                             \
-            }                                                                  \
-        };                                                                     \
-        static int INTERNAL_CATCH_UNIQUE_NAME(globalRegistrar) = []() {        \
-            using TestInit = typename create<TestName,                         \
-                decltype(get_wrapper<INTERNAL_CATCH_REMOVE_PARENS(             \
-                        TmplTypes)>()),                                        \
-                TypeList<INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES(            \
-                    INTERNAL_CATCH_REMOVE_PARENS(TypesList))>>::type;          \
-            TestInit t;                                                        \
-            t.reg_tests();                                                     \
-            return 0;                                                          \
-        }();                                                                   \
+    namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName) {                        \
+    INTERNAL_CATCH_TYPE_GEN                                                    \
+    INTERNAL_CATCH_NTTP_GEN(INTERNAL_CATCH_REMOVE_PARENS(Signature))           \
+    template <typename... Types> struct TestName {                             \
+        void reg_tests()                                                       \
+        {                                                                      \
+            int index = 0;                                                     \
+            using expander = int[];                                            \
+            constexpr char const *tmpl_types[] = {                             \
+                CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS,        \
+                    INTERNAL_CATCH_REMOVE_PARENS(TmplTypes))};                 \
+            constexpr char const *types_list[] = {                             \
+                CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS,        \
+                    INTERNAL_CATCH_REMOVE_PARENS(TypesList))};                 \
+            constexpr auto num_types =                                         \
+                sizeof(types_list) / sizeof(types_list[0]);                    \
+            (void)expander{(                                                   \
+                Catch::AutoReg(Catch::makeTestInvoker(&TestFuncName<Types>),   \
+                    CATCH_INTERNAL_LINEINFO, Catch::StringRef(),               \
+                    Catch::NameAndTags{Name " - " +                            \
+                            std::string(tmpl_types[index / num_types]) + "<" + \
+                            std::string(types_list[index % num_types]) + ">",  \
+                        Tags}),                                                \
+                index++)...}; /* NOLINT */                                     \
+        }                                                                      \
+    };                                                                         \
+    static int INTERNAL_CATCH_UNIQUE_NAME(globalRegistrar) = []() {            \
+        using TestInit = typename create<TestName,                             \
+            decltype(get_wrapper<INTERNAL_CATCH_REMOVE_PARENS(TmplTypes)>()),  \
+            TypeList<INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES(                \
+                INTERNAL_CATCH_REMOVE_PARENS(TypesList))>>::type;              \
+        TestInit t;                                                            \
+        t.reg_tests();                                                         \
+        return 0;                                                              \
+    }();                                                                       \
     }                                                                          \
     }                                                                          \
     CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION                                   \
@@ -1689,31 +1673,29 @@ struct AutoReg : NonCopyable {
     CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS                           \
     template <typename TestType> static void TestFunc();                       \
     namespace {                                                                \
-    namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName)                          \
-    {                                                                          \
-        INTERNAL_CATCH_TYPE_GEN                                                \
-        template <typename... Types> struct TestName {                         \
-            void reg_tests()                                                   \
-            {                                                                  \
-                int index = 0;                                                 \
-                using expander = int[];                                        \
-                (void)expander{                                                \
-                    (Catch::AutoReg(Catch::makeTestInvoker(&TestFunc<Types>),  \
-                         CATCH_INTERNAL_LINEINFO, Catch::StringRef(),          \
-                         Catch::NameAndTags{Name " - " +                       \
-                                 std::string(                                  \
-                                     INTERNAL_CATCH_STRINGIZE(TmplList)) +     \
-                                 " - " + std::to_string(index),                \
-                             Tags}),                                           \
-                        index++)...}; /* NOLINT */                             \
-            }                                                                  \
-        };                                                                     \
-        static int INTERNAL_CATCH_UNIQUE_NAME(globalRegistrar) = []() {        \
-            using TestInit = typename convert<TestName, TmplList>::type;       \
-            TestInit t;                                                        \
-            t.reg_tests();                                                     \
-            return 0;                                                          \
-        }();                                                                   \
+    namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName) {                        \
+    INTERNAL_CATCH_TYPE_GEN                                                    \
+    template <typename... Types> struct TestName {                             \
+        void reg_tests()                                                       \
+        {                                                                      \
+            int index = 0;                                                     \
+            using expander = int[];                                            \
+            (void)expander{                                                    \
+                (Catch::AutoReg(Catch::makeTestInvoker(&TestFunc<Types>),      \
+                     CATCH_INTERNAL_LINEINFO, Catch::StringRef(),              \
+                     Catch::NameAndTags{Name " - " +                           \
+                             std::string(INTERNAL_CATCH_STRINGIZE(TmplList)) + \
+                             " - " + std::to_string(index),                    \
+                         Tags}),                                               \
+                    index++)...}; /* NOLINT */                                 \
+        }                                                                      \
+    };                                                                         \
+    static int INTERNAL_CATCH_UNIQUE_NAME(globalRegistrar) = []() {            \
+        using TestInit = typename convert<TestName, TmplList>::type;           \
+        TestInit t;                                                            \
+        t.reg_tests();                                                         \
+        return 0;                                                              \
+    }();                                                                       \
     }                                                                          \
     }                                                                          \
     CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION                                   \
@@ -1733,33 +1715,32 @@ struct AutoReg : NonCopyable {
     CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS                             \
     CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS                           \
     namespace {                                                                \
-    namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName)                          \
-    {                                                                          \
-        INTERNAL_CATCH_TYPE_GEN                                                \
-        INTERNAL_CATCH_NTTP_GEN(INTERNAL_CATCH_REMOVE_PARENS(Signature))       \
-        INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD(                                \
-            TestName, ClassName, INTERNAL_CATCH_REMOVE_PARENS(Signature));     \
-        INTERNAL_CATCH_NTTP_REG_METHOD_GEN(                                    \
-            TestName, INTERNAL_CATCH_REMOVE_PARENS(Signature))                 \
-        template <typename... Types> struct TestNameClass {                    \
-            TestNameClass()                                                    \
-            {                                                                  \
-                int index = 0;                                                 \
-                constexpr char const *tmpl_types[] = {CATCH_REC_LIST(          \
-                    INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, __VA_ARGS__)};    \
-                using expander = int[];                                        \
-                (void)expander{(reg_test(Types{}, #ClassName,                  \
-                                    Catch::NameAndTags{Name " - " +            \
-                                            std::string(tmpl_types[index]),    \
-                                        Tags}),                                \
+    namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName) {                        \
+    INTERNAL_CATCH_TYPE_GEN                                                    \
+    INTERNAL_CATCH_NTTP_GEN(INTERNAL_CATCH_REMOVE_PARENS(Signature))           \
+    INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD(                                    \
+        TestName, ClassName, INTERNAL_CATCH_REMOVE_PARENS(Signature));         \
+    INTERNAL_CATCH_NTTP_REG_METHOD_GEN(                                        \
+        TestName, INTERNAL_CATCH_REMOVE_PARENS(Signature))                     \
+    template <typename... Types> struct TestNameClass {                        \
+        TestNameClass()                                                        \
+        {                                                                      \
+            int index = 0;                                                     \
+            constexpr char const *tmpl_types[] = {CATCH_REC_LIST(              \
+                INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, __VA_ARGS__)};        \
+            using expander = int[];                                            \
+            (void)expander{                                                    \
+                (reg_test(Types{}, #ClassName,                                 \
+                     Catch::NameAndTags{                                       \
+                         Name " - " + std::string(tmpl_types[index]), Tags}),  \
                     index++)...}; /* NOLINT */                                 \
-            }                                                                  \
-        };                                                                     \
-        static int INTERNAL_CATCH_UNIQUE_NAME(globalRegistrar) = []() {        \
-            TestNameClass<INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES(           \
-                __VA_ARGS__)>();                                               \
-            return 0;                                                          \
-        }();                                                                   \
+        }                                                                      \
+    };                                                                         \
+    static int INTERNAL_CATCH_UNIQUE_NAME(globalRegistrar) = []() {            \
+        TestNameClass<INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES(               \
+            __VA_ARGS__)>();                                                   \
+        return 0;                                                              \
+    }();                                                                       \
     }                                                                          \
     }                                                                          \
     CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION                                   \
@@ -1811,46 +1792,41 @@ struct AutoReg : NonCopyable {
         void test();                                                           \
     };                                                                         \
     namespace {                                                                \
-    namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestNameClass)                     \
-    {                                                                          \
-        INTERNAL_CATCH_TYPE_GEN                                                \
-        INTERNAL_CATCH_NTTP_GEN(INTERNAL_CATCH_REMOVE_PARENS(Signature))       \
-        template <typename... Types> struct TestNameClass {                    \
-            void reg_tests()                                                   \
-            {                                                                  \
-                int index = 0;                                                 \
-                using expander = int[];                                        \
-                constexpr char const *tmpl_types[] = {                         \
-                    CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS,    \
-                        INTERNAL_CATCH_REMOVE_PARENS(TmplTypes))};             \
-                constexpr char const *types_list[] = {                         \
-                    CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS,    \
-                        INTERNAL_CATCH_REMOVE_PARENS(TypesList))};             \
-                constexpr auto num_types =                                     \
-                    sizeof(types_list) / sizeof(types_list[0]);                \
-                (void)expander{                                                \
-                    (Catch::AutoReg(                                           \
-                         Catch::makeTestInvoker(&TestName<Types>::test),       \
-                         CATCH_INTERNAL_LINEINFO, #ClassName,                  \
-                         Catch::NameAndTags{Name " - " +                       \
-                                 std::string(tmpl_types[index / num_types]) +  \
-                                 "<" +                                         \
-                                 std::string(types_list[index % num_types]) +  \
-                                 ">",                                          \
-                             Tags}),                                           \
-                        index++)...}; /* NOLINT */                             \
-            }                                                                  \
-        };                                                                     \
-        static int INTERNAL_CATCH_UNIQUE_NAME(globalRegistrar) = []() {        \
-            using TestInit = typename create<TestNameClass,                    \
-                decltype(get_wrapper<INTERNAL_CATCH_REMOVE_PARENS(             \
-                        TmplTypes)>()),                                        \
-                TypeList<INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES(            \
-                    INTERNAL_CATCH_REMOVE_PARENS(TypesList))>>::type;          \
-            TestInit t;                                                        \
-            t.reg_tests();                                                     \
-            return 0;                                                          \
-        }();                                                                   \
+    namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestNameClass) {                   \
+    INTERNAL_CATCH_TYPE_GEN                                                    \
+    INTERNAL_CATCH_NTTP_GEN(INTERNAL_CATCH_REMOVE_PARENS(Signature))           \
+    template <typename... Types> struct TestNameClass {                        \
+        void reg_tests()                                                       \
+        {                                                                      \
+            int index = 0;                                                     \
+            using expander = int[];                                            \
+            constexpr char const *tmpl_types[] = {                             \
+                CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS,        \
+                    INTERNAL_CATCH_REMOVE_PARENS(TmplTypes))};                 \
+            constexpr char const *types_list[] = {                             \
+                CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS,        \
+                    INTERNAL_CATCH_REMOVE_PARENS(TypesList))};                 \
+            constexpr auto num_types =                                         \
+                sizeof(types_list) / sizeof(types_list[0]);                    \
+            (void)expander{(                                                   \
+                Catch::AutoReg(Catch::makeTestInvoker(&TestName<Types>::test), \
+                    CATCH_INTERNAL_LINEINFO, #ClassName,                       \
+                    Catch::NameAndTags{Name " - " +                            \
+                            std::string(tmpl_types[index / num_types]) + "<" + \
+                            std::string(types_list[index % num_types]) + ">",  \
+                        Tags}),                                                \
+                index++)...}; /* NOLINT */                                     \
+        }                                                                      \
+    };                                                                         \
+    static int INTERNAL_CATCH_UNIQUE_NAME(globalRegistrar) = []() {            \
+        using TestInit = typename create<TestNameClass,                        \
+            decltype(get_wrapper<INTERNAL_CATCH_REMOVE_PARENS(TmplTypes)>()),  \
+            TypeList<INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES(                \
+                INTERNAL_CATCH_REMOVE_PARENS(TypesList))>>::type;              \
+        TestInit t;                                                            \
+        t.reg_tests();                                                         \
+        return 0;                                                              \
+    }();                                                                       \
     }                                                                          \
     }                                                                          \
     CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION                                   \
@@ -1904,32 +1880,29 @@ struct AutoReg : NonCopyable {
         void test();                                                           \
     };                                                                         \
     namespace {                                                                \
-    namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName)                          \
-    {                                                                          \
-        INTERNAL_CATCH_TYPE_GEN                                                \
-        template <typename... Types> struct TestNameClass {                    \
-            void reg_tests()                                                   \
-            {                                                                  \
-                int index = 0;                                                 \
-                using expander = int[];                                        \
-                (void)expander{                                                \
-                    (Catch::AutoReg(                                           \
-                         Catch::makeTestInvoker(&TestName<Types>::test),       \
-                         CATCH_INTERNAL_LINEINFO, #ClassName,                  \
-                         Catch::NameAndTags{Name " - " +                       \
-                                 std::string(                                  \
-                                     INTERNAL_CATCH_STRINGIZE(TmplList)) +     \
-                                 " - " + std::to_string(index),                \
-                             Tags}),                                           \
-                        index++)...}; /* NOLINT */                             \
-            }                                                                  \
-        };                                                                     \
-        static int INTERNAL_CATCH_UNIQUE_NAME(globalRegistrar) = []() {        \
-            using TestInit = typename convert<TestNameClass, TmplList>::type;  \
-            TestInit t;                                                        \
-            t.reg_tests();                                                     \
-            return 0;                                                          \
-        }();                                                                   \
+    namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName) {                        \
+    INTERNAL_CATCH_TYPE_GEN                                                    \
+    template <typename... Types> struct TestNameClass {                        \
+        void reg_tests()                                                       \
+        {                                                                      \
+            int index = 0;                                                     \
+            using expander = int[];                                            \
+            (void)expander{(                                                   \
+                Catch::AutoReg(Catch::makeTestInvoker(&TestName<Types>::test), \
+                    CATCH_INTERNAL_LINEINFO, #ClassName,                       \
+                    Catch::NameAndTags{Name " - " +                            \
+                            std::string(INTERNAL_CATCH_STRINGIZE(TmplList)) +  \
+                            " - " + std::to_string(index),                     \
+                        Tags}),                                                \
+                index++)...}; /* NOLINT */                                     \
+        }                                                                      \
+    };                                                                         \
+    static int INTERNAL_CATCH_UNIQUE_NAME(globalRegistrar) = []() {            \
+        using TestInit = typename convert<TestNameClass, TmplList>::type;      \
+        TestInit t;                                                            \
+        t.reg_tests();                                                         \
+        return 0;                                                              \
+    }();                                                                       \
     }                                                                          \
     }                                                                          \
     CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION                                   \
@@ -2592,18 +2565,16 @@ template <typename...> struct void_type {
     using type = void;
 };
 
-template <typename T, typename = void> struct is_range_impl : std::false_type {
-};
+template <typename T, typename = void>
+struct is_range_impl : std::false_type { };
 
 template <typename T>
 struct is_range_impl<T,
     typename void_type<decltype(begin(std::declval<T>()))>::type>
-    : std::true_type {
-};
+    : std::true_type { };
 } // namespace detail
 
-template <typename T> struct is_range : detail::is_range_impl<T> {
-};
+template <typename T> struct is_range : detail::is_range_impl<T> { };
 
 #if defined(_MANAGED) // Managed types are never ranges
 template <typename T> struct is_range<T ^> {
@@ -3176,8 +3147,7 @@ IResultCapture &getResultCapture();
 // end catch_interfaces_capture.h
 namespace Catch {
 
-struct TestFailureException {
-};
+struct TestFailureException { };
 struct AssertionResultData;
 struct IResultCapture;
 class RunContext;
@@ -3359,7 +3329,10 @@ public:
 
 #define INTERNAL_CATCH_TRY try
 #define INTERNAL_CATCH_CATCH(handler)                                          \
-    catch (...) { handler.handleUnexpectedInflightException(); }
+    catch (...)                                                                \
+    {                                                                          \
+        handler.handleUnexpectedInflightException();                           \
+    }
 
 #endif
 
@@ -4908,8 +4881,7 @@ GeneratorWrapper<std::tuple<Ts...>> table(
 
 // Tag type to signal that a generator sequence should convert arguments to a
 // specific type
-template <typename T> struct as {
-};
+template <typename T> struct as { };
 
 template <typename T, typename... Gs>
 auto makeGenerators(GeneratorWrapper<T> &&generator, Gs &&...moreGenerators)
@@ -5300,11 +5272,11 @@ public:
     {
     }
     Option(T const &_value)
-        : nullableValue(new (storage) T(_value))
+        : nullableValue(new(storage) T(_value))
     {
     }
     Option(Option const &_other)
-        : nullableValue(_other ? new (storage) T(*_other) : nullptr)
+        : nullableValue(_other ? new(storage) T(*_other) : nullptr)
     {
     }
 
@@ -7532,8 +7504,7 @@ template <typename T> struct CompleteType {
     using type = T;
 };
 template <> struct CompleteType<void> {
-    struct type {
-    };
+    struct type { };
 };
 
 template <typename T> using CompleteType_t = typename CompleteType<T>::type;
@@ -7681,8 +7652,7 @@ namespace Benchmark {
 namespace Detail {
 template <typename T> using Decay = typename std::decay<T>::type;
 template <typename T, typename U>
-struct is_related : std::is_same<Decay<T>, Decay<U>> {
-};
+struct is_related : std::is_same<Decay<T>, Decay<U>> { };
 
 /// We need to reinvent std::function because every piece of code that might add
 /// overhead in a measurement context needs to have consistent performance
@@ -8698,8 +8668,8 @@ public:
 } // namespace TestCaseTracking
 
 using TestCaseTracking::ITracker;
-using TestCaseTracking::TrackerContext;
 using TestCaseTracking::SectionTracker;
+using TestCaseTracking::TrackerContext;
 
 } // namespace Catch
 
@@ -8886,8 +8856,8 @@ double outlier_variance(Estimate<double> mean, Estimate<double> stddev, int n)
         return (nc / n) * (sb2 - nc * sg2);
     };
 
-    return (std::min)(var_out(1),
-               var_out((std::min)(c_max(0.), c_max(mg_min)))) /
+    return (std::min)(
+               var_out(1), var_out((std::min)(c_max(0.), c_max(mg_min)))) /
         sb2;
 }
 
@@ -9844,8 +9814,7 @@ class Columns {
 public:
     class iterator {
         friend Columns;
-        struct EndTag {
-        };
+        struct EndTag { };
 
         std::vector<Column> const &m_columns;
         std::vector<Column::iterator> m_iterators;
@@ -9995,8 +9964,7 @@ namespace detail {
 // Traits for extracting arg and return type of lambdas (for single argument
 // lambdas)
 template <typename L>
-struct UnaryLambdaTraits : UnaryLambdaTraits<decltype(&L::operator())> {
-};
+struct UnaryLambdaTraits : UnaryLambdaTraits<decltype(&L::operator())> { };
 
 template <typename ClassT, typename ReturnT, typename... Args>
 struct UnaryLambdaTraits<ReturnT (ClassT::*)(Args...) const> {
@@ -10805,7 +10773,7 @@ struct Help : Opt {
             return ParserResult::ok(ParseResultType::ShortCircuitAll);
         })
     {
-        static_cast<Opt &> (*this)(
+        static_cast<Opt &>(*this)(
             "display usage information")["-?"]["-h"]["--help"]
             .optional();
     }
@@ -15277,8 +15245,8 @@ int Session::runInternal()
         // the return value to 255 prevents false negative when some multiple
         // of 256 tests has failed
         return (std::min)(MaxExitCode,
-            (std::max)(totals.error,
-                static_cast<int>(totals.assertions.failed)));
+            (std::max)(
+                totals.error, static_cast<int>(totals.assertions.failed)));
     }
 #if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
     catch (std::exception &ex)
@@ -16409,8 +16377,8 @@ std::string const &SectionTracker::trimmedName() const
 } // namespace TestCaseTracking
 
 using TestCaseTracking::ITracker;
-using TestCaseTracking::TrackerContext;
 using TestCaseTracking::SectionTracker;
+using TestCaseTracking::TrackerContext;
 
 } // namespace Catch
 
@@ -18283,10 +18251,8 @@ struct ColumnInfo {
     int width;
     Justification justification;
 };
-struct ColumnBreak {
-};
-struct RowBreak {
-};
+struct ColumnBreak { };
+struct RowBreak { };
 
 class Duration {
     enum class Unit {
diff --git a/tests/t00004/t00004.cc b/tests/t00004/t00004.cc
index 74881853..594bf354 100644
--- a/tests/t00004/t00004.cc
+++ b/tests/t00004/t00004.cc
@@ -14,8 +14,7 @@ public:
     public:
         enum class Lights { Green, Yellow, Red };
 
-        class AAA {
-        };
+        class AAA { };
     };
 
     void foo2() const { }
@@ -26,8 +25,7 @@ public:
     T t;
 
     class AA {
-        class AAA {
-        };
+        class AAA { };
 
         enum class CCC { CCC_1, CCC_2 };
     };
@@ -46,8 +44,7 @@ class D {
 public:
     enum class AA { AA_1, AA_2, AA_3 };
 
-    class DD {
-    };
+    class DD { };
 };
 }
 
diff --git a/tests/t00005/t00005.cc b/tests/t00005/t00005.cc
index 995b729f..e4c6d6af 100644
--- a/tests/t00005/t00005.cc
+++ b/tests/t00005/t00005.cc
@@ -1,37 +1,26 @@
 namespace clanguml {
 namespace t00005 {
-class A {
-};
+class A { };
 
-class B {
-};
+class B { };
 
-class C {
-};
+class C { };
 
-class D {
-};
+class D { };
 
-class E {
-};
+class E { };
 
-class F {
-};
+class F { };
 
-class G {
-};
+class G { };
 
-class H {
-};
+class H { };
 
-class I {
-};
+class I { };
 
-class J {
-};
+class J { };
 
-class K {
-};
+class K { };
 
 class R {
 public:
diff --git a/tests/t00006/t00006.cc b/tests/t00006/t00006.cc
index d6f80352..25ec9575 100644
--- a/tests/t00006/t00006.cc
+++ b/tests/t00006/t00006.cc
@@ -4,53 +4,37 @@
 
 namespace clanguml {
 namespace t00006 {
-class A {
-};
+class A { };
 
-class B {
-};
+class B { };
 
-class C {
-};
+class C { };
 
-class D {
-};
+class D { };
 
-class E {
-};
+class E { };
 
-class F {
-};
+class F { };
 
-class G {
-};
+class G { };
 
-class H {
-};
+class H { };
 
-class I {
-};
+class I { };
 
-class J {
-};
+class J { };
 
-class K {
-};
+class K { };
 
-class L {
-};
+class L { };
 
-class M {
-};
+class M { };
 
-class N {
-};
+class N { };
 
-class NN {
-};
+class NN { };
 
-class NNN {
-};
+class NNN { };
 
 template <typename T> class custom_container {
 public:
diff --git a/tests/t00007/t00007.cc b/tests/t00007/t00007.cc
index af9c1813..52635dd2 100644
--- a/tests/t00007/t00007.cc
+++ b/tests/t00007/t00007.cc
@@ -2,14 +2,11 @@
 
 namespace clanguml {
 namespace t00007 {
-class A {
-};
+class A { };
 
-class B {
-};
+class B { };
 
-class C {
-};
+class C { };
 
 class R {
 public:
diff --git a/tests/t00011/t00011.cc b/tests/t00011/t00011.cc
index e8b03e3c..0c4192d5 100644
--- a/tests/t00011/t00011.cc
+++ b/tests/t00011/t00011.cc
@@ -1,6 +1,5 @@
 namespace external {
-class C {
-};
+class C { };
 }
 
 namespace clanguml {
diff --git a/tests/t00015/t00015.cc b/tests/t00015/t00015.cc
index 7b5bcd71..a34db437 100644
--- a/tests/t00015/t00015.cc
+++ b/tests/t00015/t00015.cc
@@ -3,30 +3,25 @@ namespace t00015 {
 
 namespace ns1 {
 inline namespace ns2_v1_0_0 {
-class A {
-};
+class A { };
 }
 
 namespace ns2_v0_9_0 {
-class [[deprecated]] A {
-};
+class [[deprecated]] A { };
 }
 
 namespace {
-class Anon final : public A {
-};
+class Anon final : public A { };
 }
 } // namespace ns1
 
 namespace ns3 {
 
 namespace ns1::ns2 {
-class Anon : public t00015::ns1::A {
-};
+class Anon : public t00015::ns1::A { };
 }
 
-class B : public ns1::ns2::Anon {
-};
+class B : public ns1::ns2::Anon { };
 }
 } // namespace t00015
 } // namespace clanguml
diff --git a/tests/t00017/t00017.cc b/tests/t00017/t00017.cc
index e5d30b17..b038c556 100644
--- a/tests/t00017/t00017.cc
+++ b/tests/t00017/t00017.cc
@@ -2,38 +2,27 @@
 
 namespace clanguml {
 namespace t00017 {
-class A {
-};
+class A { };
 
-class B {
-};
+class B { };
 
-class C {
-};
+class C { };
 
-class D {
-};
+class D { };
 
-class E {
-};
+class E { };
 
-class F {
-};
+class F { };
 
-class G {
-};
+class G { };
 
-class H {
-};
+class H { };
 
-class I {
-};
+class I { };
 
-class J {
-};
+class J { };
 
-class K {
-};
+class K { };
 
 class R {
     explicit R(int &some_int, C &cc, const E &ee, F &&ff, I *&ii)
diff --git a/tests/t00028/t00028.cc b/tests/t00028/t00028.cc
index e452c836..b48f5ab4 100644
--- a/tests/t00028/t00028.cc
+++ b/tests/t00028/t00028.cc
@@ -5,25 +5,21 @@ namespace clanguml {
 namespace t00028 {
 
 /// \uml{note[top] A class note.}
-class A {
-};
+class A { };
 
 /// \uml{note[] B class note.}
-class B {
-};
+class B { };
 
 ///
 /// @uml{note:t00028_class[bottom] C class note.}
 /// This is class C.
-class C {
-};
+class C { };
 
 /// \uml{note
 /// D
 /// class
 /// note.}
-class D {
-};
+class D { };
 
 /// \uml{note E template class note.}
 template <typename T> class E {
@@ -31,8 +27,7 @@ template <typename T> class E {
 };
 
 /// \uml{note:other_diagram[left] G class note.}
-class G {
-};
+class G { };
 
 /// @uml{note[ bottom ] F enum note.}
 enum class F { one, two, three };
diff --git a/tests/t00029/t00029.cc b/tests/t00029/t00029.cc
index b56162bb..3e7badee 100644
--- a/tests/t00029/t00029.cc
+++ b/tests/t00029/t00029.cc
@@ -4,12 +4,10 @@
 namespace clanguml {
 namespace t00029 {
 
-class A {
-};
+class A { };
 
 /// \uml{skip}
-class B {
-};
+class B { };
 
 template <typename T> class C {
     T param;
@@ -25,17 +23,13 @@ enum class E { one, two, three };
 /// \uml{skip}
 enum class F { red, green, blue };
 
-class G1 {
-};
+class G1 { };
 
-class G2 {
-};
+class G2 { };
 
-class G3 {
-};
+class G3 { };
 
-class G4 {
-};
+class G4 { };
 
 struct R {
     G1 g1;
diff --git a/tests/t00030/t00030.cc b/tests/t00030/t00030.cc
index 7799cd04..0193421e 100644
--- a/tests/t00030/t00030.cc
+++ b/tests/t00030/t00030.cc
@@ -4,20 +4,15 @@
 namespace clanguml {
 namespace t00030 {
 
-class A {
-};
+class A { };
 
-class B {
-};
+class B { };
 
-class C {
-};
+class C { };
 
-class D {
-};
+class D { };
 
-class E {
-};
+class E { };
 
 struct R {
     /// @uml{association[]}
diff --git a/tests/t00031/t00031.cc b/tests/t00031/t00031.cc
index 9e3d1cc0..96bb8dde 100644
--- a/tests/t00031/t00031.cc
+++ b/tests/t00031/t00031.cc
@@ -5,8 +5,7 @@ namespace clanguml {
 namespace t00031 {
 
 /// @uml{style[#back:lightgreen|yellow;header:blue/red]}
-class A {
-};
+class A { };
 
 /// @uml{style[#line.dotted:blue]}
 enum B { one, two, three };
@@ -16,8 +15,7 @@ template <typename T> class C {
     T ttt;
 };
 
-class D {
-};
+class D { };
 
 struct R {
     /// @uml{style[#red,dashed,thickness=2]}
diff --git a/tests/t00032/t00032.cc b/tests/t00032/t00032.cc
index c080048e..abf02084 100644
--- a/tests/t00032/t00032.cc
+++ b/tests/t00032/t00032.cc
@@ -4,11 +4,9 @@
 namespace clanguml {
 namespace t00032 {
 
-struct Base {
-};
+struct Base { };
 
-struct TBase {
-};
+struct TBase { };
 
 struct A {
     void operator()() { }
diff --git a/tests/t00034/t00034.cc b/tests/t00034/t00034.cc
index 0ab412c7..4b50c66e 100644
--- a/tests/t00034/t00034.cc
+++ b/tests/t00034/t00034.cc
@@ -40,8 +40,7 @@ template <> struct drop_void<Void> {
 
 template <typename T> using drop_void_t = typename drop_void<T>::type;
 
-struct A {
-};
+struct A { };
 
 struct R {
     lift_void_t<A> *la;
diff --git a/tests/t00035/t00035.cc b/tests/t00035/t00035.cc
index dbc01d47..50fefebb 100644
--- a/tests/t00035/t00035.cc
+++ b/tests/t00035/t00035.cc
@@ -1,20 +1,15 @@
 namespace clanguml {
 namespace t00035 {
 
-struct Top {
-};
+struct Top { };
 
-struct Left {
-};
+struct Left { };
 
-struct Center {
-};
+struct Center { };
 
-struct Bottom {
-};
+struct Bottom { };
 
-struct Right {
-};
+struct Right { };
 
 } // namespace t00035
 } // namespace clanguml
diff --git a/tests/t00036/t00036.cc b/tests/t00036/t00036.cc
index 2ba646b7..cb0ec2fa 100644
--- a/tests/t00036/t00036.cc
+++ b/tests/t00036/t00036.cc
@@ -25,8 +25,7 @@ namespace ns2 {
 namespace ns22 {
 
 // TODO: Fix for incomplete struct C declaration "struct C;"
-struct C {
-};
+struct C { };
 
 }
 }
diff --git a/tests/t00038/t00038.cc b/tests/t00038/t00038.cc
index b6ba3b3a..b792a06e 100644
--- a/tests/t00038/t00038.cc
+++ b/tests/t00038/t00038.cc
@@ -7,12 +7,10 @@ namespace thirdparty {
 namespace ns1 {
 enum class color_t { red, green, blue };
 
-struct E {
-};
+struct E { };
 } // namespace ns1
 namespace ns2 {
-struct F {
-};
+struct F { };
 } // namespace ns2
 } // namespace thirdparty
 
@@ -21,41 +19,33 @@ namespace t00038 {
 
 enum class property_t { property_a, property_b, property_c };
 
-struct A {
-};
-struct B {
-};
-struct C {
-};
+struct A { };
+struct B { };
+struct C { };
 
 struct key_t {
     std::string key;
 };
 
-template <typename T> struct map {
-};
+template <typename T> struct map { };
 
 using namespace thirdparty::ns1;
 
-template <> struct map<std::integral_constant<color_t, color_t::red>> : E {
-};
+template <> struct map<std::integral_constant<color_t, color_t::red>> : E { };
 
 template <>
 struct map<std::integral_constant<clanguml::t00038::property_t,
-    clanguml::t00038::property_t::property_a>> : A {
-};
+    clanguml::t00038::property_t::property_a>> : A { };
 
 template <>
 struct map<std::vector<
     std::integral_constant<t00038::property_t, t00038::property_t::property_b>>>
-    : B {
-};
+    : B { };
 
 template <>
 struct map<std::map<key_t,
     std::vector<std::integral_constant<property_t, property_t::property_c>>>>
-    : C {
-};
+    : C { };
 
 } // namespace t00038
 } // namespace clanguml
diff --git a/tests/t00039/t00039.cc b/tests/t00039/t00039.cc
index d6f2c11f..c8391124 100644
--- a/tests/t00039/t00039.cc
+++ b/tests/t00039/t00039.cc
@@ -1,50 +1,38 @@
 #include <string>
 
 namespace clanguml::t00039 {
-struct B {
-};
+struct B { };
 
-struct C {
-};
+struct C { };
 
-struct D {
-};
+struct D { };
 
-struct E {
-};
+struct E { };
 
 namespace ns1 {
-struct BB : public B {
-};
+struct BB : public B { };
 } // namespace ns1
 
-struct CD : public C, public D {
-};
+struct CD : public C, public D { };
 
-struct DE : public D, public E {
-};
+struct DE : public D, public E { };
 
-struct CDE : public C, public D, public E {
-};
+struct CDE : public C, public D, public E { };
 
-struct A {
-};
+struct A { };
 
-struct AA : public A {
-};
+struct AA : public A { };
 
 struct AAA : public AA {
     B *b;
 };
 
 namespace ns2 {
-struct AAAA : public virtual AAA {
-};
+struct AAAA : public virtual AAA { };
 } // namespace ns2
 
 namespace detail {
-struct AA : public A {
-};
+struct AA : public A { };
 } // namespace detail
 
 namespace ns3 {
diff --git a/tests/t00040/t00040.cc b/tests/t00040/t00040.cc
index 21b76dd2..b94d7af1 100644
--- a/tests/t00040/t00040.cc
+++ b/tests/t00040/t00040.cc
@@ -1,7 +1,6 @@
 namespace clanguml::t00040 {
 
-struct B {
-};
+struct B { };
 
 struct A {
 public:
diff --git a/tests/t00041/t00041.cc b/tests/t00041/t00041.cc
index a65f5474..5204c843 100644
--- a/tests/t00041/t00041.cc
+++ b/tests/t00041/t00041.cc
@@ -1,16 +1,12 @@
 namespace clanguml::t00041 {
 
-struct B {
-};
+struct B { };
 
-struct A {
-};
+struct A { };
 
-class AA : public A {
-};
+class AA : public A { };
 
-struct R {
-};
+struct R { };
 
 struct RR;
 
@@ -18,15 +14,12 @@ struct D {
     RR *rr;
 };
 
-struct E {
-};
+struct E { };
 
-struct F {
-};
+struct F { };
 
 namespace detail {
-struct G {
-};
+struct G { };
 } // namespace detail
 
 struct RR : public R {
@@ -35,18 +28,14 @@ struct RR : public R {
     detail::G *g;
 };
 
-struct RRR : public RR {
-};
+struct RRR : public RR { };
 
 namespace ns1 {
-struct N {
-};
+struct N { };
 
-struct NN : public N {
-};
+struct NN : public N { };
 
-struct NM : public N {
-};
+struct NM : public N { };
 }
 
 } // namespace clanguml::t00041
diff --git a/tests/t00043/t00043.cc b/tests/t00043/t00043.cc
index a0a2a04d..d3a8a7c1 100644
--- a/tests/t00043/t00043.cc
+++ b/tests/t00043/t00043.cc
@@ -1,8 +1,7 @@
 namespace clanguml::t00043 {
 
 namespace dependants {
-struct A {
-};
+struct A { };
 
 struct B {
     void b(A *a) { }
@@ -25,17 +24,14 @@ struct E {
     void e(D *d) { }
 };
 
-struct F {
-};
+struct F { };
 } // namespace dependants
 
 namespace dependencies {
 
-struct G {
-};
+struct G { };
 
-struct GG {
-};
+struct GG { };
 
 struct H {
     void h(G *g) { }
diff --git a/tests/t00044/t00044.cc b/tests/t00044/t00044.cc
index 67ff645b..33110d68 100644
--- a/tests/t00044/t00044.cc
+++ b/tests/t00044/t00044.cc
@@ -21,8 +21,7 @@ private:
 };
 
 template <typename Ret, typename... Args, typename A>
-class signal_handler<Ret(Args...), A> {
-};
+class signal_handler<Ret(Args...), A> { };
 
 template <typename Ret, typename... Args, typename A>
 sink(signal_handler<Ret(Args...), A> &)
diff --git a/tests/t00045/t00045.cc b/tests/t00045/t00045.cc
index 09e3167d..c9622c88 100644
--- a/tests/t00045/t00045.cc
+++ b/tests/t00045/t00045.cc
@@ -1,11 +1,8 @@
-class A {
-};
+class A { };
 
-class AA {
-};
+class AA { };
 
-class AAA {
-};
+class AAA { };
 
 template <typename T> class AAAA {
     T t;
@@ -13,28 +10,21 @@ template <typename T> class AAAA {
 
 namespace ns1 {
 
-class A {
-};
+class A { };
 
 namespace ns2 {
 
-class A {
-};
+class A { };
 
-class B : public A {
-};
+class B : public A { };
 
-class C : public ns1::A {
-};
+class C : public ns1::A { };
 
-class D : public ns1::ns2::A {
-};
+class D : public ns1::ns2::A { };
 
-class E : public ::A {
-};
+class E : public ::A { };
 
-class AAA {
-};
+class AAA { };
 
 class R {
 public:
diff --git a/tests/t00046/t00046.cc b/tests/t00046/t00046.cc
index 6a26a248..6185aa5b 100644
--- a/tests/t00046/t00046.cc
+++ b/tests/t00046/t00046.cc
@@ -1,33 +1,25 @@
 #include <cstdint>
 #include <vector>
 
-class A {
-};
+class A { };
 
-class AA {
-};
+class AA { };
 
 namespace ns1 {
 
-class A {
-};
+class A { };
 
 namespace ns2 {
 
-class A {
-};
+class A { };
 
-class B : public A {
-};
+class B : public A { };
 
-class C : public ns1::A {
-};
+class C : public ns1::A { };
 
-class D : public ns1::ns2::A {
-};
+class D : public ns1::ns2::A { };
 
-class E : public ::A {
-};
+class E : public ::A { };
 
 class R {
 public:
diff --git a/tests/t00050/t00050.cc b/tests/t00050/t00050.cc
index 00cf7580..488b659a 100644
--- a/tests/t00050/t00050.cc
+++ b/tests/t00050/t00050.cc
@@ -1,14 +1,12 @@
 namespace clanguml {
 
 /// Vivamus integer non suscipit taciti mus
-class A {
-};
+class A { };
 
 namespace t00050 {
 
 /// Lorem ipsum dolor sit
-class A {
-};
+class A { };
 
 /**
  * \brief Lorem ipsum
@@ -23,8 +21,7 @@ class A {
  * \todo 2. Write tests
  * \todo 3. Implement
  */
-class B {
-};
+class B { };
 
 /// \brief Long comment example
 ///
@@ -53,8 +50,7 @@ class B {
 /// imperdiet praesent magnis ridiculus congue gravida curabitur dictum
 /// sagittis, enim et magna sit inceptos sodales parturient pharetra mollis,
 /// aenean vel nostra tellus commodo pretium sapien sociosqu.
-class C {
-};
+class C { };
 
 /// Mollis pretium lorem primis
 namespace utils {
@@ -66,8 +62,7 @@ namespace utils {
 /// tellus ligula porttitor metus.
 ///
 /// \todo Implement...
-class D {
-};
+class D { };
 
 } // namespace utils
 
@@ -93,11 +88,9 @@ template <typename T, typename V, int N> class F {
 /// This is an intermediate description of class G.
 ///
 /// This is a long description of class G.
-class G {
-};
+class G { };
 
-class NoComment {
-};
+class NoComment { };
 
 } // namespace t00050
 } // namespace clanguml
\ No newline at end of file
diff --git a/tests/t00053/t00053.cc b/tests/t00053/t00053.cc
index c93be191..5fac4af8 100644
--- a/tests/t00053/t00053.cc
+++ b/tests/t00053/t00053.cc
@@ -1,34 +1,20 @@
 namespace clanguml {
 namespace t00053 {
-struct a {
-};
-struct b {
-};
-struct c {
-};
-struct d {
-};
-struct e {
-};
-struct f {
-};
-struct g {
-};
+struct a { };
+struct b { };
+struct c { };
+struct d { };
+struct e { };
+struct f { };
+struct g { };
 
-struct A {
-};
-struct B {
-};
-struct C {
-};
-struct D {
-};
-struct E {
-};
-struct F {
-};
-struct G {
-};
+struct A { };
+struct B { };
+struct C { };
+struct D { };
+struct E { };
+struct F { };
+struct G { };
 
 enum class h { hhh };
 enum class i { iii };
diff --git a/tests/t00054/t00054.cc b/tests/t00054/t00054.cc
index 4f8080be..08c401a9 100644
--- a/tests/t00054/t00054.cc
+++ b/tests/t00054/t00054.cc
@@ -1,42 +1,28 @@
 namespace clanguml {
 namespace t00054 {
-struct a {
-};
-struct b {
-};
+struct a { };
+struct b { };
 
 namespace detail {
-struct c {
-};
-struct d {
-};
-struct e {
-};
+struct c { };
+struct d { };
+struct e { };
 } // namespace detail
-struct f {
-};
-struct g {
-};
+struct f { };
+struct g { };
 
-struct A {
-};
-struct B {
-};
+struct A { };
+struct B { };
 
 namespace detail2 {
-struct C {
-};
+struct C { };
 namespace detail3 {
-struct D {
-};
-struct E {
-};
+struct D { };
+struct E { };
 } // namespace detail3
-struct F {
-};
+struct F { };
 } // namespace detail2
-struct G {
-};
+struct G { };
 
 namespace detail4 {
 enum class h { hhh };
diff --git a/tests/t00055/t00055.cc b/tests/t00055/t00055.cc
index fb20f94f..16e9756a 100644
--- a/tests/t00055/t00055.cc
+++ b/tests/t00055/t00055.cc
@@ -1,24 +1,14 @@
 namespace clanguml {
 namespace t00055 {
-struct A {
-};
-struct B {
-};
-struct C {
-};
-struct D {
-};
-struct E {
-};
-struct F {
-};
-struct G {
-};
-struct H {
-};
-struct I {
-};
-struct J {
-};
+struct A { };
+struct B { };
+struct C { };
+struct D { };
+struct E { };
+struct F { };
+struct G { };
+struct H { };
+struct I { };
+struct J { };
 }
 }
\ No newline at end of file
diff --git a/tests/t00056/t00056.cc b/tests/t00056/t00056.cc
index 6fec5863..92d982de 100644
--- a/tests/t00056/t00056.cc
+++ b/tests/t00056/t00056.cc
@@ -7,10 +7,8 @@ template <typename T, typename L>
 concept greater_than_simple = sizeof(T) > sizeof(L);
 
 template <typename T, typename P>
-concept greater_than_with_requires = requires(T l, P r)
-{
-    sizeof(l) > sizeof(r);
-};
+concept greater_than_with_requires =
+    requires(T l, P r) { sizeof(l) > sizeof(r); };
 
 // Constraint expression
 template <typename T>
@@ -18,31 +16,26 @@ concept max_four_bytes = sizeof(T) <= 4;
 
 // Simple requirement
 template <typename T>
-concept iterable = requires(T container)
-{
-    container.begin();
-    container.end();
-};
+concept iterable = requires(T container) {
+                       container.begin();
+                       container.end();
+                   };
 
 // Type requirement
 template <typename T>
-concept has_value_type = requires
-{
-    typename T::value_type;
-};
+concept has_value_type = requires { typename T::value_type; };
 
 template <typename T>
-concept convertible_to_string = max_four_bytes<T> && requires(T s)
-{
-    std::string{s};
-    {
-        std::to_string(s)
-    }
-    noexcept;
-    {
-        std::to_string(s)
-        } -> std::same_as<std::string>;
-};
+concept convertible_to_string =
+    max_four_bytes<T> && requires(T s) {
+                             std::string{s};
+                             {
+                                 std::to_string(s)
+                             } noexcept;
+                             {
+                                 std::to_string(s)
+                                 } -> std::same_as<std::string>;
+                         };
 
 // Compound requirement
 // ...
@@ -62,29 +55,27 @@ template <max_four_bytes T> struct A {
 
 // Requires constant expression
 template <typename T>
-requires iterable_or_small_value_type<T>
+    requires iterable_or_small_value_type<T>
 struct B {
     T b;
 };
 
 // Anonymous concept requirement (TODO)
 template <convertible_to_string T>
-requires requires(T t)
-{
-    --t;
-    t--;
-}
+    requires requires(T t) {
+                 --t;
+                 t--;
+             }
 struct C {
     T c;
 };
 
 template <iterable T1, typename T2, iterable T3, typename T4, typename T5>
-requires max_four_bytes<T2> && max_four_bytes<T5>
-struct D {
-};
+    requires max_four_bytes<T2> && max_four_bytes<T5>
+struct D { };
 
 template <typename T1, typename T2, typename T3>
-requires greater_than_with_requires<T1, T3>
+    requires greater_than_with_requires<T1, T3>
 struct E {
     T1 e1;
     T2 e2;
@@ -92,7 +83,7 @@ struct E {
 };
 
 template <typename T1, typename T2, typename T3>
-requires greater_than_simple<T1, T3>
+    requires greater_than_simple<T1, T3>
 struct F {
     T1 f1;
     T2 f2;
diff --git a/tests/t00058/t00058.cc b/tests/t00058/t00058.cc
index 5232fc3b..e0ca24ee 100644
--- a/tests/t00058/t00058.cc
+++ b/tests/t00058/t00058.cc
@@ -23,13 +23,13 @@ concept same_as_first_type = std::is_same_v<std::remove_cvref_t<T>,
     std::remove_cvref_t<first_type_t<Args...>>>;
 
 template <typename T, typename... Args>
-requires same_as_first_type<T, Args...>
+    requires same_as_first_type<T, Args...>
 struct A {
     std::vector<T> a;
 };
 
 template <typename T, typename P, typename... Args>
-requires same_as_first_type<T, Args...>
+    requires same_as_first_type<T, Args...>
 struct B {
     std::vector<T> b;
     P bb;
diff --git a/tests/t00059/t00059.cc b/tests/t00059/t00059.cc
index 7b9b4240..314f1111 100644
--- a/tests/t00059/t00059.cc
+++ b/tests/t00059/t00059.cc
@@ -4,23 +4,16 @@ namespace clanguml {
 namespace t00059 {
 
 template <typename T>
-concept fruit_c = requires(T t)
-{
-    T{};
-    t.get_name();
-};
+concept fruit_c = requires(T t) {
+                      T{};
+                      t.get_name();
+                  };
 
 template <typename T>
-concept apple_c = fruit_c<T> && requires(T t)
-{
-    t.get_sweetness();
-};
+concept apple_c = fruit_c<T> && requires(T t) { t.get_sweetness(); };
 
 template <typename T>
-concept orange_c = fruit_c<T> && requires(T t)
-{
-    t.get_bitterness();
-};
+concept orange_c = fruit_c<T> && requires(T t) { t.get_bitterness(); };
 
 class gala_apple {
 public:
diff --git a/tests/t30002/t30002.cc b/tests/t30002/t30002.cc
index 159b6d41..864cd485 100644
--- a/tests/t30002/t30002.cc
+++ b/tests/t30002/t30002.cc
@@ -8,72 +8,55 @@ namespace clanguml {
 namespace t30002 {
 namespace A::AA {
 namespace A1 {
-struct CA {
-};
+struct CA { };
 }
 namespace A2 {
-struct CB {
-};
+struct CB { };
 }
 namespace A3 {
-struct CC {
-};
+struct CC { };
 }
 namespace A4 {
-struct CD {
-};
+struct CD { };
 }
 namespace A5 {
-struct CE {
-};
+struct CE { };
 }
 namespace A6 {
-struct CF {
-};
+struct CF { };
 }
 namespace A7 {
-struct CG {
-};
+struct CG { };
 }
 namespace A8 {
-struct CH {
-};
+struct CH { };
 }
 namespace A9 {
-struct CI {
-};
+struct CI { };
 }
 namespace A10 {
-struct CJ {
-};
+struct CJ { };
 }
 namespace A11 {
-struct CK {
-};
+struct CK { };
 }
 namespace A12 {
-struct CL {
-};
+struct CL { };
 }
 namespace A13 {
-struct CM {
-};
+struct CM { };
 }
 namespace A14 {
-struct CN {
-};
+struct CN { };
 }
 namespace A15 {
-struct CO {
-};
+struct CO { };
 }
 namespace A16 {
-struct CP {
-};
+struct CP { };
 }
 namespace A17 {
-struct CR {
-};
+struct CR { };
 }
 }
 namespace B::BB::BBB {
diff --git a/tests/t30003/t30003.cc b/tests/t30003/t30003.cc
index b83621a8..134e675d 100644
--- a/tests/t30003/t30003.cc
+++ b/tests/t30003/t30003.cc
@@ -3,30 +3,25 @@ namespace t30003 {
 
 namespace ns1 {
 namespace ns2_v1_0_0 {
-class A {
-};
+class A { };
 }
 
 namespace [[deprecated]] ns2_v0_9_0 {
-class A {
-};
+class A { };
 }
 
 namespace {
-class Anon final {
-};
+class Anon final { };
 }
 }
 
 namespace [[deprecated]] ns3 {
 
 namespace ns1::ns2 {
-class Anon : public t30003::ns1::ns2_v1_0_0::A {
-};
+class Anon : public t30003::ns1::ns2_v1_0_0::A { };
 }
 
-class B : public ns1::ns2::Anon {
-};
+class B : public ns1::ns2::Anon { };
 }
 }
 }
\ No newline at end of file
diff --git a/tests/t30005/t30005.cc b/tests/t30005/t30005.cc
index f87fad0a..43fc1947 100644
--- a/tests/t30005/t30005.cc
+++ b/tests/t30005/t30005.cc
@@ -2,8 +2,7 @@ namespace clanguml {
 namespace t30005 {
 
 namespace A::AA::AAA {
-struct C1 {
-};
+struct C1 { };
 }
 
 namespace B::BB::BBB {
diff --git a/tests/t30006/t30006.cc b/tests/t30006/t30006.cc
index d9778875..db5583d8 100644
--- a/tests/t30006/t30006.cc
+++ b/tests/t30006/t30006.cc
@@ -2,8 +2,7 @@ namespace clanguml {
 namespace t30006 {
 
 namespace B {
-struct BB {
-};
+struct BB { };
 }
 
 /// \uml{note[top] Top A note.}
@@ -14,8 +13,7 @@ struct A1 {
 }
 
 namespace C {
-struct CC {
-};
+struct CC { };
 }
 
 /// \uml{note[bottom] Bottom A note.}
diff --git a/tests/t30007/t30007.cc b/tests/t30007/t30007.cc
index e79461ab..a325d063 100644
--- a/tests/t30007/t30007.cc
+++ b/tests/t30007/t30007.cc
@@ -2,8 +2,7 @@ namespace clanguml {
 namespace t30007 {
 
 namespace B {
-struct BB {
-};
+struct BB { };
 }
 
 /// \uml{note[top] Compare layout with t30006.}
@@ -16,8 +15,7 @@ struct A1 {
 }
 
 namespace C {
-struct CC {
-};
+struct CC { };
 }
 
 /// \uml{note[bottom] Bottom A note.}
diff --git a/tests/t30008/t30008.cc b/tests/t30008/t30008.cc
index c7eca1df..7ccffca5 100644
--- a/tests/t30008/t30008.cc
+++ b/tests/t30008/t30008.cc
@@ -5,8 +5,7 @@ namespace dependants {
 namespace X {
 }
 namespace A {
-struct AA {
-};
+struct AA { };
 }
 namespace B {
 struct BB {
@@ -26,8 +25,7 @@ namespace Y {
 }
 
 namespace D {
-struct DD {
-};
+struct DD { };
 }
 namespace E {
 struct EE {
diff --git a/tests/test_cases.h b/tests/test_cases.h
index 1ff9fa73..d520d6d0 100644
--- a/tests/test_cases.h
+++ b/tests/test_cases.h
@@ -82,26 +82,19 @@ template <typename T, typename... Ts> constexpr bool has_type() noexcept
     return (std::is_same_v<T, Ts> || ... || false);
 }
 
-struct Public {
-};
+struct Public { };
 
-struct Protected {
-};
+struct Protected { };
 
-struct Private {
-};
+struct Private { };
 
-struct Abstract {
-};
+struct Abstract { };
 
-struct Static {
-};
+struct Static { };
 
-struct Const {
-};
+struct Const { };
 
-struct Default {
-};
+struct Default { };
 
 struct HasCallWithResultMatcher : ContainsMatcher {
     HasCallWithResultMatcher(