test: simplify/cleanup throwing_type

test/entt/common/throwing_type.hpp

@@ -9,44 +9,39 @@ class throwing_type {
 public:
     using exception_type = test_exception;
 
-    static constexpr auto moved_from_value = -1;
-    static constexpr auto trigger_on_value = 42;
-
-    throwing_type(int value)
-        : data{value} {}
+    throwing_type(bool mode)
+        : trigger{mode} {}
 
     throwing_type(const throwing_type &other)
-        : data{other.data} {
-        if(data == trigger_on_value) {
-            data = moved_from_value;
+        : trigger{other.trigger} {
+        if(trigger) {
             throw exception_type{};
         }
     }
 
     throwing_type &operator=(const throwing_type &other) {
-        if(other.data == trigger_on_value) {
-            data = moved_from_value;
+        if(trigger) {
             throw exception_type{};
         }
 
-        data = other.data;
+        trigger = other.trigger;
         return *this;
     }
 
-    int get() const {
-        return data;
+    void throw_on_copy(const bool mode) noexcept {
+        trigger = mode;
     }
 
-    void set(int value) {
-        data = value;
+    bool throw_on_copy() const noexcept {
+        return trigger;
     }
 
 private:
-    int data{};
+    bool trigger{};
 };
 
 inline bool operator==(const throwing_type &lhs, const throwing_type &rhs) {
-    return lhs.get() == rhs.get();
+    return lhs.throw_on_copy() == rhs.throw_on_copy();
 }
 
 } // namespace test

test/entt/core/memory.cpp

@@ -87,13 +87,13 @@ TEST(AllocateUnique, Functionalities) {
     test::throwing_allocator<test::throwing_type> allocator{};
     test::throwing_allocator<test::throwing_type>::trigger_on_allocate = true;
 
-    ASSERT_THROW((entt::allocate_unique<test::throwing_type>(allocator, test::throwing_type::trigger_on_value)), test::throwing_allocator<test::throwing_type>::exception_type);
-    ASSERT_THROW((entt::allocate_unique<test::throwing_type>(allocator, test::throwing_type{test::throwing_type::trigger_on_value})), test::throwing_type::exception_type);
+    ASSERT_THROW((entt::allocate_unique<test::throwing_type>(allocator, false)), test::throwing_allocator<test::throwing_type>::exception_type);
+    ASSERT_THROW((entt::allocate_unique<test::throwing_type>(allocator, test::throwing_type{true})), test::throwing_type::exception_type);
 
-    std::unique_ptr<test::throwing_type, entt::allocation_deleter<test::throwing_allocator<test::throwing_type>>> ptr = entt::allocate_unique<test::throwing_type>(allocator, 1);
+    std::unique_ptr<test::throwing_type, entt::allocation_deleter<test::throwing_allocator<test::throwing_type>>> ptr = entt::allocate_unique<test::throwing_type>(allocator, false);
 
     ASSERT_TRUE(ptr);
-    ASSERT_EQ(*ptr, 1);
+    ASSERT_EQ(*ptr, false);
 
     ptr.reset();
 

test/entt/entity/sigh_mixin.cpp

@@ -555,8 +555,8 @@ TEST(SighMixin, ThrowingComponent) {
     pool.on_construct().connect<&listener<registry_type>>(on_construct);
     pool.on_destroy().connect<&listener<registry_type>>(on_destroy);
 
-    const entt::entity entity[2u]{entity[0u], entt::entity{1}};
-    const test::throwing_type value[2u]{test::throwing_type::trigger_on_value, 1};
+    const entt::entity entity[2u]{entt::entity{42}, entt::entity{1}};
+    const test::throwing_type value[2u]{true, false};
 
     // strong exception safety
     ASSERT_THROW(pool.emplace(entity[0u], value[0u]), typename test::throwing_type::exception_type);
@@ -579,8 +579,8 @@ TEST(SighMixin, ThrowingComponent) {
     ASSERT_EQ(pool.get(entity[1u]), value[1u]);
 
     pool.clear();
-    pool.emplace(entity[1u], value[1u].get());
-    pool.emplace(entity[0u], value[0u].get());
+    pool.emplace(entity[1u], value[0u].throw_on_copy());
+    pool.emplace(entity[0u], value[1u].throw_on_copy());
 
     // basic exception safety
     ASSERT_THROW(pool.erase(entity[1u]), typename test::throwing_type::exception_type);
@@ -589,11 +589,11 @@ TEST(SighMixin, ThrowingComponent) {
     ASSERT_TRUE(pool.contains(entity[1u]));
     ASSERT_EQ(pool.at(0u), entity[1u]);
     ASSERT_EQ(pool.at(1u), entity[0u]);
-    ASSERT_EQ(pool.get(entity[0u]), value[0u]);
+    ASSERT_EQ(pool.get(entity[0u]), value[1u]);
     // the element may have been moved but it's still there
-    ASSERT_EQ(pool.get(entity[1u]), test::throwing_type::moved_from_value);
+    ASSERT_EQ(pool.get(entity[1u]), value[0u]);
 
-    pool.get(entity[0u]).set(value[1u].get());
+    pool.get(entity[1u]).throw_on_copy(false);
     pool.erase(entity[1u]);
 
     ASSERT_EQ(pool.size(), 1u);

test/entt/entity/storage.cpp

@@ -1800,7 +1800,7 @@ TEST(Storage, ThrowingComponent) {
     entt::storage<test::throwing_type> pool;
 
     const entt::entity entity[2u]{entt::entity{42}, entt::entity{1}};
-    const test::throwing_type value[2u]{test::throwing_type::trigger_on_value, 1};
+    const test::throwing_type value[2u]{true, false};
 
     // strong exception safety
     ASSERT_THROW(pool.emplace(entity[0u], value[0u]), typename test::throwing_type::exception_type);
@@ -1823,8 +1823,8 @@ TEST(Storage, ThrowingComponent) {
     ASSERT_EQ(pool.get(entity[1u]), value[1u]);
 
     pool.clear();
-    pool.emplace(entity[1u], value[1u].get());
-    pool.emplace(entity[0u], value[0u].get());
+    pool.emplace(entity[1u], value[0u].throw_on_copy());
+    pool.emplace(entity[0u], value[1u].throw_on_copy());
 
     // basic exception safety
     ASSERT_THROW(pool.erase(entity[1u]), typename test::throwing_type::exception_type);
@@ -1833,11 +1833,11 @@ TEST(Storage, ThrowingComponent) {
     ASSERT_TRUE(pool.contains(entity[1u]));
     ASSERT_EQ(pool.at(0u), entity[1u]);
     ASSERT_EQ(pool.at(1u), entity[0u]);
-    ASSERT_EQ(pool.get(entity[0u]), value[0u]);
+    ASSERT_EQ(pool.get(entity[0u]), value[1u]);
     // the element may have been moved but it's still there
-    ASSERT_EQ(pool.get(entity[1u]), test::throwing_type::moved_from_value);
+    ASSERT_EQ(pool.get(entity[1u]), value[0u]);
 
-    pool.get(entity[0u]).set(value[1u].get());
+    pool.get(entity[1u]).throw_on_copy(false);
     pool.erase(entity[1u]);
 
     ASSERT_EQ(pool.size(), 1u);