public void registerServerAliases() { Map<String, String[]> values = server.getCommandAliases(); for (String alias : values.keySet()) { if (alias.contains(":") || alias.contains(" ")) { server .getLogger() .warning( "Could not register alias " + alias + " because it contains illegal characters"); continue; } String[] commandStrings = values.get(alias); List<String> targets = new ArrayList<String>(); StringBuilder bad = new StringBuilder(); for (String commandString : commandStrings) { String[] commandArgs = commandString.split(" "); Command command = getCommand(commandArgs[0]); if (command == null) { if (bad.length() > 0) { bad.append(", "); } bad.append(commandString); } else { targets.add(commandString); } } if (bad.length() > 0) { server .getLogger() .warning( "Could not register alias " + alias + " because it contains commands that do not exist: " + bad); continue; } // We register these as commands so they have absolute priority. if (targets.size() > 0) { knownCommands.put( alias.toLowerCase(), new FormattedCommandAlias( alias.toLowerCase(), targets.toArray(new String[targets.size()]))); } else { knownCommands.remove(alias.toLowerCase()); } } }
public void enablePlugin(final Plugin plugin) { if (!(plugin instanceof JavaPlugin)) { throw new IllegalArgumentException("Plugin is not associated with this PluginLoader"); } if (!plugin.isEnabled()) { JavaPlugin jPlugin = (JavaPlugin) plugin; String pluginName = jPlugin.getDescription().getName(); if (!loaders.containsKey(pluginName)) { loaders.put(pluginName, (PluginClassLoader) jPlugin.getClassLoader()); } try { jPlugin.setEnabled(true); } catch (Throwable ex) { server .getLogger() .log( Level.SEVERE, "Error occurred while enabling " + plugin.getDescription().getFullName() + " (Is it up to date?): " + ex.getMessage(), ex); } // Perhaps abort here, rather than continue going, but as it stands, // an abort is not possible the way it's currently written server.getPluginManager().callEvent(new PluginEnableEvent(plugin)); } }
public void onEnable() { // TODO: Place any custom enable code here including the registration of any events // Setup Plugin Member Variables server = getServer(); log = server.getLogger(); commandMap = new CommandsManager<Player>() { @Override public boolean hasPermission(Player player, String perm) { // TODO: Implement Permissions return true; } }; dungeons = new HashMap<String, Dungeon>(); editSessions = new HashMap<Player, EditSession>(); PluginManager pm = getServer().getPluginManager(); try { // Register our events pm.registerEvent(Event.Type.ENTITY_DAMAGE, entityListener, Priority.Normal, this); pm.registerEvent(Event.Type.ENTITY_DEATH, entityListener, Priority.Normal, this); pm.registerEvent(Event.Type.ENTITY_COMBUST, entityListener, Priority.Normal, this); pm.registerEvent(Event.Type.ENTITY_EXPLODE, entityListener, Priority.Normal, this); pm.registerEvent(Event.Type.ENTITY_TARGET, entityListener, Priority.Normal, this); } catch (Exception e) { log.info("Exception while registering events."); log.info(e.getMessage()); } try { // Setup PlayerListener class to preprocess command events pm.registerEvent(Event.Type.PLAYER_COMMAND_PREPROCESS, playerListener, Priority.Normal, this); pm.registerEvent(Event.Type.PLAYER_MOVE, playerListener, Priority.Normal, this); // Register Commands to the command map commandMap.register(LairDungeonCommand.class); } catch (Exception e) { log.info("Exception Registering Commands: "); log.info(e.getMessage()); } // Say Hello log.info("Legends.Lair Hello!"); }
private void fireEvent(Event event) { HandlerList handlers = event.getHandlers(); RegisteredListener[] listeners = handlers.getRegisteredListeners(); for (RegisteredListener registration : listeners) { if (!registration.getPlugin().isEnabled()) { continue; } try { registration.callEvent(event); } catch (AuthorNagException ex) { Plugin plugin = registration.getPlugin(); if (plugin.isNaggable()) { plugin.setNaggable(false); server .getLogger() .log( Level.SEVERE, String.format( "Nag author(s): '%s' of '%s' about the following: %s", plugin.getDescription().getAuthors(), plugin.getDescription().getFullName(), ex.getMessage())); } } catch (Throwable ex) { server .getLogger() .log( Level.SEVERE, "Could not pass event " + event.getEventName() + " to " + registration.getPlugin().getDescription().getFullName(), ex); } } }
@Before public void beforeTest() { pluginManager = Mockito.mock(PluginManager.class); server = Mockito.mock(Server.class); Mockito.when(server.getPluginManager()).thenReturn(pluginManager); Mockito.when(server.getLogger()).thenReturn(Logger.getAnonymousLogger()); core = new DummyExpCraft(server); testModule = new DummyModule(); testModule.setInfo(new ModuleInfo("Test", "T", null)); testModule.setTranslator(new FallbackModuleTranslation(core.getTranslator(), testModule)); core.setTestModule(testModule); cmd = new CommandManager(core); }
public void disablePlugin(Plugin plugin) { if (!(plugin instanceof JavaPlugin)) { throw new IllegalArgumentException("Plugin is not associated with this PluginLoader"); } if (plugin.isEnabled()) { JavaPlugin jPlugin = (JavaPlugin) plugin; ClassLoader cloader = jPlugin.getClassLoader(); try { jPlugin.setEnabled(false); } catch (Throwable ex) { server .getLogger() .log( Level.SEVERE, "Error occurred while disabling " + plugin.getDescription().getFullName() + " (Is it up to date?): " + ex.getMessage(), ex); } server.getPluginManager().callEvent(new PluginDisableEvent(plugin)); loaders.remove(jPlugin.getDescription().getName()); if (cloader instanceof PluginClassLoader) { PluginClassLoader loader = (PluginClassLoader) cloader; Set<String> names = loader.getClasses(); for (String name : names) { removeClass(name); } } } }
public void enablePlugin(final Plugin plugin) { if (!plugin.isEnabled()) { List<Command> pluginCommands = PluginCommandYamlParser.parse(plugin); if (!pluginCommands.isEmpty()) { commandMap.registerAll(plugin.getDescription().getName(), pluginCommands); } try { plugin.getPluginLoader().enablePlugin(plugin); } catch (Throwable ex) { server .getLogger() .log( Level.SEVERE, "Error occurred (in the plugin loader) while enabling " + plugin.getDescription().getFullName() + " (Is it up to date?)", ex); } HandlerList.bakeAll(); } }
public void disablePlugin(final Plugin plugin) { if (plugin.isEnabled()) { try { plugin.getPluginLoader().disablePlugin(plugin); } catch (Throwable ex) { server .getLogger() .log( Level.SEVERE, "Error occurred (in the plugin loader) while disabling " + plugin.getDescription().getFullName() + " (Is it up to date?)", ex); } try { server.getScheduler().cancelTasks(plugin); } catch (Throwable ex) { server .getLogger() .log( Level.SEVERE, "Error occurred (in the plugin loader) while cancelling tasks for " + plugin.getDescription().getFullName() + " (Is it up to date?)", ex); } try { server.getServicesManager().unregisterAll(plugin); } catch (Throwable ex) { server .getLogger() .log( Level.SEVERE, "Error occurred (in the plugin loader) while unregistering services for " + plugin.getDescription().getFullName() + " (Is it up to date?)", ex); } try { HandlerList.unregisterAll(plugin); } catch (Throwable ex) { server .getLogger() .log( Level.SEVERE, "Error occurred (in the plugin loader) while unregistering events for " + plugin.getDescription().getFullName() + " (Is it up to date?)", ex); } try { server.getMessenger().unregisterIncomingPluginChannel(plugin); server.getMessenger().unregisterOutgoingPluginChannel(plugin); } catch (Throwable ex) { server .getLogger() .log( Level.SEVERE, "Error occurred (in the plugin loader) while unregistering plugin channels for " + plugin.getDescription().getFullName() + " (Is it up to date?)", ex); } } }
/** * Loads the plugins contained within the specified directory * * @param directory Directory to check for plugins * @return A list of all plugins loaded */ public Plugin[] loadPlugins(File directory) { Validate.notNull(directory, "Directory cannot be null"); Validate.isTrue(directory.isDirectory(), "Directory must be a directory"); List<Plugin> result = new ArrayList<Plugin>(); Set<Pattern> filters = fileAssociations.keySet(); if (!(server.getUpdateFolder().equals(""))) { updateDirectory = new File(directory, server.getUpdateFolder()); } Map<String, File> plugins = new HashMap<String, File>(); Set<String> loadedPlugins = new HashSet<String>(); Map<String, Collection<String>> dependencies = new HashMap<String, Collection<String>>(); Map<String, Collection<String>> softDependencies = new HashMap<String, Collection<String>>(); // This is where it figures out all possible plugins for (File file : directory.listFiles()) { PluginLoader loader = null; for (Pattern filter : filters) { Matcher match = filter.matcher(file.getName()); if (match.find()) { loader = fileAssociations.get(filter); } } if (loader == null) continue; PluginDescriptionFile description = null; try { description = loader.getPluginDescription(file); } catch (InvalidDescriptionException ex) { server .getLogger() .log( Level.SEVERE, "Could not load '" + file.getPath() + "' in folder '" + directory.getPath() + "'", ex); continue; } plugins.put(description.getName(), file); Collection<String> softDependencySet = description.getSoftDepend(); if (softDependencySet != null) { if (softDependencies.containsKey(description.getName())) { // Duplicates do not matter, they will be removed together if applicable softDependencies.get(description.getName()).addAll(softDependencySet); } else { softDependencies.put(description.getName(), new LinkedList<String>(softDependencySet)); } } Collection<String> dependencySet = description.getDepend(); if (dependencySet != null) { dependencies.put(description.getName(), new LinkedList<String>(dependencySet)); } Collection<String> loadBeforeSet = description.getLoadBefore(); if (loadBeforeSet != null) { for (String loadBeforeTarget : loadBeforeSet) { if (softDependencies.containsKey(loadBeforeTarget)) { softDependencies.get(loadBeforeTarget).add(description.getName()); } else { // softDependencies is never iterated, so 'ghost' plugins aren't an issue Collection<String> shortSoftDependency = new LinkedList<String>(); shortSoftDependency.add(description.getName()); softDependencies.put(loadBeforeTarget, shortSoftDependency); } } } } while (!plugins.isEmpty()) { boolean missingDependency = true; Iterator<String> pluginIterator = plugins.keySet().iterator(); while (pluginIterator.hasNext()) { String plugin = pluginIterator.next(); if (dependencies.containsKey(plugin)) { Iterator<String> dependencyIterator = dependencies.get(plugin).iterator(); while (dependencyIterator.hasNext()) { String dependency = dependencyIterator.next(); // Dependency loaded if (loadedPlugins.contains(dependency)) { dependencyIterator.remove(); // We have a dependency not found } else if (!plugins.containsKey(dependency)) { missingDependency = false; File file = plugins.get(plugin); pluginIterator.remove(); softDependencies.remove(plugin); dependencies.remove(plugin); server .getLogger() .log( Level.SEVERE, "Could not load '" + file.getPath() + "' in folder '" + directory.getPath() + "'", new UnknownDependencyException(dependency)); break; } } if (dependencies.containsKey(plugin) && dependencies.get(plugin).isEmpty()) { dependencies.remove(plugin); } } if (softDependencies.containsKey(plugin)) { Iterator<String> softDependencyIterator = softDependencies.get(plugin).iterator(); while (softDependencyIterator.hasNext()) { String softDependency = softDependencyIterator.next(); // Soft depend is no longer around if (!plugins.containsKey(softDependency)) { softDependencyIterator.remove(); } } if (softDependencies.get(plugin).isEmpty()) { softDependencies.remove(plugin); } } if (!(dependencies.containsKey(plugin) || softDependencies.containsKey(plugin)) && plugins.containsKey(plugin)) { // We're clear to load, no more soft or hard dependencies left File file = plugins.get(plugin); pluginIterator.remove(); missingDependency = false; try { result.add(loadPlugin(file)); loadedPlugins.add(plugin); continue; } catch (InvalidPluginException ex) { server .getLogger() .log( Level.SEVERE, "Could not load '" + file.getPath() + "' in folder '" + directory.getPath() + "'", ex); } } } if (missingDependency) { // We now iterate over plugins until something loads // This loop will ignore soft dependencies pluginIterator = plugins.keySet().iterator(); while (pluginIterator.hasNext()) { String plugin = pluginIterator.next(); if (!dependencies.containsKey(plugin)) { softDependencies.remove(plugin); missingDependency = false; File file = plugins.get(plugin); pluginIterator.remove(); try { result.add(loadPlugin(file)); loadedPlugins.add(plugin); break; } catch (InvalidPluginException ex) { server .getLogger() .log( Level.SEVERE, "Could not load '" + file.getPath() + "' in folder '" + directory.getPath() + "'", ex); } } } // We have no plugins left without a depend if (missingDependency) { softDependencies.clear(); dependencies.clear(); Iterator<File> failedPluginIterator = plugins.values().iterator(); while (failedPluginIterator.hasNext()) { File file = failedPluginIterator.next(); failedPluginIterator.remove(); server .getLogger() .log( Level.SEVERE, "Could not load '" + file.getPath() + "' in folder '" + directory.getPath() + "': circular dependency detected"); } } } } return result.toArray(new Plugin[result.size()]); }
@Override public Logger getLogger() { return server.getLogger(); }
public Plugin loadPlugin(File file, boolean ignoreSoftDependencies) throws InvalidPluginException, InvalidDescriptionException, UnknownDependencyException { JavaPlugin result = null; PluginDescriptionFile description = null; if (!file.exists()) { throw new InvalidPluginException( new FileNotFoundException(String.format("%s does not exist", file.getPath()))); } try { JarFile jar = new JarFile(file); JarEntry entry = jar.getJarEntry("plugin.yml"); if (entry == null) { throw new InvalidPluginException( new FileNotFoundException("Jar does not contain plugin.yml")); } InputStream stream = jar.getInputStream(entry); description = new PluginDescriptionFile(stream); stream.close(); jar.close(); } catch (IOException ex) { throw new InvalidPluginException(ex); } catch (YAMLException ex) { throw new InvalidPluginException(ex); } File dataFolder = new File(file.getParentFile(), description.getName()); File oldDataFolder = getDataFolder(file); // Found old data folder if (dataFolder.equals(oldDataFolder)) { // They are equal -- nothing needs to be done! } else if (dataFolder.isDirectory() && oldDataFolder.isDirectory()) { server .getLogger() .log( Level.INFO, String.format( "While loading %s (%s) found old-data folder: %s next to the new one: %s", description.getName(), file, oldDataFolder, dataFolder)); } else if (oldDataFolder.isDirectory() && !dataFolder.exists()) { if (!oldDataFolder.renameTo(dataFolder)) { throw new InvalidPluginException( new Exception( "Unable to rename old data folder: '" + oldDataFolder + "' to: '" + dataFolder + "'")); } server .getLogger() .log( Level.INFO, String.format( "While loading %s (%s) renamed data folder: '%s' to '%s'", description.getName(), file, oldDataFolder, dataFolder)); } if (dataFolder.exists() && !dataFolder.isDirectory()) { throw new InvalidPluginException( new Exception( String.format( "Projected datafolder: '%s' for %s (%s) exists and is not a directory", dataFolder, description.getName(), file))); } ArrayList<String> depend; try { depend = (ArrayList) description.getDepend(); if (depend == null) { depend = new ArrayList<String>(); } } catch (ClassCastException ex) { throw new InvalidPluginException(ex); } for (String pluginName : depend) { if (loaders == null) { throw new UnknownDependencyException(pluginName); } PluginClassLoader current = loaders.get(pluginName); if (current == null) { throw new UnknownDependencyException(pluginName); } } if (!ignoreSoftDependencies) { ArrayList<String> softDepend; try { softDepend = (ArrayList) description.getSoftDepend(); if (softDepend == null) { softDepend = new ArrayList<String>(); } } catch (ClassCastException ex) { throw new InvalidPluginException(ex); } for (String pluginName : softDepend) { if (loaders == null) { throw new UnknownSoftDependencyException(pluginName); } PluginClassLoader current = loaders.get(pluginName); if (current == null) { throw new UnknownSoftDependencyException(pluginName); } } } PluginClassLoader loader = null; try { URL[] urls = new URL[1]; urls[0] = file.toURI().toURL(); loader = new PluginClassLoader(this, urls, getClass().getClassLoader()); Class<?> jarClass = Class.forName(description.getMain(), true, loader); Class<? extends JavaPlugin> plugin = jarClass.asSubclass(JavaPlugin.class); Constructor<? extends JavaPlugin> constructor = plugin.getConstructor(); result = constructor.newInstance(); result.initialize(this, server, description, dataFolder, file, loader); } catch (Throwable ex) { throw new InvalidPluginException(ex); } loaders.put(description.getName(), loader); return result; }
public boolean setUp() { try { FileUtils.deleteFolder(invDirectory); FileUtils.deleteFolder(serverDirectory); invDirectory.mkdirs(); Assert.assertTrue(invDirectory.exists()); MockGateway.MOCK_STANDARD_METHODS = false; plugin = PowerMockito.spy(new MultiverseInventories()); core = PowerMockito.spy(new MultiverseCore()); // Let's let all MV files go to bin/test doReturn(invDirectory).when(plugin).getDataFolder(); // Let's let all MV files go to bin/test doReturn(coreDirectory).when(core).getDataFolder(); // Return a fake PDF file. PluginDescriptionFile pdf = PowerMockito.spy( new PluginDescriptionFile( "Multiverse-Inventories", "2.4-test", "com.onarandombox.multiverseinventories.MultiverseInventories")); when(pdf.getAuthors()).thenReturn(new ArrayList<String>()); doReturn(pdf).when(plugin).getDescription(); doReturn(core).when(plugin).getCore(); doReturn(true).when(plugin).isEnabled(); PluginDescriptionFile pdfCore = PowerMockito.spy( new PluginDescriptionFile( "Multiverse-Core", "2.2-Test", "com.onarandombox.MultiverseCore.MultiverseCore")); when(pdfCore.getAuthors()).thenReturn(new ArrayList<String>()); doReturn(pdfCore).when(core).getDescription(); doReturn(true).when(core).isEnabled(); plugin.setServerFolder(serverDirectory); // Add Core to the list of loaded plugins JavaPlugin[] plugins = new JavaPlugin[] {plugin, core}; // Mock the Plugin Manager PluginManager mockPluginManager = PowerMockito.mock(PluginManager.class); when(mockPluginManager.getPlugins()).thenReturn(plugins); when(mockPluginManager.getPlugin("Multiverse-Inventories")).thenReturn(plugin); when(mockPluginManager.getPlugin("Multiverse-Core")).thenReturn(core); when(mockPluginManager.getPermission(anyString())).thenReturn(null); // Make some fake folders to fool the fake MV into thinking these worlds exist File worldNormalFile = new File(plugin.getServerFolder(), "world"); Util.log("Creating world-folder: " + worldNormalFile.getAbsolutePath()); worldNormalFile.mkdirs(); MockWorldFactory.makeNewMockWorld("world", Environment.NORMAL, WorldType.NORMAL); File worldNetherFile = new File(plugin.getServerFolder(), "world_nether"); Util.log("Creating world-folder: " + worldNetherFile.getAbsolutePath()); worldNetherFile.mkdirs(); MockWorldFactory.makeNewMockWorld("world_nether", Environment.NETHER, WorldType.NORMAL); File worldSkylandsFile = new File(plugin.getServerFolder(), "world_the_end"); Util.log("Creating world-folder: " + worldSkylandsFile.getAbsolutePath()); worldSkylandsFile.mkdirs(); MockWorldFactory.makeNewMockWorld("world_the_end", Environment.THE_END, WorldType.NORMAL); File world2File = new File(plugin.getServerFolder(), "world2"); Util.log("Creating world-folder: " + world2File.getAbsolutePath()); world2File.mkdirs(); MockWorldFactory.makeNewMockWorld("world2", Environment.NORMAL, WorldType.NORMAL); // Initialize the Mock server. mockServer = mock(Server.class); when(mockServer.getName()).thenReturn("TestBukkit"); Logger.getLogger("Minecraft").setParent(Util.logger); when(mockServer.getLogger()).thenReturn(Util.logger); when(mockServer.getWorldContainer()).thenReturn(worldsDirectory); when(plugin.getServer()).thenReturn(mockServer); when(core.getServer()).thenReturn(mockServer); when(mockServer.getPluginManager()).thenReturn(mockPluginManager); Answer<Player> playerAnswer = new Answer<Player>() { public Player answer(InvocationOnMock invocation) throws Throwable { String arg; try { arg = (String) invocation.getArguments()[0]; } catch (Exception e) { return null; } Player player = players.get(arg); if (player == null) { player = new MockPlayer(arg, mockServer); players.put(arg, player); } return player; } }; when(mockServer.getPlayer(anyString())).thenAnswer(playerAnswer); when(mockServer.getOfflinePlayer(anyString())).thenAnswer(playerAnswer); when(mockServer.getOfflinePlayers()) .thenAnswer( new Answer<OfflinePlayer[]>() { public OfflinePlayer[] answer(InvocationOnMock invocation) throws Throwable { return players.values().toArray(new Player[players.values().size()]); } }); when(mockServer.getOnlinePlayers()) .thenAnswer( new Answer<Player[]>() { public Player[] answer(InvocationOnMock invocation) throws Throwable { return players.values().toArray(new Player[players.values().size()]); } }); // Give the server some worlds when(mockServer.getWorld(anyString())) .thenAnswer( new Answer<World>() { public World answer(InvocationOnMock invocation) throws Throwable { String arg; try { arg = (String) invocation.getArguments()[0]; } catch (Exception e) { return null; } return MockWorldFactory.getWorld(arg); } }); when(mockServer.getWorld(any(UUID.class))) .thenAnswer( new Answer<World>() { @Override public World answer(InvocationOnMock invocation) throws Throwable { UUID arg; try { arg = (UUID) invocation.getArguments()[0]; } catch (Exception e) { return null; } return MockWorldFactory.getWorld(arg); } }); when(mockServer.getWorlds()) .thenAnswer( new Answer<List<World>>() { public List<World> answer(InvocationOnMock invocation) throws Throwable { return MockWorldFactory.getWorlds(); } }); when(mockServer.createWorld(Matchers.isA(WorldCreator.class))) .thenAnswer( new Answer<World>() { public World answer(InvocationOnMock invocation) throws Throwable { WorldCreator arg; try { arg = (WorldCreator) invocation.getArguments()[0]; } catch (Exception e) { return null; } // Add special case for creating null worlds. // Not sure I like doing it this way, but this is a special case if (arg.name().equalsIgnoreCase("nullworld")) { return MockWorldFactory.makeNewNullMockWorld( arg.name(), arg.environment(), arg.type()); } return MockWorldFactory.makeNewMockWorld( arg.name(), arg.environment(), arg.type()); } }); when(mockServer.unloadWorld(anyString(), anyBoolean())).thenReturn(true); // add mock scheduler BukkitScheduler mockScheduler = mock(BukkitScheduler.class); when(mockScheduler.scheduleSyncDelayedTask(any(Plugin.class), any(Runnable.class), anyLong())) .thenAnswer( new Answer<Integer>() { public Integer answer(InvocationOnMock invocation) throws Throwable { Runnable arg; try { arg = (Runnable) invocation.getArguments()[1]; } catch (Exception e) { return null; } arg.run(); return null; } }); when(mockScheduler.scheduleSyncDelayedTask(any(Plugin.class), any(Runnable.class))) .thenAnswer( new Answer<Integer>() { public Integer answer(InvocationOnMock invocation) throws Throwable { Runnable arg; try { arg = (Runnable) invocation.getArguments()[1]; } catch (Exception e) { return null; } arg.run(); return null; } }); when(mockServer.getScheduler()).thenReturn(mockScheduler); // Set InventoriesListener InventoriesListener il = PowerMockito.spy(new InventoriesListener(plugin)); Field inventoriesListenerField = MultiverseInventories.class.getDeclaredField("inventoriesListener"); inventoriesListenerField.setAccessible(true); inventoriesListenerField.set(plugin, il); // Set Core Field coreField = MultiverseInventories.class.getDeclaredField("core"); coreField.setAccessible(true); coreField.set(plugin, core); // Set server Field serverfield = JavaPlugin.class.getDeclaredField("server"); serverfield.setAccessible(true); serverfield.set(plugin, mockServer); // Set worldManager WorldManager wm = PowerMockito.spy(new WorldManager(core)); Field worldmanagerfield = MultiverseCore.class.getDeclaredField("worldManager"); worldmanagerfield.setAccessible(true); worldmanagerfield.set(core, wm); // Set playerListener MVPlayerListener pl = PowerMockito.spy(new MVPlayerListener(core)); Field playerlistenerfield = MultiverseCore.class.getDeclaredField("playerListener"); playerlistenerfield.setAccessible(true); playerlistenerfield.set(core, pl); // Set entityListener MVEntityListener el = PowerMockito.spy(new MVEntityListener(core)); Field entitylistenerfield = MultiverseCore.class.getDeclaredField("entityListener"); entitylistenerfield.setAccessible(true); entitylistenerfield.set(core, el); // Set weatherListener MVWeatherListener wl = PowerMockito.spy(new MVWeatherListener(core)); Field weatherlistenerfield = MultiverseCore.class.getDeclaredField("weatherListener"); weatherlistenerfield.setAccessible(true); weatherlistenerfield.set(core, wl); // Init our command sender final Logger commandSenderLogger = Logger.getLogger("CommandSender"); commandSenderLogger.setParent(Util.logger); commandSender = mock(CommandSender.class); doAnswer( new Answer<Void>() { public Void answer(InvocationOnMock invocation) throws Throwable { commandSenderLogger.info( ChatColor.stripColor((String) invocation.getArguments()[0])); return null; } }) .when(commandSender) .sendMessage(anyString()); when(commandSender.getServer()).thenReturn(mockServer); when(commandSender.getName()).thenReturn("MockCommandSender"); when(commandSender.isPermissionSet(anyString())).thenReturn(true); when(commandSender.isPermissionSet(Matchers.isA(Permission.class))).thenReturn(true); when(commandSender.hasPermission(anyString())).thenReturn(true); when(commandSender.hasPermission(Matchers.isA(Permission.class))).thenReturn(true); when(commandSender.addAttachment(plugin)).thenReturn(null); when(commandSender.isOp()).thenReturn(true); Bukkit.setServer(mockServer); // Load Multiverse Core core.onLoad(); plugin.onLoad(); // Enable it. core.onEnable(); plugin.onEnable(); return true; } catch (Exception e) { e.printStackTrace(); } return false; }