[Tests] Add unit tests for database events, ManagerKey, and improve Pair/Parser coverage

src/test/java/com/diamonddagger590/mccore/event/database/DatabaseTableEventsTest.java

@@ -0,0 +1,120 @@
+package com.diamonddagger590.mccore.event.database;
+
+import org.bukkit.event.HandlerList;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertNotSame;
+import static org.junit.jupiter.api.Assertions.assertSame;
+
+class DatabaseTableEventsTest {
+
+    @Test
+    @DisplayName("Given PreTablesCreateEvent, when constructed, then getHandlers returns non-null HandlerList")
+    void preTablesCreateEvent_getHandlers_returnsNonNull() {
+        PreTablesCreateEvent event = new PreTablesCreateEvent();
+        assertNotNull(event.getHandlers());
+    }
+
+    @Test
+    @DisplayName("Given PreTablesCreateEvent, when getHandlerList called, then returns same instance as getHandlers")
+    void preTablesCreateEvent_getHandlerList_returnsSameInstanceAsGetHandlers() {
+        PreTablesCreateEvent event = new PreTablesCreateEvent();
+        assertSame(PreTablesCreateEvent.getHandlerList(), event.getHandlers());
+    }
+
+    @Test
+    @DisplayName("Given two PreTablesCreateEvents, when getHandlers called, then they share the same HandlerList")
+    void preTablesCreateEvent_handlerList_isSharedAcrossInstances() {
+        PreTablesCreateEvent event1 = new PreTablesCreateEvent();
+        PreTablesCreateEvent event2 = new PreTablesCreateEvent();
+        assertSame(event1.getHandlers(), event2.getHandlers());
+    }
+
+    @Test
+    @DisplayName("Given TablesCreatedEvent, when constructed, then getHandlers returns non-null HandlerList")
+    void tablesCreatedEvent_getHandlers_returnsNonNull() {
+        TablesCreatedEvent event = new TablesCreatedEvent();
+        assertNotNull(event.getHandlers());
+    }
+
+    @Test
+    @DisplayName("Given TablesCreatedEvent, when getHandlerList called, then returns same instance as getHandlers")
+    void tablesCreatedEvent_getHandlerList_returnsSameInstanceAsGetHandlers() {
+        TablesCreatedEvent event = new TablesCreatedEvent();
+        assertSame(TablesCreatedEvent.getHandlerList(), event.getHandlers());
+    }
+
+    @Test
+    @DisplayName("Given two TablesCreatedEvents, when getHandlers called, then they share the same HandlerList")
+    void tablesCreatedEvent_handlerList_isSharedAcrossInstances() {
+        TablesCreatedEvent event1 = new TablesCreatedEvent();
+        TablesCreatedEvent event2 = new TablesCreatedEvent();
+        assertSame(event1.getHandlers(), event2.getHandlers());
+    }
+
+    @Test
+    @DisplayName("Given PreTablesUpdateEvent, when constructed, then getHandlers returns non-null HandlerList")
+    void preTablesUpdateEvent_getHandlers_returnsNonNull() {
+        PreTablesUpdateEvent event = new PreTablesUpdateEvent();
+        assertNotNull(event.getHandlers());
+    }
+
+    @Test
+    @DisplayName("Given PreTablesUpdateEvent, when getHandlerList called, then returns same instance as getHandlers")
+    void preTablesUpdateEvent_getHandlerList_returnsSameInstanceAsGetHandlers() {
+        PreTablesUpdateEvent event = new PreTablesUpdateEvent();
+        assertSame(PreTablesUpdateEvent.getHandlerList(), event.getHandlers());
+    }
+
+    @Test
+    @DisplayName("Given two PreTablesUpdateEvents, when getHandlers called, then they share the same HandlerList")
+    void preTablesUpdateEvent_handlerList_isSharedAcrossInstances() {
+        PreTablesUpdateEvent event1 = new PreTablesUpdateEvent();
+        PreTablesUpdateEvent event2 = new PreTablesUpdateEvent();
+        assertSame(event1.getHandlers(), event2.getHandlers());
+    }
+
+    @Test
+    @DisplayName("Given TablesUpdatedEvent, when constructed, then getHandlers returns non-null HandlerList")
+    void tablesUpdatedEvent_getHandlers_returnsNonNull() {
+        TablesUpdatedEvent event = new TablesUpdatedEvent();
+        assertNotNull(event.getHandlers());
+    }
+
+    @Test
+    @DisplayName("Given TablesUpdatedEvent, when getHandlerList called, then returns same instance as getHandlers")
+    void tablesUpdatedEvent_getHandlerList_returnsSameInstanceAsGetHandlers() {
+        TablesUpdatedEvent event = new TablesUpdatedEvent();
+        assertSame(TablesUpdatedEvent.getHandlerList(), event.getHandlers());
+    }
+
+    @Test
+    @DisplayName("Given two TablesUpdatedEvents, when getHandlers called, then they share the same HandlerList")
+    void tablesUpdatedEvent_handlerList_isSharedAcrossInstances() {
+        TablesUpdatedEvent event1 = new TablesUpdatedEvent();
+        TablesUpdatedEvent event2 = new TablesUpdatedEvent();
+        assertSame(event1.getHandlers(), event2.getHandlers());
+    }
+
+    @Test
+    @DisplayName("Given all four event types, when getHandlerList called, then each type has its own distinct HandlerList")
+    void allDatabaseEvents_handlerLists_areDistinctPerType() {
+        HandlerList preCreate = PreTablesCreateEvent.getHandlerList();
+        HandlerList created = TablesCreatedEvent.getHandlerList();
+        HandlerList preUpdate = PreTablesUpdateEvent.getHandlerList();
+        HandlerList updated = TablesUpdatedEvent.getHandlerList();
+
+        assertNotNull(preCreate);
+        assertNotNull(created);
+        assertNotNull(preUpdate);
+        assertNotNull(updated);
+        assertNotSame(preCreate, created);
+        assertNotSame(preCreate, preUpdate);
+        assertNotSame(preCreate, updated);
+        assertNotSame(created, preUpdate);
+        assertNotSame(created, updated);
+        assertNotSame(preUpdate, updated);
+    }
+}

