More work on option

3 files changed, 93 insertions, 3 deletions

diff --git a/asl/tests/meta_tests.cpp b/asl/tests/meta_tests.cpp
index 5de4f8d..4397763 100644
--- a/asl/tests/meta_tests.cpp
+++ b/asl/tests/meta_tests.cpp
@@ -168,3 +168,15 @@ static_assert(!asl::trivially_copyable<HasDestructor>);
 static_assert(!asl::trivially_copyable<CopyAssignable>);

 static_assert(asl::trivially_copyable<DefaultConstructible>);

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

diff --git a/asl/tests/option_tests.cpp b/asl/tests/option_tests.cpp
index e7fff8b..dea046e 100644
--- a/asl/tests/option_tests.cpp
+++ b/asl/tests/option_tests.cpp
@@ -1,6 +1,13 @@
 #include "asl/option.hpp"

 #include "asl/tests/test_types.hpp"

-#include "asl/testing/testing.hpp"
+#include "asl/testing/testing.hpp"

+

+class Base {};

+class Derived : public Base {};

+

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

 static_assert(!asl::trivially_destructible<asl::option<HasDestructor>>);

@@ -22,8 +29,39 @@ 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<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::convertible<asl::option<Base*>, asl::option<Derived*>>);

+static_assert(asl::convertible<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<int, asl::option<ExplicitConversion>>);

+static_assert(asl::convertible<int, asl::option<ImplicitConversion>>);

+

+static_assert(!asl::convertible<asl::option<int>, asl::option<ExplicitConversion>>);

+static_assert(asl::convertible<asl::option<int>, asl::option<ImplicitConversion>>);

+

+static_assert(asl::trivially_copy_constructible<asl::option<int>>);

+static_assert(!asl::trivially_copy_constructible<asl::option<CopyConstructible>>);

+

+static_assert(asl::trivially_move_constructible<asl::option<int>>);

+static_assert(!asl::trivially_move_constructible<asl::option<MoveConstructible>>);

+

+static_assert(asl::trivially_copy_assignable<asl::option<int>>);

+static_assert(!asl::trivially_copy_assignable<asl::option<CopyAssignable>>);

+

+static_assert(asl::trivially_move_assignable<asl::option<int>>);

+static_assert(!asl::trivially_move_assignable<asl::option<MoveAssignable>>);

+

 ASL_TEST(make_null)

 {

     asl::option<int> a;

@@ -111,3 +149,43 @@ 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_EXPECT(opt16.has_value());

+    ASL_TEST_EXPECT(opt16.value() == 8);

+

+    opt8 = uint8_t{10};

+    ASL_TEST_EXPECT(opt8.has_value());

+    ASL_TEST_EXPECT(opt8.value() == 10);

+    

+    opt16 = asl::nullopt;

+    ASL_TEST_EXPECT(!opt16.has_value());

+    

+    opt16 = opt8;

+    ASL_TEST_EXPECT(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_EXPECT(opt16.has_value());

+    ASL_TEST_EXPECT(opt16.value() == 8);

+

+    opt8 = ASL_MOVE(uint8_t{10});

+    ASL_TEST_EXPECT(opt8.has_value());

+    ASL_TEST_EXPECT(opt8.value() == 10);

+    

+    opt16 = asl::nullopt;

+    ASL_TEST_EXPECT(!opt16.has_value());

+    

+    opt16 = ASL_MOVE(opt8);

+    ASL_TEST_EXPECT(opt16.has_value());

+    ASL_TEST_EXPECT(opt16.value() == 10);

+}

diff --git a/asl/tests/test_types.hpp b/asl/tests/test_types.hpp
index cabc084..f988aec 100644
--- a/asl/tests/test_types.hpp
+++ b/asl/tests/test_types.hpp
@@ -14,11 +14,11 @@ struct MoveConstructible { MoveConstructible(MoveConstructible&&) {} };
 struct TriviallyMoveConstructible { TriviallyMoveConstructible(TriviallyMoveConstructible&&) = default; };

 struct NonMoveConstructible { NonMoveConstructible(NonMoveConstructible&&) = delete; };

 

-struct CopyAssignable { CopyAssignable& operator=(const CopyAssignable&) { return *this; } };

+struct CopyAssignable { CopyAssignable(const 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 MoveAssignable { MoveAssignable(MoveAssignable&&) {} MoveAssignable& operator=(MoveAssignable&&) { return *this; } };

 struct TriviallyMoveAssignable { TriviallyMoveAssignable& operator=(TriviallyMoveAssignable&&) = default; };

 struct NonMoveAssignable { NonMoveAssignable& operator=(NonMoveAssignable&&) = delete; };