From 5642cba31b5f7610eddf552b1acd984cf718340d Mon Sep 17 00:00:00 2001
From: Steven Le Rouzic <steven.lerouzic@gmail.com>
Date: Fri, 27 Dec 2024 19:19:40 +0100
Subject: Rework some metaprogramming stuff

---
 asl/tests/buffer_tests.cpp       |  88 +++++++++++++++++++++++++++++-----
 asl/tests/maybe_uninit_tests.cpp |   4 +-
 asl/tests/meta_tests.cpp         | 101 ++++++++++++++++++++++++---------------
 asl/tests/option_tests.cpp       |  44 ++++++++++-------
 asl/tests/span_tests.cpp         |   6 +--
 asl/tests/string_view_tests.cpp  |   2 +-
 asl/tests/test_types.hpp         |  68 +++++++++++++++++++-------
 7 files changed, 220 insertions(+), 93 deletions(-)

(limited to 'asl/tests')

diff --git a/asl/tests/buffer_tests.cpp b/asl/tests/buffer_tests.cpp
index 5376dc1..b677402 100644
--- a/asl/tests/buffer_tests.cpp
+++ b/asl/tests/buffer_tests.cpp
@@ -1,4 +1,5 @@
 #include "asl/buffer.hpp"
+#include "asl/print.hpp"
 
 #include "asl/testing/testing.hpp"
 
@@ -77,7 +78,6 @@ ASL_TEST(reserve_capacity)
     ASL_TEST_EXPECT(count == 2);
 }
 
