From 8c95db33be58a545dd2e030428bded0bd958c4b6 Mon Sep 17 00:00:00 2001
From: Steven Le Rouzic <steven.lerouzic@gmail.com>
Date: Wed, 16 Oct 2024 22:54:34 +0200
Subject: Start work on the testing framework

---
 asl/BUILD.bazel                  |   5 +-
 asl/format_tests.cpp             | 106 ------------------------
 asl/integers_tests.cpp           |  13 ---
 asl/maybe_uninit_tests.cpp       |  14 ----
 asl/meta_tests.cpp               | 172 ---------------------------------------
 asl/option_tests.cpp             |  34 --------
 asl/test_types.hpp               |  25 ------
 asl/testing/BUILD.bazel          |  13 +++
 asl/testing/testing.cpp          |  14 ++++
 asl/testing/testing.hpp          |  15 ++++
 asl/tests/format_tests.cpp       | 106 ++++++++++++++++++++++++
 asl/tests/integers_tests.cpp     |  11 +++
 asl/tests/maybe_uninit_tests.cpp |  10 +++
 asl/tests/meta_tests.cpp         | 170 ++++++++++++++++++++++++++++++++++++++
 asl/tests/option_tests.cpp       |  33 ++++++++
 asl/tests/test_types.hpp         |  25 ++++++
 asl/tests/utility_tests.cpp      |   1 +
 asl/utility_tests.cpp            |   3 -
 18 files changed, 401 insertions(+), 369 deletions(-)
 delete mode 100644 asl/format_tests.cpp
 delete mode 100644 asl/integers_tests.cpp
 delete mode 100644 asl/maybe_uninit_tests.cpp
 delete mode 100644 asl/meta_tests.cpp
 delete mode 100644 asl/option_tests.cpp
 delete mode 100644 asl/test_types.hpp
 create mode 100644 asl/testing/BUILD.bazel
 create mode 100644 asl/testing/testing.cpp
 create mode 100644 asl/testing/testing.hpp
 create mode 100644 asl/tests/format_tests.cpp
 create mode 100644 asl/tests/integers_tests.cpp
 create mode 100644 asl/tests/maybe_uninit_tests.cpp
 create mode 100644 asl/tests/meta_tests.cpp
 create mode 100644 asl/tests/option_tests.cpp
 create mode 100644 asl/tests/test_types.hpp
 create mode 100644 asl/tests/utility_tests.cpp
 delete mode 100644 asl/utility_tests.cpp

(limited to 'asl')

