From 6726a96f0cf3c230e9caa2abd40fcfbf03fe73a4 Mon Sep 17 00:00:00 2001
From: Steven Le Rouzic <steven.lerouzic@gmail.com>
Date: Sun, 3 Nov 2024 19:08:01 +0100
Subject: A bunch of cleanup

---
 asl/tests/format_tests.cpp     | 12 ++++++-
 asl/tests/functional_tests.cpp | 12 +++----
 asl/tests/meta_tests.cpp       | 73 +++++++++++++++++++++---------------------
 asl/tests/option_tests.cpp     | 32 +++++++++---------
 4 files changed, 69 insertions(+), 60 deletions(-)

(limited to 'asl/tests')

diff --git a/asl/tests/format_tests.cpp b/asl/tests/format_tests.cpp
index f4ca2cf..81395c2 100644
--- a/asl/tests/format_tests.cpp
+++ b/asl/tests/format_tests.cpp
@@ -34,7 +34,7 @@ public:
     }
 };
 
-ASL_TEST(Format)
+ASL_TEST(format_args)
 {
     StringSink sink;
 
@@ -79,7 +79,12 @@ ASL_TEST(Format)
     sink.reset();
     asl::format(&sink, "{{{}}} }", "CHEESE");
     ASL_TEST_ASSERT(strcmp(sink.cstr(), "{CHEESE} }") == 0);
+}
 
+ASL_TEST(format_integers)
+{
+    StringSink sink;
+    
     sink.reset();
     asl::format(&sink, "{} {} {}", 0, 1, 2);
     ASL_TEST_ASSERT(strcmp(sink.cstr(), "0 1 2") == 0);
@@ -99,7 +104,12 @@ ASL_TEST(Format)
     sink.reset();
     asl::format(&sink, "{} {} {} {}", -1, -23, -456, -7890);
     ASL_TEST_ASSERT(strcmp(sink.cstr(), "-1 -23 -456 -7890") == 0);
+}
 
+ASL_TEST(format_boolean)
+{
+    StringSink sink;
+    
     sink.reset();
     asl::format(&sink, "{} {}", true, false);
     ASL_TEST_ASSERT(strcmp(sink.cstr(), "true false") == 0);
diff --git a/asl/tests/functional_tests.cpp b/asl/tests/functional_tests.cpp
index 9aa15c7..f32e1b2 100644
--- a/asl/tests/functional_tests.cpp
+++ b/asl/tests/functional_tests.cpp
@@ -21,14 +21,14 @@ struct Functor
 
 static int some_func0() { return 1; }
 static int some_func1(int x) { return x + 1; }
-static float some_func1(float 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::is_same<asl::result_of_t<Functor()>, int64_t>);
-static_assert(asl::is_same<asl::result_of_t<Functor(int)>, int>);
-static_assert(asl::is_same<asl::result_of_t<decltype(static_cast<float(*)(float)>(some_func1))(float)>, float>);
-static_assert(asl::is_same<asl::result_of_t<decltype(&HasFunction::do_something)(HasFunction, int, float)>, void>);
-static_assert(asl::is_same<asl::result_of_t<decltype(&HasMember::member)(HasMember)>, int>);
+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)
 {
diff --git a/asl/tests/meta_tests.cpp b/asl/tests/meta_tests.cpp
index 0f5aa63..94edc50 100644
--- a/asl/tests/meta_tests.cpp
+++ b/asl/tests/meta_tests.cpp
@@ -1,17 +1,16 @@
 #include "asl/meta.hpp"
 #include "asl/tests/test_types.hpp"
-#include "asl/testing/testing.hpp"
 
 struct Struct {};
 union Union {};
-enum Enum { EnumVariant = 0, };
-enum class EnumClass { Variant = 0, };
+enum Enum : uint8_t { EnumVariant = 0, };
+enum class EnumClass : uint8_t { Variant = 0, };
 
-static_assert(!asl::is_same<long, short>);
-static_assert(asl::is_same<int, int>);
+static_assert(!asl::same_as<long, short>);
+static_assert(asl::same_as<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::same_as<asl::select_t<false, int, float>, float>);
+static_assert(asl::same_as<asl::select_t<true, int, float>, int>);
 
 static_assert(asl::default_constructible<int>);
 static_assert(asl::default_constructible<TriviallyDefaultConstructible>);
@@ -67,18 +66,18 @@ 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::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::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::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::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::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>);
@@ -108,14 +107,14 @@ 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::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)>);
@@ -154,10 +153,10 @@ 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::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);
@@ -173,14 +172,14 @@ static_assert(asl::trivially_copyable<TriviallyDefaultConstructible>);
 class Base {};
 class Derived : public Base {};
 class C {};
