Merge branch 'master' of https://github.com/lonkaars/crepe into wouter/inputSystem

1 files changed, 40 insertions, 67 deletions

diff --git a/src/test/EventTest.cpp b/src/test/EventTest.cpp
index ef7fc10..f57a6de 100644
--- a/src/test/EventTest.cpp
+++ b/src/test/EventTest.cpp
@@ -1,56 +1,41 @@
-#include <gmock/gmock.h>
-#include <gtest/gtest.h>
-
 #include <crepe/api/Event.h>
-#include <crepe/api/IKeyListener.h>
-#include <crepe/api/IMouseListener.h>
 #include <crepe/manager/EventManager.h>
-
+#include <crepe/manager/Mediator.h>
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
 using namespace std;
 using namespace std::chrono_literals;
 using namespace crepe;
 
 class EventManagerTest : public ::testing::Test {
 protected:
+	Mediator mediator;
+	EventManager event_mgr{mediator};
 	void SetUp() override {
 		// Clear any existing subscriptions or events before each test
-		EventManager::get_instance().clear();
+		event_mgr.clear();
 	}
 
 	void TearDown() override {
 		// Ensure cleanup after each test
-		EventManager::get_instance().clear();
+		event_mgr.clear();
 	}
 };
-class MockKeyListener : public IKeyListener {
-public:
-	MOCK_METHOD(bool, on_key_pressed, (const KeyPressEvent & event), (override));
-	MOCK_METHOD(bool, on_key_released, (const KeyReleaseEvent & event), (override));
-};
-
-class MockMouseListener : public IMouseListener {
-public:
-	MOCK_METHOD(bool, on_mouse_clicked, (const MouseClickEvent & event), (override));
-	MOCK_METHOD(bool, on_mouse_pressed, (const MousePressEvent & event), (override));
-	MOCK_METHOD(bool, on_mouse_released, (const MouseReleaseEvent & event), (override));
-	MOCK_METHOD(bool, on_mouse_moved, (const MouseMoveEvent & event), (override));
-};
-
 TEST_F(EventManagerTest, EventSubscription) {
 	EventHandler<KeyPressEvent> key_handler = [](const KeyPressEvent & e) { return true; };
 
 	// Subscribe to KeyPressEvent
-	EventManager::get_instance().subscribe<KeyPressEvent>(key_handler, 1);
+	event_mgr.subscribe<KeyPressEvent>(key_handler, 1);
 
 	// Verify subscription (not directly verifiable; test by triggering event)
 
-	EventManager::get_instance().trigger_event<KeyPressEvent>(
+	event_mgr.trigger_event<KeyPressEvent>(
 		KeyPressEvent{
 			.repeat = true,
 			.key = Keycode::A,
 		},
 		1);
-	EventManager::get_instance().trigger_event<KeyPressEvent>(
+	event_mgr.trigger_event<KeyPressEvent>(
 		KeyPressEvent{
 			.repeat = true,
 			.key = Keycode::A,
@@ -68,8 +53,7 @@ TEST_F(EventManagerTest, EventManagerTest_trigger_all_channels) {
 		EXPECT_EQ(e.button, MouseButton::LEFT_MOUSE);
 		return false;
 	};
-	EventManager::get_instance().subscribe<MouseClickEvent>(mouse_handler,
-															EventManager::CHANNEL_ALL);
+	event_mgr.subscribe<MouseClickEvent>(mouse_handler, EventManager::CHANNEL_ALL);
 
 	MouseClickEvent click_event{.mouse_pos = {100, 200}, .button = MouseButton::LEFT_MOUSE};
 	EventManager::get_instance().trigger_event<MouseClickEvent>(click_event,
@@ -87,18 +71,17 @@ TEST_F(EventManagerTest, EventManagerTest_trigger_one_channel) {
 		EXPECT_EQ(e.button, MouseButton::LEFT_MOUSE);
 		return false;
 	};
-	EventManager::get_instance().subscribe<MouseClickEvent>(mouse_handler, test_channel);
+	event_mgr.subscribe<MouseClickEvent>(mouse_handler, test_channel);
 
 	MouseClickEvent click_event{.mouse_pos = {100, 200}, .button = MouseButton::LEFT_MOUSE};
 	EventManager::get_instance().trigger_event<MouseClickEvent>(click_event,
 																EventManager::CHANNEL_ALL);
 
 	EXPECT_FALSE(triggered);
-	EventManager::get_instance().trigger_event<MouseClickEvent>(click_event, test_channel);
+	event_mgr.trigger_event<MouseClickEvent>(click_event, test_channel);
 }
 
 TEST_F(EventManagerTest, EventManagerTest_callback_propagation) {
-	EventManager & event_manager = EventManager::get_instance();
 
 	// Flags to track handler calls
 	bool triggered_true = false;
@@ -127,7 +110,7 @@ TEST_F(EventManagerTest, EventManagerTest_callback_propagation) {
 	event_manager.subscribe<MouseClickEvent>(mouse_handler_false, EventManager::CHANNEL_ALL);
 
 	// Trigger event
-	event_manager.trigger_event<MouseClickEvent>(click_event, EventManager::CHANNEL_ALL);
+	event_mgr.trigger_event<MouseClickEvent>(click_event, EventManager::CHANNEL_ALL);
 
 	// Check that only the true handler was triggered
 	EXPECT_TRUE(triggered_true);
@@ -136,12 +119,12 @@ TEST_F(EventManagerTest, EventManagerTest_callback_propagation) {
 	// Reset and clear
 	triggered_true = false;
 	triggered_false = false;
-	event_manager.clear();
-	event_manager.subscribe<MouseClickEvent>(mouse_handler_false, EventManager::CHANNEL_ALL);
-	event_manager.subscribe<MouseClickEvent>(mouse_handler_true, EventManager::CHANNEL_ALL);
+	event_mgr.clear();
+	event_mgr.subscribe<MouseClickEvent>(mouse_handler_false, EventManager::CHANNEL_ALL);
+	event_mgr.subscribe<MouseClickEvent>(mouse_handler_true, EventManager::CHANNEL_ALL);
 
 	// Trigger event again
-	event_manager.trigger_event<MouseClickEvent>(click_event, EventManager::CHANNEL_ALL);
+	event_mgr.trigger_event<MouseClickEvent>(click_event, EventManager::CHANNEL_ALL);
 
 	// Check that both handlers were triggered
 	EXPECT_TRUE(triggered_true);
@@ -149,47 +132,37 @@ TEST_F(EventManagerTest, EventManagerTest_callback_propagation) {
 }
 
 TEST_F(EventManagerTest, EventManagerTest_queue_dispatch) {
-	EventManager & event_manager = EventManager::get_instance();
 	bool triggered1 = false;
 	bool triggered2 = false;
 	int test_channel = 1;
-
-	// Adjusted to use KeyPressEvent with repeat as the first variable
-	EventHandler<KeyPressEvent> key_handler1 = [&](const KeyPressEvent & e) {
+	EventHandler<MouseClickEvent> mouse_handler1 = [&](const MouseClickEvent & e) {
 		triggered1 = true;
-		EXPECT_EQ(e.repeat, false); // Expecting repeat to be false
-		EXPECT_EQ(e.key, Keycode::A); // Adjust expected key code
+		EXPECT_EQ(e.mouse_x, 100);
+		EXPECT_EQ(e.mouse_y, 200);
+		EXPECT_EQ(e.button, MouseButton::LEFT_MOUSE);
 		return false; // Allows propagation
 	};
-
-	EventHandler<KeyPressEvent> key_handler2 = [&](const KeyPressEvent & e) {
+	EventHandler<MouseClickEvent> mouse_handler2 = [&](const MouseClickEvent & e) {
 		triggered2 = true;
-		EXPECT_EQ(e.repeat, false); // Expecting repeat to be false
-		EXPECT_EQ(e.key, Keycode::A); // Adjust expected key code
+		EXPECT_EQ(e.mouse_x, 100);
+		EXPECT_EQ(e.mouse_y, 200);
+		EXPECT_EQ(e.button, MouseButton::LEFT_MOUSE);
 		return false; // Allows propagation
 	};
+	event_mgr.subscribe<MouseClickEvent>(mouse_handler1);
+	event_mgr.subscribe<MouseClickEvent>(mouse_handler2, test_channel);
 
-	// Subscribe handlers to KeyPressEvent
-	event_manager.subscribe<KeyPressEvent>(key_handler1);
-	event_manager.subscribe<KeyPressEvent>(key_handler2, test_channel);
-
-	// Queue a KeyPressEvent instead of KeyDownEvent
-	event_manager.queue_event<KeyPressEvent>(KeyPressEvent{
-		.repeat = false, .key = Keycode::A}); // Adjust event with repeat flag first
-
-	event_manager.queue_event<KeyPressEvent>(
-		KeyPressEvent{.repeat = false,
-					  .key = Keycode::A}, // Adjust event for second subscription
+	event_mgr.queue_event<MouseClickEvent>(
+		MouseClickEvent{.mouse_x = 100, .mouse_y = 200, .button = MouseButton::LEFT_MOUSE});
+	event_mgr.queue_event<MouseClickEvent>(
+		MouseClickEvent{.mouse_x = 100, .mouse_y = 200, .button = MouseButton::LEFT_MOUSE},
 		test_channel);
-
-	event_manager.dispatch_events();
-
+	event_mgr.dispatch_events();
 	EXPECT_TRUE(triggered1);
 	EXPECT_TRUE(triggered2);
 }
 
 TEST_F(EventManagerTest, EventManagerTest_unsubscribe) {
-	EventManager & event_manager = EventManager::get_instance();
 
 	// Flags to track if handlers are triggered
 	bool triggered1 = false;
@@ -212,15 +185,15 @@ TEST_F(EventManagerTest, EventManagerTest_unsubscribe) {
 		return false; // Allows propagation
 	};
 	// Subscribe handlers
-	subscription_t handler1_id = event_manager.subscribe<MouseClickEvent>(mouse_handler1);
-	subscription_t handler2_id = event_manager.subscribe<MouseClickEvent>(mouse_handler2);
+	subscription_t handler1_id = event_mgr.subscribe<MouseClickEvent>(mouse_handler1);
+	subscription_t handler2_id = event_mgr.subscribe<MouseClickEvent>(mouse_handler2);
 
 	// Queue events
 	event_manager.queue_event<MouseClickEvent>(
 		MouseClickEvent{.mouse_pos = {100, 200}, .button = MouseButton::LEFT_MOUSE});
 
 	// Dispatch events - both handlers should be triggered
-	event_manager.dispatch_events();
+	event_mgr.dispatch_events();
 	EXPECT_TRUE(triggered1); // Handler 1 should be triggered
 	EXPECT_TRUE(triggered2); // Handler 2 should be triggered
 
@@ -229,14 +202,14 @@ TEST_F(EventManagerTest, EventManagerTest_unsubscribe) {
 	triggered2 = false;
 
 	// Unsubscribe handler1
-	event_manager.unsubscribe(handler1_id);
+	event_mgr.unsubscribe(handler1_id);
 
 	// Queue the same event again
 	event_manager.queue_event<MouseClickEvent>(
 		MouseClickEvent{.mouse_pos = {100, 200}, .button = MouseButton::LEFT_MOUSE});
 
 	// Dispatch events - only handler 2 should be triggered, handler 1 should NOT
-	event_manager.dispatch_events();
+	event_mgr.dispatch_events();
 	EXPECT_FALSE(triggered1); // Handler 1 should NOT be triggered
 	EXPECT_TRUE(triggered2); // Handler 2 should be triggered
 
@@ -244,14 +217,14 @@ TEST_F(EventManagerTest, EventManagerTest_unsubscribe) {
 	triggered2 = false;
 
 	// Unsubscribe handler2
-	event_manager.unsubscribe(handler2_id);
+	event_mgr.unsubscribe(handler2_id);
 
 	// Queue the event again
 	event_manager.queue_event<MouseClickEvent>(
 		MouseClickEvent{.mouse_pos = {100, 200}, .button = MouseButton::LEFT_MOUSE});
 
 	// Dispatch events - no handler should be triggered
-	event_manager.dispatch_events();
+	event_mgr.dispatch_events();
 	EXPECT_FALSE(triggered1); // Handler 1 should NOT be triggered
 	EXPECT_FALSE(triggered2); // Handler 2 should NOT be triggered
 }