test: use common types as much as possible

test/entt/signal/dispatcher.cpp

@@ -3,21 +3,19 @@
 #include <gtest/gtest.h>
 #include <entt/core/hashed_string.hpp>
 #include <entt/signal/dispatcher.hpp>
-
-struct an_event {};
-struct another_event {};
+#include "../../common/empty.h"
 
 // makes the type non-aggregate
-struct one_more_event {
-    one_more_event(int) {}
+struct non_aggregate {
+    non_aggregate(int) {}
 };
 
 struct receiver {
-    static void forward(entt::dispatcher &dispatcher, an_event &event) {
+    static void forward(entt::dispatcher &dispatcher, test::empty &event) {
         dispatcher.enqueue(event);
     }
 
-    void receive(const an_event &) {
+    void receive(const test::empty &) {
         ++cnt;
     }
 
@@ -36,55 +34,55 @@ TEST(Dispatcher, Functionalities) {
 
     receiver receiver{};
 
-    ASSERT_EQ(dispatcher.size<an_event>(), 0u);
+    ASSERT_EQ(dispatcher.size<test::empty>(), 0u);
     ASSERT_EQ(dispatcher.size(), 0u);
 
-    dispatcher.trigger(one_more_event{1});
-    dispatcher.enqueue<one_more_event>(2);
-    dispatcher.update<one_more_event>();
+    dispatcher.trigger(non_aggregate{1});
+    dispatcher.enqueue<non_aggregate>(2);
+    dispatcher.update<non_aggregate>();
 
-    dispatcher.sink<an_event>().connect<&receiver::receive>(receiver);
-    dispatcher.trigger<an_event>();
-    dispatcher.enqueue<an_event>();
+    dispatcher.sink<test::empty>().connect<&receiver::receive>(receiver);
+    dispatcher.trigger<test::empty>();
+    dispatcher.enqueue<test::empty>();
 
-    ASSERT_EQ(dispatcher.size<one_more_event>(), 0u);
-    ASSERT_EQ(dispatcher.size<an_event>(), 1u);
+    ASSERT_EQ(dispatcher.size<non_aggregate>(), 0u);
+    ASSERT_EQ(dispatcher.size<test::empty>(), 1u);
     ASSERT_EQ(dispatcher.size(), 1u);
     ASSERT_EQ(receiver.cnt, 1);
 
-    dispatcher.enqueue(another_event{});
-    dispatcher.update<another_event>();
+    dispatcher.enqueue(test::other_empty{});
+    dispatcher.update<test::other_empty>();
 
-    ASSERT_EQ(dispatcher.size<another_event>(), 0u);
-    ASSERT_EQ(dispatcher.size<an_event>(), 1u);
+    ASSERT_EQ(dispatcher.size<test::other_empty>(), 0u);
+    ASSERT_EQ(dispatcher.size<test::empty>(), 1u);
     ASSERT_EQ(dispatcher.size(), 1u);
     ASSERT_EQ(receiver.cnt, 1);
 
-    dispatcher.update<an_event>();
-    dispatcher.trigger<an_event>();
+    dispatcher.update<test::empty>();
+    dispatcher.trigger<test::empty>();
 
-    ASSERT_EQ(dispatcher.size<an_event>(), 0u);
+    ASSERT_EQ(dispatcher.size<test::empty>(), 0u);
     ASSERT_EQ(dispatcher.size(), 0u);
     ASSERT_EQ(receiver.cnt, 3);
 
-    dispatcher.enqueue<an_event>();
-    dispatcher.clear<an_event>();
+    dispatcher.enqueue<test::empty>();
+    dispatcher.clear<test::empty>();
     dispatcher.update();
 
-    dispatcher.enqueue(an_event{});
+    dispatcher.enqueue(test::empty{});
     dispatcher.clear();
     dispatcher.update();
 
-    ASSERT_EQ(dispatcher.size<an_event>(), 0u);
+    ASSERT_EQ(dispatcher.size<test::empty>(), 0u);
     ASSERT_EQ(dispatcher.size(), 0u);
     ASSERT_EQ(receiver.cnt, 3);
 
     receiver.reset();
 
-    an_event event{};
+    test::empty event{};
 
-    dispatcher.sink<an_event>().disconnect<&receiver::receive>(receiver);
-    dispatcher.trigger<an_event>();
+    dispatcher.sink<test::empty>().disconnect<&receiver::receive>(receiver);
+    dispatcher.trigger<test::empty>();
     dispatcher.enqueue(event);
     dispatcher.update();
     dispatcher.trigger(std::as_const(event));
@@ -97,8 +95,8 @@ TEST(Dispatcher, Swap) {
     entt::dispatcher other{};
     receiver receiver{};
 
-    dispatcher.sink<an_event>().connect<&receiver::receive>(receiver);
-    dispatcher.enqueue<an_event>();
+    dispatcher.sink<test::empty>().connect<&receiver::receive>(receiver);
+    dispatcher.enqueue<test::empty>();
 
     ASSERT_EQ(dispatcher.size(), 1u);
     ASSERT_EQ(other.size(), 0u);
@@ -122,15 +120,15 @@ TEST(Dispatcher, StopAndGo) {
     entt::dispatcher dispatcher{};
     receiver receiver{};
 
-    dispatcher.sink<an_event>().connect<&receiver::forward>(dispatcher);
-    dispatcher.sink<an_event>().connect<&receiver::receive>(receiver);
+    dispatcher.sink<test::empty>().connect<&receiver::forward>(dispatcher);
+    dispatcher.sink<test::empty>().connect<&receiver::receive>(receiver);
 
-    dispatcher.enqueue<an_event>();
+    dispatcher.enqueue<test::empty>();
     dispatcher.update();
 
     ASSERT_EQ(receiver.cnt, 1);
 
-    dispatcher.sink<an_event>().disconnect<&receiver::forward>(dispatcher);
+    dispatcher.sink<test::empty>().disconnect<&receiver::forward>(dispatcher);
     dispatcher.update();
 
     ASSERT_EQ(receiver.cnt, 2);
@@ -140,13 +138,13 @@ TEST(Dispatcher, OpaqueDisconnect) {
     entt::dispatcher dispatcher{};
     receiver receiver{};
 
-    dispatcher.sink<an_event>().connect<&receiver::receive>(receiver);
-    dispatcher.trigger<an_event>();
+    dispatcher.sink<test::empty>().connect<&receiver::receive>(receiver);
+    dispatcher.trigger<test::empty>();
 
     ASSERT_EQ(receiver.cnt, 1);
 
     dispatcher.disconnect(receiver);
-    dispatcher.trigger<an_event>();
+    dispatcher.trigger<test::empty>();
 
     ASSERT_EQ(receiver.cnt, 1);
 }
@@ -157,31 +155,31 @@ TEST(Dispatcher, NamedQueue) {
     entt::dispatcher dispatcher{};
     receiver receiver{};
 
-    dispatcher.sink<an_event>("named"_hs).connect<&receiver::receive>(receiver);
-    dispatcher.trigger<an_event>();
+    dispatcher.sink<test::empty>("named"_hs).connect<&receiver::receive>(receiver);
+    dispatcher.trigger<test::empty>();
 
     ASSERT_EQ(receiver.cnt, 0);
 
-    dispatcher.trigger("named"_hs, an_event{});
+    dispatcher.trigger("named"_hs, test::empty{});
 
     ASSERT_EQ(receiver.cnt, 1);
 
-    dispatcher.enqueue<an_event>();
-    dispatcher.enqueue(an_event{});
-    dispatcher.enqueue_hint<an_event>("named"_hs);
-    dispatcher.enqueue_hint("named"_hs, an_event{});
-    dispatcher.update<an_event>();
+    dispatcher.enqueue<test::empty>();
+    dispatcher.enqueue(test::empty{});
+    dispatcher.enqueue_hint<test::empty>("named"_hs);
+    dispatcher.enqueue_hint("named"_hs, test::empty{});
+    dispatcher.update<test::empty>();
 
     ASSERT_EQ(receiver.cnt, 1);
 
-    dispatcher.clear<an_event>();
-    dispatcher.update<an_event>("named"_hs);
+    dispatcher.clear<test::empty>();
+    dispatcher.update<test::empty>("named"_hs);
 
     ASSERT_EQ(receiver.cnt, 3);
 
-    dispatcher.enqueue_hint<an_event>("named"_hs);
-    dispatcher.clear<an_event>("named"_hs);
-    dispatcher.update<an_event>("named"_hs);
+    dispatcher.enqueue_hint<test::empty>("named"_hs);
+    dispatcher.clear<test::empty>("named"_hs);
+    dispatcher.update<test::empty>("named"_hs);
 
     ASSERT_EQ(receiver.cnt, 3);
 }
@@ -193,8 +191,8 @@ TEST(Dispatcher, CustomAllocator) {
     ASSERT_EQ(dispatcher.get_allocator(), allocator);
     ASSERT_FALSE(dispatcher.get_allocator() != allocator);
 
-    dispatcher.enqueue<an_event>();
+    dispatcher.enqueue<test::empty>();
     const decltype(dispatcher) other{std::move(dispatcher), allocator};
 
-    ASSERT_EQ(other.size<an_event>(), 1u);
+    ASSERT_EQ(other.size<test::empty>(), 1u);
 }