Upstream/Multiverse-Core
1
0
Fork 0
mirror of https://github.com/Multiverse/Multiverse-Core.git synced 2025-03-09 21:29:23 +01:00
Code Issues Projects Releases Wiki Activity

Merge branch 'fixed-tests' Closes #261

Browse Source 
Tested, and the tests all pass!
This commit is contained in:
Eric Stokes 2011-11-25 18:16:22 -07:00
commit 6a80c8c1de
18 changed files with 516 additions and 498 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

40
src/main/java/com/onarandombox/MultiverseCore/MultiverseCore.java
View File

@ -30,7 +30,6 @@ import org.bukkit.configuration.file.YamlConfiguration;
import org.bukkit.entity.Player; import org.bukkit.entity.Player;
import org.bukkit.event.Event; import org.bukkit.event.Event;
import org.bukkit.event.Event.Priority; import org.bukkit.event.Event.Priority;
import org.bukkit.plugin.PluginDescriptionFile;
import org.bukkit.plugin.PluginManager; import org.bukkit.plugin.PluginManager;
import org.bukkit.plugin.java.JavaPlugin; import org.bukkit.plugin.java.JavaPlugin;
@ -49,8 +48,6 @@ public class MultiverseCore extends JavaPlugin implements MVPlugin, Core {
public static boolean EnforceAccess; public static boolean EnforceAccess;
public static boolean EnforceGameModes; public static boolean EnforceGameModes;
public static boolean PrefixChat; public static boolean PrefixChat;
private File testConfigDirectory;
private PluginDescriptionFile testDescriptionFile;
@Override @Override
public String toString() { public String toString() {
@ -118,6 +115,8 @@ public class MultiverseCore extends JavaPlugin implements MVPlugin, Core {
private double chversion = 1; private double chversion = 1;
private MVMessaging messaging; private MVMessaging messaging;
private File serverFolder = new File(System.getProperty("user.dir"));
@Override @Override
public void onLoad() { public void onLoad() {
// Create our DataFolder // Create our DataFolder
@ -126,28 +125,6 @@ public class MultiverseCore extends JavaPlugin implements MVPlugin, Core {
debugLog = new DebugLog("Multiverse-Core", getDataFolder() + File.separator + "debug.log"); debugLog = new DebugLog("Multiverse-Core", getDataFolder() + File.separator + "debug.log");
} }
@Override
public File getDataFolder() {
if (this.testConfigDirectory != null) {
return this.testConfigDirectory;
}
return super.getDataFolder();
}
@Override
public PluginDescriptionFile getDescription() {
if (this.testDescriptionFile != null) {
return this.testDescriptionFile;
}
return super.getDescription(); //To change body of overridden methods use File | Settings | File Templates.
}
public void setTestMode(File configDir, PluginDescriptionFile descriptionFile) {
this.testConfigDirectory = configDir;
this.testDescriptionFile = descriptionFile;
}
public FileConfiguration getMVConfiguration() { public FileConfiguration getMVConfiguration() {
return this.multiverseConfig; return this.multiverseConfig;
} }
@ -540,14 +517,19 @@ public class MultiverseCore extends JavaPlugin implements MVPlugin, Core {
this.getTeleporter().safelyTeleport(teleporter, p, l, false); this.getTeleporter().safelyTeleport(teleporter, p, l, false);
} }
public File getServerFolder() { public File getServerFolder() {
return new File(this.getDataFolder().getAbsolutePath()).getParentFile().getParentFile(); return serverFolder;
}
public void setServerFolder(File newServerFolder) {
if (!newServerFolder.isDirectory())
throw new IllegalArgumentException("That's not a folder!");
this.serverFolder = newServerFolder;
} }
private void checkServerProps() { private void checkServerProps() {
File serverFolder = new File(this.getDataFolder().getAbsolutePath()).getParentFile().getParentFile(); File serverProperties = new File(serverFolder, "server.properties");
File serverProperties = new File(serverFolder.getAbsolutePath() + File.separator + "server.properties");
try { try {
FileInputStream fileStream = new FileInputStream(serverProperties); FileInputStream fileStream = new FileInputStream(serverProperties);
DataInputStream in = new DataInputStream(fileStream); DataInputStream in = new DataInputStream(fileStream);

3
src/main/java/com/onarandombox/MultiverseCore/commands/CreateCommand.java
View File

@ -46,11 +46,12 @@ public class CreateCommand extends MultiverseCommand {
return; return;
} }
String worldName = args.get(0); String worldName = args.get(0);
File worldFile = new File(this.plugin.getServerFolder(), worldName);
String env = args.get(1); String env = args.get(1);
String seed = CommandHandler.getFlag("-s", args); String seed = CommandHandler.getFlag("-s", args);
String generator = CommandHandler.getFlag("-g", args); String generator = CommandHandler.getFlag("-g", args);
if (new File(worldName).exists() || this.worldManager.isMVWorld(worldName)) { if (worldFile.exists() || this.worldManager.isMVWorld(worldName)) {
sender.sendMessage(ChatColor.RED + "A Folder/World already exists with this name!"); sender.sendMessage(ChatColor.RED + "A Folder/World already exists with this name!");
sender.sendMessage(ChatColor.RED + "If you are confident it is a world you can import with /mvimport"); sender.sendMessage(ChatColor.RED + "If you are confident it is a world you can import with /mvimport");
return; return;

5
src/main/java/com/onarandombox/MultiverseCore/commands/ImportCommand.java
View File

@ -39,7 +39,8 @@ public class ImportCommand extends MultiverseCommand {
@Override @Override
public void runCommand(CommandSender sender, List<String> args) { public void runCommand(CommandSender sender, List<String> args) {
String worldName = args.get(0); String worldName = args.get(0);
if (this.worldManager.isMVWorld(worldName) && new File(worldName).exists()) { File worldFile = new File(this.plugin.getServerFolder(), worldName);
if (this.worldManager.isMVWorld(worldName) && worldFile.exists()) {
sender.sendMessage(ChatColor.RED + "Multiverse already knows about this world!"); sender.sendMessage(ChatColor.RED + "Multiverse already knows about this world!");
return; return;
} }
@ -57,7 +58,7 @@ public class ImportCommand extends MultiverseCommand {
return; return;
} }
if (new File(worldName).exists() && env != null) { if (worldFile.exists() && env != null) {
Command.broadcastCommandMessage(sender, "Starting import of world '" + worldName + "'..."); Command.broadcastCommandMessage(sender, "Starting import of world '" + worldName + "'...");
this.worldManager.addWorld(worldName, environment, null, generator); this.worldManager.addWorld(worldName, environment, null, generator);
Command.broadcastCommandMessage(sender, "Complete!"); Command.broadcastCommandMessage(sender, "Complete!");

4
src/main/java/com/onarandombox/MultiverseCore/utils/WorldManager.java
View File

@ -209,8 +209,8 @@ public class WorldManager implements MVWorldManager {
} }
removeWorldFromConfig(name); removeWorldFromConfig(name);
try { try {
File serverFolder = new File(this.plugin.getDataFolder().getAbsolutePath()).getParentFile().getParentFile(); File serverFolder = this.plugin.getServerFolder();
File worldFile = new File(serverFolder.getAbsolutePath() + File.separator + name); File worldFile = new File(serverFolder, name);
if (name.equalsIgnoreCase("plugins")) { if (name.equalsIgnoreCase("plugins")) {
this.plugin.log(Level.SEVERE, "Really? Are you high? This would delete your plugins folder. Luckily the MV2 devs are crazy smart or you're server would be ended..."); this.plugin.log(Level.SEVERE, "Really? Are you high? This would delete your plugins folder. Luckily the MV2 devs are crazy smart or you're server would be ended...");
return false; return false;

61
src/test/java/com/onarandombox/MultiverseCore/test/TestDebugMode.java
View File

@ -7,70 +7,59 @@
package com.onarandombox.MultiverseCore.test; package com.onarandombox.MultiverseCore.test;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
import java.io.File;
import com.onarandombox.MultiverseCore.MultiverseCore;
import com.onarandombox.MultiverseCore.test.utils.MVCoreFactory;
import com.onarandombox.MultiverseCore.test.utils.TestInstanceCreator;
import com.onarandombox.MultiverseCore.utils.FileUtils;
import junit.framework.Assert; import junit.framework.Assert;
import org.bukkit.Bukkit;
import org.bukkit.Server; import org.bukkit.Server;
import org.bukkit.command.Command; import org.bukkit.command.Command;
import org.bukkit.command.CommandSender; import org.bukkit.command.CommandSender;
import org.bukkit.plugin.Plugin; import org.bukkit.plugin.Plugin;
import org.junit.After; import org.junit.After;
import org.junit.Before; import org.junit.Before;
import org.junit.Ignore;
import org.junit.Test; import org.junit.Test;
import org.junit.runner.RunWith; import org.junit.runner.RunWith;
import org.powermock.core.classloader.annotations.PrepareForTest; import org.powermock.core.classloader.annotations.PrepareForTest;
import org.powermock.modules.junit4.PowerMockRunner; import org.powermock.modules.junit4.PowerMockRunner;
import java.io.File; import com.onarandombox.MultiverseCore.MultiverseCore;
import java.lang.reflect.Field; import com.onarandombox.MultiverseCore.test.utils.TestInstanceCreator;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
@RunWith(PowerMockRunner.class) @RunWith(PowerMockRunner.class)
@PrepareForTest({MultiverseCore.class}) @PrepareForTest({ MultiverseCore.class })
public class TestDebugMode { public class TestDebugMode {
@After TestInstanceCreator creator;
public void tearDown() throws NoSuchFieldException, ClassNotFoundException, IllegalAccessException { Server mockServer;
Field serverField = Bukkit.class.getDeclaredField("server"); CommandSender mockCommandSender;
serverField.setAccessible(true);
serverField.set(Class.forName("org.bukkit.Bukkit"), null);
if (MVCoreFactory.serverDirectory.exists()) {
MVCoreFactory.serverDirectory.delete();
FileUtils.deleteFolder(MVCoreFactory.serverDirectory);
}
}
@Before @Before
public void setUp() throws Exception { public void setUp() throws Exception {
if (!MVCoreFactory.serverDirectory.exists()) { creator = new TestInstanceCreator();
MVCoreFactory.serverDirectory.mkdirs(); assertTrue(creator.setUp());
} mockServer = creator.getServer();
if (!MVCoreFactory.pluginDirectory.exists()) { mockCommandSender = creator.getCommandSender();
MVCoreFactory.pluginDirectory.mkdirs(); }
}
@After
public void tearDown() throws Exception {
creator.tearDown();
} }
@Test @Test
@Ignore
public void testEnableDebugMode() { public void testEnableDebugMode() {
TestInstanceCreator creator = new TestInstanceCreator();
Server mockServer = creator.setupDefaultServerInstance();
CommandSender mockCommandSender = creator.getCommandSender();
// Start actual testing.
// Pull a core instance from the server. // Pull a core instance from the server.
Plugin plugin = mockServer.getPluginManager().getPlugin("Multiverse-Core"); Plugin plugin = mockServer.getPluginManager().getPlugin("Multiverse-Core");
// Make sure Core is not null // Make sure Core is not null
Assert.assertNotNull(plugin); assertNotNull(plugin);
// Make sure Core is enabled // Make sure Core is enabled
Assert.assertTrue(plugin.isEnabled()); assertTrue(plugin.isEnabled());
// Make a fake server folder to fool MV into thinking a world folder exists. // Make a fake server folder to fool MV into thinking a world folder exists.
File serverDirectory = new File(creator.getCore().getServerFolder(), "world"); File serverDirectory = new File(creator.getCore().getServerFolder(), "world");
@ -84,7 +73,7 @@ public class TestDebugMode {
Assert.assertEquals(0, MultiverseCore.GlobalDebug); Assert.assertEquals(0, MultiverseCore.GlobalDebug);
// Send the debug command. // Send the debug command.
String[] debugArgs = new String[]{"debug", "3"}; String[] debugArgs = new String[] { "debug", "3" };
plugin.onCommand(mockCommandSender, mockCommand, "", debugArgs); plugin.onCommand(mockCommandSender, mockCommand, "", debugArgs);
Assert.assertEquals(3, MultiverseCore.GlobalDebug); Assert.assertEquals(3, MultiverseCore.GlobalDebug);

52
src/test/java/com/onarandombox/MultiverseCore/test/TestMockWorld.java
View File

@ -1,52 +0,0 @@
package com.onarandombox.MultiverseCore.test;
import junit.framework.Assert;
import org.bukkit.World;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.powermock.modules.junit4.PowerMockRunner;
import static org.mockito.Mockito.*;
@RunWith(PowerMockRunner.class)
public class TestMockWorld {
private World mockWorld;
private World mockNetherWorld;
@Before
public void setUp() throws Exception {
// Initialize a fake world and world_nether.
this.mockWorld = mock(World.class);
when(this.mockWorld.getName()).thenReturn("world");
when(this.mockWorld.getEnvironment()).thenReturn(World.Environment.NORMAL);
this.mockNetherWorld = mock(World.class);
when(this.mockNetherWorld.getName()).thenReturn("world_nether");
when(this.mockNetherWorld.getEnvironment()).thenReturn(World.Environment.NETHER);
}
@Test
public void testWorldInit() {
Assert.assertNotNull(this.mockWorld);
Assert.assertNotNull(this.mockNetherWorld);
}
@Test
public void testWorldNames() {
// Test the mock world objects
Assert.assertEquals(this.mockWorld.getName(), "world");
Assert.assertEquals(this.mockNetherWorld.getName(), "world_nether");
verify(this.mockWorld).getName();
verify(this.mockNetherWorld).getName();
}
@Test
public void testWorldEnvironments() {
// Test the environments
Assert.assertEquals(this.mockWorld.getEnvironment(), World.Environment.NORMAL);
Assert.assertEquals(this.mockNetherWorld.getEnvironment(), World.Environment.NETHER);
verify(this.mockWorld).getEnvironment();
verify(this.mockNetherWorld).getEnvironment();
}
}

186
src/test/java/com/onarandombox/MultiverseCore/test/TestWorldImport.java
View File

@ -1,186 +0,0 @@
package com.onarandombox.MultiverseCore.test;
import com.onarandombox.MultiverseCore.MultiverseCore;
import com.onarandombox.MultiverseCore.test.utils.MVCoreFactory;
import com.onarandombox.MultiverseCore.test.utils.TestInstanceCreator;
import com.onarandombox.MultiverseCore.test.utils.WorldCreatorMatcher;
import com.onarandombox.MultiverseCore.utils.FileUtils;
import junit.framework.Assert;
import org.bukkit.*;
import org.bukkit.command.Command;
import org.bukkit.command.CommandSender;
import org.bukkit.permissions.Permission;
import org.bukkit.plugin.Plugin;
import org.bukkit.plugin.PluginManager;
import org.junit.After;
import org.junit.Before;
import org.junit.Ignore;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.internal.verification.VerificationModeFactory;
import org.powermock.core.classloader.annotations.PrepareForTest;
import org.powermock.modules.junit4.PowerMockRunner;
import java.io.File;
import java.lang.reflect.Field;
import static org.mockito.Mockito.*;
@RunWith(PowerMockRunner.class)
@PrepareForTest({PluginManager.class, MultiverseCore.class, Permission.class, Bukkit.class})
public class TestWorldImport {
@After
public void tearDown() throws NoSuchFieldException, ClassNotFoundException, IllegalAccessException {
Field serverField = Bukkit.class.getDeclaredField("server");
serverField.setAccessible(true);
serverField.set(Class.forName("org.bukkit.Bukkit"), null);
if (MVCoreFactory.serverDirectory.exists()) {
MVCoreFactory.serverDirectory.delete();
FileUtils.deleteFolder(MVCoreFactory.serverDirectory);
}
}
@Before
public void setUp() throws Exception {
if (!MVCoreFactory.serverDirectory.exists()) {
MVCoreFactory.serverDirectory.mkdirs();
}
if (!MVCoreFactory.pluginDirectory.exists()) {
MVCoreFactory.pluginDirectory.mkdirs();
}
}
@Test
@Ignore
public void testWorldImportWithNoFolder() {
TestInstanceCreator creator = new TestInstanceCreator();
Server mockServer = creator.setupDefaultServerInstance();
CommandSender mockCommandSender = creator.getCommandSender();
// Make sure the world directory do NOT exist
if (new File(MVCoreFactory.serverDirectory, "world").exists()) {
new File(MVCoreFactory.serverDirectory, "world").delete();
}
// Start actual testing.
// Pull a core instance from the server.
Plugin plugin = mockServer.getPluginManager().getPlugin("Multiverse-Core");
// Make sure Core is not null
Assert.assertNotNull(plugin);
// Make sure Core is enabled
Assert.assertTrue(plugin.isEnabled());
// Initialize a fake command
Command mockCommand = mock(Command.class);
when(mockCommand.getName()).thenReturn("mv");
String[] normalArgs = new String[]{"import", "world", "normal"};
// Ensure we have a fresh copy of MV, 0 worlds.
Assert.assertEquals(0, creator.getCore().getMVWorldManager().getMVWorlds().size());
// Import the first world. The world folder does not exist.
plugin.onCommand(mockCommandSender, mockCommand, "", normalArgs);
verify(mockCommandSender).sendMessage(ChatColor.RED + "FAILED.");
verify(mockCommandSender).sendMessage("That world folder does not exist...");
// We should still have no worlds.
Assert.assertEquals(0, creator.getCore().getMVWorldManager().getMVWorlds().size());
}
@Test
@Ignore
public void testWorldImport() {
TestInstanceCreator creator = new TestInstanceCreator();
Server mockServer = creator.setupDefaultServerInstance();
CommandSender mockCommandSender = creator.getCommandSender();
// Start actual testing.
// Pull a core instance from the server.
Plugin plugin = mockServer.getPluginManager().getPlugin("Multiverse-Core");
// Make sure Core is not null
Assert.assertNotNull(plugin);
// Make sure Core is enabled
Assert.assertTrue(plugin.isEnabled());
// Initialize a fake command
Command mockCommand = mock(Command.class);
when(mockCommand.getName()).thenReturn("mv");
// Ensure that there are no worlds imported. This is a fresh setup.
Assert.assertEquals(0, creator.getCore().getMVWorldManager().getMVWorlds().size());
// Import the first world.
String[] normalArgs = new String[]{"import", "world", "normal"};
plugin.onCommand(mockCommandSender, mockCommand, "", normalArgs);
// We should now have one world imported!
Assert.assertEquals(1, creator.getCore().getMVWorldManager().getMVWorlds().size());
// Import the second world.
String[] netherArgs = new String[]{"import", "world_nether", "nether"};
plugin.onCommand(mockCommandSender, mockCommand, "", netherArgs);
// We should now have 2 worlds imported!
Assert.assertEquals(2, creator.getCore().getMVWorldManager().getMVWorlds().size());
// Import the third world.
String[] skyArgs = new String[]{"import", "world_skylands", "skylands"};
plugin.onCommand(mockCommandSender, mockCommand, "", skyArgs);
// We should now have 2 worlds imported!
Assert.assertEquals(3, creator.getCore().getMVWorldManager().getMVWorlds().size());
// Verify that the commandSender has been called 3 times.
verify(mockCommandSender, VerificationModeFactory.times(3)).sendMessage(ChatColor.AQUA + "Starting world import...");
verify(mockCommandSender, VerificationModeFactory.times(3)).sendMessage(ChatColor.GREEN + "Complete!");
}
@Test
@Ignore
public void testWorldImportWithSeed() {
TestInstanceCreator creator = new TestInstanceCreator();
Server mockServer = creator.setupDefaultServerInstance();
CommandSender mockCommandSender = creator.getCommandSender();
// Start actual testing.
// Pull a core instance from the server.
Plugin plugin = mockServer.getPluginManager().getPlugin("Multiverse-Core");
// Make sure Core is not null
Assert.assertNotNull(plugin);
// Make sure Core is enabled
Assert.assertTrue(plugin.isEnabled());
// Initialize a fake command
Command mockCommand = mock(Command.class);
when(mockCommand.getName()).thenReturn("mv");
// Ensure that there are no worlds imported. This is a fresh setup.
Assert.assertEquals(0, creator.getCore().getMVWorldManager().getMVWorlds().size());
// Init a new WorldCreatorMatcher to match our seeded world
WorldCreator seedCreator = new WorldCreator("world");
seedCreator.environment(World.Environment.NORMAL);
WorldCreatorMatcher seedMatcher = new WorldCreatorMatcher(seedCreator);
// For this case, we're testing a seeded import, so we care about the world seed
seedMatcher.careAboutSeeds(true);
// Import the first world.
String[] normalArgs = new String[]{"import", "world", "normal", "-s", "gargamel"};
plugin.onCommand(mockCommandSender, mockCommand, "", normalArgs);
// We should now have one world imported!
Assert.assertEquals(1, creator.getCore().getMVWorldManager().getMVWorlds().size());
// Verify that the commandSender has been called 1 time.
verify(mockCommandSender, VerificationModeFactory.times(1)).sendMessage(ChatColor.AQUA + "Starting world import...");
verify(mockCommandSender, VerificationModeFactory.times(1)).sendMessage(ChatColor.GREEN + "Complete!");
}
}

171
src/test/java/com/onarandombox/MultiverseCore/test/TestWorldStuff.java Normal file
View File

@ -0,0 +1,171 @@
/******************************************************************************
* Multiverse 2 Copyright (c) the Multiverse Team 2011. *
* Multiverse 2 is licensed under the BSD License. *
* For more information please check the README.md file included *
* with this project. *
******************************************************************************/
package com.onarandombox.MultiverseCore.test;
import static junit.framework.Assert.*;
import static org.mockito.Mockito.*;
import java.io.File;
import org.bukkit.Bukkit;
import org.bukkit.ChatColor;
import org.bukkit.Server;
import org.bukkit.WorldCreator;
import org.bukkit.command.Command;
import org.bukkit.command.CommandSender;
import org.bukkit.permissions.Permission;
import org.bukkit.plugin.Plugin;
import org.bukkit.plugin.PluginManager;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Matchers;
import org.mockito.internal.verification.VerificationModeFactory;
import org.powermock.core.classloader.annotations.PrepareForTest;
import org.powermock.modules.junit4.PowerMockRunner;
import com.onarandombox.MultiverseCore.MultiverseCore;
import com.onarandombox.MultiverseCore.test.utils.TestInstanceCreator;
import com.onarandombox.MultiverseCore.test.utils.WorldCreatorMatcher;
import com.onarandombox.MultiverseCore.utils.WorldManager;
@RunWith(PowerMockRunner.class)
@PrepareForTest({ PluginManager.class, MultiverseCore.class, Permission.class, Bukkit.class, WorldManager.class })
public class TestWorldStuff {
TestInstanceCreator creator;
Server mockServer;
CommandSender mockCommandSender;
@Before
public void setUp() throws Exception {
creator = new TestInstanceCreator();
assertTrue(creator.setUp());
mockServer = creator.getServer();
mockCommandSender = creator.getCommandSender();
}
@After
public void tearDown() throws Exception {
creator.tearDown();
}
@Test
public void testWorldImportWithNoFolder() {
// Make sure the world directory do NOT exist
// (it was created by the TestInstanceCreator)
File worldFile = new File(TestInstanceCreator.serverDirectory, "world");
assertTrue(worldFile.exists());
assertTrue(worldFile.delete());
// Start actual testing.
// Pull a core instance from the server.
Plugin plugin = mockServer.getPluginManager().getPlugin("Multiverse-Core");
// Make sure Core is not null
assertNotNull(plugin);
// Make sure Core is enabled
assertTrue(plugin.isEnabled());
// Initialize a fake command
Command mockCommand = mock(Command.class);
when(mockCommand.getName()).thenReturn("mv");
String[] normalArgs = new String[] { "import", "world", "normal" };
// Ensure we have a fresh copy of MV, 0 worlds.
assertEquals(0, creator.getCore().getMVWorldManager().getMVWorlds().size());
// Import the first world. The world folder does not exist.
plugin.onCommand(mockCommandSender, mockCommand, "", normalArgs);
verify(mockCommandSender).sendMessage(ChatColor.RED + "FAILED.");
verify(mockCommandSender).sendMessage("That world folder does not exist...");
// We should still have no worlds.
assertEquals(0, creator.getCore().getMVWorldManager().getMVWorlds().size());
}
@Test
public void testWorldImport() {
// Pull a core instance from the server.
Plugin plugin = mockServer.getPluginManager().getPlugin("Multiverse-Core");
// Make sure Core is not null
assertNotNull(plugin);
// Make sure Core is enabled
assertTrue(plugin.isEnabled());
// Initialize a fake command
Command mockCommand = mock(Command.class);
when(mockCommand.getName()).thenReturn("mv");
// Ensure that there are no worlds imported. This is a fresh setup.
assertEquals(0, creator.getCore().getMVWorldManager().getMVWorlds().size());
// Import the first world.
String[] normalArgs = new String[] { "import", "world", "normal" };
plugin.onCommand(mockCommandSender, mockCommand, "", normalArgs);
// We should now have one world imported!
assertEquals(1, creator.getCore().getMVWorldManager().getMVWorlds().size());
// Import the second world.
String[] netherArgs = new String[] { "import", "world_nether", "nether" };
plugin.onCommand(mockCommandSender, mockCommand, "", netherArgs);
// We should now have 2 worlds imported!
assertEquals(2, creator.getCore().getMVWorldManager().getMVWorlds().size());
// Import the third world.
String[] skyArgs = new String[] { "import", "world_skylands", "end" };
plugin.onCommand(mockCommandSender, mockCommand, "", skyArgs);
// We should now have 2 worlds imported!
assertEquals(3, creator.getCore().getMVWorldManager().getMVWorlds().size());
// Verify that the commandSender has been called 3 times.
verify(mockCommandSender).sendMessage("Starting import of world 'world'...");
verify(mockCommandSender).sendMessage("Starting import of world 'world_nether'...");
verify(mockCommandSender).sendMessage("Starting import of world 'world_skylands'...");
verify(mockCommandSender, VerificationModeFactory.times(3)).sendMessage("Complete!");
}
@Test
public void testWorldCreation() {
// Pull a core instance from the server.
Plugin plugin = mockServer.getPluginManager().getPlugin("Multiverse-Core");
// Make sure Core is not null
assertNotNull(plugin);
// Make sure Core is enabled
assertTrue(plugin.isEnabled());
// Initialize a fake command
Command mockCommand = mock(Command.class);
when(mockCommand.getName()).thenReturn("mv");
// Ensure that there are no worlds imported. This is a fresh setup.
assertEquals(0, creator.getCore().getMVWorldManager().getMVWorlds().size());
// Create the world
String[] normalArgs = new String[] { "create", "newworld", "normal" };
plugin.onCommand(mockCommandSender, mockCommand, "", normalArgs);
// We should now have one world!
assertEquals(1, creator.getCore().getMVWorldManager().getMVWorlds().size());
// Verify
verify(mockCommandSender).sendMessage("Starting creation of world 'newworld'...");
verify(mockCommandSender).sendMessage("Complete!");
WorldCreatorMatcher matcher = new WorldCreatorMatcher(new WorldCreator("newworld"));
verify(mockServer).createWorld(Matchers.argThat(matcher));
}
}

41
src/test/java/com/onarandombox/MultiverseCore/test/utils/MVCoreFactory.java
View File

@ -1,41 +0,0 @@
/******************************************************************************
* Multiverse 2 Copyright (c) the Multiverse Team 2011. *
* Multiverse 2 is licensed under the BSD License. *
* For more information please check the README.md file included *
* with this project. *
******************************************************************************/
package com.onarandombox.MultiverseCore.test.utils;
import com.onarandombox.MultiverseCore.MultiverseCore;
import org.bukkit.plugin.PluginDescriptionFile;
import org.powermock.api.mockito.PowerMockito;
import java.io.File;
import static org.mockito.Mockito.doReturn;
/**
* Multiverse 2
*
* @author fernferret
*/
public class MVCoreFactory {
public static final File pluginDirectory = new File("bin/test/server/plugins/coretest");
public static final File serverDirectory = new File("bin/test/server");
public MultiverseCore getNewCore() {
MultiverseCore core = PowerMockito.spy(new MultiverseCore());
// Let's let all MV files go to bin/test
doReturn(pluginDirectory).when(core).getDataFolder();
// Return a fake PDF file.
PluginDescriptionFile pdf = new PluginDescriptionFile("Multiverse-Core", "2.1-Test", "com.onarandombox.MultiverseCore.MultiverseCore");
doReturn(pdf).when(core).getDescription();
doReturn(true).when(core).isEnabled();
return core;
}
}

43
src/test/java/com/onarandombox/MultiverseCore/test/utils/MVTestLogFormatter.java Normal file
View File

@ -0,0 +1,43 @@
/******************************************************************************
* Multiverse 2 Copyright (c) the Multiverse Team 2011. *
* Multiverse 2 is licensed under the BSD License. *
* For more information please check the README.md file included *
* with this project. *
******************************************************************************/
package com.onarandombox.MultiverseCore.test.utils;
import java.io.PrintWriter;
import java.io.StringWriter;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.logging.Formatter;
import java.util.logging.LogRecord;
/**
* Formatter to format log-messages in tests
*
* @author main()
*/
public class MVTestLogFormatter extends Formatter {
private static final DateFormat df = new SimpleDateFormat("HH:mm:ss");
public String format(LogRecord record) {
StringBuilder ret = new StringBuilder();
ret.append("[").append(df.format(record.getMillis())).append("] [")
.append(record.getLoggerName()).append("] [")
.append(record.getLevel().getLocalizedName()).append("] ");
ret.append(record.getMessage());
ret.append('\n');
if (record.getThrown() != null) {
// An Exception was thrown! Let's print the StackTrace!
StringWriter writer = new StringWriter();
record.getThrown().printStackTrace(new PrintWriter(writer));
ret.append(writer);
}
return ret.toString();
}
}

16
src/test/java/com/onarandombox/MultiverseCore/test/utils/MockBukkitServer.java
View File

@ -1,16 +0,0 @@
/******************************************************************************
* Multiverse 2 Copyright (c) the Multiverse Team 2011. *
* Multiverse 2 is licensed under the BSD License. *
* For more information please check the README.md file included *
* with this project. *
******************************************************************************/
package com.onarandombox.MultiverseCore.test.utils;
/**
* Multiverse 2
*
* @author fernferret
*/
public class MockBukkitServer {
}

34
src/test/java/com/onarandombox/MultiverseCore/test/utils/MockServerFactory.java
View File

@ -1,34 +0,0 @@
/******************************************************************************
* Multiverse 2 Copyright (c) the Multiverse Team 2011. *
* Multiverse 2 is licensed under the BSD License. *
* For more information please check the README.md file included *
* with this project. *
******************************************************************************/
package com.onarandombox.MultiverseCore.test.utils;
import org.bukkit.Server;
import org.bukkit.WorldCreator;
import org.mockito.ArgumentMatcher;
import org.mockito.Matchers;
import java.util.logging.Logger;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
/**
* Multiverse 2
*
* @author fernferret
*/
public class MockServerFactory {
public Server getMockServer() {
Server server = mock(Server.class);
when(server.getName()).thenReturn("FernCraft");
Logger logger = Logger.getLogger("Multiverse-Core-Test");
when(server.getLogger()).thenReturn(logger);
return server;
}
}

63
src/test/java/com/onarandombox/MultiverseCore/test/utils/MockWorldFactory.java
View File

@ -7,6 +7,14 @@
package com.onarandombox.MultiverseCore.test.utils; package com.onarandombox.MultiverseCore.test.utils;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.bukkit.Location; import org.bukkit.Location;
import org.bukkit.Material; import org.bukkit.Material;
import org.bukkit.World; import org.bukkit.World;
@ -14,17 +22,14 @@ import org.bukkit.generator.ChunkGenerator;
import org.mockito.ArgumentMatcher; import org.mockito.ArgumentMatcher;
import org.mockito.Matchers; import org.mockito.Matchers;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
/**
* Multiverse 2
*
* @author fernferret
*/
public class MockWorldFactory { public class MockWorldFactory {
class LocationMatcher extends ArgumentMatcher<Location> { private static final Map<String, World> createdWorlds = new HashMap<String, World>();
private MockWorldFactory() {
}
private static class LocationMatcher extends ArgumentMatcher<Location> {
private Location l; private Location l;
public LocationMatcher(Location location) { public LocationMatcher(Location location) {
@ -36,24 +41,24 @@ public class MockWorldFactory {
} }
} }
class LocationMatcherAbove extends LocationMatcher { private static class LocationMatcherAbove extends LocationMatcher {
public LocationMatcherAbove(Location location) { public LocationMatcherAbove(Location location) {
super(location); super(location);
} }
public boolean matches(Object creator) { public boolean matches(Object creator) {
System.out.println("Checking above..."); Util.log("Checking above...");
if (super.l == null || creator == null) { if (super.l == null || creator == null) {
return false; return false;
} }
boolean equal = ((Location) creator).getBlockY() >= super.l.getBlockY(); boolean equal = ((Location) creator).getBlockY() >= super.l.getBlockY();
System.out.println("Checking equals/\\..." + equal); Util.log("Checking equals/\\..." + equal);
return equal; return equal;
} }
} }
class LocationMatcherBelow extends LocationMatcher { private static class LocationMatcherBelow extends LocationMatcher {
public LocationMatcherBelow(Location location) { public LocationMatcherBelow(Location location) {
super(location); super(location);
@ -64,12 +69,16 @@ public class MockWorldFactory {
return false; return false;
} }
boolean equal = ((Location) creator).getBlockY() < super.l.getBlockY(); boolean equal = ((Location) creator).getBlockY() < super.l.getBlockY();
System.out.println("Checking equals\\/..." + equal); Util.log("Checking equals\\/..." + equal);
return equal; return equal;
} }
} }
public World makeNewMockWorld(String world, World.Environment env) { private static void registerWorld(World world) {
createdWorlds.put(world.getName(), world);
}
private static World basics(String world, World.Environment env) {
World mockWorld = mock(World.class); World mockWorld = mock(World.class);
when(mockWorld.getName()).thenReturn(world); when(mockWorld.getName()).thenReturn(world);
when(mockWorld.getEnvironment()).thenReturn(env); when(mockWorld.getEnvironment()).thenReturn(env);
@ -81,10 +90,26 @@ public class MockWorldFactory {
return mockWorld; return mockWorld;
} }
public World makeNewMockWorld(String world, World.Environment env, long seed, ChunkGenerator generator) { public static World makeNewMockWorld(String world, World.Environment env) {
World w = this.makeNewMockWorld(world, env); World w = basics(world, env);
when(w.getGenerator()).thenReturn(generator); registerWorld(w);
when(w.getSeed()).thenReturn(seed);
return w; return w;
} }
public static World makeNewMockWorld(String world, World.Environment env, long seed,
ChunkGenerator generator) {
World mockWorld = basics(world, env);
when(mockWorld.getGenerator()).thenReturn(generator);
when(mockWorld.getSeed()).thenReturn(seed);
registerWorld(mockWorld);
return mockWorld;
}
public static World getWorld(String name) {
return createdWorlds.get(name);
}
public static List<World> getWorlds() {
return new ArrayList<World>(createdWorlds.values());
}
} }

18
src/test/java/com/onarandombox/MultiverseCore/test/utils/TestCommandSender.java
View File

@ -7,6 +7,9 @@
package com.onarandombox.MultiverseCore.test.utils; package com.onarandombox.MultiverseCore.test.utils;
import java.util.Set;
import java.util.logging.Logger;
import org.bukkit.ChatColor; import org.bukkit.ChatColor;
import org.bukkit.Server; import org.bukkit.Server;
import org.bukkit.command.CommandSender; import org.bukkit.command.CommandSender;
@ -15,18 +18,17 @@ import org.bukkit.permissions.PermissionAttachment;
import org.bukkit.permissions.PermissionAttachmentInfo; import org.bukkit.permissions.PermissionAttachmentInfo;
import org.bukkit.plugin.Plugin; import org.bukkit.plugin.Plugin;
import java.util.Set;
/**
* Multiverse 2
*
* @author fernferret
*/
public class TestCommandSender implements CommandSender { public class TestCommandSender implements CommandSender {
private Server server; private Server server;
private boolean isOp; private boolean isOp;
static {
Logger.getLogger("CommandSender").setParent(Util.logger);
}
private static final Logger logger = Logger.getLogger("CommandSender");
public TestCommandSender(Server server) { public TestCommandSender(Server server) {
this.server = server; this.server = server;
} }
@ -38,7 +40,7 @@ public class TestCommandSender implements CommandSender {
*/ */
@Override @Override
public void sendMessage(String message) { public void sendMessage(String message) {
System.out.println(ChatColor.stripColor(message)); logger.info(ChatColor.stripColor(message));
} }
/** /**

205
src/test/java/com/onarandombox/MultiverseCore/test/utils/TestInstanceCreator.java
View File

@ -7,104 +7,181 @@
package com.onarandombox.MultiverseCore.test.utils; package com.onarandombox.MultiverseCore.test.utils;
import com.onarandombox.MultiverseCore.MultiverseCore; import static org.mockito.Matchers.anyString;
import static org.mockito.Mockito.*;
import java.io.File;
import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.List;
import java.util.logging.Level;
import java.util.logging.Logger;
import junit.framework.Assert;
import org.bukkit.Bukkit; import org.bukkit.Bukkit;
import org.bukkit.Server; import org.bukkit.Server;
import org.bukkit.World; import org.bukkit.World;
import org.bukkit.WorldCreator; import org.bukkit.WorldCreator;
import org.bukkit.command.CommandSender; import org.bukkit.command.CommandSender;
import org.bukkit.plugin.PluginDescriptionFile;
import org.bukkit.plugin.PluginManager; import org.bukkit.plugin.PluginManager;
import org.bukkit.plugin.java.JavaPlugin; import org.bukkit.plugin.java.JavaPlugin;
import org.mockito.Matchers; import org.mockito.Matchers;
import org.mockito.invocation.InvocationOnMock;
import org.mockito.stubbing.Answer;
import org.powermock.api.mockito.PowerMockito; import org.powermock.api.mockito.PowerMockito;
import java.io.File; import com.onarandombox.MultiverseCore.MultiverseCore;
import java.util.ArrayList; import com.onarandombox.MultiverseCore.api.MultiverseWorld;
import java.util.List; import com.onarandombox.MultiverseCore.utils.FileUtils;
import com.onarandombox.MultiverseCore.utils.WorldManager;
import static org.mockito.Mockito.*;
/**
* Multiverse 2
*
* @author fernferret
*/
public class TestInstanceCreator { public class TestInstanceCreator {
MultiverseCore core; MultiverseCore core;
Server mockServer;
private CommandSender commandSender; private CommandSender commandSender;
public Server setupDefaultServerInstance() { public static final File pluginDirectory = new File("bin/test/server/plugins/coretest");
public static final File serverDirectory = new File("bin/test/server");
MockWorldFactory worldFactory = new MockWorldFactory(); public boolean setUp() {
MVCoreFactory coreFactory = new MVCoreFactory(); try {
MockServerFactory serverFactory = new MockServerFactory(); pluginDirectory.mkdirs();
core = coreFactory.getNewCore(); Assert.assertTrue(pluginDirectory.exists());
// Add Core to the list of loaded plugins
JavaPlugin[] plugins = new JavaPlugin[]{core};
// Mock the Plugin Manager core = PowerMockito.spy(new MultiverseCore());
PluginManager mockPluginManager = PowerMockito.mock(PluginManager.class);
when(mockPluginManager.getPlugins()).thenReturn(plugins);
when(mockPluginManager.getPlugin("Multiverse-Core")).thenReturn(core);
// Make some fake folders to fool the fake MV into thinking these worlds exist // Let's let all MV files go to bin/test
new File(core.getServerFolder(), "world").mkdirs(); doReturn(pluginDirectory).when(core).getDataFolder();
new File(core.getServerFolder(), "world_nether").mkdirs();
new File(core.getServerFolder(), "world_skylands").mkdirs();
// Initialize the Mock Worlds // Return a fake PDF file.
World mockWorld = worldFactory.makeNewMockWorld("world", World.Environment.NORMAL); PluginDescriptionFile pdf = new PluginDescriptionFile("Multiverse-Core", "2.1-Test",
World mockNetherWorld = worldFactory.makeNewMockWorld("world_nether", World.Environment.NETHER); "com.onarandombox.MultiverseCore.MultiverseCore");
World mockSkyWorld = worldFactory.makeNewMockWorld("world_skylands", World.Environment.THE_END); doReturn(pdf).when(core).getDescription();
doReturn(true).when(core).isEnabled();
core.setServerFolder(serverDirectory);
List<World> worldList = new ArrayList<World>(); // Add Core to the list of loaded plugins
worldList.add(mockWorld); JavaPlugin[] plugins = new JavaPlugin[] { core };
worldList.add(mockNetherWorld);
worldList.add(mockSkyWorld);
// Initialize the Mock server. // Mock the Plugin Manager
Server mockServer = serverFactory.getMockServer(); PluginManager mockPluginManager = PowerMockito.mock(PluginManager.class);
when(mockPluginManager.getPlugins()).thenReturn(plugins);
when(mockPluginManager.getPlugin("Multiverse-Core")).thenReturn(core);
when(mockPluginManager.getPermission(anyString())).thenReturn(null);
// Give the server some worlds // Make some fake folders to fool the fake MV into thinking these worlds exist
when(mockServer.getWorld("world")).thenReturn(mockWorld); File worldNormalFile = new File(core.getServerFolder(), "world");
when(mockServer.getWorld("world_nether")).thenReturn(mockNetherWorld); Util.log("Creating world-folder: " + worldNormalFile.getAbsolutePath());
when(mockServer.getWorld("world_skylands")).thenReturn(mockNetherWorld); worldNormalFile.mkdirs();
when(mockServer.getWorlds()).thenReturn(worldList); File worldNetherFile = new File(core.getServerFolder(), "world_nether");
when(mockServer.getPluginManager()).thenReturn(mockPluginManager); Util.log("Creating world-folder: " + worldNetherFile.getAbsolutePath());
worldNetherFile.mkdirs();
File worldSkylandsFile = new File(core.getServerFolder(), "world_skylands");
Util.log("Creating world-folder: " + worldSkylandsFile.getAbsolutePath());
worldSkylandsFile.mkdirs();
// Initialize some worldCreatorMatchers (so we can see when a specific creator is called) // Initialize the Mock server.
WorldCreatorMatcher matchWorld = new WorldCreatorMatcher(new WorldCreator("world")); mockServer = mock(Server.class);
WorldCreator netherCreator = new WorldCreator("world_nether"); when(mockServer.getName()).thenReturn("TestBukkit");
netherCreator.environment(World.Environment.NETHER); Logger.getLogger("Minecraft").setParent(Util.logger);
WorldCreatorMatcher matchNetherWorld = new WorldCreatorMatcher(netherCreator); when(mockServer.getLogger()).thenReturn(Util.logger);
WorldCreator skyCreator = new WorldCreator("world_skylands"); // Give the server some worlds
skyCreator.environment(World.Environment.THE_END); when(mockServer.getWorld(anyString())).thenAnswer(new Answer<World>() {
WorldCreatorMatcher matchSkyWorld = new WorldCreatorMatcher(skyCreator); public World answer(InvocationOnMock invocation) throws Throwable {
String arg;
try {
arg = (String) invocation.getArguments()[0];
} catch (Exception e) {
return null;
}
return MockWorldFactory.getWorld(arg);
}
});
// If a specific creator is called, return the appropreate world. when(mockServer.getWorlds()).thenAnswer(new Answer<List<World>>() {
when(mockServer.createWorld(Matchers.argThat(matchWorld))).thenReturn(mockWorld); public List<World> answer(InvocationOnMock invocation) throws Throwable {
when(mockServer.createWorld(Matchers.argThat(matchNetherWorld))).thenReturn(mockNetherWorld); return MockWorldFactory.getWorlds();
when(mockServer.createWorld(Matchers.argThat(matchSkyWorld))).thenReturn(mockSkyWorld); }
});
// Override some methods that bukkit normally provides us with for Core when(mockServer.getPluginManager()).thenReturn(mockPluginManager);
doReturn(mockServer).when(core).getServer();
// Init our command sender when(mockServer.createWorld(Matchers.isA(WorldCreator.class))).thenAnswer(
commandSender = spy(new TestCommandSender(mockServer)); new Answer<World>() {
Bukkit.setServer(mockServer); public World answer(InvocationOnMock invocation) throws Throwable {
// Load Multiverse Core WorldCreator arg;
core.onLoad(); try {
arg = (WorldCreator) invocation.getArguments()[0];
} catch (Exception e) {
return null;
}
return MockWorldFactory.makeNewMockWorld(arg.name(), arg.environment());
}
});
// Enable it. // Set server
core.onEnable(); Field serverfield = JavaPlugin.class.getDeclaredField("server");
return mockServer; serverfield.setAccessible(true);
serverfield.set(core, mockServer);
// Set worldManager
WorldManager wm = PowerMockito.spy(new WorldManager(core));
Field worldmanagerfield = MultiverseCore.class.getDeclaredField("worldManager");
worldmanagerfield.setAccessible(true);
worldmanagerfield.set(core, wm);
// Init our command sender
commandSender = spy(new TestCommandSender(mockServer));
Bukkit.setServer(mockServer);
// Load Multiverse Core
core.onLoad();
// Enable it.
core.onEnable();
return true;
} catch (Exception e) {
e.printStackTrace();
}
return false;
}
public boolean tearDown() {
List<MultiverseWorld> worlds = new ArrayList<MultiverseWorld>(core.getMVWorldManager()
.getMVWorlds());
for (MultiverseWorld world : worlds) {
core.getMVWorldManager().deleteWorld(world.getName());
}
try {
Field serverField = Bukkit.class.getDeclaredField("server");
serverField.setAccessible(true);
serverField.set(Class.forName("org.bukkit.Bukkit"), null);
} catch (Exception e) {
Util.log(Level.SEVERE,
"Error while trying to unregister the server from Bukkit. Has Bukkit changed?");
e.printStackTrace();
Assert.fail(e.getMessage());
return false;
}
FileUtils.deleteFolder(serverDirectory);
return true;
} }
public MultiverseCore getCore() { public MultiverseCore getCore() {
return this.core; return this.core;
} }
public Server getServer() {
return this.mockServer;
}
public CommandSender getCommandSender() { public CommandSender getCommandSender() {
return commandSender; return commandSender;
} }

57
src/test/java/com/onarandombox/MultiverseCore/test/utils/Util.java Normal file
View File

@ -0,0 +1,57 @@
/******************************************************************************
* Multiverse 2 Copyright (c) the Multiverse Team 2011. *
* Multiverse 2 is licensed under the BSD License. *
* For more information please check the README.md file included *
* with this project. *
******************************************************************************/
package com.onarandombox.MultiverseCore.test.utils;
import java.util.logging.ConsoleHandler;
import java.util.logging.Handler;
import java.util.logging.Level;
import java.util.logging.LogRecord;
import java.util.logging.Logger;
public class Util {
public static final Logger logger = Logger.getLogger("MV-Test");
static {
logger.setUseParentHandlers(false);
Handler handler = new ConsoleHandler();
handler.setFormatter(new MVTestLogFormatter());
Handler[] handlers = logger.getHandlers();
for (Handler h : handlers)
logger.removeHandler(h);
logger.addHandler(handler);
}
public static void log(Throwable t) {
log(Level.WARNING, t.getLocalizedMessage(), t);
}
public static void log(Level level, Throwable t) {
log(level, t.getLocalizedMessage(), t);
}
public static void log(String message, Throwable t) {
log(Level.WARNING, message, t);
}
public static void log(Level level, String message, Throwable t) {
LogRecord record = new LogRecord(level, message);
record.setThrown(t);
logger.log(record);
}
public static void log(String message) {
log(Level.INFO, message);
}
public static void log(Level level, String message) {
logger.log(level, message);
}
}

14
src/test/java/com/onarandombox/MultiverseCore/test/utils/WorldCreatorMatcher.java
View File

@ -16,7 +16,7 @@ public class WorldCreatorMatcher extends ArgumentMatcher<WorldCreator> {
private boolean careAboutGenerators = false; private boolean careAboutGenerators = false;
public WorldCreatorMatcher(WorldCreator creator) { public WorldCreatorMatcher(WorldCreator creator) {
System.out.println("Creating NEW world matcher.(" + creator.name() + ")"); Util.log("Creating NEW world matcher.(" + creator.name() + ")");
this.worldCreator = creator; this.worldCreator = creator;
} }
@ -29,17 +29,17 @@ public class WorldCreatorMatcher extends ArgumentMatcher<WorldCreator> {
} }
public boolean matches(Object creator) { public boolean matches(Object creator) {
System.out.println("Checking world creators."); Util.log("Checking world creators.");
if (creator == null) { if (creator == null) {
System.out.println("The given creator was null, but I was checking: " + this.worldCreator.name()); Util.log("The given creator was null, but I was checking: " + this.worldCreator.name());
return false; return false;
} }
System.out.println("Checking Names...(" + ((WorldCreator) creator).name() + ") vs (" + this.worldCreator.name() + ")"); Util.log("Checking Names...(" + ((WorldCreator) creator).name() + ") vs (" + this.worldCreator.name() + ")");
System.out.println("Checking Envs...(" + ((WorldCreator) creator).environment() + ") vs (" + this.worldCreator.environment() + ")"); Util.log("Checking Envs...(" + ((WorldCreator) creator).environment() + ") vs (" + this.worldCreator.environment() + ")");
if (!((WorldCreator) creator).name().equals(this.worldCreator.name())) { if (!((WorldCreator) creator).name().equals(this.worldCreator.name())) {
return false; return false;
} else if (!((WorldCreator) creator).environment().equals(this.worldCreator.environment())) { } else if (!((WorldCreator) creator).environment().equals(this.worldCreator.environment())) {
System.out.println("Checking Environments..."); Util.log("Checking Environments...");
return false; return false;
} else if (careAboutSeeds && ((WorldCreator) creator).seed() != this.worldCreator.seed()) { } else if (careAboutSeeds && ((WorldCreator) creator).seed() != this.worldCreator.seed()) {
System.out.print("Checking Seeds..."); System.out.print("Checking Seeds...");
@ -48,7 +48,7 @@ public class WorldCreatorMatcher extends ArgumentMatcher<WorldCreator> {
System.out.print("Checking Gens..."); System.out.print("Checking Gens...");
return false; return false;
} }
System.out.println("Creators matched!!!"); Util.log("Creators matched!!!");
return true; return true;
} }
} }

1
worlds.yml
View File

@ -1 +0,0 @@
worlds: {}