-class D { public: operator C() { return c; } C c; };
-class E { public: template<class T> E(T&&) {} };
-
-static_assert(asl::convertible<Derived*, Base*>);
-static_assert(!asl::convertible<Base*, Derived*>);
-static_assert(asl::convertible<D, C>);
-static_assert(!asl::convertible<Derived*, C*>);
-static_assert(asl::convertible<Base, E>);
+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::derived_from<Derived, Base>);
 static_assert(!asl::derived_from<Base, Derived>);
diff --git a/asl/tests/option_tests.cpp b/asl/tests/option_tests.cpp
index 12b62ae..4c65892 100644
--- a/asl/tests/option_tests.cpp
+++ b/asl/tests/option_tests.cpp
@@ -32,23 +32,23 @@ static_assert(asl::move_assignable<asl::option<CopyAssignable>>);
 static_assert(asl::move_assignable<asl::option<MoveAssignable>>);
 static_assert(!asl::move_assignable<asl::option<NonMoveAssignable>>);
 
-static_assert(asl::assignable<asl::option<Base*>&, asl::option<Derived*>>);
-static_assert(!asl::assignable<asl::option<Derived*>&, asl::option<Base*>>);
+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<asl::option<Base*>, asl::option<Derived*>>);
-static_assert(asl::convertible<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<int, ExplicitConversion>);
-static_assert(asl::convertible<int, ImplicitConversion>);
+static_assert(!asl::convertible_from<ExplicitConversion, int>);
+static_assert(asl::convertible_from<ImplicitConversion, int>);
 
-static_assert(!asl::convertible<int, asl::option<ExplicitConversion>>);
-static_assert(asl::convertible<int, asl::option<ImplicitConversion>>);
+static_assert(!asl::convertible_from<asl::option<ExplicitConversion>, int>);
+static_assert(asl::convertible_from<asl::option<ImplicitConversion>, int>);
 
-static_assert(!asl::convertible<asl::option<int>, asl::option<ExplicitConversion>>);
-static_assert(asl::convertible<asl::option<int>, asl::option<ImplicitConversion>>);
+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<CopyConstructible>>);
@@ -233,12 +233,12 @@ ASL_TEST(and_then)
     auto fn = [](int x) -> asl::option<float> { return static_cast<float>(x) + 0.5F; };
 
     auto a2 = a.and_then(fn);
-    static_assert(asl::is_same<decltype(a2), asl::option<float>>);
+    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::is_same<decltype(b2), asl::option<float>>);
+    static_assert(asl::same_as<decltype(b2), asl::option<float>>);
     ASL_TEST_ASSERT(!b2.has_value());
 }
 
@@ -250,12 +250,12 @@ ASL_TEST(transform)
     auto fn = [](int x) -> float { return static_cast<float>(x) + 0.5F; };
 
     auto a2 = a.transform(fn);
-    static_assert(asl::is_same<decltype(a2), asl::option<float>>);
+    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(fn);
-    static_assert(asl::is_same<decltype(b2), asl::option<float>>);
+    static_assert(asl::same_as<decltype(b2), asl::option<float>>);
     ASL_TEST_ASSERT(!b2.has_value());
 }
 
@@ -267,12 +267,12 @@ ASL_TEST(or_else)
     auto fn = []() -> asl::option<int> { return 12; };
 
     auto a2 = a.or_else(fn);
-    static_assert(asl::is_same<decltype(a2), asl::option<int>>);
+    static_assert(asl::same_as<decltype(a2), asl::option<int>>);
     ASL_TEST_ASSERT(a2.has_value());
     ASL_TEST_EXPECT(a2.value() == 5);
 
     auto b2 = b.or_else(fn);
-    static_assert(asl::is_same<decltype(b2), asl::option<int>>);
+    static_assert(asl::same_as<decltype(b2), asl::option<int>>);
     ASL_TEST_ASSERT(b2.has_value());
     ASL_TEST_EXPECT(b2.value() == 12);
 }
-- 
cgit