From 343d872be9f91e5fcb9167021790831458cbf19c Mon Sep 17 00:00:00 2001
From: Steven Le Rouzic <steven.lerouzic@gmail.com>
Date: Fri, 1 Nov 2024 22:56:06 +0100
Subject: More work on option

---
 asl/tests/meta_tests.cpp   | 12 +++++++
 asl/tests/option_tests.cpp | 80 +++++++++++++++++++++++++++++++++++++++++++++-
 asl/tests/test_types.hpp   |  4 +--
 3 files changed, 93 insertions(+), 3 deletions(-)

(limited to 'asl/tests')

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; };
 
-- 
cgit