From a141c401f78467bc15f62882fca5d55a007cacbb Mon Sep 17 00:00:00 2001
From: Steven Le Rouzic <steven.lerouzic@gmail.com>
Date: Mon, 17 Feb 2025 00:21:48 +0100
Subject: Reorganize everything

---
 asl/tests/BUILD.bazel              |  10 +
 asl/tests/box_tests.cpp            | 102 -------
 asl/tests/buffer_tests.cpp         | 603 -------------------------------------
 asl/tests/float_tests.cpp          |  23 --
 asl/tests/format_tests.cpp         | 110 -------
 asl/tests/functional_tests.cpp     |  73 -----
 asl/tests/hash_map_tests.cpp       |  48 ---
 asl/tests/hash_set_tests.cpp       | 185 ------------
 asl/tests/hash_tests.cpp           | 260 ----------------
 asl/tests/integers_tests.cpp       |  15 -
 asl/tests/maybe_uninit_tests.cpp   |  22 --
 asl/tests/meta_tests.cpp           | 289 ------------------
 asl/tests/option_tests.cpp         | 330 --------------------
 asl/tests/span_tests.cpp           | 444 ---------------------------
 asl/tests/status_or_tests.cpp      |  84 ------
 asl/tests/status_tests.cpp         |  82 -----
 asl/tests/string_builder_tests.cpp |  23 --
 asl/tests/string_tests.cpp         |  21 --
 asl/tests/string_view_tests.cpp    | 117 -------
 asl/tests/test_types.hpp           |  92 ------
 asl/tests/types.hpp                |  89 ++++++
 asl/tests/utility_tests.cpp        |   1 -
 22 files changed, 99 insertions(+), 2924 deletions(-)
 create mode 100644 asl/tests/BUILD.bazel
 delete mode 100644 asl/tests/box_tests.cpp
 delete mode 100644 asl/tests/buffer_tests.cpp
 delete mode 100644 asl/tests/float_tests.cpp
 delete mode 100644 asl/tests/format_tests.cpp
 delete mode 100644 asl/tests/functional_tests.cpp
 delete mode 100644 asl/tests/hash_map_tests.cpp
 delete mode 100644 asl/tests/hash_set_tests.cpp
 delete mode 100644 asl/tests/hash_tests.cpp
 delete mode 100644 asl/tests/integers_tests.cpp
 delete mode 100644 asl/tests/maybe_uninit_tests.cpp
 delete mode 100644 asl/tests/meta_tests.cpp
 delete mode 100644 asl/tests/option_tests.cpp
 delete mode 100644 asl/tests/span_tests.cpp
 delete mode 100644 asl/tests/status_or_tests.cpp
 delete mode 100644 asl/tests/status_tests.cpp
 delete mode 100644 asl/tests/string_builder_tests.cpp
 delete mode 100644 asl/tests/string_tests.cpp
 delete mode 100644 asl/tests/string_view_tests.cpp
 delete mode 100644 asl/tests/test_types.hpp
 create mode 100644 asl/tests/types.hpp
 delete mode 100644 asl/tests/utility_tests.cpp

(limited to 'asl/tests')