src/test/java/com/diamonddagger590/mccore/pair/PairTest.java

@@ -4,6 +4,7 @@
 import org.junit.jupiter.api.Test;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
 import static org.junit.jupiter.api.Assertions.assertNotEquals;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 
@@ -142,4 +143,49 @@ void equals_returnsTrue_whenMutablePairMutatedToMatch() {
         pair2.setRight(1);
         assertEquals(pair1, pair2);
     }
+
+    @Test
+    @DisplayName("Given a pair, when equals called with non-Pair object, then returns false")
+    void equals_returnsFalse_whenCalledDirectlyWithNonPairObject() {
+        ImmutablePair<String, Integer> pair = ImmutablePair.of("test", 1);
+        assertFalse(pair.equals("not a pair"));
+    }
+
+    @Test
+    @DisplayName("Given a pair, when equals called with null, then returns false")
+    void equals_returnsFalse_whenCalledDirectlyWithNull() {
+        ImmutablePair<String, Integer> pair = ImmutablePair.of("test", 1);
+        assertFalse(pair.equals(null));
+    }
+
+    @Test
+    @DisplayName("Given a pair with null left, when computing hashCode, then returns valid hash")
+    void hashCode_handlesNullLeft_whenLeftIsNull() {
+        MutablePair<String, Integer> pair = MutablePair.of(null, 42);
+        int hash = pair.hashCode();
+        assertEquals(42, hash);
+    }
+
+    @Test
+    @DisplayName("Given a pair with null right, when computing hashCode, then returns valid hash")
+    void hashCode_handlesNullRight_whenRightIsNull() {
+        MutablePair<String, Integer> pair = MutablePair.of("test", null);
+        int hash = pair.hashCode();
+        assertEquals("test".hashCode(), hash);
+    }
+
+    @Test
+    @DisplayName("Given a pair with both nulls, when computing hashCode, then returns zero")
+    void hashCode_returnsZero_whenBothSidesAreNull() {
+        MutablePair<String, Integer> pair = MutablePair.of(null, null);
+        assertEquals(0, pair.hashCode());
+    }
+
+    @Test
+    @DisplayName("Given two pairs with null values in same positions, when comparing, then they are equal")
+    void equals_returnsTrue_whenBothPairsHaveNullValues() {
+        MutablePair<String, Integer> pair1 = MutablePair.of(null, null);
+        MutablePair<String, Integer> pair2 = MutablePair.of(null, null);
+        assertTrue(pair1.equals(pair2));
+    }
 }

