From f2e9d49245dd805186bd6888e24ec7700d068b22 Mon Sep 17 00:00:00 2001 From: RoinujNosde Date: Sun, 19 Jan 2025 15:27:58 -0300 Subject: [PATCH 1/3] test: added test for EliminationTournamentGame --- pom.xml | 18 + .../titansbattle/FakeBukkitScheduler.java | 225 +++ .../titansbattle/FakeBukkitTask.java | 72 + .../roinujnosde/titansbattle/FakePlayer.java | 1517 +++++++++++++++++ .../games/EliminationTournamentGameTest.java | 132 ++ 5 files changed, 1964 insertions(+) create mode 100644 src/test/java/me/roinujnosde/titansbattle/FakeBukkitScheduler.java create mode 100644 src/test/java/me/roinujnosde/titansbattle/FakeBukkitTask.java create mode 100644 src/test/java/me/roinujnosde/titansbattle/FakePlayer.java create mode 100644 src/test/java/me/roinujnosde/titansbattle/games/EliminationTournamentGameTest.java diff --git a/pom.xml b/pom.xml index 08ab0495..c10db8ff 100644 --- a/pom.xml +++ b/pom.xml @@ -171,6 +171,24 @@ 3.0.2 compile + + org.junit.jupiter + junit-jupiter-api + 5.11.3 + test + + + org.junit.jupiter + junit-jupiter-params + 5.11.3 + test + + + org.mockito + mockito-core + 5.14.2 + test + TitansBattle diff --git a/src/test/java/me/roinujnosde/titansbattle/FakeBukkitScheduler.java b/src/test/java/me/roinujnosde/titansbattle/FakeBukkitScheduler.java new file mode 100644 index 00000000..3d629450 --- /dev/null +++ b/src/test/java/me/roinujnosde/titansbattle/FakeBukkitScheduler.java @@ -0,0 +1,225 @@ +package me.roinujnosde.titansbattle; + +import org.bukkit.plugin.Plugin; +import org.bukkit.scheduler.BukkitRunnable; +import org.bukkit.scheduler.BukkitScheduler; +import org.bukkit.scheduler.BukkitTask; +import org.bukkit.scheduler.BukkitWorker; +import org.jetbrains.annotations.NotNull; + +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.concurrent.Callable; +import java.util.concurrent.CopyOnWriteArrayList; +import java.util.concurrent.Future; +import java.util.function.Consumer; + +public class FakeBukkitScheduler implements BukkitScheduler { + + private long currentTick = 0; + private int lastId = 0; + private final Map tasks = new HashMap<>(); + + public void performTicks(int ticks) { + for (int i = 0; i < ticks; i++) { + performOneTick(); + } + } + + public void performOneTick() { + for (FakeBukkitTask task : new CopyOnWriteArrayList<>(tasks.values())) { + if (task.isCancelled()) { + continue; + } + if (task.getScheduledTick() != currentTick) { + continue; + } + task.getRunnable().run(); + if (task.isRepeating()) { + task.setScheduledTick(currentTick + task.getPeriod()); + } + } + currentTick++; + } + + @Override + public int scheduleSyncDelayedTask(@NotNull Plugin plugin, @NotNull Runnable runnable, long l) { + throw new UnsupportedOperationException(); + } + + @Override + public int scheduleSyncDelayedTask(@NotNull Plugin plugin, @NotNull BukkitRunnable bukkitRunnable, long l) { + throw new UnsupportedOperationException(); + } + + @Override + public int scheduleSyncDelayedTask(@NotNull Plugin plugin, @NotNull Runnable runnable) { + throw new UnsupportedOperationException(); + } + + @Override + public int scheduleSyncDelayedTask(@NotNull Plugin plugin, @NotNull BukkitRunnable bukkitRunnable) { + throw new UnsupportedOperationException(); + } + + @Override + public int scheduleSyncRepeatingTask(@NotNull Plugin plugin, @NotNull Runnable runnable, long l, long l1) { + throw new UnsupportedOperationException(); + } + + @Override + public int scheduleSyncRepeatingTask(@NotNull Plugin plugin, @NotNull BukkitRunnable bukkitRunnable, long l, long l1) { + throw new UnsupportedOperationException(); + } + + @Override + public int scheduleAsyncDelayedTask(@NotNull Plugin plugin, @NotNull Runnable runnable, long l) { + throw new UnsupportedOperationException(); + } + + @Override + public int scheduleAsyncDelayedTask(@NotNull Plugin plugin, @NotNull Runnable runnable) { + throw new UnsupportedOperationException(); + } + + @Override + public int scheduleAsyncRepeatingTask(@NotNull Plugin plugin, @NotNull Runnable runnable, long l, long l1) { + throw new UnsupportedOperationException(); + } + + @Override + public @NotNull Future callSyncMethod(@NotNull Plugin plugin, @NotNull Callable callable) { + throw new UnsupportedOperationException(); + } + + @Override + public void cancelTask(int id) { + tasks.get(id).cancel(); + } + + @Override + public void cancelTasks(@NotNull Plugin plugin) { + throw new UnsupportedOperationException(); + } + + @Override + public boolean isCurrentlyRunning(int i) { + throw new UnsupportedOperationException(); + } + + @Override + public boolean isQueued(int i) { + throw new UnsupportedOperationException(); + } + + @Override + public @NotNull List getActiveWorkers() { + throw new UnsupportedOperationException(); + } + + @Override + public @NotNull List getPendingTasks() { + throw new UnsupportedOperationException(); + } + + @Override + public @NotNull BukkitTask runTask(@NotNull Plugin plugin, @NotNull Runnable runnable) throws IllegalArgumentException { + FakeBukkitTask task = new FakeBukkitTask(lastId, plugin, runnable, true, false, currentTick, 0); + tasks.put(lastId, task); + lastId++; + return task; + } + + @Override + public void runTask(@NotNull Plugin plugin, @NotNull Consumer consumer) throws IllegalArgumentException { + throw new UnsupportedOperationException(); + } + + @Override + public @NotNull BukkitTask runTask(@NotNull Plugin plugin, @NotNull BukkitRunnable bukkitRunnable) throws IllegalArgumentException { + throw new UnsupportedOperationException(); + } + + @Override + public @NotNull BukkitTask runTaskAsynchronously(@NotNull Plugin plugin, @NotNull Runnable runnable) throws IllegalArgumentException { + throw new UnsupportedOperationException(); + } + + @Override + public void runTaskAsynchronously(@NotNull Plugin plugin, @NotNull Consumer consumer) throws IllegalArgumentException { + throw new UnsupportedOperationException(); + } + + @Override + public @NotNull BukkitTask runTaskAsynchronously(@NotNull Plugin plugin, @NotNull BukkitRunnable bukkitRunnable) throws IllegalArgumentException { + throw new UnsupportedOperationException(); + } + + @Override + public @NotNull BukkitTask runTaskLater(@NotNull Plugin plugin, @NotNull Runnable runnable, long delay) throws IllegalArgumentException { + FakeBukkitTask task = new FakeBukkitTask(lastId, plugin, runnable, true, false, currentTick + delay, 0); + tasks.put(lastId, task); + lastId++; + return task; + } + + @Override + public void runTaskLater(@NotNull Plugin plugin, @NotNull Consumer consumer, long l) throws IllegalArgumentException { + throw new UnsupportedOperationException(); + } + + @Override + public @NotNull BukkitTask runTaskLater(@NotNull Plugin plugin, @NotNull BukkitRunnable bukkitRunnable, long l) throws IllegalArgumentException { + throw new UnsupportedOperationException(); + } + + @Override + public @NotNull BukkitTask runTaskLaterAsynchronously(@NotNull Plugin plugin, @NotNull Runnable runnable, long l) throws IllegalArgumentException { + throw new UnsupportedOperationException(); + } + + @Override + public void runTaskLaterAsynchronously(@NotNull Plugin plugin, @NotNull Consumer consumer, long l) throws IllegalArgumentException { + throw new UnsupportedOperationException(); + } + + @Override + public @NotNull BukkitTask runTaskLaterAsynchronously(@NotNull Plugin plugin, @NotNull BukkitRunnable bukkitRunnable, long l) throws IllegalArgumentException { + throw new UnsupportedOperationException(); + } + + @Override + public @NotNull BukkitTask runTaskTimer(@NotNull Plugin plugin, @NotNull Runnable runnable, long delay, long period) throws IllegalArgumentException { + FakeBukkitTask task = new FakeBukkitTask(lastId, plugin, runnable, true, true, currentTick + delay, period); + tasks.put(lastId, task); + lastId++; + return task; + } + + @Override + public void runTaskTimer(@NotNull Plugin plugin, @NotNull Consumer consumer, long l, long l1) throws IllegalArgumentException { + throw new UnsupportedOperationException(); + } + + @Override + public @NotNull BukkitTask runTaskTimer(@NotNull Plugin plugin, @NotNull BukkitRunnable bukkitRunnable, long l, long l1) throws IllegalArgumentException { + throw new UnsupportedOperationException(); + } + + @Override + public @NotNull BukkitTask runTaskTimerAsynchronously(@NotNull Plugin plugin, @NotNull Runnable runnable, long l, long l1) throws IllegalArgumentException { + throw new UnsupportedOperationException(); + } + + @Override + public void runTaskTimerAsynchronously(@NotNull Plugin plugin, @NotNull Consumer consumer, long l, long l1) throws IllegalArgumentException { + throw new UnsupportedOperationException(); + } + + @Override + public @NotNull BukkitTask runTaskTimerAsynchronously(@NotNull Plugin plugin, @NotNull BukkitRunnable bukkitRunnable, long l, long l1) throws IllegalArgumentException { + throw new UnsupportedOperationException(); + } + +} diff --git a/src/test/java/me/roinujnosde/titansbattle/FakeBukkitTask.java b/src/test/java/me/roinujnosde/titansbattle/FakeBukkitTask.java new file mode 100644 index 00000000..9e0c2d1b --- /dev/null +++ b/src/test/java/me/roinujnosde/titansbattle/FakeBukkitTask.java @@ -0,0 +1,72 @@ +package me.roinujnosde.titansbattle; + +import org.bukkit.plugin.Plugin; +import org.bukkit.scheduler.BukkitTask; +import org.jetbrains.annotations.NotNull; + +public class FakeBukkitTask implements BukkitTask { + + private final int taskId; + private final Plugin plugin; + private final Runnable runnable; + private final boolean sync; + private boolean cancelled; + private boolean repeating; + private long scheduledTick; + private long period; + + public FakeBukkitTask(int taskId, Plugin plugin, Runnable runnable, boolean sync, boolean repeating, long scheduledTick, long period) { + this.taskId = taskId; + this.plugin = plugin; + this.runnable = runnable; + this.sync = sync; + this.repeating = repeating; + this.scheduledTick = scheduledTick; + this.period = period; + } + + @Override + public int getTaskId() { + return taskId; + } + + @Override + public @NotNull Plugin getOwner() { + return plugin; + } + + public Runnable getRunnable() { + return runnable; + } + + @Override + public boolean isSync() { + return sync; + } + + @Override + public boolean isCancelled() { + return cancelled; + } + + public boolean isRepeating() { + return repeating; + } + + public long getPeriod() { + return period; + } + + public long getScheduledTick() { + return scheduledTick; + } + + public void setScheduledTick(long scheduledTick) { + this.scheduledTick = scheduledTick; + } + + @Override + public void cancel() { + cancelled = true; + } +} diff --git a/src/test/java/me/roinujnosde/titansbattle/FakePlayer.java b/src/test/java/me/roinujnosde/titansbattle/FakePlayer.java new file mode 100644 index 00000000..ad70a636 --- /dev/null +++ b/src/test/java/me/roinujnosde/titansbattle/FakePlayer.java @@ -0,0 +1,1517 @@ +package me.roinujnosde.titansbattle; + +import org.bukkit.*; +import org.bukkit.attribute.Attribute; +import org.bukkit.attribute.AttributeInstance; +import org.bukkit.block.Block; +import org.bukkit.conversations.Conversation; +import org.bukkit.conversations.ConversationAbandonedEvent; +import org.bukkit.entity.*; +import org.bukkit.event.entity.EntityDamageEvent; +import org.bukkit.event.player.PlayerTeleportEvent; +import org.bukkit.inventory.*; +import org.bukkit.map.MapView; +import org.bukkit.metadata.MetadataValue; +import org.bukkit.permissions.Permission; +import org.bukkit.permissions.PermissionAttachment; +import org.bukkit.permissions.PermissionAttachmentInfo; +import org.bukkit.plugin.Plugin; +import org.bukkit.potion.PotionEffect; +import org.bukkit.potion.PotionEffectType; +import org.bukkit.scoreboard.Scoreboard; +import org.bukkit.util.Vector; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; + +import java.net.InetSocketAddress; +import java.util.*; + +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.when; + +@SuppressWarnings({"DataFlowIssue"}) +public class FakePlayer implements Player { + + private final UUID uuid; + private final String name; + + public FakePlayer() { + uuid = UUID.randomUUID(); + name = Material.values()[(int) (Math.random() * Material.values().length)].name(); + } + + @Override + public boolean equals(Object object) { + if (this == object) return true; + if (object == null || getClass() != object.getClass()) return false; + FakePlayer that = (FakePlayer) object; + return Objects.equals(uuid, that.uuid); + } + + @Override + public int hashCode() { + return Objects.hash(uuid); + } + + @Nullable + @Override + public Player getPlayer() { + return this; + } + + @NotNull + @Override + public Spigot spigot() { + return mock(Spigot.class); + } + + @NotNull + @Override + public ItemStack getItemInHand() { + ItemStack item = mock(ItemStack.class); + when(item.getType()).thenReturn(Material.DIAMOND_SWORD); + return item; + } + + @NotNull + @Override + public UUID getUniqueId() { + return uuid; + } + + @Override + public long getFirstPlayed() { + return 0; + } + + @Override + public long getLastPlayed() { + return 0; + } + + @Override + public boolean hasPlayedBefore() { + return false; + } + + @Override + public @NotNull String getName() { + return name; + } + + @NotNull + @Override + public PlayerInventory getInventory() { + return null; + } + + @NotNull + @Override + public Inventory getEnderChest() { + return null; + } + + @NotNull + @Override + public MainHand getMainHand() { + return null; + } + + @Override + public boolean setWindowProperty(@NotNull InventoryView.Property prop, int value) { + return false; + } + + + @NotNull + @Override + public InventoryView getOpenInventory() { + return null; + } + + @Nullable + @Override + public InventoryView openInventory(@NotNull Inventory inventory) { + return null; + } + + @Nullable + @Override + public InventoryView openWorkbench(@Nullable Location location, boolean force) { + return null; + } + + @Nullable + @Override + public InventoryView openEnchanting(@Nullable Location location, boolean force) { + return null; + } + + @Override + public void openInventory(@NotNull InventoryView inventory) { + + } + + @Nullable + @Override + public InventoryView openMerchant(@NotNull Villager trader, boolean force) { + return null; + } + + + @Override + public void closeInventory() { + + } + + @Override + public void setItemInHand(@Nullable ItemStack item) { + + } + + @NotNull + @Override + public ItemStack getItemOnCursor() { + return null; + } + + @Override + public void setItemOnCursor(@Nullable ItemStack item) { + + } + + + @Override + public int getSleepTicks() { + return 0; + } + + + @NotNull + @Override + public GameMode getGameMode() { + return null; + } + + @Override + public void setGameMode(@NotNull GameMode mode) { + + } + + @Override + public boolean isBlocking() { + return false; + } + + + @Override + public int getExpToLevel() { + return 0; + } + + + @Override + public float getExhaustion() { + return 0; + } + + @Override + public void setExhaustion(float value) { + + } + + @Override + public float getSaturation() { + return 0; + } + + @Override + public void setSaturation(float value) { + + } + + @Override + public int getFoodLevel() { + return 0; + } + + @Override + public void setFoodLevel(int value) { + + } + + + @Override + public boolean isBanned() { + return false; + } + + @Override + public void setBanned(boolean b) { + + } + + + @Override + public boolean isWhitelisted() { + return false; + } + + @Override + public void setWhitelisted(boolean value) { + + } + + + @Override + public @NotNull String getDisplayName() { + return name; + } + + @Override + public void setDisplayName(@Nullable String name) { + + } + + @NotNull + @Override + public String getPlayerListName() { + return null; + } + + @Override + public void setPlayerListName(@Nullable String name) { + + } + + @Override + public void setCompassTarget(@NotNull Location loc) { + + } + + @NotNull + @Override + public Location getCompassTarget() { + return null; + } + + @Nullable + @Override + public InetSocketAddress getAddress() { + return null; + } + + @Override + public boolean isConversing() { + return false; + } + + @Override + public void acceptConversationInput(@NotNull String input) { + + } + + @Override + public boolean beginConversation(@NotNull Conversation conversation) { + return false; + } + + @Override + public void abandonConversation(@NotNull Conversation conversation) { + + } + + @Override + public void abandonConversation(@NotNull Conversation conversation, @NotNull ConversationAbandonedEvent details) { + + } + + @Override + public void sendRawMessage(@NotNull String message) { + + } + + + @Override + public void kickPlayer(@Nullable String message) { + + } + + + @Override + public void chat(@NotNull String msg) { + + } + + @Override + public boolean performCommand(@NotNull String command) { + return false; + } + + @NotNull + @Override + public Location getLocation() { + return null; + } + + @Nullable + @Override + public Location getLocation(@Nullable Location loc) { + return null; + } + + @Override + public void setVelocity(@NotNull Vector velocity) { + + } + + @NotNull + @Override + public Vector getVelocity() { + return null; + } + + + @Override + public boolean isOnGround() { + return false; + } + + + @NotNull + @Override + public World getWorld() { + return null; + } + + + @Override + public boolean isSneaking() { + return false; + } + + @Override + public void setSneaking(boolean sneak) { + + } + + @Override + public boolean isSprinting() { + return false; + } + + @Override + public void setSprinting(boolean sprinting) { + + } + + @Override + public void saveData() { + + } + + @Override + public void loadData() { + + } + + @Override + public void setSleepingIgnored(boolean isSleeping) { + + } + + @Override + public boolean isSleepingIgnored() { + return false; + } + + @Nullable + @Override + public Location getBedSpawnLocation() { + return null; + } + + + @Override + public void incrementStatistic(@NotNull Statistic statistic) throws IllegalArgumentException { + + } + + @Override + public void decrementStatistic(@NotNull Statistic statistic) throws IllegalArgumentException { + + } + + @Override + public void incrementStatistic(@NotNull Statistic statistic, int amount) throws IllegalArgumentException { + + } + + @Override + public void decrementStatistic(@NotNull Statistic statistic, int amount) throws IllegalArgumentException { + + } + + @Override + public void setStatistic(@NotNull Statistic statistic, int newValue) throws IllegalArgumentException { + + } + + @Override + public int getStatistic(@NotNull Statistic statistic) throws IllegalArgumentException { + return 0; + } + + @Override + public void incrementStatistic(@NotNull Statistic statistic, @NotNull Material material) throws IllegalArgumentException { + + } + + @Override + public void decrementStatistic(@NotNull Statistic statistic, @NotNull Material material) throws IllegalArgumentException { + + } + + @Override + public int getStatistic(@NotNull Statistic statistic, @NotNull Material material) throws IllegalArgumentException { + return 0; + } + + @Override + public void incrementStatistic(@NotNull Statistic statistic, @NotNull Material material, int amount) throws IllegalArgumentException { + + } + + @Override + public void decrementStatistic(@NotNull Statistic statistic, @NotNull Material material, int amount) throws IllegalArgumentException { + + } + + @Override + public void setStatistic(@NotNull Statistic statistic, @NotNull Material material, int newValue) throws IllegalArgumentException { + + } + + @Override + public void incrementStatistic(@NotNull Statistic statistic, @NotNull EntityType entityType) throws IllegalArgumentException { + + } + + @Override + public void decrementStatistic(@NotNull Statistic statistic, @NotNull EntityType entityType) throws IllegalArgumentException { + + } + + @Override + public int getStatistic(@NotNull Statistic statistic, @NotNull EntityType entityType) throws IllegalArgumentException { + return 0; + } + + @Override + public void incrementStatistic(@NotNull Statistic statistic, @NotNull EntityType entityType, int amount) throws IllegalArgumentException { + + } + + @Override + public void decrementStatistic(@NotNull Statistic statistic, @NotNull EntityType entityType, int amount) { + + } + + @Override + public void setStatistic(@NotNull Statistic statistic, @NotNull EntityType entityType, int newValue) { + + } + + @Override + public void setBedSpawnLocation(@Nullable Location location) { + + } + + + @Override + public void setBedSpawnLocation(@Nullable Location location, boolean force) { + + } + + @Override + public void playNote(@NotNull Location loc, byte instrument, byte note) { + + } + + @Override + public void playNote(@NotNull Location loc, @NotNull Instrument instrument, @NotNull Note note) { + + } + + @Override + public void playSound(@NotNull Location location, @NotNull Sound sound, float volume, float pitch) { + + } + + @Override + public void playSound(@NotNull Location location, @NotNull String sound, float volume, float pitch) { + + } + + @Override + public void playEffect(@NotNull Location loc, @NotNull Effect effect, int data) { + + } + + @Override + public void playEffect(@NotNull Location loc, @NotNull Effect effect, @Nullable T data) { + + } + + @Override + public void sendBlockChange(@NotNull Location loc, @NotNull Material material, byte data) { + + } + + @Override + public boolean sendChunkChange(Location location, int i, int i1, int i2, byte[] bytes) { + return false; + } + + @Override + public void sendBlockChange(Location location, int i, byte b) { + + } + + + @Override + public void sendSignChange(@NotNull Location loc, @Nullable String[] lines) throws IllegalArgumentException { + + } + + + @Override + public void sendMap(@NotNull MapView map) { + + } + + @Override + public void updateInventory() { + + } + + @Override + public void awardAchievement(Achievement achievement) { + + } + + @Override + public void removeAchievement(Achievement achievement) { + + } + + @Override + public boolean hasAchievement(Achievement achievement) { + return false; + } + + @Override + public void setPlayerTime(long time, boolean relative) { + + } + + @Override + public long getPlayerTime() { + return 0; + } + + @Override + public long getPlayerTimeOffset() { + return 0; + } + + @Override + public boolean isPlayerTimeRelative() { + return false; + } + + @Override + public void resetPlayerTime() { + + } + + @Override + public void setPlayerWeather(@NotNull WeatherType type) { + + } + + @Nullable + @Override + public WeatherType getPlayerWeather() { + return null; + } + + @Override + public void resetPlayerWeather() { + + } + + @Override + public void giveExp(int amount) { + + } + + @Override + public void giveExpLevels(int amount) { + + } + + @Override + public float getExp() { + return 0; + } + + @Override + public void setExp(float exp) { + + } + + @Override + public int getLevel() { + return 0; + } + + @Override + public void setLevel(int level) { + + } + + @Override + public int getTotalExperience() { + return 0; + } + + @Override + public void setTotalExperience(int exp) { + + } + + @Override + public boolean getAllowFlight() { + return false; + } + + @Override + public void setAllowFlight(boolean flight) { + + } + + @Override + public void hidePlayer(@NotNull Player player) { + + } + + + @Override + public void showPlayer(@NotNull Player player) { + + } + + + @Override + public boolean canSee(@NotNull Player player) { + return false; + } + + @Override + public boolean isFlying() { + return false; + } + + @Override + public void setFlying(boolean value) { + + } + + @Override + public void setFlySpeed(float value) throws IllegalArgumentException { + + } + + @Override + public void setWalkSpeed(float value) throws IllegalArgumentException { + + } + + @Override + public float getFlySpeed() { + return 0; + } + + @Override + public float getWalkSpeed() { + return 0; + } + + @Override + public void setTexturePack(@NotNull String url) { + + } + + @Override + public void setResourcePack(@NotNull String url) { + + } + + + @NotNull + @Override + public Scoreboard getScoreboard() { + return null; + } + + @Override + public void setScoreboard(@NotNull Scoreboard scoreboard) throws IllegalArgumentException, IllegalStateException { + + } + + @Override + public boolean isHealthScaled() { + return false; + } + + @Override + public void setHealthScaled(boolean scale) { + + } + + @Override + public void setHealthScale(double scale) throws IllegalArgumentException { + + } + + @Override + public double getHealthScale() { + return 0; + } + + @Nullable + @Override + public Entity getSpectatorTarget() { + return null; + } + + @Override + public void setSpectatorTarget(@Nullable Entity entity) { + + } + + @Override + public void sendTitle(@Nullable String title, @Nullable String subtitle) { + + } + + @Override + public void resetTitle() { + + } + + @Override + public void spawnParticle(@NotNull Particle particle, @NotNull Location location, int count) { + + } + + @Override + public void spawnParticle(@NotNull Particle particle, double x, double y, double z, int count) { + + } + + @Override + public void spawnParticle(@NotNull Particle particle, @NotNull Location location, int count, @Nullable T data) { + + } + + @Override + public void spawnParticle(@NotNull Particle particle, double x, double y, double z, int count, @Nullable T data) { + + } + + @Override + public void spawnParticle(@NotNull Particle particle, @NotNull Location location, int count, double offsetX, double offsetY, double offsetZ) { + + } + + @Override + public void spawnParticle(@NotNull Particle particle, double x, double y, double z, int count, double offsetX, double offsetY, double offsetZ) { + + } + + @Override + public void spawnParticle(@NotNull Particle particle, @NotNull Location location, int count, double offsetX, double offsetY, double offsetZ, @Nullable T data) { + + } + + @Override + public void spawnParticle(@NotNull Particle particle, double x, double y, double z, int count, double offsetX, double offsetY, double offsetZ, @Nullable T data) { + + } + + @Override + public void spawnParticle(@NotNull Particle particle, @NotNull Location location, int count, double offsetX, double offsetY, double offsetZ, double extra) { + + } + + @Override + public void spawnParticle(@NotNull Particle particle, double x, double y, double z, int count, double offsetX, double offsetY, double offsetZ, double extra) { + + } + + @Override + public void spawnParticle(@NotNull Particle particle, @NotNull Location location, int count, double offsetX, double offsetY, double offsetZ, double extra, @Nullable T data) { + + } + + @Override + public void spawnParticle(@NotNull Particle particle, double x, double y, double z, int count, double offsetX, double offsetY, double offsetZ, double extra, @Nullable T data) { + + } + + + @Override + public boolean teleport(@NotNull Location location) { + return true; + } + + @Override + public boolean teleport(@NotNull Location location, PlayerTeleportEvent.@NotNull TeleportCause cause) { + return true; + } + + @Override + public boolean teleport(@NotNull Entity destination) { + return true; + } + + @Override + public boolean teleport(@NotNull Entity destination, PlayerTeleportEvent.@NotNull TeleportCause cause) { + return true; + } + + @NotNull + @Override + public List getNearbyEntities(double x, double y, double z) { + return null; + } + + @Override + public int getEntityId() { + return 0; + } + + @Override + public int getFireTicks() { + return 0; + } + + @Override + public int getMaxFireTicks() { + return 0; + } + + @Override + public void setFireTicks(int ticks) { + + } + + + @Override + public void remove() { + + } + + @Override + public boolean isDead() { + return false; + } + + @Override + public boolean isValid() { + return false; + } + + @Override + public void sendMessage(@NotNull String message) { + + } + + @Override + public void sendMessage(@NotNull String... messages) { + + } + + + @NotNull + @Override + public Server getServer() { + return null; + } + + + @Nullable + @Override + public Entity getPassenger() { + return null; + } + + @Override + public boolean setPassenger(@NotNull Entity passenger) { + return false; + } + + + @Override + public boolean isEmpty() { + return false; + } + + @Override + public boolean eject() { + return false; + } + + @Override + public float getFallDistance() { + return 0; + } + + @Override + public void setFallDistance(float distance) { + + } + + @Override + public void setLastDamageCause(@Nullable EntityDamageEvent event) { + + } + + @Nullable + @Override + public EntityDamageEvent getLastDamageCause() { + return null; + } + + @Override + public int getTicksLived() { + return 0; + } + + @Override + public void setTicksLived(int value) { + + } + + @Override + public void playEffect(@NotNull EntityEffect type) { + + } + + @NotNull + @Override + public EntityType getType() { + return null; + } + + + @Override + public boolean isInsideVehicle() { + return false; + } + + @Override + public boolean leaveVehicle() { + return false; + } + + @Nullable + @Override + public Entity getVehicle() { + return null; + } + + @Override + public void setCustomNameVisible(boolean flag) { + + } + + @Override + public boolean isCustomNameVisible() { + return false; + } + + + @Override + public void setGlowing(boolean flag) { + + } + + @Override + public boolean isGlowing() { + return false; + } + + @Override + public void setInvulnerable(boolean flag) { + + } + + @Override + public boolean isInvulnerable() { + return false; + } + + @Override + public boolean isSilent() { + return false; + } + + @Override + public void setSilent(boolean flag) { + + } + + + @Override + public boolean isOnline() { + return true; + } + + @NotNull + @Override + public Map serialize() { + return null; + } + + @Override + public double getEyeHeight() { + return 0; + } + + @Override + public double getEyeHeight(boolean ignorePose) { + return 0; + } + + @NotNull + @Override + public Location getEyeLocation() { + return null; + } + + @Override + public List getLineOfSight(HashSet hashSet, int i) { + return null; + } + + @Override + public List getLineOfSight(Set set, int i) { + return null; + } + + @Override + public Block getTargetBlock(HashSet hashSet, int i) { + return null; + } + + @Override + public Block getTargetBlock(Set set, int i) { + return null; + } + + @Override + public List getLastTwoTargetBlocks(HashSet hashSet, int i) { + return null; + } + + @Override + public List getLastTwoTargetBlocks(Set set, int i) { + return null; + } + + + @Override + public int getRemainingAir() { + return 0; + } + + @Override + public void setRemainingAir(int ticks) { + + } + + @Override + public int getMaximumAir() { + return 0; + } + + @Override + public void setMaximumAir(int ticks) { + + } + + + @Override + public int getMaximumNoDamageTicks() { + return 0; + } + + @Override + public void setMaximumNoDamageTicks(int ticks) { + + } + + @Override + public double getLastDamage() { + return 0; + } + + @Override + public int _INVALID_getLastDamage() { + return 0; + } + + @Override + public void setLastDamage(double damage) { + + } + + @Override + public void _INVALID_setLastDamage(int i) { + + } + + @Override + public int getNoDamageTicks() { + return 0; + } + + @Override + public void setNoDamageTicks(int ticks) { + + } + + + @Nullable + @Override + public Player getKiller() { + return null; + } + + @Override + public boolean addPotionEffect(@NotNull PotionEffect effect) { + return false; + } + + @Override + public boolean addPotionEffect(@NotNull PotionEffect effect, boolean force) { + return false; + } + + @Override + public boolean addPotionEffects(@NotNull Collection effects) { + return false; + } + + @Override + public boolean hasPotionEffect(@NotNull PotionEffectType type) { + return false; + } + + + @Override + public void removePotionEffect(@NotNull PotionEffectType type) { + + } + + @NotNull + @Override + public Collection getActivePotionEffects() { + return null; + } + + @Override + public boolean hasLineOfSight(@NotNull Entity other) { + return false; + } + + @Override + public boolean getRemoveWhenFarAway() { + return false; + } + + @Override + public void setRemoveWhenFarAway(boolean remove) { + + } + + @Nullable + @Override + public EntityEquipment getEquipment() { + return null; + } + + @Override + public void setCanPickupItems(boolean pickup) { + + } + + @Override + public boolean getCanPickupItems() { + return false; + } + + @Override + public boolean isLeashed() { + return false; + } + + @NotNull + @Override + public Entity getLeashHolder() throws IllegalStateException { + return null; + } + + @Override + public boolean setLeashHolder(@Nullable Entity holder) { + return false; + } + + @Override + public boolean isGliding() { + return false; + } + + @Override + public void setGliding(boolean gliding) { + + } + + + @Override + public boolean isSleeping() { + return false; + } + + + @Override + public void setAI(boolean ai) { + + } + + @Override + public boolean hasAI() { + return false; + } + + + @Override + public void setCollidable(boolean collidable) { + + } + + @Override + public boolean isCollidable() { + return false; + } + + @Override + public void damage(double amount) { + + } + + @Override + public void _INVALID_damage(int i) { + + } + + @Override + public void damage(double amount, @Nullable Entity source) { + + } + + @Override + public void _INVALID_damage(int i, Entity entity) { + + } + + + @Override + public double getHealth() { + return 0; + } + + @Override + public int _INVALID_getHealth() { + return 0; + } + + @Override + public void setHealth(double health) { + + } + + @Override + public void _INVALID_setHealth(int i) { + + } + + + @Override + public double getMaxHealth() { + return 0; + } + + @Override + public int _INVALID_getMaxHealth() { + return 0; + } + + @Override + public void setMaxHealth(double health) { + + } + + @Override + public void _INVALID_setMaxHealth(int i) { + + } + + @Override + public void resetMaxHealth() { + + } + + @Nullable + @Override + public String getCustomName() { + return null; + } + + @Override + public void setCustomName(@Nullable String name) { + + } + + @Override + public void setMetadata(@NotNull String metadataKey, @NotNull MetadataValue newMetadataValue) { + + } + + @NotNull + @Override + public List getMetadata(@NotNull String metadataKey) { + return null; + } + + @Override + public boolean hasMetadata(@NotNull String metadataKey) { + return false; + } + + @Override + public void removeMetadata(@NotNull String metadataKey, @NotNull Plugin owningPlugin) { + + } + + @Override + public boolean isPermissionSet(@NotNull String name) { + return false; + } + + @Override + public boolean isPermissionSet(@NotNull Permission perm) { + return false; + } + + @Override + public boolean hasPermission(@NotNull String name) { + return false; + } + + @Override + public boolean hasPermission(@NotNull Permission perm) { + return false; + } + + @NotNull + @Override + public PermissionAttachment addAttachment(@NotNull Plugin plugin, @NotNull String name, boolean value) { + return null; + } + + @NotNull + @Override + public PermissionAttachment addAttachment(@NotNull Plugin plugin) { + return null; + } + + @Nullable + @Override + public PermissionAttachment addAttachment(@NotNull Plugin plugin, @NotNull String name, boolean value, int ticks) { + return null; + } + + @Nullable + @Override + public PermissionAttachment addAttachment(@NotNull Plugin plugin, int ticks) { + return null; + } + + @Override + public void removeAttachment(@NotNull PermissionAttachment attachment) { + + } + + @Override + public void recalculatePermissions() { + + } + + @NotNull + @Override + public Set getEffectivePermissions() { + return null; + } + + @Override + public boolean isOp() { + return false; + } + + @Override + public void setOp(boolean value) { + + } + + @Override + public void sendPluginMessage(@NotNull Plugin source, @NotNull String channel, byte[] message) { + + } + + @NotNull + @Override + public Set getListeningPluginChannels() { + return null; + } + + @NotNull + @Override + public T launchProjectile(@NotNull Class projectile) { + return null; + } + + @NotNull + @Override + public T launchProjectile(@NotNull Class projectile, @Nullable Vector velocity) { + return null; + } + + @Override + public AttributeInstance getAttribute(Attribute attribute) { + return null; + } +} diff --git a/src/test/java/me/roinujnosde/titansbattle/games/EliminationTournamentGameTest.java b/src/test/java/me/roinujnosde/titansbattle/games/EliminationTournamentGameTest.java new file mode 100644 index 00000000..0c5eacd0 --- /dev/null +++ b/src/test/java/me/roinujnosde/titansbattle/games/EliminationTournamentGameTest.java @@ -0,0 +1,132 @@ +package me.roinujnosde.titansbattle.games; + +import me.roinujnosde.titansbattle.*; +import me.roinujnosde.titansbattle.managers.ConfigManager; +import me.roinujnosde.titansbattle.managers.DatabaseManager; +import me.roinujnosde.titansbattle.managers.GameManager; +import me.roinujnosde.titansbattle.types.GameConfiguration; +import me.roinujnosde.titansbattle.types.Prizes; +import me.roinujnosde.titansbattle.types.Warrior; +import me.roinujnosde.titansbattle.types.Winners; +import org.bukkit.Bukkit; +import org.bukkit.Location; +import org.bukkit.Server; +import org.bukkit.configuration.file.FileConfiguration; +import org.bukkit.plugin.PluginManager; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.RepeatedTest; +import org.junit.jupiter.api.RepetitionInfo; + +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; +import java.util.Map; +import java.util.logging.Logger; +import java.util.stream.Collectors; + +import static org.junit.jupiter.api.Assertions.*; +import static org.mockito.ArgumentMatchers.anyString; +import static org.mockito.Mockito.*; + +public class EliminationTournamentGameTest { + + + static Server server; + static PluginManager pluginManager; + static FakeBukkitScheduler scheduler = new FakeBukkitScheduler(); + static TitansBattle plugin; + static DatabaseManager databaseManager; + static GameConfiguration config; + static EliminationTournamentGame game; + + @BeforeAll + public static void setup() { + + pluginManager = mock(PluginManager.class); + + server = mock(Server.class); + when(server.getLogger()).thenReturn(mock(Logger.class)); + when(server.getScheduler()).thenReturn(scheduler); + when(server.getPluginManager()).thenReturn(pluginManager); + + databaseManager = mock(DatabaseManager.class); + when(databaseManager.getTodaysWinners()).thenReturn(mock(Winners.class)); + + FileConfiguration fileConfiguration = mock(FileConfiguration.class); + + plugin = mock(TitansBattle.class); + when(plugin.getLogger()).thenReturn(mock(Logger.class)); + when(plugin.getGameManager()).thenReturn(mock(GameManager.class)); + when(plugin.getDatabaseManager()).thenReturn(databaseManager); + when(plugin.getConfigManager()).thenReturn(mock(ConfigManager.class)); + when(plugin.getLang(anyString(), any(BaseGame.class), any(Object[].class))).thenReturn(""); + when(plugin.getConfig()).thenReturn(fileConfiguration); + when(fileConfiguration.getString(anyString(), anyString())).thenReturn(""); + + config = mock(GameConfiguration.class); + when(config.getAnnouncementStartingInterval()).thenReturn(5); + when(config.getAnnouncementStartingTimes()).thenReturn(2); + when(config.locationsSet()).thenReturn(true); + when(config.getLobby()).thenReturn(mock(Location.class)); + when(config.getExit()).thenReturn(mock(Location.class)); + when(config.getWatchroom()).thenReturn(mock(Location.class)); + when(config.getPrizes(any(BaseGameConfiguration.Prize.class))).thenReturn(mock(Prizes.class)); + Map entrances = Collections.singletonMap(0, mock(Location.class)); + when(config.getArenaEntrances()).thenReturn(entrances); + when(config.getName()).thenReturn("test-game"); + + Bukkit.setServer(server); + } + + @BeforeEach + public void setupGame() { + game = new EliminationTournamentGame(plugin, config); + } + + @RepeatedTest(50) + public void simpleWinnerOdd(RepetitionInfo repetitionInfo) { + simpleWinner(repetitionInfo.getCurrentRepetition(), 1); + } + + @RepeatedTest(50) + public void simpleWinnerEven(RepetitionInfo repetitionInfo) { + simpleWinner(repetitionInfo.getCurrentRepetition(), 0); + } + + private void simpleWinner(int players, int oddOrEven) { + game.start(); + scheduler.performOneTick(); + for (int i = 0; i < players; i++) { + game.onJoin(new Warrior(new FakePlayer(), plugin::getGroupManager)); + } + assertTrue(game.isLobby()); + scheduler.performTicks(300); //lobby announcements + assertFalse(game.isLobby()); + + Warrior expectedWinner = game.getParticipants().get(0); + int count = 0; + while (game.getParticipants().size() > 1) { + List current = new ArrayList<>(game.getCurrentFighters()); + Warrior victim = null; + if (count % 2 == oddOrEven) { + List list = game.getParticipants().stream().filter(w -> !current.contains(w) && w != expectedWinner).collect(Collectors.toList()); + if (!list.isEmpty()) { + game.onDisconnect(list.get((int) (list.size() * Math.random()))); + } + } else { + victim = current.get(0) != expectedWinner ? current.get(0) : current.get(1); + Warrior killer = current.get(0) == victim ? current.get(1) : current.get(0); + game.onDeath(victim, killer); + } + + scheduler.performTicks(21); //respawn delay + if (victim != null) { + assertTrue(game.getCasualties().contains(victim)); + } + count++; + } + assertEquals(1, expectedWinner.getVictories("test-game")); + } + +} \ No newline at end of file From 1ec22a9d8c1e6334f2f7154dc273de0f422954f3 Mon Sep 17 00:00:00 2001 From: RoinujNosde Date: Sun, 19 Jan 2025 15:31:05 -0300 Subject: [PATCH 2/3] downgraded to spigot 1.9.4 --- .../titansbattle/FakeBukkitScheduler.java | 36 +++---------------- .../titansbattle/FakeBukkitTask.java | 5 ++- 2 files changed, 7 insertions(+), 34 deletions(-) diff --git a/src/test/java/me/roinujnosde/titansbattle/FakeBukkitScheduler.java b/src/test/java/me/roinujnosde/titansbattle/FakeBukkitScheduler.java index 3d629450..dbfd6af7 100644 --- a/src/test/java/me/roinujnosde/titansbattle/FakeBukkitScheduler.java +++ b/src/test/java/me/roinujnosde/titansbattle/FakeBukkitScheduler.java @@ -13,7 +13,6 @@ import java.util.concurrent.Callable; import java.util.concurrent.CopyOnWriteArrayList; import java.util.concurrent.Future; -import java.util.function.Consumer; public class FakeBukkitScheduler implements BukkitScheduler { @@ -103,6 +102,11 @@ public void cancelTasks(@NotNull Plugin plugin) { throw new UnsupportedOperationException(); } + @Override + public void cancelAllTasks() { + throw new UnsupportedOperationException(); + } + @Override public boolean isCurrentlyRunning(int i) { throw new UnsupportedOperationException(); @@ -131,11 +135,6 @@ public boolean isQueued(int i) { return task; } - @Override - public void runTask(@NotNull Plugin plugin, @NotNull Consumer consumer) throws IllegalArgumentException { - throw new UnsupportedOperationException(); - } - @Override public @NotNull BukkitTask runTask(@NotNull Plugin plugin, @NotNull BukkitRunnable bukkitRunnable) throws IllegalArgumentException { throw new UnsupportedOperationException(); @@ -146,11 +145,6 @@ public void runTask(@NotNull Plugin plugin, @NotNull Consumer consumer) throws IllegalArgumentException { - throw new UnsupportedOperationException(); - } - @Override public @NotNull BukkitTask runTaskAsynchronously(@NotNull Plugin plugin, @NotNull BukkitRunnable bukkitRunnable) throws IllegalArgumentException { throw new UnsupportedOperationException(); @@ -164,11 +158,6 @@ public void runTaskAsynchronously(@NotNull Plugin plugin, @NotNull Consumer consumer, long l) throws IllegalArgumentException { - throw new UnsupportedOperationException(); - } - @Override public @NotNull BukkitTask runTaskLater(@NotNull Plugin plugin, @NotNull BukkitRunnable bukkitRunnable, long l) throws IllegalArgumentException { throw new UnsupportedOperationException(); @@ -179,11 +168,6 @@ public void runTaskLater(@NotNull Plugin plugin, @NotNull Consumer consumer, long l) throws IllegalArgumentException { - throw new UnsupportedOperationException(); - } - @Override public @NotNull BukkitTask runTaskLaterAsynchronously(@NotNull Plugin plugin, @NotNull BukkitRunnable bukkitRunnable, long l) throws IllegalArgumentException { throw new UnsupportedOperationException(); @@ -197,11 +181,6 @@ public void runTaskLaterAsynchronously(@NotNull Plugin plugin, @NotNull Consumer return task; } - @Override - public void runTaskTimer(@NotNull Plugin plugin, @NotNull Consumer consumer, long l, long l1) throws IllegalArgumentException { - throw new UnsupportedOperationException(); - } - @Override public @NotNull BukkitTask runTaskTimer(@NotNull Plugin plugin, @NotNull BukkitRunnable bukkitRunnable, long l, long l1) throws IllegalArgumentException { throw new UnsupportedOperationException(); @@ -212,11 +191,6 @@ public void runTaskTimer(@NotNull Plugin plugin, @NotNull Consumer consumer, long l, long l1) throws IllegalArgumentException { - throw new UnsupportedOperationException(); - } - @Override public @NotNull BukkitTask runTaskTimerAsynchronously(@NotNull Plugin plugin, @NotNull BukkitRunnable bukkitRunnable, long l, long l1) throws IllegalArgumentException { throw new UnsupportedOperationException(); diff --git a/src/test/java/me/roinujnosde/titansbattle/FakeBukkitTask.java b/src/test/java/me/roinujnosde/titansbattle/FakeBukkitTask.java index 9e0c2d1b..6c1673d4 100644 --- a/src/test/java/me/roinujnosde/titansbattle/FakeBukkitTask.java +++ b/src/test/java/me/roinujnosde/titansbattle/FakeBukkitTask.java @@ -11,9 +11,9 @@ public class FakeBukkitTask implements BukkitTask { private final Runnable runnable; private final boolean sync; private boolean cancelled; - private boolean repeating; + private final boolean repeating; private long scheduledTick; - private long period; + private final long period; public FakeBukkitTask(int taskId, Plugin plugin, Runnable runnable, boolean sync, boolean repeating, long scheduledTick, long period) { this.taskId = taskId; @@ -44,7 +44,6 @@ public boolean isSync() { return sync; } - @Override public boolean isCancelled() { return cancelled; } From d03cc08171dcc72f7a36237e0378a9d0743fbf2c Mon Sep 17 00:00:00 2001 From: RoinujNosde Date: Sun, 19 Jan 2025 15:46:10 -0300 Subject: [PATCH 3/3] test: fixed error with junit --- pom.xml | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/pom.xml b/pom.xml index c10db8ff..ce165619 100644 --- a/pom.xml +++ b/pom.xml @@ -183,6 +183,11 @@ 5.11.3 test + + org.junit.vintage + junit-vintage-engine + 5.11.3 + org.mockito mockito-core