A bunch of cleanup

4 files changed, 69 insertions, 60 deletions

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);

 }