Start work on the testing framework

7 files changed, 356 insertions, 0 deletions

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"