Add test *and change some logic*

src/main/java/io/github/thebusybiscuit/slimefun4/api/events/TalismanActivateEvent.java

@@ -21,6 +21,7 @@ public class TalismanActivateEvent extends PlayerEvent implements Cancellable {
 	private static final HandlerList handlers = new HandlerList();
 	private final Talisman talisman;
 	private final ItemStack talismanItemStack;
+	private boolean preventConsumption = false;
 	private boolean cancelled = false;
 
 	/**
@@ -54,6 +55,26 @@ public TalismanActivateEvent(Player player, Talisman talisman, ItemStack talisma
 		return this.talismanItemStack;
 	}
 
+	/**
+	 * Only applies if {@link Talisman#isConsumable()} is true.
+	 * Defaults to false.
+	 *
+	 * @return Whether the {@link ItemStack} should not be consumed.
+	 */
+	public boolean preventsConsumption() {
+		return this.preventConsumption;
+	}
+
+	/**
+	 * Only applies if {@link Talisman#isConsumable()} is true.
+	 *
+	 * @param preventConsumption
+	 * 		Whether the {@link ItemStack} should not be consumed.
+	 */
+	public void setPreventConsumption(boolean preventConsumption) {
+		this.preventConsumption = preventConsumption;
+	}
+
 	@Override
 	public boolean isCancelled() {
 		return this.cancelled;

src/main/java/io/github/thebusybiscuit/slimefun4/implementation/items/magical/talismans/Talisman.java

@@ -188,11 +188,15 @@ public static boolean trigger(Event e, SlimefunItem item, boolean sendMessage) {
                 return false;
             }
         } else {
-            ItemStack enderTalisman = talisman.getEnderVariant();
+            SlimefunItemStack enderTalismanItem = talisman.getEnderVariant();
+            if (enderTalismanItem == null) {
+                return false;
+            }
 
-            if (SlimefunUtils.containsSimilarItem(p.getEnderChest(), enderTalisman, true)) {
+            EnderTalisman enderTalisman = enderTalismanItem.getItem(EnderTalisman.class);
+            if (enderTalisman != null && SlimefunUtils.containsSimilarItem(p.getEnderChest(), enderTalismanItem, true)) {
                 if (talisman.canUse(p, true)) {
-                    activateTalisman(e, p, p.getEnderChest(), talisman, enderTalisman, sendMessage);
+                    activateTalisman(e, p, p.getEnderChest(), enderTalisman, enderTalismanItem, sendMessage);
                     return true;
                 } else {
                     return false;
@@ -208,7 +212,10 @@ private static void activateTalisman(Event e, Player p, Inventory inv, Talisman
         TalismanActivateEvent talismanEvent = new TalismanActivateEvent(p, talisman, talismanItem);
         Bukkit.getPluginManager().callEvent(talismanEvent);
         if (!talismanEvent.isCancelled()) {
-            consumeItem(inv, talisman, talismanItem);
+            if (!talismanEvent.preventsConsumption()) {
+                consumeItem(inv, talisman, talismanItem);
+            }
+
             applyTalismanEffects(p, talisman);
             cancelEvent(e, talisman);
 

src/test/java/io/github/thebusybiscuit/slimefun4/api/events/TestTalismanActivateEvent.java

@@ -0,0 +1,160 @@
+package io.github.thebusybiscuit.slimefun4.api.events;
+
+import be.seeseemelk.mockbukkit.MockBukkit;
+import be.seeseemelk.mockbukkit.ServerMock;
+import io.github.thebusybiscuit.slimefun4.api.items.SlimefunItem;
+import io.github.thebusybiscuit.slimefun4.implementation.Slimefun;
+import io.github.thebusybiscuit.slimefun4.implementation.SlimefunItems;
+import io.github.thebusybiscuit.slimefun4.implementation.items.magical.talismans.Talisman;
+import io.github.thebusybiscuit.slimefun4.implementation.listeners.TalismanListener;
+import org.bukkit.Material;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.player.PlayerItemBreakEvent;
+import org.bukkit.inventory.ItemStack;
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+class TestTalismanActivateEvent {
+
+    private static ServerMock server;
+    private static Slimefun plugin;
+    private static Player player;
+    private static SlimefunItem talisman;
+    private static SlimefunItem enderTalisman;
+
+    @BeforeAll
+    public static void load() {
+        server = MockBukkit.mock();
+        plugin = MockBukkit.load(Slimefun.class);
+
+        new TalismanListener(plugin);
+
+        talisman = new Talisman(SlimefunItems.TALISMAN_ANVIL, new ItemStack[] {}, true, false, "anvil");
+        talisman.register(plugin);
+
+        enderTalisman = SlimefunItem.getById("ENDER_" + talisman.getId());
+
+        player = server.addPlayer();
+    }
+
+    @AfterAll
+    public static void unload() {
+        MockBukkit.unmock();
+    }
+
+    void activateAnvilTalisman(boolean ender) {
+        player.getInventory().clear();
+        player.getEnderChest().clear();
+
+        ItemStack talismanItem = ender ? enderTalisman.getItem() : talisman.getItem();
+        ItemStack breakableItem = new ItemStack(Material.IRON_PICKAXE);
+
+        if (ender) {
+            player.getEnderChest().addItem(talismanItem);
+        } else {
+            player.getInventory().addItem(talismanItem);
+        }
+
+        player.getInventory().setItemInMainHand(breakableItem);
+
+        PlayerItemBreakEvent event = new PlayerItemBreakEvent(player, breakableItem);
+        server.getPluginManager().callEvent(event);
+    }
+
+    @Test
+    @DisplayName("Test that TalismanActivateEvent is fired when an anvil talisman activates")
+    void testEventIsFired() {
+        // Assert the talisman activates in the inventory
+        activateAnvilTalisman(false);
+        server.getPluginManager().assertEventFired(TalismanActivateEvent.class, ignored -> true);
+        server.getPluginManager().clearEvents();
+
+        // Assert the talisman activates in the ender chest
+        activateAnvilTalisman(true);
+        server.getPluginManager().assertEventFired(TalismanActivateEvent.class, ignored -> true);
+        server.getPluginManager().clearEvents();
+    }
+
+    @Test
+    @DisplayName("Test that the TalismanActivateEvent has the correct fields")
+    void testEventFields() {
+        // Assert the talisman activates in the inventory
+        activateAnvilTalisman(false);
+        server.getPluginManager().assertEventFired(TalismanActivateEvent.class, event -> {
+            Assertions.assertEquals(talisman, event.getTalisman());
+            Assertions.assertEquals(talisman.getItem(), event.getTalismanItem());
+            Assertions.assertEquals(player, event.getPlayer());
+            return true;
+        });
+        server.getPluginManager().clearEvents();
+
+        // Assert the talisman activates in the ender chest
+        activateAnvilTalisman(true);
+        server.getPluginManager().assertEventFired(TalismanActivateEvent.class, event -> {
+            Assertions.assertEquals(enderTalisman, event.getTalisman());
+            Assertions.assertEquals(enderTalisman.getItem(), event.getTalismanItem());
+            Assertions.assertEquals(player, event.getPlayer());
+            return true;
+        });
+        server.getPluginManager().clearEvents();
+    }
+
+    @Test
+    @DisplayName("Test that the TalismanActivateEvent can be cancelled")
+    void testEventCanBeCancelled() {
+        server.getPluginManager().registerEvents(new Listener() {
+            @EventHandler
+            public void onTalismanActivate(TalismanActivateEvent event) {
+                event.setCancelled(true);
+            }
+        }, plugin);
+
+        // Assert the talisman activates in the inventory
+        activateAnvilTalisman(false);
+        server.getPluginManager().assertEventFired(TalismanActivateEvent.class, event -> {
+            Assertions.assertTrue(event.isCancelled());
+            return true;
+        });
+        server.getPluginManager().clearEvents();
+
+        // Assert the talisman activates in the ender chest
+        activateAnvilTalisman(true);
+        server.getPluginManager().assertEventFired(TalismanActivateEvent.class, event -> {
+            Assertions.assertTrue(event.isCancelled());
+            return true;
+        });
+        server.getPluginManager().clearEvents();
+    }
+
+    @Test
+    @DisplayName("Test that the TalismanActivateEvent can prevent consumption")
+    void testEventCanPreventConsumption() {
+        server.getPluginManager().registerEvents(new Listener() {
+            @EventHandler
+            public void onTalismanActivate(TalismanActivateEvent event) {
+                event.setPreventConsumption(true);
+            }
+        }, plugin);
+
+        // Assert the talisman activates in the inventory
+        activateAnvilTalisman(false);
+        server.getPluginManager().assertEventFired(TalismanActivateEvent.class, event -> {
+            Assertions.assertTrue(event.preventsConsumption());
+            return true;
+        });
+        server.getPluginManager().clearEvents();
+
+        // Assert the talisman activates in the ender chest
+        activateAnvilTalisman(true);
+        server.getPluginManager().assertEventFired(TalismanActivateEvent.class, event -> {
+            Assertions.assertTrue(event.preventsConsumption());
+            return true;
+        });
+        server.getPluginManager().clearEvents();
+    }
+}