1614 lines
60 KiB
Java
1614 lines
60 KiB
Java
package world.bentobox.bentobox.managers;
|
|
|
|
import static org.junit.Assert.assertEquals;
|
|
import static org.junit.Assert.assertFalse;
|
|
import static org.junit.Assert.assertNotNull;
|
|
import static org.junit.Assert.assertNull;
|
|
import static org.junit.Assert.assertTrue;
|
|
import static org.mockito.ArgumentMatchers.any;
|
|
import static org.mockito.ArgumentMatchers.anyString;
|
|
import static org.mockito.ArgumentMatchers.eq;
|
|
import static org.mockito.Mockito.mock;
|
|
import static org.mockito.Mockito.never;
|
|
import static org.mockito.Mockito.verify;
|
|
import static org.mockito.Mockito.when;
|
|
|
|
import java.io.File;
|
|
import java.io.IOException;
|
|
import java.nio.file.Files;
|
|
import java.nio.file.Path;
|
|
import java.util.ArrayList;
|
|
import java.util.Arrays;
|
|
import java.util.Collection;
|
|
import java.util.Collections;
|
|
import java.util.Comparator;
|
|
import java.util.HashMap;
|
|
import java.util.HashSet;
|
|
import java.util.List;
|
|
import java.util.Map;
|
|
import java.util.Optional;
|
|
import java.util.Set;
|
|
import java.util.UUID;
|
|
|
|
import org.bukkit.Bukkit;
|
|
import org.bukkit.Chunk;
|
|
import org.bukkit.Location;
|
|
import org.bukkit.Material;
|
|
import org.bukkit.World;
|
|
import org.bukkit.block.Block;
|
|
import org.bukkit.block.BlockFace;
|
|
import org.bukkit.block.BlockState;
|
|
import org.bukkit.block.data.BlockData;
|
|
import org.bukkit.entity.Cow;
|
|
import org.bukkit.entity.Creeper;
|
|
import org.bukkit.entity.Entity;
|
|
import org.bukkit.entity.EntityType;
|
|
import org.bukkit.entity.Player;
|
|
import org.bukkit.entity.PufferFish;
|
|
import org.bukkit.entity.Skeleton;
|
|
import org.bukkit.entity.Slime;
|
|
import org.bukkit.entity.Wither;
|
|
import org.bukkit.entity.Zombie;
|
|
import org.bukkit.permissions.PermissionAttachmentInfo;
|
|
import org.bukkit.plugin.PluginManager;
|
|
import org.bukkit.scheduler.BukkitScheduler;
|
|
import org.junit.After;
|
|
import org.junit.Before;
|
|
import org.junit.Test;
|
|
import org.junit.runner.RunWith;
|
|
import org.mockito.ArgumentCaptor;
|
|
import org.mockito.Mock;
|
|
import org.mockito.Mockito;
|
|
import org.mockito.stubbing.Answer;
|
|
import org.powermock.api.mockito.PowerMockito;
|
|
import org.powermock.core.classloader.annotations.PrepareForTest;
|
|
import org.powermock.modules.junit4.PowerMockRunner;
|
|
import org.powermock.reflect.Whitebox;
|
|
|
|
import com.google.common.collect.ImmutableSet;
|
|
import com.google.common.collect.ImmutableSet.Builder;
|
|
|
|
import io.papermc.lib.PaperLib;
|
|
import io.papermc.lib.environments.CraftBukkitEnvironment;
|
|
import io.papermc.lib.environments.Environment;
|
|
import world.bentobox.bentobox.BentoBox;
|
|
import world.bentobox.bentobox.Settings;
|
|
import world.bentobox.bentobox.api.configuration.WorldSettings;
|
|
import world.bentobox.bentobox.api.events.island.IslandDeleteEvent;
|
|
import world.bentobox.bentobox.api.user.User;
|
|
import world.bentobox.bentobox.database.Database;
|
|
import world.bentobox.bentobox.database.DatabaseSetup.DatabaseType;
|
|
import world.bentobox.bentobox.database.objects.Island;
|
|
import world.bentobox.bentobox.listeners.flags.AbstractCommonSetup;
|
|
import world.bentobox.bentobox.lists.Flags;
|
|
import world.bentobox.bentobox.managers.island.IslandCache;
|
|
import world.bentobox.bentobox.util.Util;
|
|
|
|
@RunWith(PowerMockRunner.class)
|
|
@PrepareForTest({ Bukkit.class, BentoBox.class, Util.class, Location.class })
|
|
public class IslandsManagerTest extends AbstractCommonSetup {
|
|
|
|
@Mock
|
|
private BentoBox plugin;
|
|
private UUID uuid;
|
|
@Mock
|
|
private User user;
|
|
@Mock
|
|
private PlayersManager pm;
|
|
@Mock
|
|
private Player player;
|
|
@Mock
|
|
private World world;
|
|
@Mock
|
|
private Block space1;
|
|
@Mock
|
|
private Block ground;
|
|
@Mock
|
|
private Block space2;
|
|
@Mock
|
|
private Location location;
|
|
@Mock
|
|
private IslandWorldManager iwm;
|
|
@Mock
|
|
private IslandDeletionManager deletionManager;
|
|
@Mock
|
|
private IslandChunkDeletionManager chunkDeletionManager;
|
|
@Mock
|
|
private IslandCache islandCache;
|
|
private Optional<Island> optionalIsland;
|
|
@Mock
|
|
private Island island;
|
|
@Mock
|
|
private PluginManager pim;
|
|
// Database
|
|
Database<Island> db;
|
|
@Mock
|
|
private Zombie zombie;
|
|
@Mock
|
|
private Slime slime;
|
|
@Mock
|
|
private Cow cow;
|
|
@Mock
|
|
private Wither wither;
|
|
@Mock
|
|
private Creeper creeper;
|
|
@Mock
|
|
private PufferFish pufferfish;
|
|
@Mock
|
|
private Skeleton skelly;
|
|
|
|
private Material sign;
|
|
private Material wallSign;
|
|
|
|
private Environment env;
|
|
|
|
// Class under test
|
|
IslandsManager im;
|
|
|
|
@Override
|
|
@SuppressWarnings("unchecked")
|
|
@Before
|
|
public void setUp() throws Exception {
|
|
super.setUp();
|
|
|
|
// Clear any lingering database
|
|
tearDown();
|
|
// Set up plugin
|
|
plugin = mock(BentoBox.class);
|
|
Whitebox.setInternalState(BentoBox.class, "instance", plugin);
|
|
|
|
// island world mgr
|
|
when(world.getName()).thenReturn("world");
|
|
when(world.getEnvironment()).thenReturn(World.Environment.NORMAL);
|
|
when(iwm.inWorld(any(World.class))).thenReturn(true);
|
|
when(iwm.inWorld(any(Location.class))).thenReturn(true);
|
|
when(plugin.getIWM()).thenReturn(iwm);
|
|
|
|
// Settings
|
|
Settings s = mock(Settings.class);
|
|
when(plugin.getSettings()).thenReturn(s);
|
|
when(s.getDatabaseType()).thenReturn(DatabaseType.JSON);
|
|
|
|
// World
|
|
when(world.getEnvironment()).thenReturn(World.Environment.NORMAL);
|
|
|
|
// Command manager
|
|
CommandsManager cm = mock(CommandsManager.class);
|
|
when(plugin.getCommandsManager()).thenReturn(cm);
|
|
// Player
|
|
when(user.isOp()).thenReturn(false);
|
|
uuid = UUID.randomUUID();
|
|
when(user.getUniqueId()).thenReturn(uuid);
|
|
when(user.getPlayer()).thenReturn(player);
|
|
User.setPlugin(plugin);
|
|
// Set up user already
|
|
when(player.getUniqueId()).thenReturn(uuid);
|
|
User.getInstance(player);
|
|
|
|
// Locales
|
|
LocalesManager lm = mock(LocalesManager.class);
|
|
when(plugin.getLocalesManager()).thenReturn(lm);
|
|
when(lm.get(any(), any())).thenReturn("mock translation");
|
|
|
|
// Placeholders
|
|
PlaceholdersManager placeholdersManager = mock(PlaceholdersManager.class);
|
|
when(plugin.getPlaceholdersManager()).thenReturn(placeholdersManager);
|
|
when(placeholdersManager.replacePlaceholders(any(), any())).thenReturn("mock translation");
|
|
|
|
// Player's manager
|
|
when(plugin.getPlayers()).thenReturn(pm);
|
|
|
|
// Scheduler
|
|
BukkitScheduler sch = mock(BukkitScheduler.class);
|
|
PowerMockito.mockStatic(Bukkit.class);
|
|
when(Bukkit.getScheduler()).thenReturn(sch);
|
|
// version
|
|
when(Bukkit.getVersion())
|
|
.thenReturn("Paper version git-Paper-225 (MC: 1.14.4) (Implementing API version 1.14.4-R0.1-SNAPSHOT)");
|
|
|
|
// Standard location
|
|
when(location.getWorld()).thenReturn(world);
|
|
when(location.getBlock()).thenReturn(space1);
|
|
when(location.getWorld()).thenReturn(world);
|
|
when(location.clone()).thenReturn(location);
|
|
Chunk chunk = mock(Chunk.class);
|
|
when(location.getChunk()).thenReturn(chunk);
|
|
when(space1.getRelative(BlockFace.DOWN)).thenReturn(ground);
|
|
when(space1.getRelative(BlockFace.UP)).thenReturn(space2);
|
|
// A safe spot
|
|
when(ground.getType()).thenReturn(Material.STONE);
|
|
when(space1.getType()).thenReturn(Material.AIR);
|
|
when(space2.getType()).thenReturn(Material.AIR);
|
|
// Neutral BlockState
|
|
BlockState blockState = mock(BlockState.class);
|
|
when(ground.getState()).thenReturn(blockState);
|
|
BlockData bd = mock(BlockData.class);
|
|
when(blockState.getBlockData()).thenReturn(bd);
|
|
|
|
// Online players
|
|
// Return a set of online players
|
|
when(Bukkit.getOnlinePlayers()).then((Answer<Set<Player>>) invocation -> new HashSet<>());
|
|
|
|
// Worlds
|
|
when(plugin.getIWM()).thenReturn(iwm);
|
|
// Default is player is in the world
|
|
when(iwm.inWorld(any(World.class))).thenReturn(true);
|
|
when(iwm.inWorld(any(Location.class))).thenReturn(true);
|
|
|
|
// Worlds translate to world
|
|
PowerMockito.mockStatic(Util.class);
|
|
when(Util.getWorld(any())).thenReturn(world);
|
|
|
|
// Island
|
|
when(island.getOwner()).thenReturn(uuid);
|
|
when(island.getWorld()).thenReturn(world);
|
|
when(island.getMaxMembers()).thenReturn(null); // default
|
|
when(island.getMaxMembers(Mockito.anyInt())).thenReturn(null); // default
|
|
when(island.getCenter()).thenReturn(location);
|
|
when(island.getProtectionCenter()).thenReturn(location);
|
|
|
|
// Mock island cache
|
|
when(islandCache.getIslandAt(any(Location.class))).thenReturn(island);
|
|
when(islandCache.get(any(), any())).thenReturn(island);
|
|
optionalIsland = Optional.ofNullable(island);
|
|
when(islandCache.getIslands(world, uuid)).thenReturn(List.of(island));
|
|
|
|
// User location
|
|
when(user.getLocation()).thenReturn(location);
|
|
|
|
// Plugin Manager for events
|
|
when(Bukkit.getPluginManager()).thenReturn(pim);
|
|
|
|
// Addon
|
|
when(iwm.getAddon(any())).thenReturn(Optional.empty());
|
|
|
|
// Cover hostile entities
|
|
when(Util.isHostileEntity(any())).thenCallRealMethod();
|
|
|
|
// Set up island entities
|
|
WorldSettings ws = mock(WorldSettings.class);
|
|
when(iwm.getWorldSettings(eq(world))).thenReturn(ws);
|
|
Map<String, Boolean> worldFlags = new HashMap<>();
|
|
when(ws.getWorldFlags()).thenReturn(worldFlags);
|
|
|
|
Flags.REMOVE_MOBS.setSetting(world, true);
|
|
// Default whitelist
|
|
Set<EntityType> whitelist = new HashSet<>();
|
|
whitelist.add(EntityType.ENDERMAN);
|
|
whitelist.add(EntityType.WITHER);
|
|
whitelist.add(EntityType.ZOMBIE_VILLAGER);
|
|
|
|
when(iwm.getRemoveMobsWhitelist(any())).thenReturn(whitelist);
|
|
|
|
// Monsters and animals
|
|
when(zombie.getLocation()).thenReturn(location);
|
|
when(zombie.getType()).thenReturn(EntityType.ZOMBIE);
|
|
when(zombie.getRemoveWhenFarAway()).thenReturn(true);
|
|
when(slime.getLocation()).thenReturn(location);
|
|
when(slime.getType()).thenReturn(EntityType.SLIME);
|
|
when(slime.getRemoveWhenFarAway()).thenReturn(true);
|
|
when(cow.getLocation()).thenReturn(location);
|
|
when(cow.getType()).thenReturn(EntityType.COW);
|
|
when(wither.getType()).thenReturn(EntityType.WITHER);
|
|
when(wither.getRemoveWhenFarAway()).thenReturn(true);
|
|
when(creeper.getType()).thenReturn(EntityType.CREEPER);
|
|
when(creeper.getRemoveWhenFarAway()).thenReturn(true);
|
|
when(pufferfish.getType()).thenReturn(EntityType.PUFFERFISH);
|
|
// Named monster
|
|
when(skelly.getType()).thenReturn(EntityType.SKELETON);
|
|
when(skelly.getCustomName()).thenReturn("Skelly");
|
|
when(skelly.getRemoveWhenFarAway()).thenReturn(true);
|
|
|
|
Collection<Entity> collection = new ArrayList<>();
|
|
collection.add(player);
|
|
collection.add(zombie);
|
|
collection.add(cow);
|
|
collection.add(slime);
|
|
collection.add(wither);
|
|
collection.add(creeper);
|
|
collection.add(pufferfish);
|
|
collection.add(skelly);
|
|
when(world.getNearbyEntities(any(Location.class), Mockito.anyDouble(), Mockito.anyDouble(),
|
|
Mockito.anyDouble())).thenReturn(collection);
|
|
|
|
// Deletion Manager
|
|
when(deletionManager.getIslandChunkDeletionManager()).thenReturn(chunkDeletionManager);
|
|
when(plugin.getIslandDeletionManager()).thenReturn(deletionManager);
|
|
|
|
// database must be mocked here
|
|
db = mock(Database.class);
|
|
|
|
// Signs
|
|
sign = Material.BIRCH_SIGN;
|
|
wallSign = Material.ACACIA_WALL_SIGN;
|
|
|
|
// PaperLib
|
|
env = new CraftBukkitEnvironment();
|
|
PaperLib.setCustomEnvironment(env);
|
|
|
|
// Util strip spaces
|
|
when(Util.stripSpaceAfterColorCodes(anyString())).thenCallRealMethod();
|
|
|
|
// Class under test
|
|
im = new IslandsManager(plugin);
|
|
// Set cache
|
|
// im.setIslandCache(islandCache);
|
|
}
|
|
|
|
@Override
|
|
@After
|
|
public void tearDown() throws Exception {
|
|
super.tearDown();
|
|
Mockito.framework().clearInlineMocks();
|
|
deleteAll(new File("database"));
|
|
deleteAll(new File("database_backup"));
|
|
}
|
|
|
|
private void deleteAll(File file) throws IOException {
|
|
if (file.exists()) {
|
|
Files.walk(file.toPath()).sorted(Comparator.reverseOrder()).map(Path::toFile).forEach(File::delete);
|
|
}
|
|
|
|
}
|
|
|
|
/**
|
|
* Test method for
|
|
* {@link world.bentobox.bentobox.managers.IslandsManager#isSafeLocation(org.bukkit.Location)}.
|
|
*/
|
|
@Test
|
|
public void testIsSafeLocationSafe() {
|
|
assertTrue(im.isSafeLocation(location));
|
|
}
|
|
|
|
/**
|
|
* Test method for {@link world.bentobox.bentobox.managers.IslandsManager#isSafeLocation(org.bukkit.Location)}.
|
|
*/
|
|
@Test
|
|
public void testIsSafeLocationNullWorld() {
|
|
when(location.getWorld()).thenReturn(null);
|
|
assertFalse(im.isSafeLocation(location));
|
|
}
|
|
|
|
/**
|
|
* Test method for {@link world.bentobox.bentobox.managers.IslandsManager#isSafeLocation(org.bukkit.Location)}.
|
|
*/
|
|
@Test
|
|
public void testIsSafeLocationNonSolidGround() {
|
|
when(ground.getType()).thenReturn(Material.WATER);
|
|
assertFalse(im.isSafeLocation(location));
|
|
}
|
|
|
|
/**
|
|
* Test method for {@link world.bentobox.bentobox.managers.IslandsManager#isSafeLocation(org.bukkit.Location)}.
|
|
*/
|
|
@Test
|
|
public void testIsSafeLocationSubmerged() {
|
|
when(ground.getType()).thenReturn(Material.STONE);
|
|
when(space1.getType()).thenReturn(Material.WATER);
|
|
when(space2.getType()).thenReturn(Material.WATER);
|
|
assertFalse(im.isSafeLocation(location));
|
|
}
|
|
|
|
@SuppressWarnings("deprecation")
|
|
@Test
|
|
public void testCheckIfSafeTrapdoor() {
|
|
for (Material d : Material.values()) {
|
|
if (d.name().contains("DOOR")) {
|
|
for (Material s : Material.values()) {
|
|
if (s.name().contains("_SIGN") && !s.isLegacy()) {
|
|
assertFalse("Fail " + d.name() + " " + s.name(), im.checkIfSafe(world, d, s, Material.AIR));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Test method for {@link world.bentobox.bentobox.managers.IslandsManager#isSafeLocation(org.bukkit.Location)}.
|
|
*/
|
|
@Test
|
|
public void testIsSafeLocationPortals() {
|
|
when(ground.getType()).thenReturn(Material.STONE);
|
|
when(space1.getType()).thenReturn(Material.AIR);
|
|
when(space2.getType()).thenReturn(Material.NETHER_PORTAL);
|
|
assertTrue(im.isSafeLocation(location));
|
|
when(ground.getType()).thenReturn(Material.STONE);
|
|
when(space1.getType()).thenReturn(Material.AIR);
|
|
when(space2.getType()).thenReturn(Material.END_PORTAL);
|
|
assertFalse(im.isSafeLocation(location));
|
|
when(ground.getType()).thenReturn(Material.STONE);
|
|
when(space1.getType()).thenReturn(Material.NETHER_PORTAL);
|
|
when(space2.getType()).thenReturn(Material.AIR);
|
|
assertTrue(im.isSafeLocation(location));
|
|
when(ground.getType()).thenReturn(Material.STONE);
|
|
when(space1.getType()).thenReturn(Material.END_PORTAL);
|
|
when(space2.getType()).thenReturn(Material.AIR);
|
|
assertFalse(im.isSafeLocation(location));
|
|
when(ground.getType()).thenReturn(Material.NETHER_PORTAL);
|
|
when(space1.getType()).thenReturn(Material.AIR);
|
|
when(space2.getType()).thenReturn(Material.AIR);
|
|
assertFalse(im.isSafeLocation(location));
|
|
when(ground.getType()).thenReturn(Material.END_PORTAL);
|
|
when(space1.getType()).thenReturn(Material.AIR);
|
|
when(space2.getType()).thenReturn(Material.AIR);
|
|
assertFalse(im.isSafeLocation(location));
|
|
when(ground.getType()).thenReturn(Material.END_GATEWAY);
|
|
when(space1.getType()).thenReturn(Material.AIR);
|
|
when(space2.getType()).thenReturn(Material.AIR);
|
|
assertFalse(im.isSafeLocation(location));
|
|
when(ground.getType()).thenReturn(Material.STONE);
|
|
when(space1.getType()).thenReturn(Material.END_GATEWAY);
|
|
when(space2.getType()).thenReturn(Material.AIR);
|
|
assertFalse(im.isSafeLocation(location));
|
|
when(ground.getType()).thenReturn(Material.STONE);
|
|
when(space1.getType()).thenReturn(Material.AIR);
|
|
when(space2.getType()).thenReturn(Material.END_GATEWAY);
|
|
assertFalse(im.isSafeLocation(location));
|
|
|
|
}
|
|
|
|
/**
|
|
* Test method for {@link world.bentobox.bentobox.managers.IslandsManager#isSafeLocation(org.bukkit.Location)}.
|
|
*/
|
|
@Test
|
|
public void testIsSafeLocationLava() {
|
|
when(ground.getType()).thenReturn(Material.LAVA);
|
|
when(space1.getType()).thenReturn(Material.AIR);
|
|
when(space2.getType()).thenReturn(Material.AIR);
|
|
assertFalse("In lava", im.isSafeLocation(location));
|
|
when(ground.getType()).thenReturn(Material.AIR);
|
|
when(space1.getType()).thenReturn(Material.LAVA);
|
|
when(space2.getType()).thenReturn(Material.AIR);
|
|
assertFalse("In lava", im.isSafeLocation(location));
|
|
when(ground.getType()).thenReturn(Material.AIR);
|
|
when(space1.getType()).thenReturn(Material.AIR);
|
|
when(space2.getType()).thenReturn(Material.LAVA);
|
|
assertFalse("In lava", im.isSafeLocation(location));
|
|
}
|
|
|
|
/**
|
|
* Test method for {@link world.bentobox.bentobox.managers.IslandsManager#isSafeLocation(org.bukkit.Location)}.
|
|
*/
|
|
@Test
|
|
public void testTrapDoor() {
|
|
when(ground.getType()).thenReturn(Material.OAK_TRAPDOOR);
|
|
assertFalse("Open trapdoor", im.isSafeLocation(location));
|
|
when(ground.getType()).thenReturn(Material.IRON_TRAPDOOR);
|
|
assertFalse("Open iron trapdoor", im.isSafeLocation(location));
|
|
}
|
|
|
|
/**
|
|
* Test method for {@link world.bentobox.bentobox.managers.IslandsManager#isSafeLocation(org.bukkit.Location)}.
|
|
*/
|
|
@Test
|
|
public void testBadBlocks() {
|
|
// Fences
|
|
when(ground.getType()).thenReturn(Material.SPRUCE_FENCE);
|
|
assertFalse("Fence :" + Material.SPRUCE_FENCE.toString(), im.isSafeLocation(location));
|
|
// Signs
|
|
sign = Material.BIRCH_SIGN;
|
|
when(ground.getType()).thenReturn(sign);
|
|
assertFalse("Sign", im.isSafeLocation(location));
|
|
wallSign = Material.ACACIA_WALL_SIGN;
|
|
when(ground.getType()).thenReturn(wallSign);
|
|
assertFalse("Sign", im.isSafeLocation(location));
|
|
// Bad Blocks
|
|
Material[] badMats = {Material.CACTUS, Material.OAK_BOAT};
|
|
Arrays.asList(badMats).forEach(m -> {
|
|
when(ground.getType()).thenReturn(m);
|
|
assertFalse("Bad mat :" + m.toString(), im.isSafeLocation(location));
|
|
});
|
|
|
|
}
|
|
|
|
/**
|
|
* Test method for {@link world.bentobox.bentobox.managers.IslandsManager#isSafeLocation(org.bukkit.Location)}.
|
|
*/
|
|
@Test
|
|
public void testSolidBlocks() {
|
|
when(space1.getType()).thenReturn(Material.STONE);
|
|
assertFalse("Solid", im.isSafeLocation(location));
|
|
|
|
when(space1.getType()).thenReturn(Material.AIR);
|
|
when(space2.getType()).thenReturn(Material.STONE);
|
|
assertFalse("Solid", im.isSafeLocation(location));
|
|
|
|
when(space1.getType()).thenReturn(wallSign);
|
|
when(space2.getType()).thenReturn(Material.AIR);
|
|
assertTrue("Wall sign 1", im.isSafeLocation(location));
|
|
|
|
when(space1.getType()).thenReturn(Material.AIR);
|
|
when(space2.getType()).thenReturn(wallSign);
|
|
assertTrue("Wall sign 2", im.isSafeLocation(location));
|
|
|
|
when(space1.getType()).thenReturn(sign);
|
|
when(space2.getType()).thenReturn(Material.AIR);
|
|
assertTrue("Wall sign 1", im.isSafeLocation(location));
|
|
|
|
when(space1.getType()).thenReturn(Material.AIR);
|
|
when(space2.getType()).thenReturn(sign);
|
|
assertTrue("Wall sign 2", im.isSafeLocation(location));
|
|
}
|
|
|
|
/**
|
|
* Test method for
|
|
* {@link world.bentobox.bentobox.managers.IslandsManager#createIsland(org.bukkit.Location)}.
|
|
*/
|
|
@Test
|
|
public void testCreateIslandLocation() {
|
|
Island island = im.createIsland(location);
|
|
assertNotNull(island);
|
|
assertEquals(island.getCenter().getWorld(), location.getWorld());
|
|
}
|
|
|
|
/**
|
|
* Test method for
|
|
* {@link world.bentobox.bentobox.managers.IslandsManager#createIsland(org.bukkit.Location, java.util.UUID)}.
|
|
*/
|
|
@Test
|
|
public void testCreateIslandLocationUUID() {
|
|
UUID owner = UUID.randomUUID();
|
|
Island island = im.createIsland(location, owner);
|
|
assertNotNull(island);
|
|
assertEquals(island.getCenter().getWorld(), location.getWorld());
|
|
assertEquals(owner, island.getOwner());
|
|
}
|
|
|
|
/**
|
|
* Test method for
|
|
* {@link world.bentobox.bentobox.managers.IslandsManager#deleteIsland(world.bentobox.bentobox.database.objects.Island, boolean)}.
|
|
*/
|
|
@Test
|
|
public void testDeleteIslandIslandBooleanNoBlockRemoval() {
|
|
UUID owner = UUID.randomUUID();
|
|
Island island = im.createIsland(location, owner);
|
|
im.deleteIsland(island, false, owner);
|
|
assertNull(island.getOwner());
|
|
verify(pim).callEvent(any(IslandDeleteEvent.class));
|
|
}
|
|
|
|
/**
|
|
* Test method for
|
|
* {@link world.bentobox.bentobox.managers.IslandsManager#deleteIsland(world.bentobox.bentobox.database.objects.Island, boolean)}.
|
|
*/
|
|
@Test
|
|
public void testDeleteIslandIslandBooleanRemoveBlocks() {
|
|
verify(pim, never()).callEvent(any());
|
|
UUID owner = UUID.randomUUID();
|
|
Island island = im.createIsland(location, owner);
|
|
im.deleteIsland(island, true, owner);
|
|
assertNull(island.getOwner());
|
|
verify(pim).callEvent(any(IslandDeleteEvent.class));
|
|
}
|
|
|
|
/**
|
|
* Test method for
|
|
* {@link world.bentobox.bentobox.managers.IslandsManager#getIslandCount()}.
|
|
*/
|
|
@Test
|
|
public void testGetCount() {
|
|
assertEquals(0, im.getIslandCount());
|
|
im.createIsland(location, UUID.randomUUID());
|
|
assertEquals(1, im.getIslandCount());
|
|
}
|
|
|
|
/**
|
|
* Test method for
|
|
* {@link world.bentobox.bentobox.managers.IslandsManager#getIsland(World, User)}
|
|
*/
|
|
@Test
|
|
public void testGetIslandWorldUser() {
|
|
Island island = im.createIsland(location, user.getUniqueId());
|
|
assertEquals(island, im.getIsland(world, user));
|
|
assertNull(im.getIsland(world, (User) null));
|
|
}
|
|
|
|
/**
|
|
* Test method for
|
|
* {@link world.bentobox.bentobox.managers.IslandsManager#getIsland(World, UUID)}.
|
|
*/
|
|
@Test
|
|
public void testGetIsland() {
|
|
UUID owner = UUID.randomUUID();
|
|
Island island = im.createIsland(location, owner);
|
|
assertEquals(island, im.getIsland(world, owner));
|
|
assertNull(im.getIsland(world, UUID.randomUUID()));
|
|
}
|
|
|
|
/**
|
|
* Test method for
|
|
* {@link world.bentobox.bentobox.managers.IslandsManager#getIslandAt(org.bukkit.Location)}.
|
|
*/
|
|
@Test
|
|
public void testGetIslandAtLocation() throws Exception {
|
|
im.setIslandCache(islandCache);
|
|
// In world, correct island
|
|
assertEquals(optionalIsland, im.getIslandAt(location));
|
|
|
|
// in world, wrong island
|
|
when(islandCache.getIslandAt(any(Location.class))).thenReturn(null);
|
|
assertEquals(Optional.empty(), im.getIslandAt(new Location(world, 100000, 120, -100000)));
|
|
|
|
// not in world
|
|
when(iwm.inWorld(any(World.class))).thenReturn(false);
|
|
when(iwm.inWorld(any(Location.class))).thenReturn(false);
|
|
assertEquals(Optional.empty(), im.getIslandAt(new Location(world, 100000, 120, -100000)));
|
|
assertEquals(Optional.empty(), im.getIslandAt(location));
|
|
}
|
|
|
|
/**
|
|
* Test method for
|
|
* {@link world.bentobox.bentobox.managers.IslandsManager#getIslandLocation(World, UUID)}.
|
|
*/
|
|
@Test
|
|
public void testGetIslandLocation() {
|
|
Island i = im.createIsland(location, uuid);
|
|
assertEquals(world, im.getIslandLocation(world, uuid).getWorld());
|
|
assertEquals(i.getProtectionCenter(), im.getIslandLocation(world, uuid));
|
|
assertNull(im.getIslandLocation(world, UUID.randomUUID()));
|
|
}
|
|
|
|
/**
|
|
* Test method for
|
|
* {@link world.bentobox.bentobox.managers.IslandsManager#getLast(World)}.
|
|
*/
|
|
@Test
|
|
public void testGetLast() {
|
|
im.setLast(location);
|
|
assertEquals(location, im.getLast(world));
|
|
assertNull(im.getLast(null));
|
|
}
|
|
|
|
/**
|
|
* Test method for
|
|
* {@link world.bentobox.bentobox.managers.IslandsManager#getMembers(World, UUID)}.
|
|
*/
|
|
@Test
|
|
public void testGetMembers() {
|
|
// Mock island cache
|
|
Set<UUID> members = new HashSet<>();
|
|
members.add(UUID.randomUUID());
|
|
members.add(UUID.randomUUID());
|
|
members.add(UUID.randomUUID());
|
|
/*
|
|
* when(islandCache.getMembers(any(), any(),
|
|
* Mockito.anyInt())).thenReturn(members); im.setIslandCache(islandCache);
|
|
* assertEquals(members, im.getMembers(world, UUID.randomUUID()));
|
|
*/
|
|
}
|
|
|
|
/**
|
|
* Test method for
|
|
* {@link world.bentobox.bentobox.managers.IslandsManager#getProtectedIslandAt(org.bukkit.Location)}.
|
|
*/
|
|
@Test
|
|
public void testGetProtectedIslandAt() {
|
|
// Mock island cache
|
|
Island is = mock(Island.class);
|
|
|
|
when(islandCache.getIslandAt(any(Location.class))).thenReturn(is);
|
|
|
|
// In world
|
|
|
|
im.setIslandCache(islandCache);
|
|
|
|
Optional<Island> optionalIsland = Optional.ofNullable(is);
|
|
// In world, correct island
|
|
when(is.onIsland(any())).thenReturn(true);
|
|
assertEquals(optionalIsland, im.getProtectedIslandAt(location));
|
|
|
|
// Not in protected space
|
|
when(is.onIsland(any())).thenReturn(false);
|
|
assertEquals(Optional.empty(), im.getProtectedIslandAt(location));
|
|
|
|
im.setSpawn(is);
|
|
// In world, correct island
|
|
when(is.onIsland(any())).thenReturn(true);
|
|
assertEquals(optionalIsland, im.getProtectedIslandAt(location));
|
|
|
|
// Not in protected space
|
|
when(is.onIsland(any())).thenReturn(false);
|
|
assertEquals(Optional.empty(), im.getProtectedIslandAt(location));
|
|
}
|
|
|
|
/**
|
|
* Test method for
|
|
* {@link world.bentobox.bentobox.managers.IslandsManager#getSafeHomeLocation(World, User, int)}.
|
|
*/
|
|
/*
|
|
* @Test public void testGetSafeHomeLocation() { im.setIslandCache(islandCache);
|
|
* when(island.getHome(any())).thenReturn(location);
|
|
* when(iwm.inWorld(eq(world))).thenReturn(true); assertEquals(location,
|
|
* im.getSafeHomeLocation(world, user, ""));
|
|
*
|
|
* // Change location so that it is not safe // TODO }
|
|
*/
|
|
|
|
/**
|
|
* Test method for
|
|
* {@link world.bentobox.bentobox.managers.IslandsManager#getSafeHomeLocation(World, User, int)}.
|
|
* Ensures that the method returns {@code null} if the world is not an island
|
|
* world.
|
|
*/
|
|
/*
|
|
* @Test public void testGetSafeHomeLocationWorldNotIslandWorld() {
|
|
* when(iwm.inWorld(world)).thenReturn(false);
|
|
* assertNull(im.getSafeHomeLocation(world, user, "")); }
|
|
*/
|
|
|
|
/**
|
|
* Test method for
|
|
* {@link world.bentobox.bentobox.managers.IslandsManager#getSafeHomeLocation(World, User, int)}.
|
|
*/
|
|
/*
|
|
* @Test public void testGetSafeHomeLocationNoIsland() {
|
|
* assertNull(im.getSafeHomeLocation(world, user, ""));
|
|
* verify(plugin).logWarning(eq("null player has no island in world world!")); }
|
|
*/
|
|
|
|
/**
|
|
* Test method for
|
|
* {@link world.bentobox.bentobox.managers.IslandsManager#getSpawnPoint(World)}.
|
|
*/
|
|
@Test
|
|
public void testGetSpawnPoint() {
|
|
assertNull(im.getSpawnPoint(world));
|
|
// Create a spawn island for this world
|
|
Island island = mock(Island.class);
|
|
when(island.getWorld()).thenReturn(world);
|
|
// Make a spawn position on the island
|
|
when(island.getSpawnPoint(any())).thenReturn(location);
|
|
// Set the spawn island
|
|
im.setSpawn(island);
|
|
assertEquals(location, im.getSpawnPoint(world));
|
|
}
|
|
|
|
/**
|
|
* Test method for
|
|
* {@link world.bentobox.bentobox.managers.IslandsManager#isAtSpawn(org.bukkit.Location)}.
|
|
*/
|
|
@Test
|
|
public void testIsAtSpawn() {
|
|
assertFalse(im.isAtSpawn(location));
|
|
Island island = mock(Island.class);
|
|
when(island.getWorld()).thenReturn(world);
|
|
when(island.onIsland(any())).thenReturn(true);
|
|
im.setSpawn(island);
|
|
assertTrue(im.isAtSpawn(location));
|
|
}
|
|
|
|
/**
|
|
* Test method for
|
|
* {@link world.bentobox.bentobox.managers.IslandsManager#isOwner(World, UUID)}.
|
|
*/
|
|
/*
|
|
* @Test public void testIsOwner() { // Mock island cache Island is =
|
|
* mock(Island.class);
|
|
*
|
|
* when(islandCache.getIslandAt(any())).thenReturn(is);
|
|
*
|
|
*
|
|
* im.setIslandCache(islandCache);
|
|
*
|
|
* assertFalse(im.isOwner(world, null));
|
|
*
|
|
* when(islandCache.hasIsland(any(), any())).thenReturn(false);
|
|
* assertFalse(im.isOwner(world, UUID.randomUUID()));
|
|
*
|
|
* when(islandCache.hasIsland(any(), any())).thenReturn(true);
|
|
* when(islandCache.get(any(), any(UUID.class))).thenReturn(is); UUID owner =
|
|
* UUID.randomUUID(); when(is.getOwner()).thenReturn(owner); UUID notOwner =
|
|
* UUID.randomUUID(); while (owner.equals(notOwner)) { notOwner =
|
|
* UUID.randomUUID(); } assertFalse(im.isOwner(world, notOwner));
|
|
* assertTrue(im.isOwner(world, owner)); }
|
|
*/
|
|
/**
|
|
* Test method for
|
|
* {@link world.bentobox.bentobox.managers.IslandsManager#load()}.
|
|
*/
|
|
@Test
|
|
public void testLoad() {
|
|
//
|
|
// im.load();
|
|
|
|
}
|
|
|
|
/**
|
|
* Test method for
|
|
* {@link world.bentobox.bentobox.managers.IslandsManager#locationIsOnIsland(org.bukkit.entity.Player, org.bukkit.Location)}.
|
|
*/
|
|
@Test
|
|
public void testLocationIsOnIsland() {
|
|
// Mock island cache
|
|
Island is = mock(Island.class);
|
|
|
|
when(islandCache.getIslandAt(any(Location.class))).thenReturn(is);
|
|
|
|
// In world
|
|
when(is.onIsland(any())).thenReturn(true);
|
|
|
|
Builder<UUID> members = new ImmutableSet.Builder<>();
|
|
members.add(uuid);
|
|
when(is.getMemberSet()).thenReturn(members.build());
|
|
|
|
when(player.getUniqueId()).thenReturn(uuid);
|
|
|
|
im.setIslandCache(islandCache);
|
|
|
|
assertFalse(im.locationIsOnIsland(null, null));
|
|
|
|
assertTrue(im.locationIsOnIsland(player, location));
|
|
|
|
// No members
|
|
Builder<UUID> mem = new ImmutableSet.Builder<>();
|
|
when(is.getMemberSet()).thenReturn(mem.build());
|
|
assertFalse(im.locationIsOnIsland(player, location));
|
|
|
|
// Not on island
|
|
when(is.getMemberSet()).thenReturn(members.build());
|
|
when(is.onIsland(any())).thenReturn(false);
|
|
assertFalse(im.locationIsOnIsland(player, location));
|
|
}
|
|
|
|
/**
|
|
* Test method for {@link IslandsManager#userIsOnIsland(World, User)}.
|
|
*/
|
|
@Test
|
|
public void testUserIsOnIsland() {
|
|
im.setIslandCache(islandCache);
|
|
|
|
// ----- CHECK INVALID ARGUMENTS -----
|
|
|
|
// Null user
|
|
assertFalse(im.userIsOnIsland(world, null));
|
|
|
|
// Null world
|
|
assertFalse(im.userIsOnIsland(null, user));
|
|
|
|
// Both null user and null world
|
|
assertFalse(im.userIsOnIsland(null, null));
|
|
|
|
// User is not a player
|
|
when(user.isPlayer()).thenReturn(false);
|
|
assertFalse(im.userIsOnIsland(world, user));
|
|
|
|
// ----- CHECK MEMBERSHIP -----
|
|
// We assume there that the User is in the good World.
|
|
when(user.getLocation().getWorld()).thenReturn(world);
|
|
when(user.isPlayer()).thenReturn(true);
|
|
|
|
// The method returns true if the user's location is on an island that has them
|
|
// as member (rank >= MEMBER)
|
|
when(island.onIsland(any())).thenReturn(true);
|
|
Map<UUID, Integer> members = new HashMap<>();
|
|
when(island.getMembers()).thenReturn(members);
|
|
|
|
// -- The user is not part of the island --
|
|
assertFalse(im.userIsOnIsland(world, user));
|
|
|
|
// -- The user is the owner of the island --
|
|
members.put(user.getUniqueId(), RanksManager.OWNER_RANK);
|
|
assertTrue(im.userIsOnIsland(world, user));
|
|
|
|
// Add some members to see if it still works
|
|
members.put(UUID.randomUUID(), RanksManager.MEMBER_RANK);
|
|
members.put(UUID.randomUUID(), RanksManager.MEMBER_RANK);
|
|
members.put(UUID.randomUUID(), RanksManager.MEMBER_RANK);
|
|
members.put(UUID.randomUUID(), RanksManager.MEMBER_RANK);
|
|
members.put(UUID.randomUUID(), RanksManager.MEMBER_RANK);
|
|
members.put(UUID.randomUUID(), RanksManager.MEMBER_RANK);
|
|
members.put(UUID.randomUUID(), RanksManager.MEMBER_RANK);
|
|
assertTrue(im.userIsOnIsland(world, user));
|
|
|
|
// Add some other ranks to see if it still works
|
|
members.put(UUID.randomUUID(), RanksManager.BANNED_RANK);
|
|
members.put(UUID.randomUUID(), RanksManager.BANNED_RANK);
|
|
members.put(UUID.randomUUID(), RanksManager.COOP_RANK);
|
|
members.put(UUID.randomUUID(), RanksManager.TRUSTED_RANK);
|
|
members.put(UUID.randomUUID(), RanksManager.BANNED_RANK);
|
|
assertTrue(im.userIsOnIsland(world, user));
|
|
|
|
// -- The user is a sub-owner on the island --
|
|
members.put(user.getUniqueId(), RanksManager.SUB_OWNER_RANK);
|
|
assertTrue(im.userIsOnIsland(world, user));
|
|
|
|
// -- The user is a member on the island --
|
|
members.put(user.getUniqueId(), RanksManager.MEMBER_RANK);
|
|
assertTrue(im.userIsOnIsland(world, user));
|
|
|
|
// -- The user is a trusted on the island --
|
|
members.put(user.getUniqueId(), RanksManager.TRUSTED_RANK);
|
|
assertTrue(im.userIsOnIsland(world, user));
|
|
|
|
// -- The user is a coop on the island --
|
|
members.put(user.getUniqueId(), RanksManager.COOP_RANK);
|
|
assertTrue(im.userIsOnIsland(world, user));
|
|
|
|
// -- The user is a visitor on the island --
|
|
members.remove(user.getUniqueId());
|
|
assertFalse(im.userIsOnIsland(world, user));
|
|
|
|
// -- The user is explicitly a visitor on the island --
|
|
members.put(user.getUniqueId(), RanksManager.VISITOR_RANK);
|
|
assertFalse(im.userIsOnIsland(world, user));
|
|
|
|
// -- The user is banned from the island --
|
|
members.put(user.getUniqueId(), RanksManager.BANNED_RANK);
|
|
assertFalse(im.userIsOnIsland(world, user));
|
|
|
|
// ----- CHECK WORLD -----
|
|
// Assertions above succeeded, so let's check that again with the User being a
|
|
// MEMBER and being in the wrong world.
|
|
when(user.getLocation().getWorld()).thenReturn(mock(World.class));
|
|
members.put(user.getUniqueId(), RanksManager.MEMBER_RANK);
|
|
assertFalse(im.userIsOnIsland(world, user));
|
|
}
|
|
|
|
/**
|
|
* Test method for
|
|
* {@link world.bentobox.bentobox.managers.IslandsManager#removePlayer(World, User)}.
|
|
*/
|
|
@Test
|
|
public void testRemovePlayer() {
|
|
|
|
im.removePlayer(world, uuid);
|
|
}
|
|
|
|
/**
|
|
* Test method for
|
|
* {@link world.bentobox.bentobox.managers.IslandsManager#removePlayersFromIsland(world.bentobox.bentobox.database.objects.Island)}.
|
|
*/
|
|
@Test
|
|
public void testRemovePlayersFromIsland() {
|
|
|
|
Island is = mock(Island.class);
|
|
im.removePlayersFromIsland(is);
|
|
}
|
|
|
|
/**
|
|
* Test method for
|
|
* {@link world.bentobox.bentobox.managers.IslandsManager#save(Island)}.
|
|
*/
|
|
@Test
|
|
public void testSave() {
|
|
// fail("Not yet implemented"); // TODO - warning saving stuff will go on the
|
|
// file system
|
|
}
|
|
|
|
/**
|
|
* Test method for .
|
|
*/
|
|
@Test
|
|
public void testSetIslandName() {
|
|
// fail("Not yet implemented"); // TODO
|
|
}
|
|
|
|
/**
|
|
* Test method for
|
|
* {@link world.bentobox.bentobox.managers.IslandsManager#setJoinTeam(world.bentobox.bentobox.database.objects.Island, java.util.UUID)}.
|
|
*/
|
|
@Test
|
|
public void testSetJoinTeam() {
|
|
// fail("Not yet implemented"); // TODO
|
|
}
|
|
|
|
/**
|
|
* Test method for
|
|
* {@link world.bentobox.bentobox.managers.IslandsManager#setLast(org.bukkit.Location)}.
|
|
*/
|
|
@Test
|
|
public void testSetLast() {
|
|
// fail("Not yet implemented"); // TODO
|
|
}
|
|
|
|
/**
|
|
* Test method for .
|
|
*/
|
|
@Test
|
|
public void testSetLeaveTeam() {
|
|
// fail("Not yet implemented"); // TODO
|
|
}
|
|
|
|
/**
|
|
* Test method for
|
|
* {@link world.bentobox.bentobox.managers.IslandsManager#shutdown()}.
|
|
*/
|
|
@Test
|
|
public void testShutdown() {
|
|
// Mock island cache
|
|
Island is = mock(Island.class);
|
|
|
|
Collection<Island> collection = new ArrayList<>();
|
|
collection.add(is);
|
|
when(islandCache.getIslands()).thenReturn(collection);
|
|
|
|
im.setIslandCache(islandCache);
|
|
Map<UUID, Integer> members = new HashMap<>();
|
|
when(is.getMembers()).thenReturn(members);
|
|
// -- The user is the owner of the island --
|
|
members.put(user.getUniqueId(), RanksManager.OWNER_RANK);
|
|
// Add some members
|
|
members.put(UUID.randomUUID(), RanksManager.MEMBER_RANK);
|
|
members.put(UUID.randomUUID(), RanksManager.MEMBER_RANK);
|
|
members.put(UUID.randomUUID(), RanksManager.MEMBER_RANK);
|
|
members.put(UUID.randomUUID(), RanksManager.MEMBER_RANK);
|
|
members.put(UUID.randomUUID(), RanksManager.MEMBER_RANK);
|
|
members.put(UUID.randomUUID(), RanksManager.MEMBER_RANK);
|
|
members.put(UUID.randomUUID(), RanksManager.MEMBER_RANK);
|
|
// Add some coops
|
|
members.put(UUID.randomUUID(), RanksManager.COOP_RANK);
|
|
members.put(UUID.randomUUID(), RanksManager.COOP_RANK);
|
|
members.put(UUID.randomUUID(), RanksManager.COOP_RANK);
|
|
// Add some trusted
|
|
members.put(UUID.randomUUID(), RanksManager.TRUSTED_RANK);
|
|
members.put(UUID.randomUUID(), RanksManager.TRUSTED_RANK);
|
|
|
|
im.shutdown();
|
|
|
|
assertEquals(10, members.size());
|
|
verify(islandCache).clear();
|
|
}
|
|
|
|
/**
|
|
* Test method for
|
|
* {@link world.bentobox.bentobox.managers.IslandsManager#clearRank(int, UUID)}.
|
|
*/
|
|
@Test
|
|
public void testClearRank() {
|
|
// Mock island cache
|
|
Island is = mock(Island.class);
|
|
|
|
Collection<Island> collection = new ArrayList<>();
|
|
collection.add(is);
|
|
when(islandCache.getIslands()).thenReturn(collection);
|
|
|
|
im.setIslandCache(islandCache);
|
|
Map<UUID, Integer> members = new HashMap<>();
|
|
when(is.getMembers()).thenReturn(members);
|
|
// -- The user is the owner of the island --
|
|
members.put(user.getUniqueId(), RanksManager.OWNER_RANK);
|
|
// Add some members
|
|
members.put(UUID.randomUUID(), RanksManager.MEMBER_RANK);
|
|
members.put(UUID.randomUUID(), RanksManager.MEMBER_RANK);
|
|
members.put(UUID.randomUUID(), RanksManager.MEMBER_RANK);
|
|
members.put(UUID.randomUUID(), RanksManager.MEMBER_RANK);
|
|
members.put(UUID.randomUUID(), RanksManager.MEMBER_RANK);
|
|
members.put(UUID.randomUUID(), RanksManager.MEMBER_RANK);
|
|
members.put(UUID.randomUUID(), RanksManager.MEMBER_RANK);
|
|
// Add some coops
|
|
members.put(UUID.randomUUID(), RanksManager.COOP_RANK);
|
|
members.put(UUID.randomUUID(), RanksManager.COOP_RANK);
|
|
members.put(UUID.randomUUID(), RanksManager.COOP_RANK);
|
|
// Add some trusted
|
|
members.put(UUID.randomUUID(), RanksManager.TRUSTED_RANK);
|
|
members.put(UUID.randomUUID(), RanksManager.TRUSTED_RANK);
|
|
// Add specific coop
|
|
UUID coopUUID = UUID.randomUUID();
|
|
members.put(coopUUID, RanksManager.COOP_RANK);
|
|
// Clear a random user
|
|
im.clearRank(RanksManager.COOP_RANK, UUID.randomUUID());
|
|
assertEquals(14, members.size());
|
|
im.clearRank(RanksManager.COOP_RANK, coopUUID);
|
|
assertEquals(13, members.size());
|
|
}
|
|
|
|
/**
|
|
* Test method for {@link world.bentobox.bentobox.managers.IslandsManager#clearArea(Location)}.
|
|
*/
|
|
@Test
|
|
public void testClearAreaWrongWorld() {
|
|
when(iwm.inWorld(any(Location.class))).thenReturn(false);
|
|
im.clearArea(location);
|
|
// No entities should be cleared
|
|
verify(zombie, never()).remove();
|
|
verify(player, never()).remove();
|
|
verify(cow, never()).remove();
|
|
verify(slime, never()).remove();
|
|
verify(wither, never()).remove();
|
|
verify(creeper, never()).remove();
|
|
verify(pufferfish, never()).remove();
|
|
verify(skelly, never()).remove();
|
|
|
|
}
|
|
|
|
/**
|
|
* Test method for
|
|
* {@link world.bentobox.bentobox.managers.IslandsManager#clearArea(Location)}.
|
|
*/
|
|
@Test
|
|
public void testClearArea() {
|
|
im.clearArea(location);
|
|
// Only the correct entities should be cleared
|
|
verify(zombie).remove();
|
|
verify(player, never()).remove();
|
|
verify(cow, never()).remove();
|
|
verify(slime).remove();
|
|
verify(wither, never()).remove();
|
|
verify(creeper).remove();
|
|
verify(pufferfish, never()).remove();
|
|
verify(skelly, never()).remove();
|
|
}
|
|
|
|
/**
|
|
* Test method for
|
|
* {@link world.bentobox.bentobox.managers.IslandsManager#getIslandById(String)}.
|
|
*/
|
|
@Test
|
|
public void testGetIslandByIdString() {
|
|
Island island = mock(Island.class);
|
|
String uuid = UUID.randomUUID().toString();
|
|
when(islandCache.getIslandById(anyString())).thenReturn(island);
|
|
// Test
|
|
im.setIslandCache(islandCache);
|
|
assertEquals(island, im.getIslandById(uuid).get());
|
|
}
|
|
|
|
/**
|
|
* Test method for
|
|
* {@link world.bentobox.bentobox.managers.IslandsManager#fixIslandCenter(Island)}.
|
|
*/
|
|
@Test
|
|
public void testFixIslandCenter() {
|
|
Island island = mock(Island.class);
|
|
when(island.getWorld()).thenReturn(world);
|
|
// Island center
|
|
when(location.getBlockX()).thenReturn(0);
|
|
when(location.getBlockY()).thenReturn(120);
|
|
when(location.getBlockZ()).thenReturn(0);
|
|
when(island.getCenter()).thenReturn(location);
|
|
// Start x,z
|
|
when(iwm.getIslandStartX(eq(world))).thenReturn(0);
|
|
when(iwm.getIslandStartZ(eq(world))).thenReturn(0);
|
|
// Offset x,z
|
|
when(iwm.getIslandXOffset(eq(world))).thenReturn(0);
|
|
when(iwm.getIslandZOffset(eq(world))).thenReturn(0);
|
|
// World
|
|
when(iwm.inWorld(eq(world))).thenReturn(true);
|
|
// Island distance
|
|
when(iwm.getIslandDistance(eq(world))).thenReturn(100);
|
|
// Test
|
|
assertFalse(im.fixIslandCenter(island));
|
|
}
|
|
|
|
/**
|
|
* Test method for
|
|
* {@link world.bentobox.bentobox.managers.IslandsManager#fixIslandCenter(Island)}.
|
|
*/
|
|
@Test
|
|
public void testFixIslandCenterOff() {
|
|
Island island = mock(Island.class);
|
|
when(island.getWorld()).thenReturn(world);
|
|
// Island center
|
|
when(location.getBlockX()).thenReturn(10);
|
|
when(location.getBlockY()).thenReturn(120);
|
|
when(location.getBlockZ()).thenReturn(-10);
|
|
when(island.getCenter()).thenReturn(location);
|
|
// Start x,z
|
|
when(iwm.getIslandStartX(eq(world))).thenReturn(0);
|
|
when(iwm.getIslandStartZ(eq(world))).thenReturn(0);
|
|
// Offset x,z
|
|
when(iwm.getIslandXOffset(eq(world))).thenReturn(0);
|
|
when(iwm.getIslandZOffset(eq(world))).thenReturn(0);
|
|
// World
|
|
when(iwm.inWorld(eq(world))).thenReturn(true);
|
|
// Island distance
|
|
when(iwm.getIslandDistance(eq(world))).thenReturn(100);
|
|
// Test
|
|
ArgumentCaptor<Location> captor = ArgumentCaptor.forClass(Location.class);
|
|
assertTrue(im.fixIslandCenter(island));
|
|
// Verify location
|
|
verify(island).setCenter(captor.capture());
|
|
assertEquals(world, captor.getValue().getWorld());
|
|
assertEquals(0, captor.getValue().getBlockX());
|
|
assertEquals(120, captor.getValue().getBlockY());
|
|
assertEquals(0, captor.getValue().getBlockZ());
|
|
|
|
}
|
|
|
|
/**
|
|
* Test method for
|
|
* {@link world.bentobox.bentobox.managers.IslandsManager#fixIslandCenter(Island)}.
|
|
*/
|
|
@Test
|
|
public void testFixIslandCenterOffStart() {
|
|
Island island = mock(Island.class);
|
|
when(island.getWorld()).thenReturn(world);
|
|
// Island center
|
|
when(location.getBlockX()).thenReturn(100010);
|
|
when(location.getBlockY()).thenReturn(120);
|
|
when(location.getBlockZ()).thenReturn(8755);
|
|
when(island.getCenter()).thenReturn(location);
|
|
// Start x,z
|
|
when(iwm.getIslandStartX(eq(world))).thenReturn(100000);
|
|
when(iwm.getIslandStartZ(eq(world))).thenReturn(8765);
|
|
// Offset x,z
|
|
when(iwm.getIslandXOffset(eq(world))).thenReturn(0);
|
|
when(iwm.getIslandZOffset(eq(world))).thenReturn(0);
|
|
// World
|
|
when(iwm.inWorld(eq(world))).thenReturn(true);
|
|
// Island distance
|
|
when(iwm.getIslandDistance(eq(world))).thenReturn(100);
|
|
// Test
|
|
ArgumentCaptor<Location> captor = ArgumentCaptor.forClass(Location.class);
|
|
assertTrue(im.fixIslandCenter(island));
|
|
// Verify location
|
|
verify(island).setCenter(captor.capture());
|
|
assertEquals(world, captor.getValue().getWorld());
|
|
assertEquals(100000, captor.getValue().getBlockX());
|
|
assertEquals(120, captor.getValue().getBlockY());
|
|
assertEquals(8765, captor.getValue().getBlockZ());
|
|
|
|
}
|
|
|
|
/**
|
|
* Test method for
|
|
* {@link world.bentobox.bentobox.managers.IslandsManager#fixIslandCenter(Island)}.
|
|
*/
|
|
@Test
|
|
public void testFixIslandCenterStartOnGrid() {
|
|
Island island = mock(Island.class);
|
|
when(island.getWorld()).thenReturn(world);
|
|
// Island center
|
|
when(location.getBlockX()).thenReturn(10000);
|
|
when(location.getBlockY()).thenReturn(120);
|
|
when(location.getBlockZ()).thenReturn(8765);
|
|
when(island.getCenter()).thenReturn(location);
|
|
// Start x,z
|
|
when(iwm.getIslandStartX(eq(world))).thenReturn(100000);
|
|
when(iwm.getIslandStartZ(eq(world))).thenReturn(8765);
|
|
// Offset x,z
|
|
when(iwm.getIslandXOffset(eq(world))).thenReturn(0);
|
|
when(iwm.getIslandZOffset(eq(world))).thenReturn(0);
|
|
// World
|
|
when(iwm.inWorld(eq(world))).thenReturn(true);
|
|
// Island distance
|
|
when(iwm.getIslandDistance(eq(world))).thenReturn(100);
|
|
// Test
|
|
assertFalse(im.fixIslandCenter(island));
|
|
}
|
|
|
|
/**
|
|
* Test method for
|
|
* {@link world.bentobox.bentobox.managers.IslandsManager#fixIslandCenter(Island)}.
|
|
*/
|
|
@Test
|
|
public void testFixIslandCenterStartOnGridOffset() {
|
|
Island island = mock(Island.class);
|
|
when(island.getWorld()).thenReturn(world);
|
|
// Island center
|
|
when(location.getBlockX()).thenReturn(10050);
|
|
when(location.getBlockY()).thenReturn(120);
|
|
when(location.getBlockZ()).thenReturn(8815);
|
|
when(island.getCenter()).thenReturn(location);
|
|
// Start x,z
|
|
when(iwm.getIslandStartX(eq(world))).thenReturn(100000);
|
|
when(iwm.getIslandStartZ(eq(world))).thenReturn(8765);
|
|
// Offset x,z
|
|
when(iwm.getIslandXOffset(eq(world))).thenReturn(50);
|
|
when(iwm.getIslandZOffset(eq(world))).thenReturn(50);
|
|
// World
|
|
when(iwm.inWorld(eq(world))).thenReturn(true);
|
|
// Island distance
|
|
when(iwm.getIslandDistance(eq(world))).thenReturn(100);
|
|
// Test
|
|
assertFalse(im.fixIslandCenter(island));
|
|
}
|
|
|
|
/**
|
|
* Test method for
|
|
* {@link world.bentobox.bentobox.managers.IslandsManager#fixIslandCenter(Island)}.
|
|
*/
|
|
@Test
|
|
public void testFixIslandCenterOffStartOffOffset() {
|
|
Island island = mock(Island.class);
|
|
when(island.getWorld()).thenReturn(world);
|
|
// Island center
|
|
when(location.getBlockX()).thenReturn(100060);
|
|
when(location.getBlockY()).thenReturn(120);
|
|
when(location.getBlockZ()).thenReturn(8815);
|
|
when(island.getCenter()).thenReturn(location);
|
|
// Start x,z
|
|
when(iwm.getIslandStartX(eq(world))).thenReturn(100000);
|
|
when(iwm.getIslandStartZ(eq(world))).thenReturn(8765);
|
|
// Offset x,z
|
|
when(iwm.getIslandXOffset(eq(world))).thenReturn(50);
|
|
when(iwm.getIslandZOffset(eq(world))).thenReturn(50);
|
|
// World
|
|
when(iwm.inWorld(eq(world))).thenReturn(true);
|
|
// Island distance
|
|
when(iwm.getIslandDistance(eq(world))).thenReturn(100);
|
|
// Test
|
|
ArgumentCaptor<Location> captor = ArgumentCaptor.forClass(Location.class);
|
|
assertTrue(im.fixIslandCenter(island));
|
|
// Verify location
|
|
verify(island).setCenter(captor.capture());
|
|
assertEquals(world, captor.getValue().getWorld());
|
|
assertEquals(100050, captor.getValue().getBlockX());
|
|
assertEquals(120, captor.getValue().getBlockY());
|
|
assertEquals(8815, captor.getValue().getBlockZ());
|
|
|
|
}
|
|
|
|
/**
|
|
* Test method for
|
|
* {@link world.bentobox.bentobox.managers.IslandsManager#fixIslandCenter(Island)}.
|
|
*/
|
|
@Test
|
|
public void testFixIslandCenterNulls() {
|
|
Island island = mock(Island.class);
|
|
when(island.getWorld()).thenReturn(null);
|
|
// Test
|
|
assertFalse(im.fixIslandCenter(island));
|
|
when(island.getWorld()).thenReturn(world);
|
|
when(island.getCenter()).thenReturn(null);
|
|
assertFalse(im.fixIslandCenter(island));
|
|
when(island.getCenter()).thenReturn(location);
|
|
when(iwm.inWorld(eq(world))).thenReturn(false);
|
|
assertFalse(im.fixIslandCenter(island));
|
|
}
|
|
|
|
/**
|
|
* Test method for
|
|
* {@link world.bentobox.bentobox.managers.IslandsManager#getMaxMembers(Island, Integer)}.
|
|
*/
|
|
@Test
|
|
public void testGetMaxMembersNoOwner() {
|
|
Island island = mock(Island.class);
|
|
when(island.getOwner()).thenReturn(null);
|
|
// Test
|
|
assertEquals(0, im.getMaxMembers(island, RanksManager.MEMBER_RANK));
|
|
verify(island).setMaxMembers(eq(null));
|
|
}
|
|
|
|
/**
|
|
* Test method for
|
|
* {@link world.bentobox.bentobox.managers.IslandsManager#getMaxMembers(Island, Integer)}.
|
|
*/
|
|
@Test
|
|
public void testGetMaxMembersOfflineOwner() {
|
|
Island island = mock(Island.class);
|
|
when(island.getOwner()).thenReturn(uuid);
|
|
when(island.getWorld()).thenReturn(world);
|
|
when(island.getMaxMembers()).thenReturn(null);
|
|
when(island.getMaxMembers(Mockito.anyInt())).thenReturn(null);
|
|
when(iwm.getMaxTeamSize(eq(world))).thenReturn(4);
|
|
// Offline owner
|
|
when(Bukkit.getPlayer(any(UUID.class))).thenReturn(null);
|
|
// Test
|
|
assertEquals(4, im.getMaxMembers(island, RanksManager.MEMBER_RANK));
|
|
verify(island).setMaxMembers(eq(RanksManager.MEMBER_RANK), eq(null));
|
|
}
|
|
|
|
/**
|
|
* Test method for
|
|
* {@link world.bentobox.bentobox.managers.IslandsManager#getMaxMembers(Island, Integer)}.
|
|
*/
|
|
@Test
|
|
public void testGetMaxMembersOnlineOwnerNoPerms() {
|
|
Island island = mock(Island.class);
|
|
when(island.getOwner()).thenReturn(uuid);
|
|
when(island.getWorld()).thenReturn(world);
|
|
when(island.getMaxMembers()).thenReturn(null);
|
|
when(island.getMaxMembers(Mockito.anyInt())).thenReturn(null);
|
|
when(iwm.getMaxTeamSize(eq(world))).thenReturn(4);
|
|
// Online owner
|
|
when(Bukkit.getPlayer(any(UUID.class))).thenReturn(player);
|
|
// Test
|
|
assertEquals(4, im.getMaxMembers(island, RanksManager.MEMBER_RANK));
|
|
verify(island).setMaxMembers(eq(RanksManager.MEMBER_RANK), eq(null));
|
|
}
|
|
|
|
/**
|
|
* Test method for
|
|
* {@link world.bentobox.bentobox.managers.IslandsManager#getMaxMembers(Island, Integer)}.
|
|
*/
|
|
@Test
|
|
public void testGetMaxMembersOnlineOwnerNoPermsCoopTrust() {
|
|
Island island = mock(Island.class);
|
|
when(island.getOwner()).thenReturn(uuid);
|
|
when(island.getWorld()).thenReturn(world);
|
|
when(island.getMaxMembers()).thenReturn(null);
|
|
when(island.getMaxMembers(Mockito.anyInt())).thenReturn(null);
|
|
when(iwm.getMaxTeamSize(eq(world))).thenReturn(4);
|
|
when(iwm.getMaxCoopSize(eq(world))).thenReturn(2);
|
|
when(iwm.getMaxTrustSize(eq(world))).thenReturn(3);
|
|
// Online owner
|
|
when(Bukkit.getPlayer(any(UUID.class))).thenReturn(player);
|
|
// Test
|
|
assertEquals(2, im.getMaxMembers(island, RanksManager.COOP_RANK));
|
|
verify(island).setMaxMembers(eq(RanksManager.COOP_RANK), eq(null));
|
|
assertEquals(3, im.getMaxMembers(island, RanksManager.TRUSTED_RANK));
|
|
verify(island).setMaxMembers(eq(RanksManager.TRUSTED_RANK), eq(null));
|
|
}
|
|
|
|
/**
|
|
* Test method for
|
|
* {@link world.bentobox.bentobox.managers.IslandsManager#getMaxMembers(Island, Integer)}.
|
|
*/
|
|
@Test
|
|
public void testGetMaxMembersOnlineOwnerNoPermsPreset() {
|
|
Island island = mock(Island.class);
|
|
when(island.getOwner()).thenReturn(uuid);
|
|
when(island.getWorld()).thenReturn(world);
|
|
when(island.getMaxMembers(eq(RanksManager.MEMBER_RANK))).thenReturn(10);
|
|
when(iwm.getMaxTeamSize(eq(world))).thenReturn(4);
|
|
// Online owner
|
|
when(Bukkit.getPlayer(any(UUID.class))).thenReturn(player);
|
|
// Test
|
|
assertEquals(10, im.getMaxMembers(island, RanksManager.MEMBER_RANK));
|
|
verify(island).setMaxMembers(eq(RanksManager.MEMBER_RANK), eq(10));
|
|
}
|
|
|
|
/**
|
|
* Test method for
|
|
* {@link world.bentobox.bentobox.managers.IslandsManager#getMaxMembers(Island, Integer)}.
|
|
*/
|
|
@Test
|
|
public void testGetMaxMembersOnlineOwnerNoPermsPresetLessThanDefault() {
|
|
Island island = mock(Island.class);
|
|
when(island.getOwner()).thenReturn(uuid);
|
|
when(island.getWorld()).thenReturn(world);
|
|
when(island.getMaxMembers(eq(RanksManager.MEMBER_RANK))).thenReturn(10);
|
|
when(iwm.getMaxTeamSize(eq(world))).thenReturn(40);
|
|
// Online owner
|
|
when(Bukkit.getPlayer(any(UUID.class))).thenReturn(player);
|
|
// Test
|
|
assertEquals(10, im.getMaxMembers(island, RanksManager.MEMBER_RANK));
|
|
verify(island).setMaxMembers(eq(RanksManager.MEMBER_RANK), eq(10));
|
|
}
|
|
|
|
/**
|
|
* Test method for
|
|
* {@link world.bentobox.bentobox.managers.IslandsManager#getMaxMembers(Island, Integer)}.
|
|
*/
|
|
@Test
|
|
public void testGetMaxMembersOnlineOwnerHasPerm() {
|
|
Island island = mock(Island.class);
|
|
when(island.getOwner()).thenReturn(uuid);
|
|
when(island.getWorld()).thenReturn(world);
|
|
when(island.getMaxMembers()).thenReturn(null);
|
|
when(iwm.getMaxTeamSize(eq(world))).thenReturn(4);
|
|
// Permission
|
|
when(iwm.getPermissionPrefix(any())).thenReturn("bskyblock.");
|
|
PermissionAttachmentInfo pai = mock(PermissionAttachmentInfo.class);
|
|
when(pai.getValue()).thenReturn(true);
|
|
when(pai.getPermission()).thenReturn("bskyblock.team.maxsize.8");
|
|
Set<PermissionAttachmentInfo> set = Collections.singleton(pai);
|
|
when(player.getEffectivePermissions()).thenReturn(set);
|
|
// Online owner
|
|
when(Bukkit.getPlayer(any(UUID.class))).thenReturn(player);
|
|
// Test
|
|
assertEquals(8, im.getMaxMembers(island, RanksManager.MEMBER_RANK));
|
|
verify(island).setMaxMembers(eq(RanksManager.MEMBER_RANK), eq(8));
|
|
}
|
|
|
|
/**
|
|
* Test method for
|
|
* {@link world.bentobox.bentobox.managers.IslandsManager#setMaxMembers(Island, Integer, Integer)}.
|
|
*/
|
|
@Test
|
|
public void testsetMaxMembers() {
|
|
Island island = mock(Island.class);
|
|
// Test
|
|
im.setMaxMembers(island, RanksManager.MEMBER_RANK, 40);
|
|
verify(island).setMaxMembers(eq(RanksManager.MEMBER_RANK), eq(40));
|
|
}
|
|
|
|
/**
|
|
* Test method for
|
|
* {@link world.bentobox.bentobox.managers.IslandsManager#getMaxHomes(Island)}.
|
|
*/
|
|
@Test
|
|
public void testGetMaxHomesOnlineOwnerHasPerm() {
|
|
Island island = mock(Island.class);
|
|
when(island.getOwner()).thenReturn(uuid);
|
|
when(island.getWorld()).thenReturn(world);
|
|
when(island.getMaxHomes()).thenReturn(null);
|
|
when(iwm.getMaxHomes(eq(world))).thenReturn(4);
|
|
// Permission
|
|
when(iwm.getPermissionPrefix(any())).thenReturn("bskyblock.");
|
|
PermissionAttachmentInfo pai = mock(PermissionAttachmentInfo.class);
|
|
when(pai.getValue()).thenReturn(true);
|
|
when(pai.getPermission()).thenReturn("bskyblock.island.maxhomes.8");
|
|
Set<PermissionAttachmentInfo> set = Collections.singleton(pai);
|
|
when(player.getEffectivePermissions()).thenReturn(set);
|
|
// Online owner
|
|
when(Bukkit.getPlayer(any(UUID.class))).thenReturn(player);
|
|
// Test
|
|
IslandsManager im = new IslandsManager(plugin);
|
|
assertEquals(8, im.getMaxHomes(island));
|
|
verify(island).setMaxHomes(eq(8));
|
|
}
|
|
|
|
/**
|
|
* Test method for
|
|
* {@link world.bentobox.bentobox.managers.IslandsManager#getMaxHomes(Island)}.
|
|
*/
|
|
@Test
|
|
public void testGetMaxHomesOnlineOwnerHasNoPerm() {
|
|
Island island = mock(Island.class);
|
|
when(island.getOwner()).thenReturn(uuid);
|
|
when(island.getWorld()).thenReturn(world);
|
|
when(island.getMaxHomes()).thenReturn(null);
|
|
when(iwm.getMaxHomes(eq(world))).thenReturn(4);
|
|
// Permission
|
|
when(iwm.getPermissionPrefix(any())).thenReturn("bskyblock.");
|
|
PermissionAttachmentInfo pai = mock(PermissionAttachmentInfo.class);
|
|
when(pai.getValue()).thenReturn(true);
|
|
when(pai.getPermission()).thenReturn("bskyblock.island.something.else");
|
|
Set<PermissionAttachmentInfo> set = Collections.singleton(pai);
|
|
when(player.getEffectivePermissions()).thenReturn(set);
|
|
// Online owner
|
|
when(Bukkit.getPlayer(any(UUID.class))).thenReturn(player);
|
|
// Test
|
|
IslandsManager im = new IslandsManager(plugin);
|
|
assertEquals(4, im.getMaxHomes(island));
|
|
verify(island).setMaxHomes(eq(null));
|
|
}
|
|
|
|
/**
|
|
* Test method for
|
|
* {@link world.bentobox.bentobox.managers.IslandsManager#getMaxHomes(Island)}.
|
|
*/
|
|
@Test
|
|
public void testGetMaxHomesIslandSetOnlineOwner() {
|
|
Island island = mock(Island.class);
|
|
when(island.getOwner()).thenReturn(uuid);
|
|
when(island.getWorld()).thenReturn(world);
|
|
when(island.getMaxHomes()).thenReturn(20);
|
|
when(iwm.getMaxHomes(eq(world))).thenReturn(4);
|
|
// Permission
|
|
when(iwm.getPermissionPrefix(any())).thenReturn("bskyblock.");
|
|
PermissionAttachmentInfo pai = mock(PermissionAttachmentInfo.class);
|
|
when(pai.getValue()).thenReturn(true);
|
|
when(pai.getPermission()).thenReturn("bskyblock.island.something.else");
|
|
Set<PermissionAttachmentInfo> set = Collections.singleton(pai);
|
|
when(player.getEffectivePermissions()).thenReturn(set);
|
|
// Online owner
|
|
when(Bukkit.getPlayer(any(UUID.class))).thenReturn(player);
|
|
// Test
|
|
IslandsManager im = new IslandsManager(plugin);
|
|
assertEquals(20, im.getMaxHomes(island));
|
|
verify(island).setMaxHomes(eq(20));
|
|
}
|
|
|
|
/**
|
|
* Test method for
|
|
* {@link world.bentobox.bentobox.managers.IslandsManager#getMaxHomes(Island)}.
|
|
*/
|
|
@Test
|
|
public void testGetMaxHomesIslandSetOnlineOwnerLowerPerm() {
|
|
Island island = mock(Island.class);
|
|
when(island.getOwner()).thenReturn(uuid);
|
|
when(island.getWorld()).thenReturn(world);
|
|
when(island.getMaxHomes()).thenReturn(20);
|
|
when(iwm.getMaxHomes(eq(world))).thenReturn(4);
|
|
// Permission
|
|
when(iwm.getPermissionPrefix(any())).thenReturn("bskyblock.");
|
|
PermissionAttachmentInfo pai = mock(PermissionAttachmentInfo.class);
|
|
when(pai.getValue()).thenReturn(true);
|
|
when(pai.getPermission()).thenReturn("bskyblock.island.maxhomes.8");
|
|
Set<PermissionAttachmentInfo> set = Collections.singleton(pai);
|
|
when(player.getEffectivePermissions()).thenReturn(set);
|
|
// Online owner
|
|
when(Bukkit.getPlayer(any(UUID.class))).thenReturn(player);
|
|
// Test
|
|
IslandsManager im = new IslandsManager(plugin);
|
|
assertEquals(8, im.getMaxHomes(island));
|
|
verify(island).setMaxHomes(eq(8));
|
|
}
|
|
|
|
/**
|
|
* Test method for
|
|
* {@link world.bentobox.bentobox.managers.IslandsManager#setMaxHomes(Island, Integer)}.
|
|
*/
|
|
@Test
|
|
public void testsetMaxHomes() {
|
|
Island island = mock(Island.class);
|
|
// Test
|
|
IslandsManager im = new IslandsManager(plugin);
|
|
im.setMaxHomes(island, 40);
|
|
verify(island).setMaxHomes(eq(40));
|
|
}
|
|
}
|