-// NOLINTBEGIN(*-pointer-arithmetic)
 ASL_TEST(push)
 {
     asl::buffer<int32_t> b;
@@ -85,28 +85,90 @@ ASL_TEST(push)
 
     b.push(1);
     ASL_TEST_EXPECT(b.size() == 1);
-    ASL_TEST_EXPECT(b.data()[0] == 1);
+    ASL_TEST_EXPECT(b[0] == 1);
 
     b.push(2);
     b.push(3);
     ASL_TEST_EXPECT(b.size() == 3);
-    ASL_TEST_EXPECT(b.data()[0] == 1);
-    ASL_TEST_EXPECT(b.data()[1] == 2);
-    ASL_TEST_EXPECT(b.data()[2] == 3);
+    ASL_TEST_EXPECT(b[0] == 1);
+    ASL_TEST_EXPECT(b[1] == 2);
+    ASL_TEST_EXPECT(b[2] == 3);
 
     b.push(4);
     b.push(5);
     b.push(6);
     b.push(7);
     ASL_TEST_EXPECT(b.size() == 7);
-    ASL_TEST_EXPECT(b.data()[0] == 1);
-    ASL_TEST_EXPECT(b.data()[1] == 2);
-    ASL_TEST_EXPECT(b.data()[2] == 3);
-    ASL_TEST_EXPECT(b.data()[3] == 4);
-    ASL_TEST_EXPECT(b.data()[4] == 5);
-    ASL_TEST_EXPECT(b.data()[5] == 6);
-    ASL_TEST_EXPECT(b.data()[6] == 7);
+    ASL_TEST_EXPECT(b[0] == 1);
+    ASL_TEST_EXPECT(b[1] == 2);
+    ASL_TEST_EXPECT(b[2] == 3);
+    ASL_TEST_EXPECT(b[3] == 4);
+    ASL_TEST_EXPECT(b[4] == 5);
+    ASL_TEST_EXPECT(b[5] == 6);
+    ASL_TEST_EXPECT(b[6] == 7);
+}
+
+struct MoveableType
+{
+    int moved{};
+    int value;
+
+    explicit MoveableType(int x) : value{x} {}
+    MoveableType(const MoveableType&) = delete;
+    MoveableType(MoveableType&& other)  : moved{other.moved + 1}, value{other.value} {}
+    MoveableType& operator=(const MoveableType&) = delete;
+    MoveableType& operator=(MoveableType&&) = delete;
+};
+static_assert(!asl::trivially_copy_constructible<MoveableType>);
+static_assert(!asl::trivially_move_constructible<MoveableType>);
+static_assert(!asl::copyable<MoveableType>);
+static_assert(asl::move_constructible<MoveableType>);
+
+ASL_TEST(push_move)
+{
+    asl::buffer<MoveableType> b;
+
+    static_assert(asl::buffer<MoveableType>::kInlineCapacity > 0);
+
+    b.push(0);
+    ASL_TEST_EXPECT(b[0].value == 0);
+    ASL_TEST_EXPECT(b[0].moved == 0);
+    
+    b.push(1);
+    ASL_TEST_EXPECT(b[0].value == 0);
+    ASL_TEST_EXPECT(b[0].moved == 0);
+    ASL_TEST_EXPECT(b[1].value == 1);
+    ASL_TEST_EXPECT(b[1].moved == 0);
+    
+    b.push(2);
+    ASL_TEST_EXPECT(b[0].value == 0);
+    ASL_TEST_EXPECT(b[0].moved == 1);
+    ASL_TEST_EXPECT(b[1].value == 1);
+    ASL_TEST_EXPECT(b[1].moved == 1);
+    ASL_TEST_EXPECT(b[2].value == 2);
+    ASL_TEST_EXPECT(b[2].moved == 0);
+    
+    b.push(3);
+    ASL_TEST_EXPECT(b[0].value == 0);
+    ASL_TEST_EXPECT(b[0].moved == 1);
+    ASL_TEST_EXPECT(b[1].value == 1);
+    ASL_TEST_EXPECT(b[1].moved == 1);
+    ASL_TEST_EXPECT(b[2].value == 2);
+    ASL_TEST_EXPECT(b[2].moved == 0);
+    ASL_TEST_EXPECT(b[3].value == 3);
+    ASL_TEST_EXPECT(b[3].moved == 0);
+    
+    b.push(4);
+    ASL_TEST_EXPECT(b[0].value == 0);
+    ASL_TEST_EXPECT(b[0].moved == 2);
+    ASL_TEST_EXPECT(b[1].value == 1);
+    ASL_TEST_EXPECT(b[1].moved == 2);
+    ASL_TEST_EXPECT(b[2].value == 2);
+    ASL_TEST_EXPECT(b[2].moved == 1);
+    ASL_TEST_EXPECT(b[3].value == 3);
+    ASL_TEST_EXPECT(b[3].moved == 1);
+    ASL_TEST_EXPECT(b[4].value == 4);
+    ASL_TEST_EXPECT(b[4].moved == 0);
 }
-// NOLINTEND(*-pointer-arithmetic)
 
 // @Todo Test push with non trivial move (non copy) types