diff --git a/asl/tests/BUILD.bazel b/asl/tests/BUILD.bazel
new file mode 100644
index 0000000..eb51ec8
--- /dev/null
+++ b/asl/tests/BUILD.bazel
@@ -0,0 +1,10 @@
+cc_library(
+    name = "utils",
+    hdrs = [
+        "types.hpp",
+    ],
+    deps = [
+        "//asl/base",
+    ],
+    visibility = ["//asl:__subpackages__"],
+)
diff --git a/asl/tests/box_tests.cpp b/asl/tests/box_tests.cpp
deleted file mode 100644
index 3faf121..0000000
--- a/asl/tests/box_tests.cpp
+++ /dev/null
@@ -1,102 +0,0 @@
-#include "asl/box.hpp"
-#include "asl/option.hpp"
-
-#include "asl/testing/testing.hpp"
-#include "asl/tests/test_types.hpp"
-
-static_assert(sizeof(asl::box<int>) == sizeof(int*));
-static_assert(!asl::copyable<asl::box<int>>);
-static_assert(asl::moveable<asl::box<int>>);
-static_assert(asl::has_niche<asl::box<int>>);
-static_assert(sizeof(asl::option<asl::box<int>>) == sizeof(int*));
-
-ASL_TEST(destructor)
-{
-    bool d = false;
-
-    {
-        auto box = asl::make_box<DestructorObserver>(&d);
-        ASL_TEST_ASSERT(!d);
-
-
-        auto box3 = ASL_MOVE(box);
-        ASL_TEST_ASSERT(!d);
-    }
-
-    ASL_TEST_ASSERT(d);
-}
-
-ASL_TEST(value)
-{
-    auto b = asl::make_box<int>(24);
-    ASL_TEST_EXPECT(*b == 24);
-
-    auto b2 = ASL_MOVE(b);
-    ASL_TEST_EXPECT(*b2 == 24);
-}
-
-ASL_TEST(ptr)
-{
-    auto b = asl::make_box<int>(24);
-    auto* ptr1 = b.get();
-
-    auto b2 = ASL_MOVE(b);
-    auto* ptr2 = b2.get();
-    ASL_TEST_EXPECT(ptr1 == ptr2);
-}
-
-struct Struct { int a; };
-
-ASL_TEST(arrow)
-{
-    auto b = asl::make_box<Struct>(45);
-    ASL_TEST_EXPECT(b->a == 45);
-}
-
-ASL_TEST(niche)
-{
-    static_assert(sizeof(asl::box<int>) == sizeof(asl::option<asl::box<int>>));
-
-    asl::option<asl::box<int>> opt;
-    ASL_TEST_EXPECT(!opt.has_value());
-
-    opt = asl::make_box<int>(66);
-    ASL_TEST_EXPECT(opt.has_value());
-    ASL_TEST_EXPECT(*opt.value() == 66);
-
-    opt = asl::nullopt;
-    ASL_TEST_EXPECT(!opt.has_value());
-
-    bool destroyed = false;
-    asl::option opt2 = asl::make_box<DestructorObserver>(&destroyed);
-    ASL_TEST_EXPECT(opt2.has_value());
-    ASL_TEST_EXPECT(!destroyed);
-
-    opt2.reset();
-    ASL_TEST_EXPECT(!opt2.has_value());
-    ASL_TEST_EXPECT(destroyed);
-}
-
-class Base
-{
-public:
-    virtual ~Base() = default;
-    virtual int number() { return 1; }
-};
-
-class Derived : public Base
-{
-public:
-    int number() override { return 2; }
-};
-
-static_assert(asl::convertible_from<asl::box<Base>, asl::box<Derived>>);
-static_assert(asl::convertible_from<asl::box<Base>, asl::box<Base>>);
-static_assert(!asl::convertible_from<asl::box<Derived>, asl::box<Base>>);
-static_assert(!asl::convertible_from<asl::box<int>, asl::box<float>>);
-
-ASL_TEST(derived)
-{
-    asl::box<Base> obj = asl::make_box<Derived>();
-    ASL_TEST_ASSERT(obj->number() == 2);
-}
diff --git a/asl/tests/buffer_tests.cpp b/asl/tests/buffer_tests.cpp
deleted file mode 100644
index 174b3bc..0000000
--- a/asl/tests/buffer_tests.cpp
+++ /dev/null
@@ -1,603 +0,0 @@
-#include "asl/buffer.hpp"
-
-#include "asl/testing/testing.hpp"
-#include "asl/tests/test_types.hpp"
-
-struct Big
-{
-    uint64_t data[8];
-};
-
-static_assert(asl::buffer<int32_t>::kInlineCapacity == 5);
-static_assert(asl::buffer<int64_t>::kInlineCapacity == 2);
-static_assert(asl::buffer<char>::kInlineCapacity == 23);
-static_assert(asl::buffer<Big>::kInlineCapacity == 0);
-
-ASL_TEST(default_size)
-{
-    asl::buffer<int32_t>  b1;
-    ASL_TEST_EXPECT(b1.size() == 0);
-    ASL_TEST_EXPECT(b1.capacity() == 5);
-    ASL_TEST_EXPECT(static_cast<const void*>(b1.data()) == &b1);
-
-    asl::buffer<Big> b2;
-    ASL_TEST_EXPECT(b2.size() == 0);
-    ASL_TEST_EXPECT(b2.capacity() == 0);
-    ASL_TEST_EXPECT(b2.data() == nullptr);
-}
-
-struct CounterAllocator
-{
-    isize_t* count;
-
-    void* alloc(const asl::layout& layout) const
-    {
-        *count += 1;
-        return asl::GlobalHeap::alloc(layout);
-    }
-
-    void* realloc(void* ptr, const asl::layout& old, const asl::layout& new_layout) const
-    {
-        *count += 1;
-        return asl::GlobalHeap::realloc(ptr, old, new_layout);
-    }
-
-    static void dealloc(void* ptr, const asl::layout& layout)
-    {
-        asl::GlobalHeap::dealloc(ptr, layout);
-    }
-
-    constexpr bool operator==(const CounterAllocator&) const { return true; }
-};
-static_assert(asl::allocator<CounterAllocator>);
-
-struct IncompatibleAllocator
-{
-    static void* alloc(const asl::layout& layout)
-    {
-        return asl::GlobalHeap::alloc(layout);
-    }
-
-    static void* realloc(void* ptr, const asl::layout& old, const asl::layout& new_layout)
-    {
-        return asl::GlobalHeap::realloc(ptr, old, new_layout);
-    }
-
-    static void dealloc(void* ptr, const asl::layout& layout)
-    {
-        asl::GlobalHeap::dealloc(ptr, layout);
-    }
-
-    constexpr bool operator==(const IncompatibleAllocator&) const { return false; }
-};
-static_assert(asl::allocator<IncompatibleAllocator>);
-
-ASL_TEST(reserve_capacity)
-{
-    isize_t count = 0;
-    asl::buffer<int32_t, CounterAllocator> b(CounterAllocator{&count});
-    ASL_TEST_EXPECT(b.size() == 0);
-    ASL_TEST_EXPECT(b.capacity() == 5);
-    ASL_TEST_EXPECT(count == 0);
-
-    b.reserve_capacity(4);
-    ASL_TEST_EXPECT(b.size() == 0);
-    ASL_TEST_EXPECT(b.capacity() == 5);
-    ASL_TEST_EXPECT(count == 0);
-
-    b.reserve_capacity(12);
-    ASL_TEST_EXPECT(b.size() == 0);
-    ASL_TEST_EXPECT(b.capacity() >= 12);
-    ASL_TEST_EXPECT(count == 1);
-
-    b.reserve_capacity(13);
-    ASL_TEST_EXPECT(b.size() == 0);
-    ASL_TEST_EXPECT(b.capacity() >= 13);
-    ASL_TEST_EXPECT(count == 1);
-
-    b.reserve_capacity(130);
-    ASL_TEST_EXPECT(b.size() == 0);
-    ASL_TEST_EXPECT(b.capacity() >= 130);
-    ASL_TEST_EXPECT(count == 2);
-}
-
-ASL_TEST(push)
-{
-    asl::buffer<int32_t> b;
-    ASL_TEST_EXPECT(b.size() == 0);
-
-    b.push(1);
-    ASL_TEST_EXPECT(b.size() == 1);
-    ASL_TEST_EXPECT(b[0] == 1);
-
-    b.push(2);
-    b.push(3);
-    ASL_TEST_EXPECT(b.size() == 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[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);
-}
-
-ASL_TEST(from_span)
-{
-    int data[] = {1, 2, 4, 8};
-    asl::buffer<int> b{data};
-
-    ASL_TEST_EXPECT(b.size() == 4);
-    ASL_TEST_EXPECT(b[0] == 1);
-    ASL_TEST_EXPECT(b[1] == 2);
-    ASL_TEST_EXPECT(b[2] == 4);
-    ASL_TEST_EXPECT(b[3] == 8);
-}
-
-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);
-}
-
-ASL_TEST(clear)
-{
-    asl::buffer<int32_t> b;
-    ASL_TEST_EXPECT(b.size() == 0);
-
-    b.push(1);
-    b.push(2);
-    b.push(3);
-    b.push(4);
-    b.push(5);
-    b.push(6);
-    b.push(7);
-    ASL_TEST_EXPECT(b.size() == 7);
-
-    b.clear();
-    ASL_TEST_EXPECT(b.size() == 0);
-}
-
-static_assert(asl::buffer<DestructorObserver>::kInlineCapacity == 2);
-
-ASL_TEST(clear_destructor_small)
-{
-    bool d0 = false;
-    bool d1 = false;
-
-    asl::buffer<DestructorObserver> buf;
-
-    buf.push(&d0);
-    buf.push(&d1);
-
-    buf.clear();
-    ASL_TEST_EXPECT(d0 == true);
-    ASL_TEST_EXPECT(d1 == true);
-}
-
-ASL_TEST(clear_destructor_heap)
-{
-    bool d0 = false;
-    bool d1 = false;
-    bool d2 = false;
-
-    asl::buffer<DestructorObserver> buf;
-
-    buf.push(&d0);
-    buf.push(&d1);
-    buf.push(&d2);
-    ASL_TEST_EXPECT(d0 == false);
-    ASL_TEST_EXPECT(d1 == false);
-    ASL_TEST_EXPECT(d2 == false);
-
-    buf.clear();
-    ASL_TEST_EXPECT(d0 == true);
-    ASL_TEST_EXPECT(d1 == true);
-    ASL_TEST_EXPECT(d2 == true);
-}
-
-ASL_TEST(move_construct_from_heap)
-{
-    bool d[3]{};
-    asl::buffer<DestructorObserver> buf;
-    buf.push(&d[0]);
-    buf.push(&d[1]);
-    buf.push(&d[2]);
-
-    {
-        asl::buffer<DestructorObserver> buf2(ASL_MOVE(buf));
-        ASL_TEST_EXPECT(buf2.size() == 3);
-        ASL_TEST_EXPECT(d[0] == false);
-        ASL_TEST_EXPECT(d[1] == false);
-        ASL_TEST_EXPECT(d[2] == false);
-    }
-
-    ASL_TEST_EXPECT(buf.size() == 0);
-    ASL_TEST_EXPECT(d[0] == true);
-    ASL_TEST_EXPECT(d[1] == true);
-    ASL_TEST_EXPECT(d[2] == true);
-}
-
-ASL_TEST(move_construct_inline_trivial)
-{
-    asl::buffer<uint64_t> buf;
-    buf.push(1U);
-    buf.push(2U);
-
-    asl::buffer<uint64_t> buf2(ASL_MOVE(buf));
-    ASL_TEST_EXPECT(buf2[0] == 1U);
-    ASL_TEST_EXPECT(buf2[1] == 2U);
-
-    ASL_TEST_EXPECT(buf2.size() == 2);
-    ASL_TEST_EXPECT(buf.size() == 0);
-}
-
-ASL_TEST(move_construct_from_inline_non_trivial)
-{
-    bool d[2]{};
-    asl::buffer<DestructorObserver> buf;
-    buf.push(&d[0]);
-    buf.push(&d[1]);
-
-    {
-        asl::buffer<DestructorObserver> buf2(ASL_MOVE(buf));
-        ASL_TEST_EXPECT(buf2.size() == 2);
-        ASL_TEST_EXPECT(d[0] == false);
-        ASL_TEST_EXPECT(d[1] == false);
-    }
-
-    ASL_TEST_EXPECT(buf.size() == 0);
-    ASL_TEST_EXPECT(d[0] == true);
-    ASL_TEST_EXPECT(d[1] == true);
-}
-
-ASL_TEST(move_assign_from_heap)
-{
-    bool d[6]{};
-
-    {
-        asl::buffer<DestructorObserver> buf;
-        asl::buffer<DestructorObserver> buf2;
-
-        buf.push(&d[0]);
-        buf.push(&d[1]);
-        buf.push(&d[2]);
-
-        buf2.push(&d[3]);
-        buf2.push(&d[4]);
-        buf2.push(&d[5]);
-
-        ASL_TEST_EXPECT(d[0] == false);
-        ASL_TEST_EXPECT(d[1] == false);
-        ASL_TEST_EXPECT(d[2] == false);
-        ASL_TEST_EXPECT(d[3] == false);
-        ASL_TEST_EXPECT(d[4] == false);
-        ASL_TEST_EXPECT(d[5] == false);
-
-        buf2 = ASL_MOVE(buf);
-
-        ASL_TEST_EXPECT(buf.size() == 0);
-        ASL_TEST_EXPECT(buf2.size() == 3);
-
-        ASL_TEST_EXPECT(d[0] == false);
-        ASL_TEST_EXPECT(d[1] == false);
-        ASL_TEST_EXPECT(d[2] == false);
-        ASL_TEST_EXPECT(d[3] == true);
-        ASL_TEST_EXPECT(d[4] == true);
-        ASL_TEST_EXPECT(d[5] == true);
-    }
-
-    ASL_TEST_EXPECT(d[0] == true);
-    ASL_TEST_EXPECT(d[1] == true);
-    ASL_TEST_EXPECT(d[2] == true);
-    ASL_TEST_EXPECT(d[3] == true);
-    ASL_TEST_EXPECT(d[4] == true);
-    ASL_TEST_EXPECT(d[5] == true);
-}
-
-ASL_TEST(move_assign_trivial_heap_to_inline)
-{
-    isize_t alloc_count = 0;
-    asl::buffer<int64_t, CounterAllocator> buf{CounterAllocator{&alloc_count}};
-    asl::buffer<int64_t, CounterAllocator> buf2{CounterAllocator{&alloc_count}};
-
-    buf.push(1);
-    buf.push(2);
-    ASL_TEST_EXPECT(alloc_count == 0);
-
-    buf2.push(3);
-    buf2.push(4);
-    buf2.push(5);
-    ASL_TEST_EXPECT(alloc_count == 1);
-
-    buf = ASL_MOVE(buf2);
-    ASL_TEST_EXPECT(alloc_count == 1);
-
-    ASL_TEST_EXPECT(buf.size() == 3);
-    ASL_TEST_EXPECT(buf2.size() == 0);
-    ASL_TEST_EXPECT(buf[0] == 3);
-    ASL_TEST_EXPECT(buf[1] == 4);
-    ASL_TEST_EXPECT(buf[2] == 5);
-}
-
-ASL_TEST(move_assign_trivial_inline_to_heap)
-{
-    isize_t alloc_count = 0;
-    asl::buffer<int64_t, CounterAllocator> buf{CounterAllocator{&alloc_count}};
-    asl::buffer<int64_t, CounterAllocator> buf2{CounterAllocator{&alloc_count}};
-
-    buf.push(1);
-    buf.push(2);
-    ASL_TEST_EXPECT(alloc_count == 0);
-
-    buf2.push(3);
-    buf2.push(4);
-    buf2.push(5);
-    ASL_TEST_EXPECT(alloc_count == 1);
-
-    buf2 = ASL_MOVE(buf);
-    ASL_TEST_EXPECT(alloc_count == 1);
-
-    ASL_TEST_EXPECT(buf.size() == 0);
-    ASL_TEST_EXPECT(buf2.size() == 2);
-    ASL_TEST_EXPECT(buf2[0] == 1);
-    ASL_TEST_EXPECT(buf2[1] == 2);
-}
-
-ASL_TEST(move_assign_inline_to_heap)
-{
-    bool d[6]{};
-
-    {
-        asl::buffer<DestructorObserver> buf;
-        asl::buffer<DestructorObserver> buf2;
-
-        buf.push(&d[0]);
-        buf.push(&d[1]);
-
-        buf2.push(&d[2]);
-        buf2.push(&d[3]);
-        buf2.push(&d[4]);
-        buf2.push(&d[5]);
-
-        buf2 = ASL_MOVE(buf);
-
-        ASL_TEST_EXPECT(buf.size() == 0);
-        ASL_TEST_EXPECT(buf2.size() == 2);
-        ASL_TEST_EXPECT(d[0] == false);
-        ASL_TEST_EXPECT(d[1] == false);
-        ASL_TEST_EXPECT(d[2] == false); // moved but not destroyed
-        ASL_TEST_EXPECT(d[3] == false); // moved but not destroyed
-        ASL_TEST_EXPECT(d[4] == true);
-        ASL_TEST_EXPECT(d[5] == true);
-    }
-
-    ASL_TEST_EXPECT(d[0] == true);
-    ASL_TEST_EXPECT(d[1] == true);
-    ASL_TEST_EXPECT(d[2] == false); // moved but not destroyed
-    ASL_TEST_EXPECT(d[3] == false); // moved but not destroyed
-    ASL_TEST_EXPECT(d[4] == true);
-    ASL_TEST_EXPECT(d[5] == true);
-}
-
-ASL_TEST(move_assign_from_inline_incompatible_allocator)
-{
-    bool d[6]{};
-
-    {
-        asl::buffer<DestructorObserver, IncompatibleAllocator> buf;
-        asl::buffer<DestructorObserver, IncompatibleAllocator> buf2;
-
-        buf.push(&d[0]);
-        buf.push(&d[1]);
-
-        buf2.push(&d[2]);
-        buf2.push(&d[3]);
-        buf2.push(&d[4]);
-        buf2.push(&d[5]);
-
-        buf2 = ASL_MOVE(buf);
-
-        ASL_TEST_EXPECT(buf.size() == 0);
-        ASL_TEST_EXPECT(buf2.size() == 2);
-        ASL_TEST_EXPECT(d[0] == false);
-        ASL_TEST_EXPECT(d[1] == false);
-        ASL_TEST_EXPECT(d[2] == true);
-        ASL_TEST_EXPECT(d[3] == true);
-        ASL_TEST_EXPECT(d[4] == true);
-        ASL_TEST_EXPECT(d[5] == true);
-    }
-
-    ASL_TEST_EXPECT(d[0] == true);
-    ASL_TEST_EXPECT(d[1] == true);
-    ASL_TEST_EXPECT(d[2] == true);
-    ASL_TEST_EXPECT(d[3] == true);
-    ASL_TEST_EXPECT(d[4] == true);
-    ASL_TEST_EXPECT(d[5] == true);
-}
-
-ASL_TEST(copy_construct_inline)
-{
-    asl::buffer<int> buf;
-    buf.push(0);
-    buf.push(1);
-    buf.push(2);
-
-    asl::buffer<int> buf2{buf};
-
-    ASL_TEST_EXPECT(buf.size() == buf2.size());
-    ASL_TEST_EXPECT(buf.size() == 3);
-    ASL_TEST_EXPECT(buf[0] == 0);
-    ASL_TEST_EXPECT(buf[1] == 1);
-    ASL_TEST_EXPECT(buf[2] == 2);
-    ASL_TEST_EXPECT(buf2[0] == 0);
-    ASL_TEST_EXPECT(buf2[1] == 1);
-    ASL_TEST_EXPECT(buf2[2] == 2);
-}
-
-ASL_TEST(copy_assign_into_smaller)
-{
-    asl::buffer<int> buf;
-    buf.push(0);
-    buf.push(1);
-    buf.push(2);
-
-    asl::buffer<int> buf2;
-    buf2.push(4);
-
-    buf2 = buf;
-
-    ASL_TEST_EXPECT(buf.size() == 3);
-    ASL_TEST_EXPECT(buf2.size() == 3);
-
-    ASL_TEST_EXPECT(buf[0] == 0);
-    ASL_TEST_EXPECT(buf[1] == 1);
-    ASL_TEST_EXPECT(buf[2] == 2);
-    ASL_TEST_EXPECT(buf2[0] == 0);
-    ASL_TEST_EXPECT(buf2[1] == 1);
-    ASL_TEST_EXPECT(buf2[2] == 2);
-}
-
-ASL_TEST(copy_assign_into_larger)
-{
-    asl::buffer<int> buf;
-    buf.push(0);
-    buf.push(1);
-    buf.push(2);
-
-    asl::buffer<int> buf2;
-    buf2.push(4);
-
-    buf = buf2;
-
-    ASL_TEST_EXPECT(buf.size() == 1);
-    ASL_TEST_EXPECT(buf2.size() == 1);
-
-    ASL_TEST_EXPECT(buf[0] == 4);
-    ASL_TEST_EXPECT(buf2[0] == 4);
-}
-
-ASL_TEST(resize_default)
-{
-    asl::buffer<int> buf;
-
-    buf.push(5);
-    buf.resize(4);
-
-    ASL_TEST_ASSERT(buf.size() == 4);
-    ASL_TEST_EXPECT(buf[0] == 5);
-    ASL_TEST_EXPECT(buf[1] == 0);
-    ASL_TEST_EXPECT(buf[2] == 0);
-    ASL_TEST_EXPECT(buf[3] == 0);
-
-    buf.resize(2);
-
-    ASL_TEST_ASSERT(buf.size() == 2);
-    ASL_TEST_EXPECT(buf[0] == 5);
-    ASL_TEST_EXPECT(buf[1] == 0);
-}
-
-ASL_TEST(resize)
-{
-    asl::buffer<int> buf;
-
-    buf.push(5);
-    buf.resize(4, 6);
-
-    ASL_TEST_ASSERT(buf.size() == 4);
-    ASL_TEST_EXPECT(buf[0] == 5);
-    ASL_TEST_EXPECT(buf[1] == 6);
-    ASL_TEST_EXPECT(buf[2] == 6);
-    ASL_TEST_EXPECT(buf[3] == 6);
-
-    buf.resize(2, 7);
-
-    ASL_TEST_ASSERT(buf.size() == 2);
-    ASL_TEST_EXPECT(buf[0] == 5);
-    ASL_TEST_EXPECT(buf[1] == 6);
-}
-
-ASL_TEST(resize_zero)
-{
-    asl::buffer<int> buf;
-    for (int i = 0; i < 100; ++i)
-    {
-        buf.push(i);
-    }
-
-    buf.resize_zero(200);
-    ASL_TEST_ASSERT(buf.size() == 200);
-
-    for (int i = 0; i < 100; ++i)
-    {
-        ASL_TEST_EXPECT(buf[i] == i);
-        ASL_TEST_EXPECT(buf[100 + i] == 0);
-    }
-}
-
diff --git a/asl/tests/float_tests.cpp b/asl/tests/float_tests.cpp
deleted file mode 100644
index d645be8..0000000
--- a/asl/tests/float_tests.cpp
+++ /dev/null
@@ -1,23 +0,0 @@
-#include "asl/float.hpp"
-
-#include "asl/testing/testing.hpp"
-
-ASL_TEST(is_infinity)
-{
-    ASL_TEST_EXPECT(!asl::is_infinity(0.0F));
-    ASL_TEST_EXPECT(!asl::is_infinity(-25.0F));
-    ASL_TEST_EXPECT(asl::is_infinity(45.0F / 0.0F));
-    ASL_TEST_EXPECT(asl::is_infinity(-45.0F / 0.0F));
-    ASL_TEST_EXPECT(asl::is_infinity(asl::infinity<float>()));
-    ASL_TEST_EXPECT(asl::is_infinity(-asl::infinity<double>()));
-}
-
-ASL_TEST(is_nan)
-{
-    ASL_TEST_EXPECT(!asl::is_nan(0.0F));
-    ASL_TEST_EXPECT(!asl::is_nan(-25.0F));
-    ASL_TEST_EXPECT(!asl::is_nan(45.0F / 0.0F));
-    ASL_TEST_EXPECT(asl::is_nan(asl::nan<float>()));
-    ASL_TEST_EXPECT(asl::is_nan(asl::nan<double>()));
-}
-
diff --git a/asl/tests/format_tests.cpp b/asl/tests/format_tests.cpp
deleted file mode 100644
index a91cac6..0000000
--- a/asl/tests/format_tests.cpp
+++ /dev/null
@@ -1,110 +0,0 @@
-#include "asl/format.hpp"
-#include "asl/testing/testing.hpp"
-#include "asl/float.hpp"
-#include "asl/string_builder.hpp"
-
-static_assert(asl::formattable<decltype("Hello")>);
-
-ASL_TEST(format_args)
-{
-    // @Todo Introduce ASL_TEST_EXPECT_EQ, or ASL_TEST_EXPECT_STREQ
-
-    auto s = asl::format_to_string("Hello, world!");
-    ASL_TEST_EXPECT(s == "Hello, world!"_sv);
-
-    s = asl::format_to_string("");
-    ASL_TEST_EXPECT(s == ""_sv);
-
-    s = asl::format_to_string("Hello, {}!", "world");
-    ASL_TEST_EXPECT(s == "Hello, world!"_sv);
-
-    s = asl::format_to_string("Hello, {}! {}", "world");
-    ASL_TEST_EXPECT(s == "Hello, world! <ERROR>"_sv);
-
-    s = asl::format_to_string("Hello, pup!", "world");
-    ASL_TEST_EXPECT(s == "Hello, pup!"_sv);
-
-    s = asl::format_to_string("{}", "CHEESE");
-    ASL_TEST_EXPECT(s == "CHEESE"_sv);
-
-    s = asl::format_to_string("{   ", "CHEESE");
-    ASL_TEST_EXPECT(s == "<ERROR>   "_sv);
-
-    s = asl::format_to_string("{", "CHEESE");
-    ASL_TEST_EXPECT(s == "<ERROR>"_sv);
-
-    s = asl::format_to_string("a{{b");
-    ASL_TEST_EXPECT(s == "a{b"_sv);
-
-    s = asl::format_to_string("{{{}}} }", "CHEESE");
-    ASL_TEST_EXPECT(s == "{CHEESE} }"_sv);
-}
-
-ASL_TEST(format_integers)
-{
-    auto s = asl::format_to_string("{} {} {}", 0, 1, 2);
-    ASL_TEST_EXPECT(s == "0 1 2"_sv);
-
-    s = asl::format_to_string("{} {} {}", 10, 11, 12);
-    ASL_TEST_EXPECT(s == "10 11 12"_sv);
-
-    s = asl::format_to_string("{} {} {}", 100, 101, 102);
-    ASL_TEST_EXPECT(s == "100 101 102"_sv);
-
-    s = asl::format_to_string("{} {} {}", 1000, 1001, 1002);
-    ASL_TEST_EXPECT(s == "1000 1001 1002"_sv);
-
-    s = asl::format_to_string("{} {} {} {}", -1, -23, -456, -7890);
-    ASL_TEST_EXPECT(s == "-1 -23 -456 -7890"_sv);
-}
-
-ASL_TEST(format_floats)
-{
-    auto s = asl::format_to_string("{} {} {}", 0.0F, 1.0, 2.0F);
-    ASL_TEST_EXPECT(s == "0 1 2"_sv);
-
-    s = asl::format_to_string("{} {} {}", 0.1F, 0.001F, 0.123F);
-    ASL_TEST_EXPECT(s == "0.1 0.001 0.123"_sv);
-
-    s = asl::format_to_string("{} {}", 1.25F, -22.3);
-    ASL_TEST_EXPECT(s == "1.25 -22.3"_sv);
-
-    s = asl::format_to_string("{}", 1e32);
-    ASL_TEST_EXPECT(s == "100000000000000000000000000000000"_sv);
-
-    s = asl::format_to_string("{}", 123e-8);
-    ASL_TEST_EXPECT(s == "0.00000123"_sv);
-
-    s = asl::format_to_string("{} {}", asl::infinity<float>(), -asl::infinity<double>());
-    ASL_TEST_EXPECT(s == "Infinity -Infinity"_sv);
-
-    s = asl::format_to_string("{}", asl::nan<float>());
-    ASL_TEST_EXPECT(s == "NaN"_sv);
-}
-
-ASL_TEST(format_boolean)
-{
-    auto s = asl::format_to_string("{} {}", true, false);
-    ASL_TEST_EXPECT(s == "true false"_sv);
-}
-
-struct CustomFormat
-{
-    int x;
-    friend void AslFormat(asl::Formatter&, const CustomFormat&);
-};
-
-void AslFormat(asl::Formatter& f, const CustomFormat& c)
-{
-    f.write("("_sv);
-    AslFormat(f, c.x);
-    f.write(")"_sv);
-}
-
-static_assert(asl::formattable<CustomFormat>);
-
-ASL_TEST(format_custom)
-{
-    auto s = asl::format_to_string("{}", CustomFormat{37});
-    ASL_TEST_EXPECT(s == "(37)"_sv);
-}
diff --git a/asl/tests/functional_tests.cpp b/asl/tests/functional_tests.cpp
deleted file mode 100644
index 2cdbe7a..0000000
--- a/asl/tests/functional_tests.cpp
+++ /dev/null
@@ -1,73 +0,0 @@
-#include "asl/functional.hpp"
-#include "asl/testing/testing.hpp"
-
-struct HasFunction
-{
-    void do_something(int, float) {}
-};
-
-struct HasMember
-{
-    int member{};
-    int member_array[4]{};
-    void (*member_fn)(){};
-};
-
-struct Functor
-{
-    int64_t operator()() { return 35; }
-    int operator()(int x) { return x; }
-};
-
-static int some_func0() { return 1; }
-static int some_func1(int x) { return x + 1; }
-[[maybe_unused]] static float some_func1(float x) { return x + 1; }
-static int some_func2(int x, int b) { return x + b; }
-
-static_assert(asl::same_as<asl::result_of_t<Functor()>, int64_t>);
-static_assert(asl::same_as<asl::result_of_t<Functor(int)>, int>);
-static_assert(asl::same_as<asl::result_of_t<decltype(static_cast<float(*)(float)>(some_func1))(float)>, float>);
-static_assert(asl::same_as<asl::result_of_t<decltype(&HasFunction::do_something)(HasFunction, int, float)>, void>);
-static_assert(asl::same_as<asl::result_of_t<decltype(&HasMember::member)(HasMember)>, int>);
-
-ASL_TEST(invoke_member_function)
-{
-    HasFunction c;
-    asl::invoke(&HasFunction::do_something, c, 5, 5.0F);
-    asl::invoke(&HasFunction::do_something, &c, 5, 5.0F);
-}
-
-ASL_TEST(invoke_member_data)
-{
-    HasMember c;
-
-    asl::invoke(&HasMember::member, c);
-    asl::invoke(&HasMember::member_array, c);
-    asl::invoke(&HasMember::member_fn, c);
-    asl::invoke(&HasMember::member, &c);
-    asl::invoke(&HasMember::member_array, &c);
-    asl::invoke(&HasMember::member_fn, &c);
-}
-
-ASL_TEST(invoke_fn)
-{
-    ASL_TEST_EXPECT(asl::invoke(some_func0) == 1);
-    ASL_TEST_EXPECT(asl::invoke(static_cast<int(*)(int)>(some_func1), 8) == 9);
-    ASL_TEST_EXPECT(asl::invoke(some_func2, 4, 8) == 12);
-    ASL_TEST_EXPECT(asl::invoke(&some_func0) == 1);
-    ASL_TEST_EXPECT(asl::invoke(static_cast<int(*)(int)>(&some_func1), 8) == 9);
-    ASL_TEST_EXPECT(asl::invoke(&some_func2, 4, 8) == 12);
-}
-
-ASL_TEST(invoke_operator_call)
-{
-    Functor f;
-    ASL_TEST_EXPECT(asl::invoke(f) == 35);
-    ASL_TEST_EXPECT(asl::invoke(f, 8) == 8);
-}
-
-ASL_TEST(invoke_lambda)
-{
-    ASL_TEST_EXPECT(asl::invoke([](){ return 35; }) == 35);
-    ASL_TEST_EXPECT(asl::invoke([](int x){ return x + 2; }, 6) == 8);
-}
diff --git a/asl/tests/hash_map_tests.cpp b/asl/tests/hash_map_tests.cpp
deleted file mode 100644
index 619c5e7..0000000
--- a/asl/tests/hash_map_tests.cpp
+++ /dev/null
@@ -1,48 +0,0 @@
-#include "asl/testing/testing.hpp"
-#include "asl/hash_map.hpp"
-
-ASL_TEST(default)
-{
-    asl::hash_map<int, int> map;
-
-    ASL_TEST_EXPECT(!map.contains(45));
-    ASL_TEST_EXPECT(!map.contains(46));
-
-    map.insert(45, 5);
-    map.insert(46, 6);
-
-    ASL_TEST_EXPECT(map.size() == 2);
-
-    ASL_TEST_EXPECT(map.contains(45));
-    ASL_TEST_EXPECT(map.contains(46));
-    ASL_TEST_EXPECT(!map.contains(47));
-
-    ASL_TEST_EXPECT(*map.get(45) == 5);
-    ASL_TEST_EXPECT(*map.get(46) == 6);
-    ASL_TEST_EXPECT(map.get(47) == nullptr);
-
-    ASL_TEST_EXPECT(map.remove(45));
-    ASL_TEST_EXPECT(!map.remove(45));
-
-    ASL_TEST_EXPECT(map.size() == 1);
-
-    ASL_TEST_EXPECT(!map.contains(45));
-    ASL_TEST_EXPECT(map.contains(46));
-    ASL_TEST_EXPECT(!map.contains(47));
-
-    ASL_TEST_EXPECT(map.get(45) == nullptr);
-    ASL_TEST_EXPECT(*map.get(46) == 6);
-    ASL_TEST_EXPECT(map.get(47) == nullptr);
-
-    map.insert(46, 460);
-
-    ASL_TEST_EXPECT(map.size() == 1);
-
-    ASL_TEST_EXPECT(!map.contains(45));
-    ASL_TEST_EXPECT(map.contains(46));
-    ASL_TEST_EXPECT(!map.contains(47));
-
-    ASL_TEST_EXPECT(map.get(45) == nullptr);
-    ASL_TEST_EXPECT(*map.get(46) == 460);
-    ASL_TEST_EXPECT(map.get(47) == nullptr);
-}
diff --git a/asl/tests/hash_set_tests.cpp b/asl/tests/hash_set_tests.cpp
deleted file mode 100644
index 0c00c87..0000000
--- a/asl/tests/hash_set_tests.cpp
+++ /dev/null
@@ -1,185 +0,0 @@
-#include "asl/hash_set.hpp"
-#include "asl/testing/testing.hpp"
-#include "asl/tests/test_types.hpp"
-#include "asl/string.hpp"
-#include "asl/string_view.hpp"
-
-ASL_TEST(empty)
-{
-    asl::hash_set<int> set;
-
-    ASL_TEST_EXPECT(set.size() == 0);
-
-    for (int i = 0; i < 100; ++i)
-    {
-        ASL_TEST_EXPECT(!set.contains(i));
-    }
-}
-
-ASL_TEST(a_bunch_of_strings)
-{
-    asl::hash_set<asl::string<>> set;
-
-    set.insert("Hello, world!");
-    ASL_TEST_EXPECT(set.size() == 1);
-
-    set.insert("Hello, puppy!");
-    ASL_TEST_EXPECT(set.size() == 2);
-
-    set.insert("Hello, puppy!");
-    ASL_TEST_EXPECT(set.size() == 2);
-
-    ASL_TEST_EXPECT(set.contains("Hello, world!"_sv));
-    ASL_TEST_EXPECT(set.contains("Hello, puppy!"_sv));
-    ASL_TEST_EXPECT(!set.contains("Hello, Steven!"_sv));
-}
-
-ASL_TEST(a_bunch_of_ints)
-{
-    asl::hash_set<int> set;
-
-    int count = 3000;
-
-    for (int i = 0; i < count; ++i)
-    {
-        set.insert(i);
-    }
-
-    ASL_TEST_EXPECT(set.size() == count);
-
-    for (int i = 0; i < count * 2; ++i)
-    {
-        ASL_TEST_EXPECT(set.contains(i) == (i < count));
-    }
-}
-
-struct HashWithDestructor: public DestructorObserver
-{
-    int x;
-
-    HashWithDestructor(int x_, bool* ptr)
-        : DestructorObserver{ptr}
-        , x{x_}
-    {}
-
-    constexpr bool operator==(const HashWithDestructor& other) const
-    {
-        return x == other.x;
-    }
-};
-
-struct CustomComparator
-{
-    static bool eq(const HashWithDestructor& a, const HashWithDestructor& b)
-    {
-        return a.x == b.x;
-    }
-
-    static bool eq(const HashWithDestructor& a, int b)
-    {
-        return a.x == b;
-    }
-};
-
-struct CustomHasher
-{
-    static uint64_t hash(const HashWithDestructor& b)
-    {
-        return asl::hash_value(b.x);
-    }
-
-    static uint64_t hash(int x)
-    {
-        return asl::hash_value(x);
-    }
-};
-
-ASL_TEST(destructor_and_remove)
-{
-    static constexpr int kCount = 200;
-    bool destroyed[kCount]{};
-
-    {
-        asl::hash_set<HashWithDestructor, asl::DefaultAllocator, CustomHasher, CustomComparator> set;
-
-        for (int i = 0; i < kCount; ++i)
-        {
-            set.insert(i, &destroyed[i]); // NOLINT
-        }
-
-        ASL_TEST_EXPECT(set.size() == kCount);
-
-        for (int i = 0; i < kCount; ++i)
-        {
-            ASL_TEST_EXPECT(!destroyed[i]); // NOLINT
-        }
-
-        for (int i = 0; i < kCount; i += 2)
-        {
-            ASL_TEST_EXPECT(set.remove(i));
-        }
-
-        for (int i = 0; i < kCount; i += 2)
-        {
-            ASL_TEST_EXPECT(!set.contains(i));
-            ASL_TEST_EXPECT(set.contains(i+1));
-            ASL_TEST_EXPECT(destroyed[i]); // NOLINT
-            ASL_TEST_EXPECT(!destroyed[i + 1]); // NOLINT
-        }
-    }
-
-    for (int i = 0; i < kCount; ++i)
-    {
-        ASL_TEST_EXPECT(destroyed[i]); // NOLINT
-    }
-}
-
-ASL_TEST(copy)
-{
-    asl::hash_set<int> set1;
-
-    for (int i = 0; i < 100; ++i)
-    {
-        set1.insert(i);
-    }
-
-    asl::hash_set<int> set2 = set1;
-    asl::hash_set<int> set3;
-    set3 = set1;
-
-    ASL_TEST_EXPECT(set2.size() == 100);
-    ASL_TEST_EXPECT(set3.size() == 100);
-
-    for (int i = 0; i < 100; ++i)
-    {
-        ASL_TEST_EXPECT(set2.contains(i));
-        ASL_TEST_EXPECT(set3.contains(i));
-    }
-}
-
-ASL_TEST(move)
-{
-    asl::hash_set<int> set1;
-
-    for (int i = 0; i < 100; ++i)
-    {
-        set1.insert(i);
-    }
-
-    asl::hash_set<int> set2 = ASL_MOVE(set1);
-
-    ASL_TEST_EXPECT(set2.size() == 100);
-    for (int i = 0; i < 100; ++i)
-    {
-        ASL_TEST_EXPECT(set2.contains(i));
-    }
-
-    set1 = ASL_MOVE(set2);
-
-    ASL_TEST_EXPECT(set1.size() == 100);
-    for (int i = 0; i < 100; ++i)
-    {
-        ASL_TEST_EXPECT(set1.contains(i));
-    }
-}
-
diff --git a/asl/tests/hash_tests.cpp b/asl/tests/hash_tests.cpp
deleted file mode 100644
index 20a5183..0000000
--- a/asl/tests/hash_tests.cpp
+++ /dev/null
@@ -1,260 +0,0 @@
-#include "asl/testing/testing.hpp"
-#include "asl/hash.hpp"
-#include "asl/string_view.hpp"
-#include "asl/string.hpp"
-#include "asl/buffer.hpp"
-#include "asl/box.hpp"
-#include "asl/option.hpp"
-#include "asl/status.hpp"
-#include "asl/status_or.hpp"
-
-static_assert(!asl::hashable<int*>);
-static_assert(!asl::hashable<int[]>);
-static_assert(!asl::hashable<int[9]>);
-
-static_assert(asl::hashable<uint8_t>);
-static_assert(asl::hashable<uint16_t>);
-static_assert(asl::hashable<uint32_t>);
-static_assert(asl::hashable<uint64_t>);
-static_assert(asl::hashable<uint128_t>);
-
-static_assert(asl::hashable<int8_t>);
-static_assert(asl::hashable<int16_t>);
-static_assert(asl::hashable<int32_t>);
-static_assert(asl::hashable<int64_t>);
-
-ASL_TEST(integers)
-{
-    uint64_t a = asl::hash_value<uint16_t>(45);
-    uint64_t b = asl::hash_value<uint16_t>(45);
-    uint64_t c = asl::hash_value<uint16_t>(46);
-    uint64_t d = asl::hash_value<uint32_t>(45);
-
-    ASL_TEST_EXPECT(a == b);
-    ASL_TEST_EXPECT(a != c);
-    ASL_TEST_EXPECT(a != d);
-}
-
-static_assert(asl::hashable<bool>);
-
-ASL_TEST(bool)
-{
-    ASL_TEST_EXPECT(asl::hash_value(true) == asl::hash_value(true));
-    ASL_TEST_EXPECT(asl::hash_value(false) == asl::hash_value(false));
-    ASL_TEST_EXPECT(asl::hash_value(true) != asl::hash_value(false));
-}
-
-static_assert(asl::hashable<asl::string_view>);
-static_assert(asl::hashable<asl::string<>>);
-
-ASL_TEST(strings)
-{
-    ASL_TEST_EXPECT(asl::hash_value("hello"_sv) == asl::hash_value("hello"_sv));
-    ASL_TEST_EXPECT(asl::hash_value("hello"_sv) != asl::hash_value("hello "_sv));
-    ASL_TEST_EXPECT(asl::hash_value("hello"_sv) != asl::hash_value("HELLO"_sv));
-
-    ASL_TEST_EXPECT(asl::hash_value(asl::string("hello"_sv)) == asl::hash_value(asl::string("hello"_sv)));
-    ASL_TEST_EXPECT(asl::hash_value(asl::string("hello"_sv)) != asl::hash_value(asl::string("hello "_sv)));
-    ASL_TEST_EXPECT(asl::hash_value(asl::string("hello"_sv)) != asl::hash_value(asl::string("HELLO"_sv)));
-
-    ASL_TEST_EXPECT(asl::hash_value("hello"_sv) == asl::hash_value(asl::string("hello"_sv)));
-}
-
-static_assert(asl::hashable<asl::span<const int>>);
-static_assert(!asl::hashable<asl::span<const int*>>);
-static_assert(asl::hashable<asl::span<asl::string_view>>);
-
-ASL_TEST(span)
-{
-    int ints1[] = {1, 2, 3};
-    int ints2[] = {1, 2, 3};
-    int ints3[] = {1, 2};
-    int ints4[] = {3, 2, 1};
-
-    ASL_TEST_EXPECT(asl::hash_value(asl::span<int>(ints1)) == asl::hash_value(asl::span<int>(ints2)));
-    ASL_TEST_EXPECT(asl::hash_value(asl::span<int>(ints1)) != asl::hash_value(asl::span<int>(ints3)));
-    ASL_TEST_EXPECT(asl::hash_value(asl::span<int>(ints1)) != asl::hash_value(asl::span<int>(ints4)));
-
-    asl::string_view strs1[] = {"a", "abc", "hello"};
-    asl::string_view strs2[] = {"a", "abc", "hello"};
-    asl::string_view strs3[] = {"a", "abc"};
-    asl::string_view strs4[] = {"a", "abc", "hello", "what"};
-
-    ASL_TEST_EXPECT(asl::hash_value(asl::span<asl::string_view>(strs1)) == asl::hash_value(asl::span<asl::string_view>(strs2)));
-    ASL_TEST_EXPECT(asl::hash_value(asl::span<asl::string_view>(strs1)) != asl::hash_value(asl::span<asl::string_view>(strs3)));
-    ASL_TEST_EXPECT(asl::hash_value(asl::span<asl::string_view>(strs1)) != asl::hash_value(asl::span<asl::string_view>(strs4)));
-}
-
-static_assert(asl::hashable<asl::buffer<int>>);
-static_assert(!asl::hashable<asl::buffer<int*>>);
-
-ASL_TEST(buffer)
-{
-    asl::buffer<int> ints1;
-    ints1.push(1);
-    ints1.push(2);
-    ints1.push(3);
-
-    asl::buffer<int> ints2;
-    ints2.push(1);
-    ints2.push(2);
-    ints2.push(3);
-
-    asl::buffer<int> ints3;
-    ints3.push(1);
-    ints3.push(2);
-
-    asl::buffer<int> ints4;
-    ints4.push(1);
-    ints4.push(2);
-    ints4.push(4);
-
-    ASL_TEST_EXPECT(asl::hash_value(ints1) == asl::hash_value(ints2));
-    ASL_TEST_EXPECT(asl::hash_value(ints1) != asl::hash_value(ints3));
-    ASL_TEST_EXPECT(asl::hash_value(ints1) != asl::hash_value(ints4));
-    ASL_TEST_EXPECT(asl::hash_value(ints1) == asl::hash_value(ints1.as_span()));
-
-    asl::buffer<asl::string_view> strs1;
-    strs1.push("Hello");
-    strs1.push("World");
-
-    asl::buffer<asl::string_view> strs2;
-    strs2.push("Hello");
-    strs2.push("World");
-
-    asl::buffer<asl::string_view> strs3;
-    strs3.push("Hello");
-    strs3.push("world");
-
-    asl::buffer<asl::string_view> strs4;
-    strs4.push("Hello");
-    strs4.push("World");
-    strs4.push("World");
-
-    ASL_TEST_EXPECT(asl::hash_value(strs1) == asl::hash_value(strs2));
-    ASL_TEST_EXPECT(asl::hash_value(strs1) != asl::hash_value(strs3));
-    ASL_TEST_EXPECT(asl::hash_value(strs1) != asl::hash_value(strs4));
-    ASL_TEST_EXPECT(asl::hash_value(strs1) == asl::hash_value(strs1.as_span()));
-}
-
-enum Enum1 {};
-enum class Enum2 {};
-
-static_assert(asl::hashable<Enum1>);
-static_assert(asl::hashable<Enum2>);
-
-static_assert(!asl::hashable<asl::box<int*>>);
-static_assert(asl::hashable<asl::box<asl::string_view>>);
-
-ASL_TEST(box)
-{
-    auto b1 = asl::make_box<asl::string_view>("Hello, world!");
-    auto b2 = asl::make_box<asl::string_view>("Hello, world!");
-    auto b3 = asl::make_box<asl::string_view>("Hello, world! 2");
-
-    ASL_TEST_EXPECT(asl::hash_value(b1) == asl::hash_value(b2));
-    ASL_TEST_EXPECT(asl::hash_value(b1) != asl::hash_value(b3));
-    ASL_TEST_EXPECT(asl::hash_value(b1) == asl::hash_value("Hello, world!"_sv));
-}
-
-struct NonZero
-{
-    int value;
-
-    constexpr explicit NonZero(int x) : value(x)
-    {
-        ASL_ASSERT(x != 0);
-    }
-
-    constexpr explicit NonZero(asl::niche_t) : value(0) {}
-
-    constexpr bool operator==(asl::niche_t) const { return value == 0; }
-};
-
-namespace asl { template<> struct is_uniquely_represented<NonZero> : true_type {}; }
-static_assert(asl::has_niche<NonZero>);
-static_assert(asl::uniquely_represented<NonZero>);
-
-static_assert(asl::hashable<asl::option<int>>);
-static_assert(!asl::hashable<asl::option<int*>>);
-static_assert(asl::hashable<asl::option<asl::string_view>>);
-static_assert(asl::hashable<asl::option<NonZero>>);
-static_assert(asl::uniquely_represented<asl::option<NonZero>>);
-
-ASL_TEST(option)
-{
-    asl::option<int> int1 = 0;
-    asl::option<int> int2 = 0;
-    asl::option<int> int3 = 1;
-    asl::option<int> int4 = asl::nullopt;
-
-    ASL_TEST_EXPECT(asl::hash_value(int1) == asl::hash_value(int2));
-    ASL_TEST_EXPECT(asl::hash_value(int1) != asl::hash_value(int3));
-    ASL_TEST_EXPECT(asl::hash_value(int1) != asl::hash_value(int4));
-
-    asl::option<NonZero> noz1{8};
-    asl::option<NonZero> noz2{8};
-    asl::option<NonZero> noz3{9};
-    asl::option<NonZero> noz4 = asl::nullopt;
-
-    ASL_TEST_EXPECT(asl::hash_value(noz1) == asl::hash_value(noz2));
-    ASL_TEST_EXPECT(asl::hash_value(noz1) != asl::hash_value(noz3));
-    ASL_TEST_EXPECT(asl::hash_value(noz1) != asl::hash_value(noz4));
-}
-
-static_assert(asl::hashable<asl::status>);
-
-ASL_TEST(status)
-{
-    asl::status s1 = asl::ok();
-    asl::status s2 = asl::ok();
-    asl::status s3 = asl::internal_error();
-    asl::status s4 = asl::internal_error();
-    asl::status s5 = asl::runtime_error();
-    asl::status s6 = asl::internal_error("Oh, no!");
-    asl::status s7 = asl::internal_error("Oh, no!");
-    asl::status s8 = asl::internal_error("Oh, no");
-    asl::status s9 = asl::runtime_error("Oh, no!");
-
-    ASL_TEST_EXPECT(asl::hash_value(s1) == asl::hash_value(s2));
-    ASL_TEST_EXPECT(asl::hash_value(s3) == asl::hash_value(s4));
-    ASL_TEST_EXPECT(asl::hash_value(s6) == asl::hash_value(s7));
-
-    ASL_TEST_EXPECT(asl::hash_value(s1) != asl::hash_value(s3));
-    ASL_TEST_EXPECT(asl::hash_value(s1) != asl::hash_value(s5));
-    ASL_TEST_EXPECT(asl::hash_value(s1) != asl::hash_value(s6));
-    ASL_TEST_EXPECT(asl::hash_value(s1) != asl::hash_value(s9));
-
-    ASL_TEST_EXPECT(asl::hash_value(s3) != asl::hash_value(s5));
-    ASL_TEST_EXPECT(asl::hash_value(s3) != asl::hash_value(s6));
-    ASL_TEST_EXPECT(asl::hash_value(s3) != asl::hash_value(s8));
-    ASL_TEST_EXPECT(asl::hash_value(s3) != asl::hash_value(s9));
-
-    ASL_TEST_EXPECT(asl::hash_value(s6) != asl::hash_value(s8));
-    ASL_TEST_EXPECT(asl::hash_value(s6) != asl::hash_value(s9));
-}
-
-static_assert(asl::hashable<asl::status_or<int>>);
-static_assert(asl::hashable<asl::status_or<asl::string_view>>);
-static_assert(!asl::hashable<asl::status_or<int*>>);
-
-ASL_TEST(status_or)
-{
-    asl::status_or<int> s1 = 42;
-    asl::status_or<int> s2 = 42;
-    asl::status_or<int> s3 = 43;
-    asl::status_or<int> s4 = asl::runtime_error();
-    asl::status_or<int> s5 = asl::runtime_error();
-    asl::status_or<int> s6 = asl::runtime_error("Hello");
-    asl::status_or<int> s7 = asl::runtime_error("Hello");
-
-    ASL_TEST_EXPECT(asl::hash_value(s1) == asl::hash_value(s2));
-    ASL_TEST_EXPECT(asl::hash_value(s4) == asl::hash_value(s5));
-    ASL_TEST_EXPECT(asl::hash_value(s6) == asl::hash_value(s7));
-
-    ASL_TEST_EXPECT(asl::hash_value(s1) != asl::hash_value(s3));
-    ASL_TEST_EXPECT(asl::hash_value(s1) != asl::hash_value(s4));
-    ASL_TEST_EXPECT(asl::hash_value(s1) != asl::hash_value(s6));
-
-    ASL_TEST_EXPECT(asl::hash_value(s4) != asl::hash_value(s6));
-}
diff --git a/asl/tests/integers_tests.cpp b/asl/tests/integers_tests.cpp
deleted file mode 100644
index 1b5a20a..0000000
--- a/asl/tests/integers_tests.cpp
+++ /dev/null
@@ -1,15 +0,0 @@
-#include "asl/integers.hpp"
-
-static_assert(sizeof(int8_t)  == 1);
-static_assert(sizeof(int16_t) == 2);
-static_assert(sizeof(int32_t) == 4);
-static_assert(sizeof(int64_t) == 8);
-
-static_assert(sizeof(uint8_t)  == 1);
-static_assert(sizeof(uint16_t) == 2);
-static_assert(sizeof(uint32_t) == 4);
-static_assert(sizeof(uint64_t) == 8);
-
-static_assert(sizeof(asl::byte) == 1);
-
-static_assert(sizeof(uintptr_t) == sizeof(void*));
diff --git a/asl/tests/maybe_uninit_tests.cpp b/asl/tests/maybe_uninit_tests.cpp
deleted file mode 100644
index 9861c33..0000000
--- a/asl/tests/maybe_uninit_tests.cpp
+++ /dev/null
@@ -1,22 +0,0 @@
-#include "asl/maybe_uninit.hpp"
-#include "asl/tests/test_types.hpp"
-
-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>>);
-
-#define TEST_TYPE_PROPERTIES(PRP) \
-    static_assert(asl::PRP<asl::maybe_uninit<TrivialType>> == asl::PRP<TrivialType>); \
-    static_assert(asl::PRP<asl::maybe_uninit<TrivialTypeDefaultValue>> == asl::PRP<TrivialTypeDefaultValue>); \
-    static_assert(asl::PRP<asl::maybe_uninit<WithDestructor>> == asl::PRP<WithDestructor>); \
-    static_assert(asl::PRP<asl::maybe_uninit<Copyable>> == asl::PRP<Copyable>); \
-    static_assert(asl::PRP<asl::maybe_uninit<MoveableOnly>> == asl::PRP<MoveableOnly>); \
-    static_assert(asl::PRP<asl::maybe_uninit<Pinned>> == asl::PRP<Pinned>);
-
-TEST_TYPE_PROPERTIES(trivially_default_constructible);
-TEST_TYPE_PROPERTIES(trivially_copy_constructible);
-TEST_TYPE_PROPERTIES(trivially_move_constructible);
-TEST_TYPE_PROPERTIES(trivially_copy_assignable);
-TEST_TYPE_PROPERTIES(trivially_move_assignable);
-TEST_TYPE_PROPERTIES(trivially_destructible);
-
diff --git a/asl/tests/meta_tests.cpp b/asl/tests/meta_tests.cpp
deleted file mode 100644
index b015eb6..0000000
--- a/asl/tests/meta_tests.cpp
+++ /dev/null
@@ -1,289 +0,0 @@
-#include "asl/meta.hpp"
-#include "asl/tests/test_types.hpp"
-#include "asl/testing/testing.hpp"
-#include "asl/box.hpp"
-
-struct Struct {};
-union Union {};
-enum Enum : uint8_t { EnumVariant = 0, };
-enum class EnumClass : uint8_t { Variant = 0, };
-
-static_assert(!asl::same_as<long, short>);
-static_assert(asl::same_as<int, int>);
-
-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<TrivialType>);
-static_assert(asl::default_constructible<TrivialTypeDefaultValue>);
-
-static_assert(asl::trivially_default_constructible<int>);
-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<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<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<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<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<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<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<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<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<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>>);
-static_assert(asl::same_as<const int&, asl::un_const_t<const int&>>);
-
-static_assert(asl::same_as<int, asl::un_volatile_t<int>>);
-static_assert(asl::same_as<int, asl::un_volatile_t<volatile int>>);
-static_assert(asl::same_as<volatile int&, asl::un_volatile_t<volatile int&>>);
-
-static_assert(asl::same_as<int, asl::un_cv_t<int>>);
-static_assert(asl::same_as<int, asl::un_cv_t<const int>>);
-static_assert(asl::same_as<int, asl::un_cv_t<const volatile int>>);
-static_assert(asl::same_as<int, asl::un_cv_t<volatile int>>);
-
-static_assert(asl::is_void<void>);
-static_assert(asl::is_void<const void>);
-static_assert(asl::is_void<const volatile void>);
-static_assert(asl::is_void<volatile void>);
-static_assert(!asl::is_void<int>);
-static_assert(!asl::is_void<Struct>);
-static_assert(!asl::is_void<int&>);
-static_assert(!asl::is_void<int&&>);
-static_assert(!asl::is_void<void()>);
-static_assert(!asl::is_void<void() const &&>);
-
-static_assert(asl::is_ref<int&>);
-static_assert(asl::is_ref<const int&>);
-static_assert(asl::is_ref<const volatile int&>);
-static_assert(asl::is_ref<int&&>);
-static_assert(!asl::is_ref<int>);
-static_assert(!asl::is_ref<void>);
-static_assert(!asl::is_ref<void()>);
-static_assert(!asl::is_ref<void() const &&>);
-
-static_assert(asl::is_ptr<int*>);
-static_assert(asl::is_ptr<const int* const>);
-static_assert(asl::is_ptr<const volatile int*>);
-static_assert(!asl::is_ptr<int>);
-static_assert(!asl::is_ptr<void>);
-static_assert(!asl::is_ptr<void()>);
-static_assert(!asl::is_ptr<void() const &&>);
-
-static_assert(asl::same_as<int, asl::tame_t<int>>);
-static_assert(asl::same_as<int(), asl::tame_t<int()>>);
-static_assert(asl::same_as<int(float), asl::tame_t<int(float)>>);
-static_assert(asl::same_as<int(float), asl::tame_t<int(float) &>>);
-static_assert(asl::same_as<int(float), asl::tame_t<int(float) const &&>>);
-static_assert(asl::same_as<int(float), asl::tame_t<int(float) volatile noexcept>>);
-static_assert(asl::same_as<int(float), asl::tame_t<int(float) && noexcept>>);
-static_assert(asl::same_as<int(float), asl::tame_t<int(float) const>>);
-
-static_assert(asl::is_func<void()>);
-static_assert(asl::is_func<void(int)>);
-static_assert(asl::is_func<void(int, float)>);
-static_assert(asl::is_func<void() &>);
-static_assert(asl::is_func<void() const &&>);
-static_assert(asl::is_func<void() volatile noexcept>);
-static_assert(!asl::is_func<void(*)()>);
-static_assert(!asl::is_func<int>);
-static_assert(!asl::is_func<int&>);
-static_assert(!asl::is_func<void>);
-
-static_assert(asl::is_object<Struct>);
-static_assert(asl::is_object<int>);
-static_assert(asl::is_object<int*>);
-static_assert(asl::is_object<int Struct::*>);
-static_assert(asl::is_object<int (Struct::*)(float)>);
-static_assert(asl::is_object<int[]>);
-static_assert(asl::is_object<int[45]>);
-static_assert(asl::is_object<Enum>);
-static_assert(!asl::is_object<int&>);
-static_assert(!asl::is_object<void>);
-static_assert(!asl::is_object<void(int)>);
-static_assert(!asl::is_object<int(float) const && noexcept>);
-
-static_assert(!asl::is_array<Struct>);
-static_assert(!asl::is_array<int>);
-static_assert(!asl::is_array<int*>);
-static_assert(!asl::is_array<int Struct::*>);
-static_assert(!asl::is_array<int (Struct::*)(float)>);
-static_assert(asl::is_array<int[]>);
-static_assert(asl::is_array<int[45]>);
-static_assert(!asl::is_array<Enum>);
-static_assert(!asl::is_array<int&>);
-static_assert(!asl::is_array<void>);
-static_assert(!asl::is_array<void(int)>);
-static_assert(!asl::is_array<int(float) const && noexcept>);
-
-static_assert(asl::same_as<int, asl::un_ref_t<int>>);
-static_assert(asl::same_as<int, asl::un_ref_t<int&>>);
-static_assert(asl::same_as<int, asl::un_ref_t<int&&>>);
-static_assert(asl::same_as<int() &, asl::un_ref_t<int() &>>);
-
-static_assert(asl::types_count<int, float> == 2);
-static_assert(asl::types_count<int, int> == 2);
-static_assert(asl::types_count<int> == 1);
-static_assert(asl::types_count<> == 0);
-
-class Base {};
-class Derived : public Base {};
-class C {};
-class D { public: operator C() { return c; } C c; }; // NOLINT
-class E { public: template<class T> E(T&&) {} }; // NOLINT
-
-static_assert(asl::convertible_from<Base*, Derived*>);
-static_assert(!asl::convertible_from<Derived*, Base*>);
-static_assert(asl::convertible_from<C, D>);
-static_assert(!asl::convertible_from<C*, Derived*>);
-static_assert(asl::convertible_from<E, Base>);
-
-static_assert(!asl::convertible_from<int16_t(&)[], int32_t(&)[]>);
-static_assert(asl::convertible_from<const int16_t(&)[], int16_t(&)[]>);
-static_assert(asl::convertible_from<const int16_t(&)[], const int16_t(&)[]>);
-static_assert(asl::convertible_from<int16_t(&)[], int16_t(&)[]>);
-static_assert(!asl::convertible_from<int32_t(&)[], int16_t(&)[]>);
-static_assert(!asl::convertible_from<int16_t(&)[], const int16_t(&)[]>);
-static_assert(!asl::convertible_from<C(&)[], D(&)[]>);
-
-static_assert(asl::derived_from<Derived, Base>);
-static_assert(!asl::derived_from<Base, Derived>);
-static_assert(!asl::derived_from<D, C>);
-static_assert(!asl::derived_from<C, D>);
-static_assert(!asl::derived_from<uint8_t, uint16_t>);
-static_assert(!asl::derived_from<uint16_t, uint8_t>);
-static_assert(!asl::derived_from<int, int>);
-
-static_assert(!asl::is_const<int>);
-static_assert(asl::is_const<const int>);
-static_assert(!asl::is_const<const int*>);
-static_assert(asl::is_const<int* const>);
-
-static_assert(asl::is_floating_point<float>);
-static_assert(asl::is_floating_point<const float>);
-static_assert(asl::is_floating_point<volatile double>);
-static_assert(!asl::is_floating_point<const float&>);
-static_assert(!asl::is_floating_point<int>);
-static_assert(!asl::is_floating_point<C>);
-
-static_assert(asl::uniquely_represented<int>);
-static_assert(asl::uniquely_represented<uint128_t>);
-static_assert(!asl::uniquely_represented<bool>);
-
-enum Enum1 {};
-enum class Enum2 {};
-
-static_assert(asl::uniquely_represented<Enum1>);
-static_assert(asl::uniquely_represented<Enum2>);
-
-static_assert(!asl::is_enum<int>);
-static_assert(asl::is_enum<Enum1>);
-static_assert(asl::is_enum<Enum2>);
-
-static_assert(asl::derefs_as<int, int>);
-static_assert(asl::derefs_as<int*, int>);
-static_assert(asl::derefs_as<int&, int>);
-static_assert(asl::derefs_as<asl::box<int>, int>);
-
-static_assert(asl::derefs_as<Derived, Base>);
-static_assert(asl::derefs_as<Derived*, Base>);
-static_assert(asl::derefs_as<Derived&, Base>);
-static_assert(asl::derefs_as<asl::box<Derived>, Base>);
-
-static void wants_int(int) {}
-static void wants_base(Base&) {}
-static void wants_base_ptr(Base*) {}
-
-ASL_TEST(deref)
-{
-    int a = 4;
-    auto b = asl::make_box<int>(5);
-
-    wants_int(asl::deref<int>(5));
-    wants_int(asl::deref<int>(a));
-    wants_int(asl::deref<int>(&a));
-    wants_int(asl::deref<int>(b));
-
-    Derived c{};
-    auto d = asl::make_box<Derived>();
-
-    wants_base(asl::deref<Base>(Derived{}));
-    wants_base(asl::deref<Base>(c));
-    wants_base(asl::deref<Base>(&c));
-    wants_base(asl::deref<Base>(d));
-
-    wants_base_ptr(&asl::deref<Base>(Derived{}));
-    wants_base_ptr(&asl::deref<Base>(c));
-    wants_base_ptr(&asl::deref<Base>(&c));
-    wants_base_ptr(&asl::deref<Base>(d));
-}
-
diff --git a/asl/tests/option_tests.cpp b/asl/tests/option_tests.cpp
deleted file mode 100644
index c5461b1..0000000
--- a/asl/tests/option_tests.cpp
+++ /dev/null
@@ -1,330 +0,0 @@
-#include "asl/option.hpp"
-#include "asl/tests/test_types.hpp"
-#include "asl/testing/testing.hpp"
-
-class Base {};
-class Derived : public Base {};
-
-struct NonZero
-{
-    int value;
-
-    constexpr explicit NonZero(int x) : value(x)
-    {
-        ASL_ASSERT(x != 0);
-    }
-
-    constexpr explicit NonZero(asl::niche_t) : value(0) {}
-
-    constexpr bool operator==(asl::niche_t) const { return value == 0; }
-};
-static_assert(asl::has_niche<NonZero>);
-static_assert(!asl::has_niche<int>);
-
-static_assert(sizeof(asl::option<int>) >= sizeof(int));
-static_assert(sizeof(asl::option<NonZero>) == sizeof(NonZero));
-
-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<TrivialType>>);
-static_assert(!asl::trivially_destructible<asl::option<WithDestructor>>);
-
-static_assert(asl::trivially_copy_constructible<asl::option<int>>);
-static_assert(asl::trivially_copy_constructible<asl::option<NonZero>>);
-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::trivially_move_constructible<asl::option<int>>);
-static_assert(asl::trivially_move_constructible<asl::option<NonZero>>);
-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::trivially_copy_assignable<asl::option<int>>);
-static_assert(asl::trivially_copy_assignable<asl::option<NonZero>>);
-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::trivially_move_assignable<asl::option<int>>);
-static_assert(asl::trivially_move_assignable<asl::option<NonZero>>);
-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*>>);
-
-static_assert(asl::convertible_from<asl::option<Base*>, asl::option<Derived*>>);
-static_assert(!asl::convertible_from<asl::option<Derived*>, asl::option<Base*>>);
-
-class ExplicitConversion { public: explicit ExplicitConversion(int) {} };
-class ImplicitConversion { public: ImplicitConversion(int) {} }; // NOLINT
-
-static_assert(!asl::convertible_from<ExplicitConversion, int>);
-static_assert(asl::convertible_from<ImplicitConversion, int>);
-
-static_assert(!asl::convertible_from<asl::option<ExplicitConversion>, int>);
-static_assert(asl::convertible_from<asl::option<ImplicitConversion>, int>);
-
-static_assert(!asl::convertible_from<asl::option<ExplicitConversion>, asl::option<int>>);
-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<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<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<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<TrivialType>>);
-static_assert(asl::trivially_move_assignable<asl::option<TrivialTypeDefaultValue>>);
-static_assert(!asl::trivially_move_assignable<asl::option<MoveableOnly>>);
-
-ASL_TEST(make_null)
-{
-    asl::option<int> a;
-    asl::option<int> b = asl::nullopt;
-
-    ASL_TEST_EXPECT(!a.has_value());
-    ASL_TEST_EXPECT(!b.has_value());
-}
-
-ASL_TEST(make_value)
-{
-    asl::option<int> a = 48;
-
-    ASL_TEST_EXPECT(a.has_value());
-}
-
-ASL_TEST(reset)
-{
-    asl::option<int> b = 48;
-    ASL_TEST_EXPECT(b.has_value());
-
-    b.reset();
-    ASL_TEST_EXPECT(!b.has_value());
-}
-
-ASL_TEST(call_destructor)
-{
-    bool destroyed = false;
-
-    {
-        DestructorObserver obs(&destroyed);
-
-        asl::option<DestructorObserver> opt(ASL_MOVE(obs));
-        ASL_TEST_EXPECT(!destroyed);
-
-        asl::option<DestructorObserver> opt2 = ASL_MOVE(opt);
-        ASL_TEST_EXPECT(!destroyed);
-    }
-
-    ASL_TEST_EXPECT(destroyed);
-}
-
-ASL_TEST(call_destructor_on_reset)
-{
-    bool destroyed = false;
-
-    asl::option<DestructorObserver> opt(&destroyed);
-    ASL_TEST_EXPECT(!destroyed);
-
-    opt.reset();
-    ASL_TEST_EXPECT(destroyed);
-}
-
-ASL_TEST(value)
-{
-    asl::option<int> a = 1;
-    asl::option<int> b = 2;
-    asl::option<int> c = a;
-
-    ASL_TEST_EXPECT(a.value() == 1);
-    ASL_TEST_EXPECT(b.value() == 2);
-    ASL_TEST_EXPECT(c.value() == 1);
-
-    c = b;
-    ASL_TEST_EXPECT(c.value() == 2);
-}
-
-ASL_TEST(value_move)
-{
-    bool destroyed = false;
-
-    asl::option<DestructorObserver> opt(&destroyed);
-    ASL_TEST_EXPECT(!destroyed);
-
-    {
-        auto x = ASL_MOVE(opt).value();
-        ASL_TEST_EXPECT(!destroyed);
-    }
-
-    ASL_TEST_EXPECT(destroyed);
-}
-
-ASL_TEST(deduction_guide)
-{
-    asl::option opt(45);
-    ASL_TEST_EXPECT(opt.value() == 45);
-}
-
-ASL_TEST(convert_copy)
-{
-    asl::option<uint8_t> opt8 = uint8_t{8};
-    asl::option<uint16_t> opt16 = opt8;
-
-    ASL_TEST_ASSERT(opt16.has_value());
-    ASL_TEST_EXPECT(opt16.value() == 8);
-
-    opt8 = uint8_t{10};
-    ASL_TEST_ASSERT(opt8.has_value());
-    ASL_TEST_EXPECT(opt8.value() == 10);
-
-    opt16 = asl::nullopt;
-    ASL_TEST_EXPECT(!opt16.has_value());
-
-    opt16 = opt8;
-    ASL_TEST_ASSERT(opt16.has_value());
-    ASL_TEST_EXPECT(opt16.value() == 10);
-}
-
-ASL_TEST(convert_move)
-{
-    asl::option<uint8_t> opt8 = uint8_t{8};
-    asl::option<uint16_t> opt16 = ASL_MOVE(opt8);
-
-    ASL_TEST_ASSERT(opt16.has_value());
-    ASL_TEST_EXPECT(opt16.value() == 8);
-
-    opt8 = ASL_MOVE(uint8_t{10});
-    ASL_TEST_ASSERT(opt8.has_value());
-    ASL_TEST_EXPECT(opt8.value() == 10);
-
-    opt16 = asl::nullopt;
-    ASL_TEST_EXPECT(!opt16.has_value());
-
-    opt16 = ASL_MOVE(opt8);
-    ASL_TEST_ASSERT(opt16.has_value());
-    ASL_TEST_EXPECT(opt16.value() == 10);
-}
-
-ASL_TEST(value_or)
-{
-    asl::option<int> a = asl::nullopt;
-    asl::option<int> b = 2;
-
-    ASL_TEST_EXPECT(a.value_or(5) == 5);
-    ASL_TEST_EXPECT(b.value_or(5) == 2);
-}
-
-ASL_TEST(emplace)
-{
-    asl::option<int> a = asl::nullopt;
-
-    a.emplace(42);
-    ASL_TEST_ASSERT(a.has_value());
-    ASL_TEST_EXPECT(a.value() == 42);
-}
-
-ASL_TEST(emplace_destroys_previous)
-{
-    bool b1 = false;
-    bool b2 = false;
-
-    {
-        asl::option<DestructorObserver> a{&b1};
-        ASL_TEST_EXPECT(!b1);
-
-        a.emplace(&b2);
-        ASL_TEST_EXPECT(b1);
-        ASL_TEST_EXPECT(!b2);
-    }
-
-    ASL_TEST_EXPECT(b2);
-}
-
-ASL_TEST(and_then)
-{
-    asl::option<int> a = 5;
-    asl::option<int> b;
-
-    auto fn = [](int x) -> asl::option<float> { return static_cast<float>(x) + 0.5F; };
-
-    auto a2 = a.and_then(fn);
-    static_assert(asl::same_as<decltype(a2), asl::option<float>>);
-    ASL_TEST_ASSERT(a2.has_value());
-    ASL_TEST_EXPECT(a2.value() == 5.5F);
-
-    auto b2 = b.and_then(fn);
-    static_assert(asl::same_as<decltype(b2), asl::option<float>>);
-    ASL_TEST_ASSERT(!b2.has_value());
-}
-
-ASL_TEST(transform)
-{
-    asl::option<int> a = 5;
-    asl::option<int> b;
-
-    auto fn = [](int x) -> float { return static_cast<float>(x) + 0.5F; };
-
-    auto a2 = a.transform(fn);
-    static_assert(asl::same_as<decltype(a2), asl::option<float>>);
-    ASL_TEST_ASSERT(a2.has_value());
-    ASL_TEST_EXPECT(a2.value() == 5.5F);
-
-    auto b2 = b.transform