diff --git a/asl/BUILD.bazel b/asl/BUILD.bazel
index f0d4c27..f7dddd1 100644
--- a/asl/BUILD.bazel
+++ b/asl/BUILD.bazel
@@ -24,11 +24,12 @@ cc_library(
 [cc_test(
     name = "%s_tests" % name,
     srcs = [
-        "%s_tests.cpp" % name,
-        "test_types.hpp",
+        "tests/%s_tests.cpp" % name,
+        "tests/test_types.hpp",
     ],
     deps = [
         ":asl",
+        "//asl/testing",
     ],
 ) for name in [
     "format",
diff --git a/asl/format_tests.cpp b/asl/format_tests.cpp
deleted file mode 100644
index 818773b..0000000
--- a/asl/format_tests.cpp
+++ /dev/null
@@ -1,106 +0,0 @@
-#include "asl/format.hpp"
-
-#include <cstdlib>
-#include <cstring>
-#include <cassert>
-#include <cstdio>
-
-// @Todo Improve this to use our utilities, not the C stdlib
-
-static_assert(asl::formattable<decltype("Hello")>);
-
-class StringSink : public asl::writer
-{
-    int64_t m_current_len{};
-    char*   m_data{};
-    
-public:
-    void write(const char* str, int64_t len) override
-    {
-        m_data = (char*)realloc(m_data, (size_t)(m_current_len + len + 1));
-        memcpy(m_data + m_current_len, str, (size_t)len);
-        m_current_len += len;
-        m_data[m_current_len] = '\0';
-    }
-
-    constexpr const char* cstr() const { return m_data; }
-
-    void reset()
-    {
-        m_current_len = 0;
-        free(m_data);
-        m_data = nullptr;
-    }
-};
-
-int main()
-{
-    StringSink sink;
-
-    // @Todo Use the testing framework
-
-    asl::format(&sink, "Hello, world!");
-    assert(strcmp(sink.cstr(), "Hello, world!") == 0);
-
-    sink.reset();
-    asl::format(&sink, "");
-    assert(strcmp(sink.cstr(), "") == 0);
-
-    sink.reset();
-    asl::format(&sink, "Hello, {}!", "world");
-    assert(strcmp(sink.cstr(), "Hello, world!") == 0);
-
-    sink.reset();
-    asl::format(&sink, "Hello, {}! {}", "world");
-    assert(strcmp(sink.cstr(), "Hello, world! <ERROR>") == 0);
-
-    sink.reset();
-    asl::format(&sink, "Hello, pup!", "world");
-    assert(strcmp(sink.cstr(), "Hello, pup!") == 0);
-
-    sink.reset();
-    asl::format(&sink, "{}", "CHEESE");
-    assert(strcmp(sink.cstr(), "CHEESE") == 0);
-
-    sink.reset();
-    asl::format(&sink, "{   ", "CHEESE");
-    assert(strcmp(sink.cstr(), "<ERROR>   ") == 0);
-
-    sink.reset();
-    asl::format(&sink, "{", "CHEESE");
-    assert(strcmp(sink.cstr(), "<ERROR>") == 0);
-
-    sink.reset();
-    asl::format(&sink, "a{{b");
-    assert(strcmp(sink.cstr(), "a{b") == 0);
-
-    sink.reset();
-    asl::format(&sink, "{{{}}} }", "CHEESE");
-    assert(strcmp(sink.cstr(), "{CHEESE} }") == 0);
-
-    sink.reset();
-    asl::format(&sink, "{} {} {}", 0, 1, 2);
-    assert(strcmp(sink.cstr(), "0 1 2") == 0);
-
-    sink.reset();
-    asl::format(&sink, "{} {} {}", 10, 11, 12);
-    assert(strcmp(sink.cstr(), "10 11 12") == 0);
-
-    sink.reset();
-    asl::format(&sink, "{} {} {}", 100, 101, 102);
-    assert(strcmp(sink.cstr(), "100 101 102") == 0);
-
-    sink.reset();
-    asl::format(&sink, "{} {} {}", 1000, 1001, 1002);
-    assert(strcmp(sink.cstr(), "1000 1001 1002") == 0);
-
-    sink.reset();
-    asl::format(&sink, "{} {} {} {}", -1, -23, -456, -7890);
-    assert(strcmp(sink.cstr(), "-1 -23 -456 -7890") == 0);
-
-    sink.reset();
-    asl::format(&sink, "{} {}", true, false);
-    assert(strcmp(sink.cstr(), "true false") == 0);
-
-    return 0;
-}
diff --git a/asl/integers_tests.cpp b/asl/integers_tests.cpp
deleted file mode 100644
index 0393a3c..0000000
--- a/asl/integers_tests.cpp
+++ /dev/null
@@ -1,13 +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);
-
-int main() { return 0; }
diff --git a/asl/maybe_uninit_tests.cpp b/asl/maybe_uninit_tests.cpp
deleted file mode 100644
index 7584eea..0000000
--- a/asl/maybe_uninit_tests.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#include "asl/maybe_uninit.hpp"
-#include "asl/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>>);
-
-static_assert(asl::trivially_destructible<asl::maybe_uninit<TriviallyDestructible>>);
-static_assert(!asl::trivially_destructible<asl::maybe_uninit<HasDestructor>>);
-
-int main()
-{
-    return 0;
-}
diff --git a/asl/meta_tests.cpp b/asl/meta_tests.cpp
deleted file mode 100644
index 2bebb01..0000000
--- a/asl/meta_tests.cpp
+++ /dev/null
@@ -1,172 +0,0 @@
-#include "asl/meta.hpp"
-#include "asl/test_types.hpp"
-
-struct Struct {};
-union Union {};
-enum Enum { EnumVariant = 0, };
-enum class EnumClass { Variant = 0, };
-
-static_assert(!asl::is_same<long, short>);
-static_assert(asl::is_same<int, int>);
-
-static_assert(asl::is_same<asl::select_t<false, int, float>, float>);
-static_assert(asl::is_same<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::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::copy_constructible<int>);
-static_assert(asl::copy_constructible<TriviallyCopyConstructible>);
-static_assert(asl::copy_constructible<CopyConstructible>);
-static_assert(!asl::copy_constructible<NonCopyConstructible>);
-
-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::move_constructible<int>);
-static_assert(asl::move_constructible<TriviallyMoveConstructible>);
-static_assert(asl::move_constructible<MoveConstructible>);
-static_assert(!asl::move_constructible<NonMoveConstructible>);
-
-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::copy_assignable<int>);
-static_assert(asl::copy_assignable<CopyAssignable>);
-static_assert(asl::copy_assignable<TriviallyCopyAssignable>);
-static_assert(!asl::copy_assignable<NonCopyAssignable>);
-
-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::move_assignable<int>);
-static_assert(asl::move_assignable<MoveAssignable>);
-static_assert(asl::move_assignable<TriviallyMoveAssignable>);
-static_assert(!asl::move_assignable<NonMoveAssignable>);
-
-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_destructible<int>);
-static_assert(asl::trivially_destructible<TriviallyDestructible>);
-static_assert(!asl::trivially_destructible<HasDestructor>);
-
-static_assert(asl::is_same<int, asl::un_const_t<int>>);
-static_assert(asl::is_same<int, asl::un_const_t<const int>>);
-static_assert(asl::is_same<const int&, asl::un_const_t<const int&>>);
-
-static_assert(asl::is_same<int, asl::un_volatile_t<int>>);
-static_assert(asl::is_same<int, asl::un_volatile_t<volatile int>>);
-static_assert(asl::is_same<volatile int&, asl::un_volatile_t<volatile int&>>);
-
-static_assert(asl::is_same<int, asl::un_cv_t<int>>);
-static_assert(asl::is_same<int, asl::un_cv_t<const int>>);
-static_assert(asl::is_same<int, asl::un_cv_t<const volatile int>>);
-static_assert(asl::is_same<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::is_same<int, asl::tame_t<int>>);
-static_assert(asl::is_same<int(), asl::tame_t<int()>>);
-static_assert(asl::is_same<int(float), asl::tame_t<int(float)>>);
-static_assert(asl::is_same<int(float), asl::tame_t<int(float) &>>);
-static_assert(asl::is_same<int(float), asl::tame_t<int(float) const &&>>);
-static_assert(asl::is_same<int(float), asl::tame_t<int(float) volatile noexcept>>);
-static_assert(asl::is_same<int(float), asl::tame_t<int(float) && noexcept>>);
-static_assert(asl::is_same<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::is_same<int, asl::un_ref_t<int>>);
-static_assert(asl::is_same<int, asl::un_ref_t<int&>>);
-static_assert(asl::is_same<int, asl::un_ref_t<int&&>>);
-static_assert(asl::is_same<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);
-
-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>);
-
-int main() { return 0; }
diff --git a/asl/option_tests.cpp b/asl/option_tests.cpp
deleted file mode 100644
index 38bce2e..0000000
--- a/asl/option_tests.cpp
+++ /dev/null
@@ -1,34 +0,0 @@
-#include "asl/option.hpp"
-#include "asl/test_types.hpp"
-
-static_assert(asl::trivially_destructible<asl::option<TriviallyDestructible>>);
-static_assert(!asl::trivially_destructible<asl::option<HasDestructor>>);
-
-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::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::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::move_assignable<asl::option<int>>);
-static_assert(asl::move_assignable<asl::option<CopyAssignable>>);
-static_assert(!asl::move_assignable<asl::option<NonMoveAssignable>>);
-
-int main()
-{
-    asl::option<int> a;
-    asl::option<int> b;
-
-    a = ASL_MOVE(b);
-    
-    return 0;
-}
diff --git a/asl/test_types.hpp b/asl/test_types.hpp
deleted file mode 100644
index da1faa6..0000000
--- a/asl/test_types.hpp
+++ /dev/null
@@ -1,25 +0,0 @@
-#pragma once
-
-struct DefaultConstructible { DefaultConstructible() {} };
-struct TriviallyDefaultConstructible { TriviallyDefaultConstructible() = default; };
-struct NonDefaultConstructible { NonDefaultConstructible() = delete; };
-
-struct CopyConstructible { CopyConstructible(const CopyConstructible&) {} };
-struct TriviallyCopyConstructible { TriviallyCopyConstructible(const TriviallyCopyConstructible&) = default; };
-struct NonCopyConstructible { NonCopyConstructible(const NonCopyConstructible&) = delete; };
-
-struct MoveConstructible { MoveConstructible(MoveConstructible&&) {} };
-struct TriviallyMoveConstructible { TriviallyMoveConstructible(TriviallyMoveConstructible&&) = default; };
-struct NonMoveConstructible { NonMoveConstructible(NonMoveConstructible&&) = delete; };
-
-struct CopyAssignable { CopyAssignable& operator=(const CopyAssignable&) { return *this; } };
-struct TriviallyCopyAssignable { TriviallyCopyAssignable& operator=(const TriviallyCopyAssignable&) = default; };
-struct NonCopyAssignable { NonCopyAssignable& operator=(const NonCopyAssignable&) = delete; };
-
-struct MoveAssignable { MoveAssignable& operator=(MoveAssignable&&) { return *this; } };
-struct TriviallyMoveAssignable { TriviallyMoveAssignable& operator=(TriviallyMoveAssignable&&) = default; };
-struct NonMoveAssignable { NonMoveAssignable& operator=(NonMoveAssignable&&) = delete; };
-
-struct TriviallyDestructible { ~TriviallyDestructible() = default; };
-struct HasDestructor { ~HasDestructor() {} };
-
diff --git a/asl/testing/BUILD.bazel b/asl/testing/BUILD.bazel
new file mode 100644
index 0000000..2942073
--- /dev/null
+++ b/asl/testing/BUILD.bazel
@@ -0,0 +1,13 @@
+cc_library(
+    name = "testing",
+    hdrs = [
+        "testing.hpp",
+    ],
+    srcs = [
+        "testing.cpp",
+    ],
+    deps = [
+        "//asl",
+    ],
+    visibility = ["//visibility:public"],
+)
diff --git a/asl/testing/testing.cpp b/asl/testing/testing.cpp
new file mode 100644
index 0000000..a2fe152
--- /dev/null
+++ b/asl/testing/testing.cpp
@@ -0,0 +1,14 @@
+#include "asl/testing/testing.hpp"
+
+int asl::testing::register_test(
+    const char* suite_name,
+    const char* case_name,
+    TestFunction* fn)
+{
+    return 0;
+}
+
+int main(int argc, char* argv[])
+{
+    return 0;
+}
diff --git a/asl/testing/testing.hpp b/asl/testing/testing.hpp
new file mode 100644
index 0000000..a489d61
--- /dev/null
+++ b/asl/testing/testing.hpp
@@ -0,0 +1,15 @@
+#pragma once
+
+namespace asl::testing
+{
+
+using TestFunction = void();
+int register_test(const char* suite_name, const char* case_name, TestFunction* fn);
+
+} // namespace asl::testing
+
+#define ASL_TEST(SUITE, CASE)                                                      \
+    static void asl_test_fn_##SUITE##_##CASE();                                    \
+    static const int asl_test_##SUITE##_##CASE = ::asl::testing::register_test(    \
+        #SUITE, #CASE, asl_test_fn_##SUITE##_##CASE);                              \
+    void asl_test_fn_##SUITE##_##CASE()
diff --git a/asl/tests/format_tests.cpp b/asl/tests/format_tests.cpp
new file mode 100644
index 0000000..6e2430d
--- /dev/null
+++ b/asl/tests/format_tests.cpp
@@ -0,0 +1,106 @@
+#include "asl/format.hpp"
+
+#include <cstdlib>
+#include <cstring>
+#include <cassert>
+#include <cstdio>
+
+// @Todo Improve this to use our utilities, not the C stdlib
+
+static_assert(asl::formattable<decltype("Hello")>);
+
+class StringSink : public asl::writer
+{
+    int64_t m_current_len{};
+    char*   m_data{};
+    
+public:
+    void write(const char* str, int64_t len) override
+    {
+        m_data = (char*)realloc(m_data, (size_t)(m_current_len + len + 1));
+        memcpy(m_data + m_current_len, str, (size_t)len);
+        m_current_len += len;
+        m_data[m_current_len] = '\0';
+    }
+
+    constexpr const char* cstr() const { return m_data; }
+
+    void reset()
+    {
+        m_current_len = 0;
+        free(m_data);
+        m_data = nullptr;
+    }
+};
+
+int main2()
+{
+    StringSink sink;
+
+    // @Todo Use the testing framework
+
+    asl::format(&sink, "Hello, world!");
+    assert(strcmp(sink.cstr(), "Hello, world!") == 0);
+
+    sink.reset();
+    asl::format(&sink, "");
+    assert(strcmp(sink.cstr(), "") == 0);
+
+    sink.reset();
+    asl::format(&sink, "Hello, {}!", "world");
+    assert(strcmp(sink.cstr(), "Hello, world!") == 0);
+
+    sink.reset();
+    asl::format(&sink, "Hello, {}! {}", "world");
+    assert(strcmp(sink.cstr(), "Hello, world! <ERROR>") == 0);
+
+    sink.reset();
+    asl::format(&sink, "Hello, pup!", "world");
+    assert(strcmp(sink.cstr(), "Hello, pup!") == 0);
+
+    sink.reset();
+    asl::format(&sink, "{}", "CHEESE");
+    assert(strcmp(sink.cstr(), "CHEESE") == 0);
+
+    sink.reset();
+    asl::format(&sink, "{   ", "CHEESE");
+    assert(strcmp(sink.cstr(), "<ERROR>   ") == 0);
+
+    sink.reset();
+    asl::format(&sink, "{", "CHEESE");
+    assert(strcmp(sink.cstr(), "<ERROR>") == 0);
+
+    sink.reset();
+    asl::format(&sink, "a{{b");
+    assert(strcmp(sink.cstr(), "a{b") == 0);
+
+    sink.reset();
+    asl::format(&sink, "{{{}}} }", "CHEESE");
+    assert(strcmp(sink.cstr(), "{CHEESE} }") == 0);
+
+    sink.reset();
+    asl::format(&sink, "{} {} {}", 0, 1, 2);
+    assert(strcmp(sink.cstr(), "0 1 2") == 0);
+
+    sink.reset();
+    asl::format(&sink, "{} {} {}", 10, 11, 12);
+    assert(strcmp(sink.cstr(), "10 11 12") == 0);
+
+    sink.reset();
+    asl::format(&sink, "{} {} {}", 100, 101, 102);
+    assert(strcmp(sink.cstr(), "100 101 102") == 0);
+
+    sink.reset();
+    asl::format(&sink, "{} {} {}", 1000, 1001, 1002);
+    assert(strcmp(sink.cstr(), "1000 1001 1002") == 0);
+
+    sink.reset();
+    asl::format(&sink, "{} {} {} {}", -1, -23, -456, -7890);
+    assert(strcmp(sink.cstr(), "-1 -23 -456 -7890") == 0);
+
+    sink.reset();
+    asl::format(&sink, "{} {}", true, false);
+    assert(strcmp(sink.cstr(), "true false") == 0);
+
+    return 0;
+}
diff --git a/asl/tests/integers_tests.cpp b/asl/tests/integers_tests.cpp
new file mode 100644
index 0000000..d15168e
--- /dev/null
+++ b/asl/tests/integers_tests.cpp
@@ -0,0 +1,11 @@
+#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);
diff --git a/asl/tests/maybe_uninit_tests.cpp b/asl/tests/maybe_uninit_tests.cpp
new file mode 100644
index 0000000..3f60558
--- /dev/null
+++ b/asl/tests/maybe_uninit_tests.cpp
@@ -0,0 +1,10 @@
+#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>>);
+
+static_assert(asl::trivially_destructible<asl::maybe_uninit<TriviallyDestructible>>);
+static_assert(!asl::trivially_destructible<asl::maybe_uninit<HasDestructor>>);
+
diff --git a/asl/tests/meta_tests.cpp b/asl/tests/meta_tests.cpp
new file mode 100644
index 0000000..5de4f8d
--- /dev/null
+++ b/asl/tests/meta_tests.cpp
@@ -0,0 +1,170 @@
+#include "asl/meta.hpp"
+#include "asl/tests/test_types.hpp"
+
+struct Struct {};
+union Union {};
+enum Enum { EnumVariant = 0, };
+enum class EnumClass { Variant = 0, };
+
+static_assert(!asl::is_same<long, short>);
+static_assert(asl::is_same<int, int>);
+
+static_assert(asl::is_same<asl::select_t<false, int, float>, float>);
+static_assert(asl::is_same<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::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::copy_constructible<int>);
+static_assert(asl::copy_constructible<TriviallyCopyConstructible>);
+static_assert(asl::copy_constructible<CopyConstructible>);
+static_assert(!asl::copy_constructible<NonCopyConstructible>);
+
+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::move_constructible<int>);
+static_assert(asl::move_constructible<TriviallyMoveConstructible>);
+static_assert(asl::move_constructible<MoveConstructible>);
+static_assert(!asl::move_constructible<NonMoveConstructible>);
+
+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::copy_assignable<int>);
+static_assert(asl::copy_assignable<CopyAssignable>);
+static_assert(asl::copy_assignable<TriviallyCopyAssignable>);
+static_assert(!asl::copy_assignable<NonCopyAssignable>);
+
+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::move_assignable<int>);
+static_assert(asl::move_assignable<MoveAssignable>);
+static_assert(asl::move_assignable<TriviallyMoveAssignable>);
+static_assert(!asl::move_assignable<NonMoveAssignable>);
+
+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_destructible<int>);
+static_assert(asl::trivially_destructible<TriviallyDestructible>);
+static_assert(!asl::trivially_destructible<HasDestructor>);
+
+static_assert(asl::is_same<int, asl::un_const_t<int>>);
+static_assert(asl::is_same<int, asl::un_const_t<const int>>);
+static_assert(asl::is_same<const int&, asl::un_const_t<const int&>>);
+
+static_assert(asl::is_same<int, asl::un_volatile_t<int>>);
+static_assert(asl::is_same<int, asl::un_volatile_t<volatile int>>);
+static_assert(asl::is_same<volatile int&, asl::un_volatile_t<volatile int&>>);
+
+static_assert(asl::is_same<int, asl::un_cv_t<int>>);
+static_assert(asl::is_same<int, asl::un_cv_t<const int>>);
+static_assert(asl::is_same<int, asl::un_cv_t<const volatile int>>);
+static_assert(asl::is_same<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::is_same<int, asl::tame_t<int>>);
+static_assert(asl::is_same<int(), asl::tame_t<int()>>);
+static_assert(asl::is_same<int(float), asl::tame_t<int(float)>>);
+static_assert(asl::is_same<int(float), asl::tame_t<int(float) &>>);
+static_assert(asl::is_same<int(float), asl::tame_t<int(float) const &&>>);
+static_assert(asl::is_same<int(float), asl::tame_t<int(float) volatile noexcept>>);
+static_assert(asl::is_same<int(float), asl::tame_t<int(float) && noexcept>>);
+static_assert(asl::is_same<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::is_same<int, asl::un_ref_t<int>>);
+static_assert(asl::is_same<int, asl::un_ref_t<int&>>);
+static_assert(asl::is_same<int, asl::un_ref_t<int&&>>);
+static_assert(asl::is_same<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);
+
+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>);
diff --git a/asl/tests/option_tests.cpp b/asl/tests/option_tests.cpp
new file mode 100644
index 0000000..7de1f9c
--- /dev/null
+++ b/asl/tests/option_tests.cpp
@@ -0,0 +1,33 @@
+#include "asl/option.hpp"
+#include "asl/tests/test_types.hpp"
+#include <asl/testing/testing.hpp>
+
+static_assert(asl::trivially_destructible<asl::option<TriviallyDestructible>>);
+static_assert(!asl::trivially_destructible<asl::option<HasDestructor>>);
+
+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::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::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::move_assignable<asl::option<int>>);
+static_assert(asl::move_assignable<asl::option<CopyAssignable>>);
+static_assert(!asl::move_assignable<asl::option<NonMoveAssignable>>);
+
+ASL_TEST(Option, cheese)
+{
+    asl::option<int> a;
+    asl::option<int> b;
+
+    a = ASL_MOVE(b);
+}
diff --git a/asl/tests/test_types.hpp b/asl/tests/test_types.hpp
new file mode 100644
index 0000000..da1faa6
--- /dev/null
+++ b/asl/tests/test_types.hpp
@@ -0,0 +1,25 @@
+#pragma once
+
+struct DefaultConstructible { DefaultConstructible() {} };
+struct TriviallyDefaultConstructible { TriviallyDefaultConstructible() = default; };
+struct NonDefaultConstructible { NonDefaultConstructible() = delete; };
+
+struct CopyConstructible { CopyConstructible(const CopyConstructible&) {} };
+struct TriviallyCopyConstructible { TriviallyCopyConstructible(const TriviallyCopyConstructible&) = default; };
+struct NonCopyConstructible { NonCopyConstructible(const NonCopyConstructible&) = delete; };
+
+struct MoveConstructible { MoveConstructible(MoveConstructible&&) {} };
+struct TriviallyMoveConstructible { TriviallyMoveConstructible(TriviallyMoveConstructible&&) = default; };
+struct NonMoveConstructible { NonMoveConstructible(NonMoveConstructible&&) = delete; };
+
+struct CopyAssignable { CopyAssignable& operator=(const CopyAssignable&) { return *this; } };
+struct TriviallyCopyAssignable { TriviallyCopyAssignable& operator=(const TriviallyCopyAssignable&) = default; };
+struct NonCopyAssignable { NonCopyAssignable& operator=(const NonCopyAssignable&) = delete; };
+
+struct MoveAssignable { MoveAssignable& operator=(MoveAssignable&&) { return *this; } };
+struct TriviallyMoveAssignable { TriviallyMoveAssignable& operator=(TriviallyMoveAssignable&&) = default; };
+struct NonMoveAssignable { NonMoveAssignable& operator=(NonMoveAssignable&&) = delete; };
+
+struct TriviallyDestructible { ~TriviallyDestructible() = default; };
+struct HasDestructor { ~HasDestructor() {} };
+
diff --git a/asl/tests/utility_tests.cpp b/asl/tests/utility_tests.cpp
new file mode 100644
index 0000000..4acded7
--- /dev/null
+++ b/asl/tests/utility_tests.cpp
@@ -0,0 +1 @@
+#include "asl/utility.hpp"
diff --git a/asl/utility_tests.cpp b/asl/utility_tests.cpp
deleted file mode 100644
index 5802cec..0000000
--- a/asl/utility_tests.cpp
+++ /dev/null
@@ -1,3 +0,0 @@
-#include "asl/utility.hpp"
-
-int main() { return 0; }
-- 
cgit