diff --git a/asl/tests/maybe_uninit_tests.cpp b/asl/tests/maybe_uninit_tests.cpp
index 3f60558..92999a2 100644
--- a/asl/tests/maybe_uninit_tests.cpp
+++ b/asl/tests/maybe_uninit_tests.cpp
@@ -5,6 +5,6 @@ static_assert(asl::layout::of<int>() == asl::layout::of<asl::maybe_uninit<int>>(
 static_assert(asl::size_of<int> == asl::size_of<asl::maybe_uninit<int>>);
 static_assert(asl::align_of<int> == asl::align_of<asl::maybe_uninit<int>>);
 
-static_assert(asl::trivially_destructible<asl::maybe_uninit<TriviallyDestructible>>);
-static_assert(!asl::trivially_destructible<asl::maybe_uninit<HasDestructor>>);
+static_assert(asl::trivially_destructible<asl::maybe_uninit<TrivialType>>);
+static_assert(!asl::trivially_destructible<asl::maybe_uninit<WithDestructor>>);
 
diff --git a/asl/tests/meta_tests.cpp b/asl/tests/meta_tests.cpp
index fcafe1c..24e9754 100644
--- a/asl/tests/meta_tests.cpp
+++ b/asl/tests/meta_tests.cpp
@@ -13,59 +13,88 @@ static_assert(asl::same_as<asl::select_t<false, int, float>, float>);
 static_assert(asl::same_as<asl::select_t<true, int, float>, int>);
 
 static_assert(asl::default_constructible<int>);
-static_assert(asl::default_constructible<TriviallyDefaultConstructible>);
-static_assert(asl::default_constructible<DefaultConstructible>);
-static_assert(!asl::default_constructible<NonDefaultConstructible>);
+static_assert(asl::default_constructible<TrivialType>);
+static_assert(asl::default_constructible<TrivialTypeDefaultValue>);
 
 static_assert(asl::trivially_default_constructible<int>);
-static_assert(asl::trivially_default_constructible<TriviallyDefaultConstructible>);
-static_assert(!asl::trivially_default_constructible<DefaultConstructible>);
-static_assert(!asl::trivially_default_constructible<NonDefaultConstructible>);
+static_assert(asl::trivially_default_constructible<TrivialType>);
+static_assert(!asl::trivially_default_constructible<TrivialTypeDefaultValue>);
 
 static_assert(asl::copy_constructible<int>);
-static_assert(asl::copy_constructible<TriviallyCopyConstructible>);
-static_assert(asl::copy_constructible<CopyConstructible>);
-static_assert(!asl::copy_constructible<NonCopyConstructible>);
+static_assert(asl::copy_constructible<TrivialType>);
+static_assert(asl::copy_constructible<Copyable>);
+static_assert(!asl::copy_constructible<MoveableOnly>);
+static_assert(!asl::copy_constructible<Pinned>);
 
 static_assert(asl::trivially_copy_constructible<int>);
-static_assert(asl::trivially_copy_constructible<TriviallyCopyConstructible>);
-static_assert(!asl::trivially_copy_constructible<CopyConstructible>);
-static_assert(!asl::trivially_copy_constructible<NonCopyConstructible>);
+static_assert(asl::trivially_copy_constructible<TrivialType>);
+static_assert(asl::trivially_copy_constructible<TrivialTypeDefaultValue>);
+static_assert(!asl::trivially_copy_constructible<WithDestructor>);
+static_assert(!asl::trivially_copy_constructible<Copyable>);
+static_assert(!asl::trivially_copy_constructible<MoveableOnly>);
+static_assert(!asl::trivially_copy_constructible<Pinned>);
 
 static_assert(asl::move_constructible<int>);
-static_assert(asl::move_constructible<TriviallyMoveConstructible>);
-static_assert(asl::move_constructible<MoveConstructible>);
-static_assert(asl::move_constructible<CopyConstructible>);
-static_assert(!asl::move_constructible<NonMoveConstructible>);
+static_assert(asl::move_constructible<TrivialType>);
+static_assert(asl::move_constructible<Copyable>);
+static_assert(asl::move_constructible<MoveableOnly>);
+static_assert(!asl::move_constructible<Pinned>);
 
 static_assert(asl::trivially_move_constructible<int>);
-static_assert(asl::trivially_move_constructible<TriviallyMoveConstructible>);
-static_assert(!asl::trivially_move_constructible<MoveConstructible>);
-static_assert(!asl::trivially_move_constructible<NonMoveConstructible>);
+static_assert(asl::trivially_move_constructible<TrivialType>);
+static_assert(asl::trivially_move_constructible<TrivialTypeDefaultValue>);
+static_assert(!asl::trivially_move_constructible<WithDestructor>);
+static_assert(!asl::trivially_move_constructible<Copyable>);
+static_assert(!asl::trivially_move_constructible<MoveableOnly>);
+static_assert(!asl::trivially_move_constructible<Pinned>);
 
 static_assert(asl::copy_assignable<int>);
-static_assert(asl::copy_assignable<CopyAssignable>);
-static_assert(asl::copy_assignable<TriviallyCopyAssignable>);
-static_assert(!asl::copy_assignable<NonCopyAssignable>);
+static_assert(asl::copy_assignable<TrivialType>);
+static_assert(asl::copy_assignable<Copyable>);
+static_assert(!asl::copy_assignable<MoveableOnly>);
+static_assert(!asl::copy_assignable<Pinned>);
 
 static_assert(asl::trivially_copy_assignable<int>);
-static_assert(!asl::trivially_copy_assignable<CopyAssignable>);
-static_assert(asl::trivially_copy_assignable<TriviallyCopyAssignable>);
-static_assert(!asl::trivially_copy_assignable<NonCopyAssignable>);
+static_assert(asl::trivially_copy_assignable<TrivialType>);
+static_assert(asl::trivially_copy_assignable<TrivialTypeDefaultValue>);
+static_assert(asl::trivially_copy_assignable<WithDestructor>);
+static_assert(!asl::trivially_copy_assignable<Copyable>);
+static_assert(!asl::trivially_copy_assignable<MoveableOnly>);
+static_assert(!asl::trivially_copy_assignable<Pinned>);
+
+static_assert(asl::copyable<int>);
+static_assert(asl::copyable<TrivialType>);
+static_assert(asl::copyable<Copyable>);
+static_assert(!asl::copyable<MoveableOnly>);
+static_assert(!asl::copyable<Pinned>);
+
+static_assert(asl::moveable<int>);
+static_assert(asl::moveable<TrivialType>);
+static_assert(asl::moveable<Copyable>);
+static_assert(asl::moveable<MoveableOnly>);
+static_assert(!asl::moveable<Pinned>);
 
 static_assert(asl::move_assignable<int>);
-static_assert(asl::move_assignable<MoveAssignable>);
-static_assert(asl::move_assignable<TriviallyMoveAssignable>);
-static_assert(!asl::move_assignable<NonMoveAssignable>);
+static_assert(asl::move_assignable<TrivialType>);
+static_assert(asl::move_assignable<Copyable>);
+static_assert(asl::move_assignable<MoveableOnly>);
+static_assert(!asl::move_assignable<Pinned>);
 
 static_assert(asl::trivially_move_assignable<int>);
-static_assert(!asl::trivially_move_assignable<MoveAssignable>);
-static_assert(asl::trivially_move_assignable<TriviallyMoveAssignable>);
-static_assert(!asl::trivially_move_assignable<NonMoveAssignable>);
+static_assert(asl::trivially_move_assignable<TrivialType>);
+static_assert(asl::trivially_move_assignable<TrivialTypeDefaultValue>);
+static_assert(asl::trivially_move_assignable<WithDestructor>);
+static_assert(!asl::trivially_move_assignable<Copyable>);
+static_assert(!asl::trivially_move_assignable<MoveableOnly>);
+static_assert(!asl::trivially_move_assignable<Pinned>);
 
 static_assert(asl::trivially_destructible<int>);
-static_assert(asl::trivially_destructible<TriviallyDestructible>);
-static_assert(!asl::trivially_destructible<HasDestructor>);
+static_assert(asl::trivially_destructible<TrivialType>);
+static_assert(asl::trivially_destructible<TrivialTypeDefaultValue>);
+static_assert(!asl::trivially_destructible<WithDestructor>);
+static_assert(asl::trivially_destructible<Copyable>);
+static_assert(asl::trivially_destructible<MoveableOnly>);
+static_assert(asl::trivially_destructible<Pinned>);
 
 static_assert(asl::same_as<int, asl::un_const_t<int>>);
 static_assert(asl::same_as<int, asl::un_const_t<const int>>);
@@ -164,12 +193,6 @@ static_assert(asl::types_count<int, int> == 2);
 static_assert(asl::types_count<int> == 1);
 static_assert(asl::types_count<> == 0);
 
-static_assert(asl::trivially_copyable<int>);
-static_assert(!asl::trivially_copyable<HasDestructor>);
-static_assert(!asl::trivially_copyable<CopyAssignable>);
-static_assert(asl::trivially_copyable<DefaultConstructible>);
-static_assert(asl::trivially_copyable<TriviallyDefaultConstructible>);
-
 class Base {};
 class Derived : public Base {};
 class C {};
diff --git a/asl/tests/option_tests.cpp b/asl/tests/option_tests.cpp
index 8261583..557e2fe 100644
--- a/asl/tests/option_tests.cpp
+++ b/asl/tests/option_tests.cpp
@@ -28,28 +28,28 @@ static_assert(!asl::is_option<int>);
 static_assert(asl::is_option<asl::option<int>>);
 static_assert(asl::is_option<const asl::option<int>>);
 
-static_assert(asl::trivially_destructible<asl::option<TriviallyDestructible>>);
-static_assert(!asl::trivially_destructible<asl::option<HasDestructor>>);
+static_assert(asl::trivially_destructible<asl::option<TrivialType>>);
+static_assert(!asl::trivially_destructible<asl::option<WithDestructor>>);
 
 static_assert(asl::copy_constructible<asl::option<int>>);
-static_assert(asl::copy_constructible<asl::option<CopyConstructible>>);
-static_assert(!asl::copy_constructible<asl::option<MoveConstructible>>);
-static_assert(!asl::copy_constructible<asl::option<NonMoveConstructible>>);
+static_assert(asl::copy_constructible<asl::option<Copyable>>);
+static_assert(!asl::copy_constructible<asl::option<MoveableOnly>>);
+static_assert(!asl::copy_constructible<asl::option<Pinned>>);
 
 static_assert(asl::move_constructible<asl::option<int>>);
-static_assert(asl::move_constructible<asl::option<CopyConstructible>>);
-static_assert(asl::move_constructible<asl::option<MoveConstructible>>);
-static_assert(!asl::move_constructible<asl::option<NonMoveConstructible>>);
+static_assert(asl::move_constructible<asl::option<Copyable>>);
+static_assert(asl::move_constructible<asl::option<MoveableOnly>>);
+static_assert(!asl::move_constructible<asl::option<Pinned>>);
 
 static_assert(asl::copy_assignable<asl::option<int>>);
-static_assert(asl::copy_assignable<asl::option<CopyAssignable>>);
-static_assert(!asl::copy_assignable<asl::option<MoveAssignable>>);
-static_assert(!asl::copy_assignable<asl::option<NonMoveAssignable>>);
+static_assert(asl::copy_assignable<asl::option<Copyable>>);
+static_assert(!asl::copy_assignable<asl::option<MoveableOnly>>);
+static_assert(!asl::copy_assignable<asl::option<Pinned>>);
 
 static_assert(asl::move_assignable<asl::option<int>>);
-static_assert(asl::move_assignable<asl::option<CopyAssignable>>);
-static_assert(asl::move_assignable<asl::option<MoveAssignable>>);
-static_assert(!asl::move_assignable<asl::option<NonMoveAssignable>>);
+static_assert(asl::move_assignable<asl::option<Copyable>>);
+static_assert(asl::move_assignable<asl::option<MoveableOnly>>);
+static_assert(!asl::move_assignable<asl::option<Pinned>>);
 
 static_assert(asl::assignable_from<asl::option<Base*>&, asl::option<Derived*>>);
 static_assert(!asl::assignable_from<asl::option<Derived*>&, asl::option<Base*>>);
@@ -70,16 +70,24 @@ static_assert(!asl::convertible_from<asl::option<ExplicitConversion>, asl::optio
 static_assert(asl::convertible_from<asl::option<ImplicitConversion>, asl::option<int>>);
 
 static_assert(asl::trivially_copy_constructible<asl::option<int>>);
-static_assert(!asl::trivially_copy_constructible<asl::option<CopyConstructible>>);
+static_assert(asl::trivially_copy_constructible<asl::option<TrivialType>>);
+static_assert(asl::trivially_copy_constructible<asl::option<TrivialTypeDefaultValue>>);
+static_assert(!asl::trivially_copy_constructible<asl::option<Copyable>>);
 
 static_assert(asl::trivially_move_constructible<asl::option<int>>);
-static_assert(!asl::trivially_move_constructible<asl::option<MoveConstructible>>);
+static_assert(asl::trivially_move_constructible<asl::option<TrivialType>>);
+static_assert(asl::trivially_move_constructible<asl::option<TrivialTypeDefaultValue>>);
+static_assert(!asl::trivially_move_constructible<asl::option<MoveableOnly>>);
 
 static_assert(asl::trivially_copy_assignable<asl::option<int>>);
-static_assert(!asl::trivially_copy_assignable<asl::option<CopyAssignable>>);
+static_assert(asl::trivially_copy_assignable<asl::option<TrivialType>>);
+static_assert(asl::trivially_copy_assignable<asl::option<TrivialTypeDefaultValue>>);
+static_assert(!asl::trivially_copy_assignable<asl::option<Copyable>>);
 
 static_assert(asl::trivially_move_assignable<asl::option<int>>);
-static_assert(!asl::trivially_move_assignable<asl::option<MoveAssignable>>);
+static_assert(asl::trivially_move_assignable<asl::option<TrivialType>>);
+static_assert(asl::trivially_move_assignable<asl::option<TrivialTypeDefaultValue>>);
+static_assert(!asl::trivially_move_assignable<asl::option<MoveableOnly>>);
 
 ASL_TEST(make_null)
 {
diff --git a/asl/tests/span_tests.cpp b/asl/tests/span_tests.cpp
index 8b5db76..52e7736 100644
--- a/asl/tests/span_tests.cpp
+++ b/asl/tests/span_tests.cpp
@@ -3,10 +3,10 @@
 #include "asl/tests/test_types.hpp"
 
 static_assert(asl::trivially_destructible<asl::span<int>>);
-static_assert(asl::trivially_destructible<asl::span<HasDestructor>>);
+static_assert(asl::trivially_destructible<asl::span<WithDestructor>>);
 
-static_assert(asl::trivially_copyable<asl::span<int>>);
-static_assert(asl::trivially_copyable<asl::span<NonCopyConstructible>>);
+static_assert(asl::trivially_copy_constructible<asl::span<int>>);
+static_assert(asl::trivially_copy_constructible<asl::span<Pinned>>);
 
 static_assert(asl::size_of<asl::span<int>> == asl::size_of<void*> * 2);
 static_assert(asl::size_of<asl::span<int, 2>> == asl::size_of<void*>);
diff --git a/asl/tests/string_view_tests.cpp b/asl/tests/string_view_tests.cpp
index 708877d..b00da45 100644
--- a/asl/tests/string_view_tests.cpp
+++ b/asl/tests/string_view_tests.cpp
@@ -2,7 +2,7 @@
 #include "asl/testing/testing.hpp"
 
 static_assert(asl::trivially_destructible<asl::string_view>);
-static_assert(asl::trivially_copyable<asl::string_view>);
+static_assert(asl::trivially_copy_constructible<asl::string_view>);
 
 ASL_TEST(default)
 {
diff --git a/asl/tests/test_types.hpp b/asl/tests/test_types.hpp
index f988aec..f91afb3 100644
--- a/asl/tests/test_types.hpp
+++ b/asl/tests/test_types.hpp
@@ -2,28 +2,59 @@
 
 #include "asl/utility.hpp"
 
-struct DefaultConstructible { DefaultConstructible() {} };
-struct TriviallyDefaultConstructible { TriviallyDefaultConstructible() = default; };
-struct NonDefaultConstructible { NonDefaultConstructible() = delete; };
+struct TrivialType
+{
+    int x;
+    TrivialType() = default;
+    TrivialType(const TrivialType&) = default;
+    TrivialType(TrivialType&&) = default;
+    TrivialType& operator=(const TrivialType&) = default;
+    TrivialType& operator=(TrivialType&&) = default;
+    ~TrivialType() = default;
+};
 
-struct CopyConstructible { CopyConstructible(const CopyConstructible&) {} };
-struct TriviallyCopyConstructible { TriviallyCopyConstructible(const TriviallyCopyConstructible&) = default; };
-struct NonCopyConstructible { NonCopyConstructible(const NonCopyConstructible&) = delete; };
+struct TrivialTypeDefaultValue
+{
+    int x{};
+    TrivialTypeDefaultValue() = default;
+    TrivialTypeDefaultValue(const TrivialTypeDefaultValue&) = default;
+    TrivialTypeDefaultValue(TrivialTypeDefaultValue&&) = default;
+    TrivialTypeDefaultValue& operator=(const TrivialTypeDefaultValue&) = default;
+    TrivialTypeDefaultValue& operator=(TrivialTypeDefaultValue&&) = default;
+    ~TrivialTypeDefaultValue() = default;
+};
 
-struct MoveConstructible { MoveConstructible(MoveConstructible&&) {} };
-struct TriviallyMoveConstructible { TriviallyMoveConstructible(TriviallyMoveConstructible&&) = default; };
-struct NonMoveConstructible { NonMoveConstructible(NonMoveConstructible&&) = delete; };
+struct WithDestructor
+{
+    WithDestructor() = default;
+    WithDestructor(const WithDestructor&) = default;
+    WithDestructor(WithDestructor&&) = default;
+    WithDestructor& operator=(const WithDestructor&) = default;
+    WithDestructor& operator=(WithDestructor&&) = default;
+    ~WithDestructor() {} // NOLINT
+};
 
-struct CopyAssignable { CopyAssignable(const CopyAssignable&) {} CopyAssignable& operator=(const CopyAssignable&) { return *this; } };
-struct TriviallyCopyAssignable { TriviallyCopyAssignable& operator=(const TriviallyCopyAssignable&) = default; };
-struct NonCopyAssignable { NonCopyAssignable& operator=(const NonCopyAssignable&) = delete; };
+struct Copyable // NOLINT
+{
+    Copyable(const Copyable&) {} // NOLINT
+    Copyable& operator=(const Copyable&); // NOLINT
+};
 
-struct MoveAssignable { MoveAssignable(MoveAssignable&&) {} MoveAssignable& operator=(MoveAssignable&&) { return *this; } };
-struct TriviallyMoveAssignable { TriviallyMoveAssignable& operator=(TriviallyMoveAssignable&&) = default; };
-struct NonMoveAssignable { NonMoveAssignable& operator=(NonMoveAssignable&&) = delete; };
+struct MoveableOnly // NOLINT
+{
+    MoveableOnly(const MoveableOnly&) = delete;
+    MoveableOnly& operator=(const MoveableOnly&) = delete;
+    MoveableOnly(MoveableOnly&&);
+    MoveableOnly& operator=(MoveableOnly&&); // NOLINT
+};
 
-struct TriviallyDestructible { ~TriviallyDestructible() = default; };
-struct HasDestructor { ~HasDestructor() {} };
+struct Pinned // NOLINT
+{
+    Pinned(const Pinned&) = delete;
+    Pinned& operator=(const Pinned&) = delete;
+    Pinned(Pinned&&) = delete;
+    Pinned& operator=(Pinned&&) = delete;
+};
 
 struct DestructorObserver
 {
@@ -31,6 +62,9 @@ struct DestructorObserver
 
     explicit DestructorObserver(bool* destroyed_) : destroyed{destroyed_} {}
 
+    DestructorObserver(const DestructorObserver&) = delete;
+    DestructorObserver& operator=(const DestructorObserver&) = delete;
+
     DestructorObserver(DestructorObserver&& other)
         : destroyed{asl::exchange(other.destroyed, nullptr)}
     {}
-- 
cgit