src/test/java/com/diamonddagger590/mccore/parser/ParserTest.java

@@ -7,6 +7,7 @@
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertSame;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 
@@ -415,4 +416,38 @@ void getValue_multipliesAllFactors_whenMultiplicationsAreChained() {
     void getValue_appliesCorrectPrecedence_whenOperatorsAreMixed() {
         assertEquals(12.0, new Parser("2+3*4-6/2+1").getValue(), DELTA);
     }
+
+    @Test
+    @DisplayName("Given trailing extra token after valid expression, when evaluating, then throws ParseError")
+    void getValue_throwsParseError_whenExtraTokenAfterExpression() {
+        assertThrows(ParseError.class, () -> new Parser("2+3)").getValue());
+    }
+
+    @Test
+    @DisplayName("Given unmatched closing parenthesis mid-expression, when evaluating, then throws ParseError")
+    void getValue_throwsParseError_whenUnmatchedClosingParenMidExpression() {
+        assertThrows(ParseError.class, () -> new Parser(")2+3").getValue());
+    }
+
+    @Test
+    @DisplayName("Given function call missing closing bracket, when evaluating, then throws ParseError")
+    void getValue_throwsParseError_whenFunctionCallMissingClosingBracket() {
+        assertThrows(ParseError.class, () -> new Parser("sin(2+3").getValue());
+    }
+
+    @Test
+    @DisplayName("Given expression with spaces, when getInputString called, then returns input with spaces stripped")
+    void getInputString_returnsStrippedInput_whenExpressionContainsSpaces() {
+        Parser parser = new Parser("2 + 3");
+        assertEquals("2+3", parser.getInputString());
+    }
+
+    @Test
+    @DisplayName("Given a parsed expression, when getTree called twice, then returns the same cached instance")
+    void getTree_returnsSameCachedInstance_whenCalledTwice() {
+        Parser parser = new Parser("2+3");
+        ExpressionNode tree1 = parser.getTree();
+        ExpressionNode tree2 = parser.getTree();
+        assertSame(tree1, tree2);
+    }
 }

src/test/java/com/diamonddagger590/mccore/registry/manager/ManagerKeyTest.java

@@ -0,0 +1,34 @@
+package com.diamonddagger590.mccore.registry.manager;
+
+import com.diamonddagger590.mccore.chat.ChatResponseManager;
+import com.diamonddagger590.mccore.command.CoreCommandManager;
+import com.diamonddagger590.mccore.configuration.ReloadableContentManager;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+
+class ManagerKeyTest {
+
+    @Test
+    @DisplayName("Given the COMMAND key constant, when managerClass called, then returns CoreCommandManager class")
+    void managerClass_returnsCoreCommandManagerClass_whenKeyIsCommand() {
+        assertNotNull(ManagerKey.COMMAND);
+        assertEquals(CoreCommandManager.class, ManagerKey.COMMAND.managerClass());
+    }
+
+    @Test
+    @DisplayName("Given the RELOADABLE_CONTENT key constant, when managerClass called, then returns ReloadableContentManager class")
+    void managerClass_returnsReloadableContentManagerClass_whenKeyIsReloadableContent() {
+        assertNotNull(ManagerKey.RELOADABLE_CONTENT);
+        assertEquals(ReloadableContentManager.class, ManagerKey.RELOADABLE_CONTENT.managerClass());
+    }
+
+    @Test
+    @DisplayName("Given the CHAT_RESPONSE key constant, when managerClass called, then returns ChatResponseManager class")
+    void managerClass_returnsChatResponseManagerClass_whenKeyIsChatResponse() {
+        assertNotNull(ManagerKey.CHAT_RESPONSE);
+        assertEquals(ChatResponseManager.class, ManagerKey.CHAT_RESPONSE.managerClass());
+    }
+}