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

Updated clang-format to version 15

Browse Source
This commit is contained in:
Bartek Kryza
2023-03-01 20:22:00 +01:00
parent fe99b72099
commit cf0d87a0bf
39 changed files with 454 additions and 719 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
Makefile
View File

@@ -114,11 +114,11 @@ init_compile_commands: debug
.PHONY: clang-format .PHONY: clang-format
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 .PHONY: format
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 .PHONY: debug_tidy
tidy: debug_tidy tidy: debug_tidy

168
tests/catch.h
View File

@@ -532,8 +532,7 @@ unsigned int rngSeed();
// We need a dummy global operator<< so we can bring it into Catch namespace // We need a dummy global operator<< so we can bring it into Catch namespace
// later // later
struct Catch_global_namespace_dummy { struct Catch_global_namespace_dummy { };
};
std::ostream &operator<<(std::ostream &, Catch_global_namespace_dummy); std::ostream &operator<<(std::ostream &, Catch_global_namespace_dummy);
namespace Catch { namespace Catch {
@@ -914,17 +913,15 @@ constexpr auto operator"" _catch_sr(
N N
#define INTERNAL_CATCH_TYPE_GEN \ #define INTERNAL_CATCH_TYPE_GEN \
template <typename...> struct TypeList { \ template <typename...> struct TypeList { }; \
}; \
template <typename... Ts> \ template <typename... Ts> \
constexpr auto get_wrapper() noexcept->TypeList<Ts...> \ constexpr auto get_wrapper() noexcept -> TypeList<Ts...> \
{ \ { \
return {}; \ return {}; \
} \ } \
template <template <typename...> class...> struct TemplateTypeList { \ template <template <typename...> class...> struct TemplateTypeList { }; \
}; \
template <template <typename...> class... Cs> \ template <template <typename...> class... Cs> \
constexpr auto get_wrapper() noexcept->TemplateTypeList<Cs...> \ constexpr auto get_wrapper() noexcept -> TemplateTypeList<Cs...> \
{ \ { \
return {}; \ return {}; \
} \ } \
@@ -976,18 +973,16 @@ constexpr auto operator"" _catch_sr(
}; };
#define INTERNAL_CATCH_NTTP_1(signature, ...) \ #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)> \ template <INTERNAL_CATCH_REMOVE_PARENS(signature)> \
constexpr auto get_wrapper() noexcept->Nttp<__VA_ARGS__> \ constexpr auto get_wrapper() noexcept -> Nttp<__VA_ARGS__> \
{ \ { \
return {}; \ return {}; \
} \ } \
template <template <INTERNAL_CATCH_REMOVE_PARENS(signature)> class...> \ template <template <INTERNAL_CATCH_REMOVE_PARENS(signature)> class...> \
struct NttpTemplateTypeList { \ struct NttpTemplateTypeList { }; \
}; \
template <template <INTERNAL_CATCH_REMOVE_PARENS(signature)> class... Cs> \ template <template <INTERNAL_CATCH_REMOVE_PARENS(signature)> class... Cs> \
constexpr auto get_wrapper() noexcept->NttpTemplateTypeList<Cs...> \ constexpr auto get_wrapper() noexcept -> NttpTemplateTypeList<Cs...> \
{ \ { \
return {}; \ return {}; \
} \ } \
@@ -1283,11 +1278,9 @@ constexpr auto operator"" _catch_sr(
#include <type_traits> #include <type_traits>
namespace Catch { 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 { struct is_callable_tester {
template <typename Fun, typename... Args> template <typename Fun, typename... Args>
true_given<decltype(std::declval<Fun>()( true_given<decltype(std::declval<Fun>()(
@@ -1299,8 +1292,7 @@ template <typename T> struct is_callable;
template <typename Fun, typename... Args> template <typename Fun, typename... Args>
struct is_callable<Fun(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 #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 // std::result_of is deprecated in C++17 and removed in C++20. Hence, it is
@@ -1383,8 +1375,7 @@ struct AutoReg : NonCopyable {
#define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION_2( \ #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION_2( \
TestNameClass, TestName, ClassName, Name, Tags, Signature, ...) \ TestNameClass, TestName, ClassName, Name, Tags, Signature, ...) \
namespace { \ namespace { \
namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName) \ namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName) { \
{ \
INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD( \ INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD( \
TestName, ClassName, INTERNAL_CATCH_REMOVE_PARENS(Signature)); \ TestName, ClassName, INTERNAL_CATCH_REMOVE_PARENS(Signature)); \
} \ } \
@@ -1532,8 +1523,7 @@ struct AutoReg : NonCopyable {
INTERNAL_CATCH_DECLARE_SIG_TEST( \ INTERNAL_CATCH_DECLARE_SIG_TEST( \
TestFunc, INTERNAL_CATCH_REMOVE_PARENS(Signature)); \ TestFunc, INTERNAL_CATCH_REMOVE_PARENS(Signature)); \
namespace { \ namespace { \
namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName) \ namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName) { \
{ \
INTERNAL_CATCH_TYPE_GEN \ INTERNAL_CATCH_TYPE_GEN \
INTERNAL_CATCH_NTTP_GEN(INTERNAL_CATCH_REMOVE_PARENS(Signature)) \ INTERNAL_CATCH_NTTP_GEN(INTERNAL_CATCH_REMOVE_PARENS(Signature)) \
INTERNAL_CATCH_NTTP_REG_GEN( \ INTERNAL_CATCH_NTTP_REG_GEN( \
@@ -1545,16 +1535,15 @@ struct AutoReg : NonCopyable {
constexpr char const *tmpl_types[] = {CATCH_REC_LIST( \ constexpr char const *tmpl_types[] = {CATCH_REC_LIST( \
INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, __VA_ARGS__)}; \ INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, __VA_ARGS__)}; \
using expander = int[]; \ using expander = int[]; \
(void)expander{(reg_test(Types{}, \ (void)expander{ \
Catch::NameAndTags{Name " - " + \ (reg_test(Types{}, \
std::string(tmpl_types[index]), \ Catch::NameAndTags{ \
Tags}), \ Name " - " + std::string(tmpl_types[index]), Tags}), \
index++)...}; /* NOLINT */ \ index++)...}; /* NOLINT */ \
} \ } \
}; \ }; \
static int INTERNAL_CATCH_UNIQUE_NAME(globalRegistrar) = []() { \ static int INTERNAL_CATCH_UNIQUE_NAME(globalRegistrar) = []() { \
TestName<INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES( \ TestName<INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES(__VA_ARGS__)>(); \
__VA_ARGS__)>(); \
return 0; \ return 0; \
}(); \ }(); \
} \ } \
@@ -1603,8 +1592,7 @@ struct AutoReg : NonCopyable {
CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \ CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
template <typename TestType> static void TestFuncName(); \ template <typename TestType> static void TestFuncName(); \
namespace { \ namespace { \
namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName) \ namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName) { \
{ \
INTERNAL_CATCH_TYPE_GEN \ INTERNAL_CATCH_TYPE_GEN \
INTERNAL_CATCH_NTTP_GEN(INTERNAL_CATCH_REMOVE_PARENS(Signature)) \ INTERNAL_CATCH_NTTP_GEN(INTERNAL_CATCH_REMOVE_PARENS(Signature)) \
template <typename... Types> struct TestName { \ template <typename... Types> struct TestName { \
@@ -1620,23 +1608,19 @@ struct AutoReg : NonCopyable {
INTERNAL_CATCH_REMOVE_PARENS(TypesList))}; \ INTERNAL_CATCH_REMOVE_PARENS(TypesList))}; \
constexpr auto num_types = \ constexpr auto num_types = \
sizeof(types_list) / sizeof(types_list[0]); \ sizeof(types_list) / sizeof(types_list[0]); \
(void)expander{ \ (void)expander{( \
(Catch::AutoReg( \ Catch::AutoReg(Catch::makeTestInvoker(&TestFuncName<Types>), \
Catch::makeTestInvoker(&TestFuncName<Types>), \
CATCH_INTERNAL_LINEINFO, Catch::StringRef(), \ CATCH_INTERNAL_LINEINFO, Catch::StringRef(), \
Catch::NameAndTags{Name " - " + \ Catch::NameAndTags{Name " - " + \
std::string(tmpl_types[index / num_types]) + \ std::string(tmpl_types[index / num_types]) + "<" + \
"<" + \ std::string(types_list[index % num_types]) + ">", \
std::string(types_list[index % num_types]) + \
">", \
Tags}), \ Tags}), \
index++)...}; /* NOLINT */ \ index++)...}; /* NOLINT */ \
} \ } \
}; \ }; \
static int INTERNAL_CATCH_UNIQUE_NAME(globalRegistrar) = []() { \ static int INTERNAL_CATCH_UNIQUE_NAME(globalRegistrar) = []() { \
using TestInit = typename create<TestName, \ using TestInit = typename create<TestName, \
decltype(get_wrapper<INTERNAL_CATCH_REMOVE_PARENS( \ decltype(get_wrapper<INTERNAL_CATCH_REMOVE_PARENS(TmplTypes)>()), \
TmplTypes)>()), \
TypeList<INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES( \ TypeList<INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES( \
INTERNAL_CATCH_REMOVE_PARENS(TypesList))>>::type; \ INTERNAL_CATCH_REMOVE_PARENS(TypesList))>>::type; \
TestInit t; \ TestInit t; \
@@ -1689,8 +1673,7 @@ struct AutoReg : NonCopyable {
CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \ CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
template <typename TestType> static void TestFunc(); \ template <typename TestType> static void TestFunc(); \
namespace { \ namespace { \
namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName) \ namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName) { \
{ \
INTERNAL_CATCH_TYPE_GEN \ INTERNAL_CATCH_TYPE_GEN \
template <typename... Types> struct TestName { \ template <typename... Types> struct TestName { \
void reg_tests() \ void reg_tests() \
@@ -1701,8 +1684,7 @@ struct AutoReg : NonCopyable {
(Catch::AutoReg(Catch::makeTestInvoker(&TestFunc<Types>), \ (Catch::AutoReg(Catch::makeTestInvoker(&TestFunc<Types>), \
CATCH_INTERNAL_LINEINFO, Catch::StringRef(), \ CATCH_INTERNAL_LINEINFO, Catch::StringRef(), \
Catch::NameAndTags{Name " - " + \ Catch::NameAndTags{Name " - " + \
std::string( \ std::string(INTERNAL_CATCH_STRINGIZE(TmplList)) + \
INTERNAL_CATCH_STRINGIZE(TmplList)) + \
" - " + std::to_string(index), \ " - " + std::to_string(index), \
Tags}), \ Tags}), \
index++)...}; /* NOLINT */ \ index++)...}; /* NOLINT */ \
@@ -1733,8 +1715,7 @@ struct AutoReg : NonCopyable {
CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS \ CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS \
CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \ CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
namespace { \ namespace { \
namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName) \ namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName) { \
{ \
INTERNAL_CATCH_TYPE_GEN \ INTERNAL_CATCH_TYPE_GEN \
INTERNAL_CATCH_NTTP_GEN(INTERNAL_CATCH_REMOVE_PARENS(Signature)) \ INTERNAL_CATCH_NTTP_GEN(INTERNAL_CATCH_REMOVE_PARENS(Signature)) \
INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD( \ INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD( \
@@ -1748,10 +1729,10 @@ struct AutoReg : NonCopyable {
constexpr char const *tmpl_types[] = {CATCH_REC_LIST( \ constexpr char const *tmpl_types[] = {CATCH_REC_LIST( \
INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, __VA_ARGS__)}; \ INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, __VA_ARGS__)}; \
using expander = int[]; \ using expander = int[]; \
(void)expander{(reg_test(Types{}, #ClassName, \ (void)expander{ \
Catch::NameAndTags{Name " - " + \ (reg_test(Types{}, #ClassName, \
std::string(tmpl_types[index]), \ Catch::NameAndTags{ \
Tags}), \ Name " - " + std::string(tmpl_types[index]), Tags}), \
index++)...}; /* NOLINT */ \ index++)...}; /* NOLINT */ \
} \ } \
}; \ }; \
@@ -1811,8 +1792,7 @@ struct AutoReg : NonCopyable {
void test(); \ void test(); \
}; \ }; \
namespace { \ namespace { \
namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestNameClass) \ namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestNameClass) { \
{ \
INTERNAL_CATCH_TYPE_GEN \ INTERNAL_CATCH_TYPE_GEN \
INTERNAL_CATCH_NTTP_GEN(INTERNAL_CATCH_REMOVE_PARENS(Signature)) \ INTERNAL_CATCH_NTTP_GEN(INTERNAL_CATCH_REMOVE_PARENS(Signature)) \
template <typename... Types> struct TestNameClass { \ template <typename... Types> struct TestNameClass { \
@@ -1828,23 +1808,19 @@ struct AutoReg : NonCopyable {
INTERNAL_CATCH_REMOVE_PARENS(TypesList))}; \ INTERNAL_CATCH_REMOVE_PARENS(TypesList))}; \
constexpr auto num_types = \ constexpr auto num_types = \
sizeof(types_list) / sizeof(types_list[0]); \ sizeof(types_list) / sizeof(types_list[0]); \
(void)expander{ \ (void)expander{( \
(Catch::AutoReg( \ Catch::AutoReg(Catch::makeTestInvoker(&TestName<Types>::test), \
Catch::makeTestInvoker(&TestName<Types>::test), \
CATCH_INTERNAL_LINEINFO, #ClassName, \ CATCH_INTERNAL_LINEINFO, #ClassName, \
Catch::NameAndTags{Name " - " + \ Catch::NameAndTags{Name " - " + \
std::string(tmpl_types[index / num_types]) + \ std::string(tmpl_types[index / num_types]) + "<" + \
"<" + \ std::string(types_list[index % num_types]) + ">", \
std::string(types_list[index % num_types]) + \
">", \
Tags}), \ Tags}), \
index++)...}; /* NOLINT */ \ index++)...}; /* NOLINT */ \
} \ } \
}; \ }; \
static int INTERNAL_CATCH_UNIQUE_NAME(globalRegistrar) = []() { \ static int INTERNAL_CATCH_UNIQUE_NAME(globalRegistrar) = []() { \
using TestInit = typename create<TestNameClass, \ using TestInit = typename create<TestNameClass, \
decltype(get_wrapper<INTERNAL_CATCH_REMOVE_PARENS( \ decltype(get_wrapper<INTERNAL_CATCH_REMOVE_PARENS(TmplTypes)>()), \
TmplTypes)>()), \
TypeList<INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES( \ TypeList<INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES( \
INTERNAL_CATCH_REMOVE_PARENS(TypesList))>>::type; \ INTERNAL_CATCH_REMOVE_PARENS(TypesList))>>::type; \
TestInit t; \ TestInit t; \
@@ -1904,21 +1880,18 @@ struct AutoReg : NonCopyable {
void test(); \ void test(); \
}; \ }; \
namespace { \ namespace { \
namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName) \ namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName) { \
{ \
INTERNAL_CATCH_TYPE_GEN \ INTERNAL_CATCH_TYPE_GEN \
template <typename... Types> struct TestNameClass { \ template <typename... Types> struct TestNameClass { \
void reg_tests() \ void reg_tests() \
{ \ { \
int index = 0; \ int index = 0; \
using expander = int[]; \ using expander = int[]; \
(void)expander{ \ (void)expander{( \
(Catch::AutoReg( \ Catch::AutoReg(Catch::makeTestInvoker(&TestName<Types>::test), \
Catch::makeTestInvoker(&TestName<Types>::test), \
CATCH_INTERNAL_LINEINFO, #ClassName, \ CATCH_INTERNAL_LINEINFO, #ClassName, \
Catch::NameAndTags{Name " - " + \ Catch::NameAndTags{Name " - " + \
std::string( \ std::string(INTERNAL_CATCH_STRINGIZE(TmplList)) + \
INTERNAL_CATCH_STRINGIZE(TmplList)) + \
" - " + std::to_string(index), \ " - " + std::to_string(index), \
Tags}), \ Tags}), \
index++)...}; /* NOLINT */ \ index++)...}; /* NOLINT */ \
@@ -2592,18 +2565,16 @@ template <typename...> struct void_type {
using type = void; 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> template <typename T>
struct is_range_impl<T, struct is_range_impl<T,
typename void_type<decltype(begin(std::declval<T>()))>::type> typename void_type<decltype(begin(std::declval<T>()))>::type>
: std::true_type { : std::true_type { };
};
} // namespace detail } // 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 #if defined(_MANAGED) // Managed types are never ranges
template <typename T> struct is_range<T ^> { template <typename T> struct is_range<T ^> {
@@ -3176,8 +3147,7 @@ IResultCapture &getResultCapture();
// end catch_interfaces_capture.h // end catch_interfaces_capture.h
namespace Catch { namespace Catch {
struct TestFailureException { struct TestFailureException { };
};
struct AssertionResultData; struct AssertionResultData;
struct IResultCapture; struct IResultCapture;
class RunContext; class RunContext;
@@ -3359,7 +3329,10 @@ public:
#define INTERNAL_CATCH_TRY try #define INTERNAL_CATCH_TRY try
#define INTERNAL_CATCH_CATCH(handler) \ #define INTERNAL_CATCH_CATCH(handler) \
catch (...) { handler.handleUnexpectedInflightException(); } catch (...) \
{ \
handler.handleUnexpectedInflightException(); \
}
#endif #endif
@@ -4908,8 +4881,7 @@ GeneratorWrapper<std::tuple<Ts...>> table(
// Tag type to signal that a generator sequence should convert arguments to a // Tag type to signal that a generator sequence should convert arguments to a
// specific type // specific type
template <typename T> struct as { template <typename T> struct as { };
};
template <typename T, typename... Gs> template <typename T, typename... Gs>
auto makeGenerators(GeneratorWrapper<T> &&generator, Gs &&...moreGenerators) auto makeGenerators(GeneratorWrapper<T> &&generator, Gs &&...moreGenerators)
@@ -5300,11 +5272,11 @@ public:
{ {
} }
Option(T const &_value) Option(T const &_value)
: nullableValue(new (storage) T(_value)) : nullableValue(new(storage) T(_value))
{ {
} }
Option(Option const &_other) 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; using type = T;
}; };
template <> struct CompleteType<void> { template <> struct CompleteType<void> {
struct type { struct type { };
};
}; };
template <typename T> using CompleteType_t = typename CompleteType<T>::type; template <typename T> using CompleteType_t = typename CompleteType<T>::type;
@@ -7681,8 +7652,7 @@ namespace Benchmark {
namespace Detail { namespace Detail {
template <typename T> using Decay = typename std::decay<T>::type; template <typename T> using Decay = typename std::decay<T>::type;
template <typename T, typename U> 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 /// We need to reinvent std::function because every piece of code that might add
/// overhead in a measurement context needs to have consistent performance /// overhead in a measurement context needs to have consistent performance
@@ -8698,8 +8668,8 @@ public:
} // namespace TestCaseTracking } // namespace TestCaseTracking
using TestCaseTracking::ITracker; using TestCaseTracking::ITracker;
using TestCaseTracking::TrackerContext;
using TestCaseTracking::SectionTracker; using TestCaseTracking::SectionTracker;
using TestCaseTracking::TrackerContext;
} // namespace Catch } // namespace Catch
@@ -8886,8 +8856,8 @@ double outlier_variance(Estimate<double> mean, Estimate<double> stddev, int n)
return (nc / n) * (sb2 - nc * sg2); return (nc / n) * (sb2 - nc * sg2);
}; };
return (std::min)(var_out(1), return (std::min)(
var_out((std::min)(c_max(0.), c_max(mg_min)))) / var_out(1), var_out((std::min)(c_max(0.), c_max(mg_min)))) /
sb2; sb2;
} }
@@ -9844,8 +9814,7 @@ class Columns {
public: public:
class iterator { class iterator {
friend Columns; friend Columns;
struct EndTag { struct EndTag { };
};
std::vector<Column> const &m_columns; std::vector<Column> const &m_columns;
std::vector<Column::iterator> m_iterators; std::vector<Column::iterator> m_iterators;
@@ -9995,8 +9964,7 @@ namespace detail {
// Traits for extracting arg and return type of lambdas (for single argument // Traits for extracting arg and return type of lambdas (for single argument
// lambdas) // lambdas)
template <typename L> template <typename L>
struct UnaryLambdaTraits : UnaryLambdaTraits<decltype(&L::operator())> { struct UnaryLambdaTraits : UnaryLambdaTraits<decltype(&L::operator())> { };
};
template <typename ClassT, typename ReturnT, typename... Args> template <typename ClassT, typename ReturnT, typename... Args>
struct UnaryLambdaTraits<ReturnT (ClassT::*)(Args...) const> { struct UnaryLambdaTraits<ReturnT (ClassT::*)(Args...) const> {
@@ -10805,7 +10773,7 @@ struct Help : Opt {
return ParserResult::ok(ParseResultType::ShortCircuitAll); return ParserResult::ok(ParseResultType::ShortCircuitAll);
}) })
{ {
static_cast<Opt &> (*this)( static_cast<Opt &>(*this)(
"display usage information")["-?"]["-h"]["--help"] "display usage information")["-?"]["-h"]["--help"]
.optional(); .optional();
} }
@@ -15277,8 +15245,8 @@ int Session::runInternal()
// the return value to 255 prevents false negative when some multiple // the return value to 255 prevents false negative when some multiple
// of 256 tests has failed // of 256 tests has failed
return (std::min)(MaxExitCode, return (std::min)(MaxExitCode,
(std::max)(totals.error, (std::max)(
static_cast<int>(totals.assertions.failed))); totals.error, static_cast<int>(totals.assertions.failed)));
} }
#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS) #if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
catch (std::exception &ex) catch (std::exception &ex)
@@ -16409,8 +16377,8 @@ std::string const &SectionTracker::trimmedName() const
} // namespace TestCaseTracking } // namespace TestCaseTracking
using TestCaseTracking::ITracker; using TestCaseTracking::ITracker;
using TestCaseTracking::TrackerContext;
using TestCaseTracking::SectionTracker; using TestCaseTracking::SectionTracker;
using TestCaseTracking::TrackerContext;
} // namespace Catch } // namespace Catch
@@ -18283,10 +18251,8 @@ struct ColumnInfo {
int width; int width;
Justification justification; Justification justification;
}; };
struct ColumnBreak { struct ColumnBreak { };
}; struct RowBreak { };
struct RowBreak {
};
class Duration { class Duration {
enum class Unit { enum class Unit {

9
tests/t00004/t00004.cc
View File

@@ -14,8 +14,7 @@ public:
public: public:
enum class Lights { Green, Yellow, Red }; enum class Lights { Green, Yellow, Red };
class AAA { class AAA { };
};
}; };
void foo2() const { } void foo2() const { }
@@ -26,8 +25,7 @@ public:
T t; T t;
class AA { class AA {
class AAA { class AAA { };
};
enum class CCC { CCC_1, CCC_2 }; enum class CCC { CCC_1, CCC_2 };
}; };
@@ -46,8 +44,7 @@ class D {
public: public:
enum class AA { AA_1, AA_2, AA_3 }; enum class AA { AA_1, AA_2, AA_3 };
class DD { class DD { };
};
}; };
} }

33
tests/t00005/t00005.cc
View File

@@ -1,37 +1,26 @@
namespace clanguml { namespace clanguml {
namespace t00005 { 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 { class R {
public: public:

48
tests/t00006/t00006.cc
View File

@@ -4,53 +4,37 @@
namespace clanguml { namespace clanguml {
namespace t00006 { 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 { template <typename T> class custom_container {
public: public:

9
tests/t00007/t00007.cc
View File

@@ -2,14 +2,11 @@
namespace clanguml { namespace clanguml {
namespace t00007 { namespace t00007 {
class A { class A { };
};
class B { class B { };
};
class C { class C { };
};
class R { class R {
public: public:

3
tests/t00011/t00011.cc
View File

@@ -1,6 +1,5 @@
namespace external { namespace external {
class C { class C { };
};
} }
namespace clanguml { namespace clanguml {

15
tests/t00015/t00015.cc
View File

@@ -3,30 +3,25 @@ namespace t00015 {
namespace ns1 { namespace ns1 {
inline namespace ns2_v1_0_0 { inline namespace ns2_v1_0_0 {
class A { class A { };
};
} }
namespace ns2_v0_9_0 { namespace ns2_v0_9_0 {
class [[deprecated]] A { class [[deprecated]] A { };
};
} }
namespace { namespace {
class Anon final : public A { class Anon final : public A { };
};
} }
} // namespace ns1 } // namespace ns1
namespace ns3 { namespace ns3 {
namespace ns1::ns2 { 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 t00015
} // namespace clanguml } // namespace clanguml

33
tests/t00017/t00017.cc
View File

@@ -2,38 +2,27 @@
namespace clanguml { namespace clanguml {
namespace t00017 { 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 { class R {
explicit R(int &some_int, C &cc, const E &ee, F &&ff, I *&ii) explicit R(int &some_int, C &cc, const E &ee, F &&ff, I *&ii)

15
tests/t00028/t00028.cc
View File

@@ -5,25 +5,21 @@ namespace clanguml {
namespace t00028 { namespace t00028 {
/// \uml{note[top] A class note.} /// \uml{note[top] A class note.}
class A { class A { };
};
/// \uml{note[] B class note.} /// \uml{note[] B class note.}
class B { class B { };
};
/// ///
/// @uml{note:t00028_class[bottom] C class note.} /// @uml{note:t00028_class[bottom] C class note.}
/// This is class C. /// This is class C.
class C { class C { };
};
/// \uml{note /// \uml{note
/// D /// D
/// class /// class
/// note.} /// note.}
class D { class D { };
};
/// \uml{note E template class note.} /// \uml{note E template class note.}
template <typename T> class E { template <typename T> class E {
@@ -31,8 +27,7 @@ template <typename T> class E {
}; };
/// \uml{note:other_diagram[left] G class note.} /// \uml{note:other_diagram[left] G class note.}
class G { class G { };
};
/// @uml{note[ bottom ] F enum note.} /// @uml{note[ bottom ] F enum note.}
enum class F { one, two, three }; enum class F { one, two, three };

18
tests/t00029/t00029.cc
View File

@@ -4,12 +4,10 @@
namespace clanguml { namespace clanguml {
namespace t00029 { namespace t00029 {
class A { class A { };
};
/// \uml{skip} /// \uml{skip}
class B { class B { };
};
template <typename T> class C { template <typename T> class C {
T param; T param;
@@ -25,17 +23,13 @@ enum class E { one, two, three };
/// \uml{skip} /// \uml{skip}
enum class F { red, green, blue }; enum class F { red, green, blue };
class G1 { class G1 { };
};
class G2 { class G2 { };
};
class G3 { class G3 { };
};
class G4 { class G4 { };
};
struct R { struct R {
G1 g1; G1 g1;

15
tests/t00030/t00030.cc
View File

@@ -4,20 +4,15 @@
namespace clanguml { namespace clanguml {
namespace t00030 { namespace t00030 {
class A { class A { };
};
class B { class B { };
};
class C { class C { };
};
class D { class D { };
};
class E { class E { };
};
struct R { struct R {
/// @uml{association[]} /// @uml{association[]}

6
tests/t00031/t00031.cc
View File

@@ -5,8 +5,7 @@ namespace clanguml {
namespace t00031 { namespace t00031 {
/// @uml{style[#back:lightgreen|yellow;header:blue/red]} /// @uml{style[#back:lightgreen|yellow;header:blue/red]}
class A { class A { };
};
/// @uml{style[#line.dotted:blue]} /// @uml{style[#line.dotted:blue]}
enum B { one, two, three }; enum B { one, two, three };
@@ -16,8 +15,7 @@ template <typename T> class C {
T ttt; T ttt;
}; };
class D { class D { };
};
struct R { struct R {
/// @uml{style[#red,dashed,thickness=2]} /// @uml{style[#red,dashed,thickness=2]}

6
tests/t00032/t00032.cc
View File

@@ -4,11 +4,9 @@
namespace clanguml { namespace clanguml {
namespace t00032 { namespace t00032 {
struct Base { struct Base { };
};
struct TBase { struct TBase { };
};
struct A { struct A {
void operator()() { } void operator()() { }

3
tests/t00034/t00034.cc
View File

@@ -40,8 +40,7 @@ template <> struct drop_void<Void> {
template <typename T> using drop_void_t = typename drop_void<T>::type; template <typename T> using drop_void_t = typename drop_void<T>::type;
struct A { struct A { };
};
struct R { struct R {
lift_void_t<A> *la; lift_void_t<A> *la;

15
tests/t00035/t00035.cc
View File

@@ -1,20 +1,15 @@
namespace clanguml { namespace clanguml {
namespace t00035 { 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 t00035
} // namespace clanguml } // namespace clanguml

3
tests/t00036/t00036.cc
View File

@@ -25,8 +25,7 @@ namespace ns2 {
namespace ns22 { namespace ns22 {
// TODO: Fix for incomplete struct C declaration "struct C;" // TODO: Fix for incomplete struct C declaration "struct C;"
struct C { struct C { };
};
} }
} }

30
tests/t00038/t00038.cc
View File

@@ -7,12 +7,10 @@ namespace thirdparty {
namespace ns1 { namespace ns1 {
enum class color_t { red, green, blue }; enum class color_t { red, green, blue };
struct E { struct E { };
};
} // namespace ns1 } // namespace ns1
namespace ns2 { namespace ns2 {
struct F { struct F { };
};
} // namespace ns2 } // namespace ns2
} // namespace thirdparty } // namespace thirdparty
@@ -21,41 +19,33 @@ namespace t00038 {
enum class property_t { property_a, property_b, property_c }; enum class property_t { property_a, property_b, property_c };
struct A { struct A { };
}; struct B { };
struct B { struct C { };
};
struct C {
};
struct key_t { struct key_t {
std::string key; std::string key;
}; };
template <typename T> struct map { template <typename T> struct map { };
};
using namespace thirdparty::ns1; 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 <> template <>
struct map<std::integral_constant<clanguml::t00038::property_t, struct map<std::integral_constant<clanguml::t00038::property_t,
clanguml::t00038::property_t::property_a>> : A { clanguml::t00038::property_t::property_a>> : A { };
};
template <> template <>
struct map<std::vector< struct map<std::vector<
std::integral_constant<t00038::property_t, t00038::property_t::property_b>>> std::integral_constant<t00038::property_t, t00038::property_t::property_b>>>
: B { : B { };
};
template <> template <>
struct map<std::map<key_t, struct map<std::map<key_t,
std::vector<std::integral_constant<property_t, property_t::property_c>>>> std::vector<std::integral_constant<property_t, property_t::property_c>>>>
: C { : C { };
};
} // namespace t00038 } // namespace t00038
} // namespace clanguml } // namespace clanguml

36
tests/t00039/t00039.cc
View File

@@ -1,50 +1,38 @@
#include <string> #include <string>
namespace clanguml::t00039 { namespace clanguml::t00039 {
struct B { struct B { };
};
struct C { struct C { };
};
struct D { struct D { };
};
struct E { struct E { };
};
namespace ns1 { namespace ns1 {
struct BB : public B { struct BB : public B { };
};
} // namespace ns1 } // 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 { struct AAA : public AA {
B *b; B *b;
}; };
namespace ns2 { namespace ns2 {
struct AAAA : public virtual AAA { struct AAAA : public virtual AAA { };
};
} // namespace ns2 } // namespace ns2
namespace detail { namespace detail {
struct AA : public A { struct AA : public A { };
};
} // namespace detail } // namespace detail
namespace ns3 { namespace ns3 {

3
tests/t00040/t00040.cc
View File

@@ -1,7 +1,6 @@
namespace clanguml::t00040 { namespace clanguml::t00040 {
struct B { struct B { };
};
struct A { struct A {
public: public:

33
tests/t00041/t00041.cc
View File

@@ -1,16 +1,12 @@
namespace clanguml::t00041 { 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; struct RR;
@@ -18,15 +14,12 @@ struct D {
RR *rr; RR *rr;
}; };
struct E { struct E { };
};
struct F { struct F { };
};
namespace detail { namespace detail {
struct G { struct G { };
};
} // namespace detail } // namespace detail
struct RR : public R { struct RR : public R {
@@ -35,18 +28,14 @@ struct RR : public R {
detail::G *g; detail::G *g;
}; };
struct RRR : public RR { struct RRR : public RR { };
};
namespace ns1 { 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 } // namespace clanguml::t00041

12
tests/t00043/t00043.cc
View File

@@ -1,8 +1,7 @@
namespace clanguml::t00043 { namespace clanguml::t00043 {
namespace dependants { namespace dependants {
struct A { struct A { };
};
struct B { struct B {
void b(A *a) { } void b(A *a) { }
@@ -25,17 +24,14 @@ struct E {
void e(D *d) { } void e(D *d) { }
}; };
struct F { struct F { };
};
} // namespace dependants } // namespace dependants
namespace dependencies { namespace dependencies {
struct G { struct G { };
};
struct GG { struct GG { };
};
struct H { struct H {
void h(G *g) { } void h(G *g) { }

3
tests/t00044/t00044.cc
View File

@@ -21,8 +21,7 @@ private:
}; };
template <typename Ret, typename... Args, typename A> 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> template <typename Ret, typename... Args, typename A>
sink(signal_handler<Ret(Args...), A> &) sink(signal_handler<Ret(Args...), A> &)

30
tests/t00045/t00045.cc
View File

@@ -1,11 +1,8 @@
class A { class A { };
};
class AA { class AA { };
};
class AAA { class AAA { };
};
template <typename T> class AAAA { template <typename T> class AAAA {
T t; T t;
@@ -13,28 +10,21 @@ template <typename T> class AAAA {
namespace ns1 { namespace ns1 {
class A { class A { };
};
namespace ns2 { 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 { class R {
public: public:

24
tests/t00046/t00046.cc
View File

@@ -1,33 +1,25 @@
#include <cstdint> #include <cstdint>
#include <vector> #include <vector>
class A { class A { };
};
class AA { class AA { };
};
namespace ns1 { namespace ns1 {
class A { class A { };
};
namespace ns2 { 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 { class R {
public: public:

21
tests/t00050/t00050.cc
View File

@@ -1,14 +1,12 @@
namespace clanguml { namespace clanguml {
/// Vivamus integer non suscipit taciti mus /// Vivamus integer non suscipit taciti mus
class A { class A { };
};
namespace t00050 { namespace t00050 {
/// Lorem ipsum dolor sit /// Lorem ipsum dolor sit
class A { class A { };
};
/** /**
* \brief Lorem ipsum * \brief Lorem ipsum
@@ -23,8 +21,7 @@ class A {
* \todo 2. Write tests * \todo 2. Write tests
* \todo 3. Implement * \todo 3. Implement
*/ */
class B { class B { };
};
/// \brief Long comment example /// \brief Long comment example
/// ///
@@ -53,8 +50,7 @@ class B {
/// imperdiet praesent magnis ridiculus congue gravida curabitur dictum /// imperdiet praesent magnis ridiculus congue gravida curabitur dictum
/// sagittis, enim et magna sit inceptos sodales parturient pharetra mollis, /// sagittis, enim et magna sit inceptos sodales parturient pharetra mollis,
/// aenean vel nostra tellus commodo pretium sapien sociosqu. /// aenean vel nostra tellus commodo pretium sapien sociosqu.
class C { class C { };
};
/// Mollis pretium lorem primis /// Mollis pretium lorem primis
namespace utils { namespace utils {
@@ -66,8 +62,7 @@ namespace utils {
/// tellus ligula porttitor metus. /// tellus ligula porttitor metus.
/// ///
/// \todo Implement... /// \todo Implement...
class D { class D { };
};
} // namespace utils } // 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 an intermediate description of class G.
/// ///
/// This is a long description of class G. /// This is a long description of class G.
class G { class G { };
};
class NoComment { class NoComment { };
};
} // namespace t00050 } // namespace t00050
} // namespace clanguml } // namespace clanguml

42
tests/t00053/t00053.cc
View File

@@ -1,34 +1,20 @@
namespace clanguml { namespace clanguml {
namespace t00053 { namespace t00053 {
struct a { struct a { };
}; struct b { };
struct b { struct c { };
}; struct d { };
struct c { struct e { };
}; struct f { };
struct d { struct g { };
};
struct e {
};
struct f {
};
struct g {
};
struct A { struct A { };
}; struct B { };
struct B { struct C { };
}; struct D { };
struct C { struct E { };
}; struct F { };
struct D { struct G { };
};
struct E {
};
struct F {
};
struct G {
};
enum class h { hhh }; enum class h { hhh };
enum class i { iii }; enum class i { iii };

42
tests/t00054/t00054.cc
View File

@@ -1,42 +1,28 @@
namespace clanguml { namespace clanguml {
namespace t00054 { namespace t00054 {
struct a { struct a { };
}; struct b { };
struct b {
};
namespace detail { namespace detail {
struct c { struct c { };
}; struct d { };
struct d { struct e { };
};
struct e {
};
} // namespace detail } // namespace detail
struct f { struct f { };
}; struct g { };
struct g {
};
struct A { struct A { };
}; struct B { };
struct B {
};
namespace detail2 { namespace detail2 {
struct C { struct C { };
};
namespace detail3 { namespace detail3 {
struct D { struct D { };
}; struct E { };
struct E {
};
} // namespace detail3 } // namespace detail3
struct F { struct F { };
};
} // namespace detail2 } // namespace detail2
struct G { struct G { };
};
namespace detail4 { namespace detail4 {
enum class h { hhh }; enum class h { hhh };

30
tests/t00055/t00055.cc
View File

@@ -1,24 +1,14 @@
namespace clanguml { namespace clanguml {
namespace t00055 { namespace t00055 {
struct A { struct A { };
}; struct B { };
struct B { struct C { };
}; struct D { };
struct C { struct E { };
}; struct F { };
struct D { struct G { };
}; struct H { };
struct E { struct I { };
}; struct J { };
struct F {
};
struct G {
};
struct H {
};
struct I {
};
struct J {
};
} }
} }

41
tests/t00056/t00056.cc
View File

@@ -7,10 +7,8 @@ template <typename T, typename L>
concept greater_than_simple = sizeof(T) > sizeof(L); concept greater_than_simple = sizeof(T) > sizeof(L);
template <typename T, typename P> template <typename T, typename P>
concept greater_than_with_requires = requires(T l, P r) concept greater_than_with_requires =
{ requires(T l, P r) { sizeof(l) > sizeof(r); };
sizeof(l) > sizeof(r);
};
// Constraint expression // Constraint expression
template <typename T> template <typename T>
@@ -18,31 +16,26 @@ concept max_four_bytes = sizeof(T) <= 4;
// Simple requirement // Simple requirement
template <typename T> template <typename T>
concept iterable = requires(T container) concept iterable = requires(T container) {
{
container.begin(); container.begin();
container.end(); container.end();
}; };
// Type requirement // Type requirement
template <typename T> template <typename T>
concept has_value_type = requires concept has_value_type = requires { typename T::value_type; };
{
typename T::value_type;
};
template <typename T> template <typename T>
concept convertible_to_string = max_four_bytes<T> && requires(T s) concept convertible_to_string =
{ max_four_bytes<T> && requires(T s) {
std::string{s}; std::string{s};
{ {
std::to_string(s) std::to_string(s)
} } noexcept;
noexcept;
{ {
std::to_string(s) std::to_string(s)
} -> std::same_as<std::string>; } -> std::same_as<std::string>;
}; };
// Compound requirement // Compound requirement
// ... // ...
@@ -62,29 +55,27 @@ template <max_four_bytes T> struct A {
// Requires constant expression // Requires constant expression
template <typename T> template <typename T>
requires iterable_or_small_value_type<T> requires iterable_or_small_value_type<T>
struct B { struct B {
T b; T b;
}; };
// Anonymous concept requirement (TODO) // Anonymous concept requirement (TODO)
template <convertible_to_string T> template <convertible_to_string T>
requires requires(T t) requires requires(T t) {
{
--t; --t;
t--; t--;
} }
struct C { struct C {
T c; T c;
}; };
template <iterable T1, typename T2, iterable T3, typename T4, typename T5> template <iterable T1, typename T2, iterable T3, typename T4, typename T5>
requires max_four_bytes<T2> && max_four_bytes<T5> requires max_four_bytes<T2> && max_four_bytes<T5>
struct D { struct D { };
};
template <typename T1, typename T2, typename T3> template <typename T1, typename T2, typename T3>
requires greater_than_with_requires<T1, T3> requires greater_than_with_requires<T1, T3>
struct E { struct E {
T1 e1; T1 e1;
T2 e2; T2 e2;
@@ -92,7 +83,7 @@ struct E {
}; };
template <typename T1, typename T2, typename T3> template <typename T1, typename T2, typename T3>
requires greater_than_simple<T1, T3> requires greater_than_simple<T1, T3>
struct F { struct F {
T1 f1; T1 f1;
T2 f2; T2 f2;

4
tests/t00058/t00058.cc
View File

@@ -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...>>>; std::remove_cvref_t<first_type_t<Args...>>>;
template <typename T, typename... Args> template <typename T, typename... Args>
requires same_as_first_type<T, Args...> requires same_as_first_type<T, Args...>
struct A { struct A {
std::vector<T> a; std::vector<T> a;
}; };
template <typename T, typename P, typename... Args> template <typename T, typename P, typename... Args>
requires same_as_first_type<T, Args...> requires same_as_first_type<T, Args...>
struct B { struct B {
std::vector<T> b; std::vector<T> b;
P bb; P bb;

15
tests/t00059/t00059.cc
View File

@@ -4,23 +4,16 @@ namespace clanguml {
namespace t00059 { namespace t00059 {
template <typename T> template <typename T>
concept fruit_c = requires(T t) concept fruit_c = requires(T t) {
{
T{}; T{};
t.get_name(); t.get_name();
}; };
template <typename T> template <typename T>
concept apple_c = fruit_c<T> && requires(T t) concept apple_c = fruit_c<T> && requires(T t) { t.get_sweetness(); };
{
t.get_sweetness();
};
template <typename T> template <typename T>
concept orange_c = fruit_c<T> && requires(T t) concept orange_c = fruit_c<T> && requires(T t) { t.get_bitterness(); };
{
t.get_bitterness();
};
class gala_apple { class gala_apple {
public: public:

51
tests/t30002/t30002.cc
View File

@@ -8,72 +8,55 @@ namespace clanguml {
namespace t30002 { namespace t30002 {
namespace A::AA { namespace A::AA {
namespace A1 { namespace A1 {
struct CA { struct CA { };
};
} }
namespace A2 { namespace A2 {
struct CB { struct CB { };
};
} }
namespace A3 { namespace A3 {
struct CC { struct CC { };
};
} }
namespace A4 { namespace A4 {
struct CD { struct CD { };
};
} }
namespace A5 { namespace A5 {
struct CE { struct CE { };
};
} }
namespace A6 { namespace A6 {
struct CF { struct CF { };
};
} }
namespace A7 { namespace A7 {
struct CG { struct CG { };
};
} }
namespace A8 { namespace A8 {
struct CH { struct CH { };
};
} }
namespace A9 { namespace A9 {
struct CI { struct CI { };
};
} }
namespace A10 { namespace A10 {
struct CJ { struct CJ { };
};
} }
namespace A11 { namespace A11 {
struct CK { struct CK { };
};
} }
namespace A12 { namespace A12 {
struct CL { struct CL { };
};
} }
namespace A13 { namespace A13 {
struct CM { struct CM { };
};
} }
namespace A14 { namespace A14 {
struct CN { struct CN { };
};
} }
namespace A15 { namespace A15 {
struct CO { struct CO { };
};
} }
namespace A16 { namespace A16 {
struct CP { struct CP { };
};
} }
namespace A17 { namespace A17 {
struct CR { struct CR { };
};
} }
} }
namespace B::BB::BBB { namespace B::BB::BBB {

15
tests/t30003/t30003.cc
View File

@@ -3,30 +3,25 @@ namespace t30003 {
namespace ns1 { namespace ns1 {
namespace ns2_v1_0_0 { namespace ns2_v1_0_0 {
class A { class A { };
};
} }
namespace [[deprecated]] ns2_v0_9_0 { namespace [[deprecated]] ns2_v0_9_0 {
class A { class A { };
};
} }
namespace { namespace {
class Anon final { class Anon final { };
};
} }
} }
namespace [[deprecated]] ns3 { namespace [[deprecated]] ns3 {
namespace ns1::ns2 { 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 { };
};
} }
} }
} }

3
tests/t30005/t30005.cc
View File

@@ -2,8 +2,7 @@ namespace clanguml {
namespace t30005 { namespace t30005 {
namespace A::AA::AAA { namespace A::AA::AAA {
struct C1 { struct C1 { };
};
} }
namespace B::BB::BBB { namespace B::BB::BBB {

6
tests/t30006/t30006.cc
View File

@@ -2,8 +2,7 @@ namespace clanguml {
namespace t30006 { namespace t30006 {
namespace B { namespace B {
struct BB { struct BB { };
};
} }
/// \uml{note[top] Top A note.} /// \uml{note[top] Top A note.}
@@ -14,8 +13,7 @@ struct A1 {
} }
namespace C { namespace C {
struct CC { struct CC { };
};
} }
/// \uml{note[bottom] Bottom A note.} /// \uml{note[bottom] Bottom A note.}

6
tests/t30007/t30007.cc
View File

@@ -2,8 +2,7 @@ namespace clanguml {
namespace t30007 { namespace t30007 {
namespace B { namespace B {
struct BB { struct BB { };
};
} }
/// \uml{note[top] Compare layout with t30006.} /// \uml{note[top] Compare layout with t30006.}
@@ -16,8 +15,7 @@ struct A1 {
} }
namespace C { namespace C {
struct CC { struct CC { };
};
} }
/// \uml{note[bottom] Bottom A note.} /// \uml{note[bottom] Bottom A note.}

6
tests/t30008/t30008.cc
View File

@@ -5,8 +5,7 @@ namespace dependants {
namespace X { namespace X {
} }
namespace A { namespace A {
struct AA { struct AA { };
};
} }
namespace B { namespace B {
struct BB { struct BB {
@@ -26,8 +25,7 @@ namespace Y {
} }
namespace D { namespace D {
struct DD { struct DD { };
};
} }
namespace E { namespace E {
struct EE { struct EE {

21
tests/test_cases.h
View File

@@ -82,26 +82,19 @@ template <typename T, typename... Ts> constexpr bool has_type() noexcept
return (std::is_same_v<T, Ts> || ... || false); 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 { struct HasCallWithResultMatcher : ContainsMatcher {
HasCallWithResultMatcher( HasCallWithResultMatcher(