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

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

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

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