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
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

440
tests/catch.h
View File

File diff suppressed because it is too large Load Diff

9
tests/t00004/t00004.cc
View File

@@ -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 { };
};
}

33
tests/t00005/t00005.cc
View File

@@ -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:

48
tests/t00006/t00006.cc
View File

@@ -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:

9
tests/t00007/t00007.cc
View File

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

3
tests/t00011/t00011.cc
View File

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

15
tests/t00015/t00015.cc
View File

@@ -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

33
tests/t00017/t00017.cc
View File

@@ -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)

15
tests/t00028/t00028.cc
View File

@@ -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 };

18
tests/t00029/t00029.cc
View File

@@ -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;

15
tests/t00030/t00030.cc
View File

@@ -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[]}

6
tests/t00031/t00031.cc
View File

@@ -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]}

6
tests/t00032/t00032.cc
View File

@@ -4,11 +4,9 @@
namespace clanguml {
namespace t00032 {
struct Base {
};
struct Base { };
struct TBase {
};
struct TBase { };
struct A {
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;
struct A {
};
struct A { };
struct R {
lift_void_t<A> *la;

15
tests/t00035/t00035.cc
View File

@@ -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

3
tests/t00036/t00036.cc
View File

@@ -25,8 +25,7 @@ namespace ns2 {
namespace ns22 {
// 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 {
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

36
tests/t00039/t00039.cc
View File

@@ -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 {

3
tests/t00040/t00040.cc
View File

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

33
tests/t00041/t00041.cc
View File

@@ -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

12
tests/t00043/t00043.cc
View File

@@ -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) { }

3
tests/t00044/t00044.cc
View File

@@ -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> &)

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 {
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:

24
tests/t00046/t00046.cc
View File

@@ -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:

21
tests/t00050/t00050.cc
View File

@@ -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

42
tests/t00053/t00053.cc
View File

@@ -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 };

42
tests/t00054/t00054.cc
View File

@@ -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 };

30
tests/t00055/t00055.cc
View File

@@ -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 { };
}
}

61
tests/t00056/t00056.cc
View File

@@ -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;

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...>>>;
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;

19
tests/t00059/t00059.cc
View File

@@ -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:

51
tests/t30002/t30002.cc
View File

@@ -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 {

15
tests/t30003/t30003.cc
View File

@@ -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 { };
}
}
}

3
tests/t30005/t30005.cc
View File

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

6
tests/t30006/t30006.cc
View File

@@ -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.}

6
tests/t30007/t30007.cc
View File

@@ -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.}

6
tests/t30008/t30008.cc
View File

@@ -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 {

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);
}
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(