From 06d51700e1d7210f3851e98e989be6215bee0efd Mon Sep 17 00:00:00 2001 From: Claude Date: Thu, 24 Sep 2026 09:45:32 +0000 Subject: [PATCH] Add tests for CombatHealingReportEvent, display events, and CenterContentPriority Cover three previously untested areas: - CombatHealingReportEvent: cancellable contract, mutable amount, constructor/getters - ActionBarSlotSetEvent and ActionBarSlotClearEvent: constructor fields, cancellable contract (set only), mutable content replacement, null previousContent, priority edge cases, non-cancellable assertion (clear only) - CenterContentPriority: ordering invariants, positivity, third-party gap contracts, sub-100 ceiling for combo state Co-Authored-By: Claude Opus 4.6 Claude-Session: https://claude.ai/code/session_014CCA8XG1FVwwnmuP6Rf91c --- .../hud/CenterContentPriorityTest.java | 79 +++++++ .../combat/CombatHealingReportEventTest.java | 176 +++++++++++++++ .../display/DisplayEventCoverageTest.java | 211 ++++++++++++++++++ 3 files changed, 466 insertions(+) create mode 100644 src/test/java/us/eunoians/mcrpg/display/hud/CenterContentPriorityTest.java create mode 100644 src/test/java/us/eunoians/mcrpg/event/combat/CombatHealingReportEventTest.java create mode 100644 src/test/java/us/eunoians/mcrpg/event/display/DisplayEventCoverageTest.java diff --git a/src/test/java/us/eunoians/mcrpg/display/hud/CenterContentPriorityTest.java b/src/test/java/us/eunoians/mcrpg/display/hud/CenterContentPriorityTest.java new file mode 100644 index 000000000..0a51b3c7b --- /dev/null +++ b/src/test/java/us/eunoians/mcrpg/display/hud/CenterContentPriorityTest.java @@ -0,0 +1,79 @@ +package us.eunoians.mcrpg.display.hud; + +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertTrue; + +@DisplayName("CenterContentPriority") +class CenterContentPriorityTest { + + @Test + @DisplayName("AMBIENT_FEEDBACK is higher than COMBAT_EXIT_FEEDBACK") + void ambientFeedback_isHigherThanCombatExitFeedback() { + assertTrue(CenterContentPriority.AMBIENT_FEEDBACK > CenterContentPriority.COMBAT_EXIT_FEEDBACK); + } + + @Test + @DisplayName("SAFE_ZONE_TRANSITION is higher than AMBIENT_FEEDBACK") + void safeZoneTransition_isHigherThanAmbientFeedback() { + assertTrue(CenterContentPriority.SAFE_ZONE_TRANSITION > CenterContentPriority.AMBIENT_FEEDBACK); + } + + @Test + @DisplayName("ABILITY_FEEDBACK is higher than SAFE_ZONE_TRANSITION") + void abilityFeedback_isHigherThanSafeZoneTransition() { + assertTrue(CenterContentPriority.ABILITY_FEEDBACK > CenterContentPriority.SAFE_ZONE_TRANSITION); + } + + @Test + @DisplayName("COMBO_STATE is higher than ABILITY_FEEDBACK") + void comboState_isHigherThanAbilityFeedback() { + assertTrue(CenterContentPriority.COMBO_STATE > CenterContentPriority.ABILITY_FEEDBACK); + } + + @Test + @DisplayName("all priorities are positive") + void allPriorities_arePositive() { + assertTrue(CenterContentPriority.COMBAT_EXIT_FEEDBACK > 0); + assertTrue(CenterContentPriority.AMBIENT_FEEDBACK > 0); + assertTrue(CenterContentPriority.SAFE_ZONE_TRANSITION > 0); + assertTrue(CenterContentPriority.ABILITY_FEEDBACK > 0); + assertTrue(CenterContentPriority.COMBO_STATE > 0); + } + + @Test + @DisplayName("third-party gap between COMBAT_EXIT_FEEDBACK and AMBIENT_FEEDBACK exists") + void gap_betweenCombatExitAndAmbient() { + assertTrue(CenterContentPriority.AMBIENT_FEEDBACK - CenterContentPriority.COMBAT_EXIT_FEEDBACK > 1, + "gap should allow third-party priorities between combat exit and ambient"); + } + + @Test + @DisplayName("third-party gap between AMBIENT_FEEDBACK and SAFE_ZONE_TRANSITION exists") + void gap_betweenAmbientAndSafeZone() { + assertTrue(CenterContentPriority.SAFE_ZONE_TRANSITION - CenterContentPriority.AMBIENT_FEEDBACK > 1, + "gap should allow third-party priorities between ambient and safe zone"); + } + + @Test + @DisplayName("third-party gap between SAFE_ZONE_TRANSITION and ABILITY_FEEDBACK exists") + void gap_betweenSafeZoneAndAbilityFeedback() { + assertTrue(CenterContentPriority.ABILITY_FEEDBACK - CenterContentPriority.SAFE_ZONE_TRANSITION > 1, + "gap should allow third-party priorities between safe zone and ability feedback"); + } + + @Test + @DisplayName("third-party gap between ABILITY_FEEDBACK and COMBO_STATE exists") + void gap_betweenAbilityFeedbackAndComboState() { + assertTrue(CenterContentPriority.COMBO_STATE - CenterContentPriority.ABILITY_FEEDBACK > 1, + "gap should allow third-party priorities between ability feedback and combo state"); + } + + @Test + @DisplayName("COMBO_STATE is below 100 to leave room for emergency overrides") + void comboState_isBelowHundred() { + assertTrue(CenterContentPriority.COMBO_STATE < 100, + "COMBO_STATE should be below 100 to leave room for third-party emergency overrides"); + } +} diff --git a/src/test/java/us/eunoians/mcrpg/event/combat/CombatHealingReportEventTest.java b/src/test/java/us/eunoians/mcrpg/event/combat/CombatHealingReportEventTest.java new file mode 100644 index 000000000..1c5d54f8d --- /dev/null +++ b/src/test/java/us/eunoians/mcrpg/event/combat/CombatHealingReportEventTest.java @@ -0,0 +1,176 @@ +package us.eunoians.mcrpg.event.combat; + +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Nested; +import org.junit.jupiter.api.Test; +import us.eunoians.mcrpg.McRPGBaseTest; + +import java.util.UUID; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertTrue; + +@DisplayName("CombatHealingReportEvent") +class CombatHealingReportEventTest extends McRPGBaseTest { + + @Nested + @DisplayName("Constructor and getters") + class ConstructorAndGetters { + + @Test + @DisplayName("constructor stores healer UUID") + void constructor_storesHealerUUID() { + UUID healer = UUID.randomUUID(); + UUID target = UUID.randomUUID(); + var event = new CombatHealingReportEvent(healer, target, 5.0); + + assertEquals(healer, event.getHealerUUID()); + } + + @Test + @DisplayName("constructor stores target UUID") + void constructor_storesTargetUUID() { + UUID healer = UUID.randomUUID(); + UUID target = UUID.randomUUID(); + var event = new CombatHealingReportEvent(healer, target, 5.0); + + assertEquals(target, event.getTargetUUID()); + } + + @Test + @DisplayName("constructor stores amount") + void constructor_storesAmount() { + UUID healer = UUID.randomUUID(); + UUID target = UUID.randomUUID(); + var event = new CombatHealingReportEvent(healer, target, 7.5); + + assertEquals(7.5, event.getAmount()); + } + + @Test + @DisplayName("constructor accepts zero amount") + void constructor_acceptsZeroAmount() { + var event = new CombatHealingReportEvent(UUID.randomUUID(), UUID.randomUUID(), 0.0); + + assertEquals(0.0, event.getAmount()); + } + + @Test + @DisplayName("constructor accepts negative amount") + void constructor_acceptsNegativeAmount() { + var event = new CombatHealingReportEvent(UUID.randomUUID(), UUID.randomUUID(), -3.0); + + assertEquals(-3.0, event.getAmount()); + } + } + + @Nested + @DisplayName("Mutable amount") + class MutableAmount { + + @Test + @DisplayName("setAmount updates the healing amount") + void setAmount_updatesAmount() { + var event = new CombatHealingReportEvent(UUID.randomUUID(), UUID.randomUUID(), 5.0); + + event.setAmount(10.0); + + assertEquals(10.0, event.getAmount()); + } + + @Test + @DisplayName("setAmount to zero clears the amount") + void setAmount_toZero() { + var event = new CombatHealingReportEvent(UUID.randomUUID(), UUID.randomUUID(), 5.0); + + event.setAmount(0.0); + + assertEquals(0.0, event.getAmount()); + } + + @Test + @DisplayName("setAmount accepts negative values for scaling down") + void setAmount_acceptsNegative() { + var event = new CombatHealingReportEvent(UUID.randomUUID(), UUID.randomUUID(), 5.0); + + event.setAmount(-2.0); + + assertEquals(-2.0, event.getAmount()); + } + + @Test + @DisplayName("setAmount can be called multiple times") + void setAmount_canBeCalledMultipleTimes() { + var event = new CombatHealingReportEvent(UUID.randomUUID(), UUID.randomUUID(), 5.0); + + event.setAmount(10.0); + event.setAmount(20.0); + + assertEquals(20.0, event.getAmount()); + } + } + + @Nested + @DisplayName("Cancellable contract") + class CancellableContract { + + @Test + @DisplayName("isCancelled defaults to false") + void isCancelled_defaultsFalse() { + var event = new CombatHealingReportEvent(UUID.randomUUID(), UUID.randomUUID(), 5.0); + + assertFalse(event.isCancelled()); + } + + @Test + @DisplayName("setCancelled(true) makes isCancelled return true") + void setCancelled_true() { + var event = new CombatHealingReportEvent(UUID.randomUUID(), UUID.randomUUID(), 5.0); + + event.setCancelled(true); + + assertTrue(event.isCancelled()); + } + + @Test + @DisplayName("setCancelled can revert to false") + void setCancelled_canRevert() { + var event = new CombatHealingReportEvent(UUID.randomUUID(), UUID.randomUUID(), 5.0); + + event.setCancelled(true); + event.setCancelled(false); + + assertFalse(event.isCancelled()); + } + } + + @Nested + @DisplayName("HandlerList") + class HandlerListTests { + + @Test + @DisplayName("getHandlers returns non-null") + void getHandlers_returnsNonNull() { + var event = new CombatHealingReportEvent(UUID.randomUUID(), UUID.randomUUID(), 5.0); + + assertNotNull(event.getHandlers()); + } + + @Test + @DisplayName("static getHandlerList returns non-null") + void getHandlerList_returnsNonNull() { + assertNotNull(CombatHealingReportEvent.getHandlerList()); + } + + @Test + @DisplayName("instance and static handler lists are the same object") + void handlerLists_areSameObject() { + var event = new CombatHealingReportEvent(UUID.randomUUID(), UUID.randomUUID(), 5.0); + + assertNotNull(event.getHandlers()); + assertEquals(CombatHealingReportEvent.getHandlerList(), event.getHandlers()); + } + } +} diff --git a/src/test/java/us/eunoians/mcrpg/event/display/DisplayEventCoverageTest.java b/src/test/java/us/eunoians/mcrpg/event/display/DisplayEventCoverageTest.java new file mode 100644 index 000000000..feb425c1b --- /dev/null +++ b/src/test/java/us/eunoians/mcrpg/event/display/DisplayEventCoverageTest.java @@ -0,0 +1,211 @@ +package us.eunoians.mcrpg.event.display; + +import net.kyori.adventure.text.Component; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Nested; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; +import us.eunoians.mcrpg.McRPGBaseTest; +import us.eunoians.mcrpg.display.hud.ActionBarCenterContent; +import us.eunoians.mcrpg.entity.player.McRPGPlayer; +import us.eunoians.mcrpg.entity.player.McRPGPlayerExtension; + +import java.util.Optional; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertSame; +import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.mockito.Mockito.mock; + +@ExtendWith(McRPGPlayerExtension.class) +@DisplayName("Display events") +class DisplayEventCoverageTest extends McRPGBaseTest { + + @Nested + @DisplayName("ActionBarSlotSetEvent") + class ActionBarSlotSetEventTests { + + @Test + @DisplayName("constructor stores player, priority, previous content, and new content") + void constructor_storesAllFields(McRPGPlayer player) { + ActionBarCenterContent previous = mock(ActionBarCenterContent.class); + ActionBarCenterContent newContent = mock(ActionBarCenterContent.class); + + var event = new ActionBarSlotSetEvent(player, 40, previous, newContent); + + assertSame(player, event.getMcRPGPlayer()); + assertEquals(40, event.getPriority()); + assertSame(previous, event.getPreviousContent()); + assertSame(newContent, event.getNewContent()); + } + + @Test + @DisplayName("previousContent can be null when slot was empty") + void previousContent_canBeNull(McRPGPlayer player) { + ActionBarCenterContent newContent = mock(ActionBarCenterContent.class); + + var event = new ActionBarSlotSetEvent(player, 10, null, newContent); + + assertNull(event.getPreviousContent()); + } + + @Test + @DisplayName("setNewContent replaces the content to be written") + void setNewContent_replacesContent(McRPGPlayer player) { + ActionBarCenterContent original = mock(ActionBarCenterContent.class); + ActionBarCenterContent replacement = mock(ActionBarCenterContent.class); + + var event = new ActionBarSlotSetEvent(player, 10, null, original); + event.setNewContent(replacement); + + assertSame(replacement, event.getNewContent()); + } + + @Test + @DisplayName("setNewContent can be called multiple times") + void setNewContent_canBeCalledMultipleTimes(McRPGPlayer player) { + ActionBarCenterContent first = mock(ActionBarCenterContent.class); + ActionBarCenterContent second = mock(ActionBarCenterContent.class); + ActionBarCenterContent third = mock(ActionBarCenterContent.class); + + var event = new ActionBarSlotSetEvent(player, 10, null, first); + event.setNewContent(second); + event.setNewContent(third); + + assertSame(third, event.getNewContent()); + } + + @Test + @DisplayName("isCancelled defaults to false") + void isCancelled_defaultsFalse(McRPGPlayer player) { + var event = new ActionBarSlotSetEvent(player, 10, null, mock(ActionBarCenterContent.class)); + + assertFalse(event.isCancelled()); + } + + @Test + @DisplayName("setCancelled(true) makes isCancelled return true") + void setCancelled_true(McRPGPlayer player) { + var event = new ActionBarSlotSetEvent(player, 10, null, mock(ActionBarCenterContent.class)); + + event.setCancelled(true); + + assertTrue(event.isCancelled()); + } + + @Test + @DisplayName("setCancelled can revert to false") + void setCancelled_canRevert(McRPGPlayer player) { + var event = new ActionBarSlotSetEvent(player, 10, null, mock(ActionBarCenterContent.class)); + + event.setCancelled(true); + event.setCancelled(false); + + assertFalse(event.isCancelled()); + } + + @Test + @DisplayName("priority preserves zero value") + void priority_preservesZero(McRPGPlayer player) { + var event = new ActionBarSlotSetEvent(player, 0, null, mock(ActionBarCenterContent.class)); + + assertEquals(0, event.getPriority()); + } + + @Test + @DisplayName("priority preserves negative value") + void priority_preservesNegative(McRPGPlayer player) { + var event = new ActionBarSlotSetEvent(player, -5, null, mock(ActionBarCenterContent.class)); + + assertEquals(-5, event.getPriority()); + } + + @Test + @DisplayName("getHandlers returns non-null") + void getHandlers_returnsNonNull(McRPGPlayer player) { + var event = new ActionBarSlotSetEvent(player, 10, null, mock(ActionBarCenterContent.class)); + + assertNotNull(event.getHandlers()); + } + + @Test + @DisplayName("static getHandlerList returns non-null") + void getHandlerList_returnsNonNull() { + assertNotNull(ActionBarSlotSetEvent.getHandlerList()); + } + + @Test + @DisplayName("instance and static handler lists are the same object") + void handlerLists_areSameObject(McRPGPlayer player) { + var event = new ActionBarSlotSetEvent(player, 10, null, mock(ActionBarCenterContent.class)); + + assertSame(ActionBarSlotSetEvent.getHandlerList(), event.getHandlers()); + } + } + + @Nested + @DisplayName("ActionBarSlotClearEvent") + class ActionBarSlotClearEventTests { + + @Test + @DisplayName("constructor stores player, priority, and content") + void constructor_storesAllFields(McRPGPlayer player) { + ActionBarCenterContent content = mock(ActionBarCenterContent.class); + + var event = new ActionBarSlotClearEvent(player, 40, content); + + assertSame(player, event.getMcRPGPlayer()); + assertEquals(40, event.getPriority()); + assertSame(content, event.getContent()); + } + + @Test + @DisplayName("priority preserves zero value") + void priority_preservesZero(McRPGPlayer player) { + var event = new ActionBarSlotClearEvent(player, 0, mock(ActionBarCenterContent.class)); + + assertEquals(0, event.getPriority()); + } + + @Test + @DisplayName("priority preserves high value") + void priority_preservesHighValue(McRPGPlayer player) { + var event = new ActionBarSlotClearEvent(player, 99, mock(ActionBarCenterContent.class)); + + assertEquals(99, event.getPriority()); + } + + @Test + @DisplayName("getHandlers returns non-null") + void getHandlers_returnsNonNull(McRPGPlayer player) { + var event = new ActionBarSlotClearEvent(player, 10, mock(ActionBarCenterContent.class)); + + assertNotNull(event.getHandlers()); + } + + @Test + @DisplayName("static getHandlerList returns non-null") + void getHandlerList_returnsNonNull() { + assertNotNull(ActionBarSlotClearEvent.getHandlerList()); + } + + @Test + @DisplayName("instance and static handler lists are the same object") + void handlerLists_areSameObject(McRPGPlayer player) { + var event = new ActionBarSlotClearEvent(player, 10, mock(ActionBarCenterContent.class)); + + assertSame(ActionBarSlotClearEvent.getHandlerList(), event.getHandlers()); + } + + @Test + @DisplayName("event is not cancellable") + void event_isNotCancellable(McRPGPlayer player) { + var event = new ActionBarSlotClearEvent(player, 10, mock(ActionBarCenterContent.class)); + + assertFalse(event instanceof org.bukkit.event.Cancellable); + } + } +}