Finish work on hashing probably

3 files changed, 121 insertions, 14 deletions

diff --git a/asl/tests/hash_tests.cpp b/asl/tests/hash_tests.cpp
index 1ef051e..6098102 100644
--- a/asl/tests/hash_tests.cpp
+++ b/asl/tests/hash_tests.cpp
@@ -3,6 +3,10 @@
 #include "asl/string_view.hpp"

 #include "asl/string.hpp"

 #include "asl/buffer.hpp"

+#include "asl/box.hpp"

+#include "asl/option.hpp"

+#include "asl/status.hpp"

+#include "asl/status_or.hpp"

 

 static_assert(!asl::hashable<int*>);

 static_assert(!asl::hashable<int[]>);

@@ -57,6 +61,7 @@ ASL_TEST(strings)
 }

 

 static_assert(asl::hashable<asl::span<const int>>);

+static_assert(!asl::hashable<asl::span<const int*>>);

 static_assert(asl::hashable<asl::span<asl::string_view>>);

 

 ASL_TEST(span)

@@ -81,6 +86,7 @@ ASL_TEST(span)
 }

 

 static_assert(asl::hashable<asl::buffer<int>>);

+static_assert(!asl::hashable<asl::buffer<int*>>);

 

 ASL_TEST(buffer)

 {

@@ -137,6 +143,118 @@ enum class Enum2 {};
 static_assert(asl::hashable<Enum1>);

 static_assert(asl::hashable<Enum2>);

 

-// @Todo option (optimize uniquely_represented + has_niche)

-// @Todo status, status_or

-// @Todo box

+static_assert(!asl::hashable<asl::box<int*>>);

+static_assert(asl::hashable<asl::box<asl::string_view>>);

+

+ASL_TEST(box)

+{

+    auto b1 = asl::make_box<asl::string_view>("Hello, world!");

+    auto b2 = asl::make_box<asl::string_view>("Hello, world!");

+    auto b3 = asl::make_box<asl::string_view>("Hello, world! 2");

+

+    ASL_TEST_EXPECT(asl::hash_value(b1) == asl::hash_value(b2));

+    ASL_TEST_EXPECT(asl::hash_value(b1) != asl::hash_value(b3));

+    ASL_TEST_EXPECT(asl::hash_value(b1) == asl::hash_value("Hello, world!"_sv));

+}

+

+struct NonZero

+{

+    int value;

+

+    constexpr explicit NonZero(int x) : value(x)

+    {

+        ASL_ASSERT(x != 0);

+    }

+

+    constexpr explicit NonZero(asl::niche_t) : value(0) {}

+

+    constexpr bool operator==(asl::niche_t) const { return value == 0; }

+};

+

+namespace asl { template<> struct is_uniquely_represented<NonZero> : true_type {}; }

+static_assert(asl::has_niche<NonZero>);

+static_assert(asl::uniquely_represented<NonZero>);

+

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

+static_assert(!asl::hashable<asl::option<int*>>);

+static_assert(asl::hashable<asl::option<asl::string_view>>);

+static_assert(asl::hashable<asl::option<NonZero>>);

+static_assert(asl::uniquely_represented<asl::option<NonZero>>);

+

+ASL_TEST(option)

+{

+    asl::option<int> int1 = 0;

+    asl::option<int> int2 = 0;

+    asl::option<int> int3 = 1;

+    asl::option<int> int4 = asl::nullopt;

+

+    ASL_TEST_EXPECT(asl::hash_value(int1) == asl::hash_value(int2));

+    ASL_TEST_EXPECT(asl::hash_value(int1) != asl::hash_value(int3));

+    ASL_TEST_EXPECT(asl::hash_value(int1) != asl::hash_value(int4));

+

+    asl::option<NonZero> noz1{8};

+    asl::option<NonZero> noz2{8};

+    asl::option<NonZero> noz3{9};

+    asl::option<NonZero> noz4 = asl::nullopt;

+

+    ASL_TEST_EXPECT(asl::hash_value(noz1) == asl::hash_value(noz2));

+    ASL_TEST_EXPECT(asl::hash_value(noz1) != asl::hash_value(noz3));

+    ASL_TEST_EXPECT(asl::hash_value(noz1) != asl::hash_value(noz4));

+}

+

+static_assert(asl::hashable<asl::status>);

+

+ASL_TEST(status)

+{

+    asl::status s1 = asl::ok();

+    asl::status s2 = asl::ok();

+    asl::status s3 = asl::internal_error();

+    asl::status s4 = asl::internal_error();

+    asl::status s5 = asl::runtime_error();

+    asl::status s6 = asl::internal_error("Oh, no!");

+    asl::status s7 = asl::internal_error("Oh, no!");

+    asl::status s8 = asl::internal_error("Oh, no");

+    asl::status s9 = asl::runtime_error("Oh, no!");

+

+    ASL_TEST_EXPECT(asl::hash_value(s1) == asl::hash_value(s2));

+    ASL_TEST_EXPECT(asl::hash_value(s3) == asl::hash_value(s4));

+    ASL_TEST_EXPECT(asl::hash_value(s6) == asl::hash_value(s7));

+    

+    ASL_TEST_EXPECT(asl::hash_value(s1) != asl::hash_value(s3));

+    ASL_TEST_EXPECT(asl::hash_value(s1) != asl::hash_value(s5));

+    ASL_TEST_EXPECT(asl::hash_value(s1) != asl::hash_value(s6));

+    ASL_TEST_EXPECT(asl::hash_value(s1) != asl::hash_value(s9));

+    

+    ASL_TEST_EXPECT(asl::hash_value(s3) != asl::hash_value(s5));

+    ASL_TEST_EXPECT(asl::hash_value(s3) != asl::hash_value(s6));

+    ASL_TEST_EXPECT(asl::hash_value(s3) != asl::hash_value(s8));

+    ASL_TEST_EXPECT(asl::hash_value(s3) != asl::hash_value(s9));

+    

+    ASL_TEST_EXPECT(asl::hash_value(s6) != asl::hash_value(s8));

+    ASL_TEST_EXPECT(asl::hash_value(s6) != asl::hash_value(s9));

+}

+

+static_assert(asl::hashable<asl::status_or<int>>);

+static_assert(asl::hashable<asl::status_or<asl::string_view>>);

+static_assert(!asl::hashable<asl::status_or<int*>>);

+

+ASL_TEST(status_or)

+{

+    asl::status_or<int> s1 = 42;

+    asl::status_or<int> s2 = 42;

+    asl::status_or<int> s3 = 43;

+    asl::status_or<int> s4 = asl::runtime_error();

+    asl::status_or<int> s5 = asl::runtime_error();

+    asl::status_or<int> s6 = asl::runtime_error("Hello");

+    asl::status_or<int> s7 = asl::runtime_error("Hello");

+

+    ASL_TEST_EXPECT(asl::hash_value(s1) == asl::hash_value(s2));

+    ASL_TEST_EXPECT(asl::hash_value(s4) == asl::hash_value(s5));

+    ASL_TEST_EXPECT(asl::hash_value(s6) == asl::hash_value(s7));

+    

+    ASL_TEST_EXPECT(asl::hash_value(s1) != asl::hash_value(s3));

+    ASL_TEST_EXPECT(asl::hash_value(s1) != asl::hash_value(s4));

+    ASL_TEST_EXPECT(asl::hash_value(s1) != asl::hash_value(s6));

+    

+    ASL_TEST_EXPECT(asl::hash_value(s4) != asl::hash_value(s6));

+}

diff --git a/asl/tests/status_or_tests.cpp b/asl/tests/status_or_tests.cpp
index 5038e7e..e792270 100644
--- a/asl/tests/status_or_tests.cpp
+++ b/asl/tests/status_or_tests.cpp
@@ -18,7 +18,6 @@ ASL_TEST(ok)
 {

     asl::status_or<int> s = 6;

     ASL_TEST_EXPECT(s.ok());

-    ASL_TEST_EXPECT(s);

     ASL_TEST_EXPECT(s.code() == asl::status_code::ok);

 }

 

@@ -26,19 +25,16 @@ ASL_TEST(from_status)
 {

     asl::status_or<char> s = asl::internal_error();

     ASL_TEST_EXPECT(!s.ok());

-    ASL_TEST_EXPECT(!s);

     ASL_TEST_EXPECT(s.code() == asl::status_code::internal);

     ASL_TEST_EXPECT(s.message() == ""_sv);

     

     asl::status_or<int> s2 = asl::internal_error("oh no");

     ASL_TEST_EXPECT(!s2.ok());

-    ASL_TEST_EXPECT(!s2);

     ASL_TEST_EXPECT(s2.code() == asl::status_code::internal);

     ASL_TEST_EXPECT(s2.message() == "oh no"_sv);

     

     asl::status_or<int> s3 = asl::internal_error("{} {}", 1, 2);

     ASL_TEST_EXPECT(!s3.ok());

-    ASL_TEST_EXPECT(!s3);

     ASL_TEST_EXPECT(s3.code() == asl::status_code::internal);

     ASL_TEST_EXPECT(s3.message() == "1 2"_sv);

 }

diff --git a/asl/tests/status_tests.cpp b/asl/tests/status_tests.cpp
index 8ac6373..b598389 100644
--- a/asl/tests/status_tests.cpp
+++ b/asl/tests/status_tests.cpp
@@ -6,7 +6,6 @@
 ASL_TEST(simple_ok)
 {
     asl::status s = asl::ok();
-    ASL_TEST_ASSERT(s);
     ASL_TEST_ASSERT(s.ok());
     ASL_TEST_ASSERT(s.code() == asl::status_code::ok);
 }
@@ -14,7 +13,6 @@ ASL_TEST(simple_ok)
 ASL_TEST(simple_code)
 {
     asl::status s = asl::runtime_error();
-    ASL_TEST_ASSERT(!s);
     ASL_TEST_ASSERT(!s.ok());
     ASL_TEST_ASSERT(s.code() == asl::status_code::runtime);
     ASL_TEST_ASSERT(s.message() == ""_sv);
@@ -23,7 +21,6 @@ ASL_TEST(simple_code)
 ASL_TEST(with_message)
 {
     asl::status s = asl::internal_error("We done goofed");
-    ASL_TEST_ASSERT(!s);
     ASL_TEST_ASSERT(!s.ok());
     ASL_TEST_ASSERT(s.code() == asl::status_code::internal);
     ASL_TEST_ASSERT(s.message() == "We done goofed"_sv);
@@ -47,25 +44,21 @@ ASL_TEST(copy_message)
 
     {
         asl::status s = asl::internal_error("Oh no!");
-        ASL_TEST_ASSERT(!s);
         ASL_TEST_ASSERT(!s.ok());
         ASL_TEST_ASSERT(s.code() == asl::status_code::internal);
         ASL_TEST_ASSERT(s.message() == "Oh no!"_sv);
 
         const asl::status s3{s}; // NOLINT
-        ASL_TEST_ASSERT(!s3);
         ASL_TEST_ASSERT(!s3.ok());
         ASL_TEST_ASSERT(s3.code() == asl::status_code::internal);
         ASL_TEST_ASSERT(s3.message() == "Oh no!"_sv);
 
         s2 = s;
-        ASL_TEST_ASSERT(!s2);
         ASL_TEST_ASSERT(!s2.ok());
         ASL_TEST_ASSERT(s2.code() == asl::status_code::internal);
         ASL_TEST_ASSERT(s2.message() == "Oh no!"_sv);
     }
 
-    ASL_TEST_ASSERT(!s2);
     ASL_TEST_ASSERT(!s2.ok());
     ASL_TEST_ASSERT(s2.code() == asl::status_code::internal);
     ASL_TEST_ASSERT(s2.message() == "Oh no!"_sv);