summaryrefslogtreecommitdiffstats
path: root/src/test/java
diff options
context:
space:
mode:
authorNathan Adams <dinnerbone@dinnerbone.com>2012-01-13 08:51:10 +0000
committerNathan Adams <dinnerbone@dinnerbone.com>2012-01-13 08:53:14 +0000
commitce4f4af087f55bed13c5821dd631b520a7286e8c (patch)
treee7d84ec7d0bc88f1dd04757379fb9fa158b35341 /src/test/java
parent389d70dbe2279253cf5ea5fcb97a6ed894f9e426 (diff)
downloadbukkit-ce4f4af087f55bed13c5821dd631b520a7286e8c.tar
bukkit-ce4f4af087f55bed13c5821dd631b520a7286e8c.tar.gz
bukkit-ce4f4af087f55bed13c5821dd631b520a7286e8c.tar.lz
bukkit-ce4f4af087f55bed13c5821dd631b520a7286e8c.tar.xz
bukkit-ce4f4af087f55bed13c5821dd631b520a7286e8c.zip
Implemented new Plugin Message API - see http://dinnerbone.com/blog/2012/01/13/minecraft-plugin-channels-messaging/
Diffstat (limited to 'src/test/java')
-rw-r--r--src/test/java/org/bukkit/plugin/messaging/StandardMessengerTest.java288
-rw-r--r--src/test/java/org/bukkit/plugin/messaging/TestMessageListener.java29
-rw-r--r--src/test/java/org/bukkit/plugin/messaging/TestPlayer.java605
-rw-r--r--src/test/java/org/bukkit/plugin/messaging/TestPlugin.java116
4 files changed, 1038 insertions, 0 deletions
diff --git a/src/test/java/org/bukkit/plugin/messaging/StandardMessengerTest.java b/src/test/java/org/bukkit/plugin/messaging/StandardMessengerTest.java
new file mode 100644
index 00000000..abf85427
--- /dev/null
+++ b/src/test/java/org/bukkit/plugin/messaging/StandardMessengerTest.java
@@ -0,0 +1,288 @@
+package org.bukkit.plugin.messaging;
+
+import org.bukkit.plugin.messaging.ReservedChannelException;
+import java.util.Collection;
+import org.junit.Test;
+import static org.junit.Assert.*;
+import static org.hamcrest.CoreMatchers.*;
+import static org.junit.matchers.JUnitMatchers.*;
+
+public class StandardMessengerTest {
+ public StandardMessenger getMessenger() {
+ return new StandardMessenger();
+ }
+
+ public TestPlugin getPlugin() {
+ return new TestPlugin();
+ }
+
+ @Test
+ public void testIsReservedChannel() {
+ Messenger messenger = getMessenger();
+
+ assertTrue(messenger.isReservedChannel("REGISTER"));
+ assertFalse(messenger.isReservedChannel("register"));
+ assertTrue(messenger.isReservedChannel("UNREGISTER"));
+ assertFalse(messenger.isReservedChannel("unregister"));
+ assertFalse(messenger.isReservedChannel("notReserved"));
+ }
+
+ @Test
+ public void testRegisterAndUnregisterOutgoingPluginChannel() {
+ Messenger messenger = getMessenger();
+ TestPlugin plugin = getPlugin();
+
+ assertFalse(messenger.isOutgoingChannelRegistered(plugin, "foo"));
+ messenger.registerOutgoingPluginChannel(plugin, "foo");
+ assertTrue(messenger.isOutgoingChannelRegistered(plugin, "foo"));
+ assertFalse(messenger.isOutgoingChannelRegistered(plugin, "bar"));
+
+ messenger.unregisterOutgoingPluginChannel(plugin, "foo");
+ assertFalse(messenger.isOutgoingChannelRegistered(plugin, "foo"));
+ }
+
+ @Test(expected=ReservedChannelException.class)
+ public void testReservedOutgoingRegistration() {
+ Messenger messenger = getMessenger();
+ TestPlugin plugin = getPlugin();
+
+ messenger.registerOutgoingPluginChannel(plugin, "REGISTER");
+ }
+
+ @Test
+ public void testUnregisterOutgoingPluginChannel_Plugin() {
+ Messenger messenger = getMessenger();
+ TestPlugin plugin = getPlugin();
+
+ assertFalse(messenger.isOutgoingChannelRegistered(plugin, "foo"));
+ messenger.registerOutgoingPluginChannel(plugin, "foo");
+ messenger.registerOutgoingPluginChannel(plugin, "bar");
+ assertTrue(messenger.isOutgoingChannelRegistered(plugin, "foo"));
+ assertTrue(messenger.isOutgoingChannelRegistered(plugin, "bar"));
+
+ messenger.unregisterOutgoingPluginChannel(plugin);
+ assertFalse(messenger.isOutgoingChannelRegistered(plugin, "foo"));
+ assertFalse(messenger.isOutgoingChannelRegistered(plugin, "bar"));
+ }
+
+ @Test
+ public void testRegisterIncomingPluginChannel() {
+ Messenger messenger = getMessenger();
+ TestPlugin plugin = getPlugin();
+ TestMessageListener listener = new TestMessageListener("foo", "bar".getBytes());
+ TestPlayer player = new TestPlayer();
+ PluginMessageListenerRegistration registration = messenger.registerIncomingPluginChannel(plugin, "foo", listener);
+
+ assertTrue(registration.isValid());
+ assertTrue(messenger.isIncomingChannelRegistered(plugin, "foo"));
+ messenger.dispatchIncomingMessage(player, "foo", "bar".getBytes());
+ assertTrue(listener.hasReceived());
+
+ messenger.unregisterIncomingPluginChannel(plugin, "foo", listener);
+ listener.reset();
+
+ assertFalse(registration.isValid());
+ assertFalse(messenger.isIncomingChannelRegistered(plugin, "foo"));
+ messenger.dispatchIncomingMessage(player, "foo", "bar".getBytes());
+ assertFalse(listener.hasReceived());
+ }
+
+ @Test(expected=ReservedChannelException.class)
+ public void testReservedIncomingRegistration() {
+ Messenger messenger = getMessenger();
+ TestPlugin plugin = getPlugin();
+
+ messenger.registerIncomingPluginChannel(plugin, "REGISTER", new TestMessageListener("foo", "bar".getBytes()));
+ }
+
+ @Test(expected=IllegalArgumentException.class)
+ public void testDuplicateIncomingRegistration() {
+ Messenger messenger = getMessenger();
+ TestPlugin plugin = getPlugin();
+ TestMessageListener listener = new TestMessageListener("foo", "bar".getBytes());
+
+ messenger.registerIncomingPluginChannel(plugin, "baz", listener);
+ messenger.registerIncomingPluginChannel(plugin, "baz", listener);
+ }
+
+ @Test
+ public void testUnregisterIncomingPluginChannel_Plugin_String() {
+ Messenger messenger = getMessenger();
+ TestPlugin plugin = getPlugin();
+ TestMessageListener listener1 = new TestMessageListener("foo", "bar".getBytes());
+ TestMessageListener listener2 = new TestMessageListener("baz", "qux".getBytes());
+ TestPlayer player = new TestPlayer();
+ PluginMessageListenerRegistration registration1 = messenger.registerIncomingPluginChannel(plugin, "foo", listener1);
+ PluginMessageListenerRegistration registration2 = messenger.registerIncomingPluginChannel(plugin, "baz", listener2);
+
+ assertTrue(registration1.isValid());
+ assertTrue(registration2.isValid());
+ messenger.dispatchIncomingMessage(player, "foo", "bar".getBytes());
+ messenger.dispatchIncomingMessage(player, "baz", "qux".getBytes());
+ assertTrue(listener1.hasReceived());
+ assertTrue(listener2.hasReceived());
+
+ messenger.unregisterIncomingPluginChannel(plugin, "foo");
+ listener1.reset();
+ listener2.reset();
+
+ assertFalse(registration1.isValid());
+ assertTrue(registration2.isValid());
+ messenger.dispatchIncomingMessage(player, "foo", "bar".getBytes());
+ messenger.dispatchIncomingMessage(player, "baz", "qux".getBytes());
+ assertFalse(listener1.hasReceived());
+ assertTrue(listener2.hasReceived());
+ }
+
+ @Test
+ public void testUnregisterIncomingPluginChannel_Plugin() {
+ Messenger messenger = getMessenger();
+ TestPlugin plugin = getPlugin();
+ TestMessageListener listener1 = new TestMessageListener("foo", "bar".getBytes());
+ TestMessageListener listener2 = new TestMessageListener("baz", "qux".getBytes());
+ TestPlayer player = new TestPlayer();
+ PluginMessageListenerRegistration registration1 = messenger.registerIncomingPluginChannel(plugin, "foo", listener1);
+ PluginMessageListenerRegistration registration2 = messenger.registerIncomingPluginChannel(plugin, "baz", listener2);
+
+ assertTrue(registration1.isValid());
+ assertTrue(registration2.isValid());
+ messenger.dispatchIncomingMessage(player, "foo", "bar".getBytes());
+ messenger.dispatchIncomingMessage(player, "baz", "qux".getBytes());
+ assertTrue(listener1.hasReceived());
+ assertTrue(listener2.hasReceived());
+
+ messenger.unregisterIncomingPluginChannel(plugin);
+ listener1.reset();
+ listener2.reset();
+
+ assertFalse(registration1.isValid());
+ assertFalse(registration2.isValid());
+ messenger.dispatchIncomingMessage(player, "foo", "bar".getBytes());
+ messenger.dispatchIncomingMessage(player, "baz", "qux".getBytes());
+ assertFalse(listener1.hasReceived());
+ assertFalse(listener2.hasReceived());
+ }
+
+ @Test
+ public void testGetOutgoingChannels() {
+ Messenger messenger = getMessenger();
+ TestPlugin plugin1 = getPlugin();
+ TestPlugin plugin2 = getPlugin();
+
+ assertEquals(messenger.getOutgoingChannels());
+
+ messenger.registerOutgoingPluginChannel(plugin1, "foo");
+ messenger.registerOutgoingPluginChannel(plugin1, "bar");
+ messenger.registerOutgoingPluginChannel(plugin2, "baz");
+ messenger.registerOutgoingPluginChannel(plugin2, "baz");
+
+ assertEquals(messenger.getOutgoingChannels(), "foo", "bar", "baz");
+ }
+
+ @Test
+ public void testGetOutgoingChannels_Plugin() {
+ Messenger messenger = getMessenger();
+ TestPlugin plugin1 = getPlugin();
+ TestPlugin plugin2 = getPlugin();
+ TestPlugin plugin3 = getPlugin();
+
+ messenger.registerOutgoingPluginChannel(plugin1, "foo");
+ messenger.registerOutgoingPluginChannel(plugin1, "bar");
+ messenger.registerOutgoingPluginChannel(plugin2, "baz");
+ messenger.registerOutgoingPluginChannel(plugin2, "qux");
+
+ assertEquals(messenger.getOutgoingChannels(plugin1), "foo", "bar");
+ assertEquals(messenger.getOutgoingChannels(plugin2), "baz", "qux");
+ assertEquals(messenger.getOutgoingChannels(plugin3));
+ }
+
+ @Test
+ public void testGetIncomingChannels() {
+ Messenger messenger = getMessenger();
+ TestPlugin plugin1 = getPlugin();
+ TestPlugin plugin2 = getPlugin();
+
+ assertEquals(messenger.getIncomingChannels());
+
+ messenger.registerIncomingPluginChannel(plugin1, "foo", new TestMessageListener("foo", "bar".getBytes()));
+ messenger.registerIncomingPluginChannel(plugin1, "bar", new TestMessageListener("foo", "bar".getBytes()));
+ messenger.registerIncomingPluginChannel(plugin2, "baz", new TestMessageListener("foo", "bar".getBytes()));
+ messenger.registerIncomingPluginChannel(plugin2, "baz", new TestMessageListener("foo", "bar".getBytes()));
+
+ assertEquals(messenger.getIncomingChannels(), "foo", "bar", "baz");
+ }
+
+ @Test
+ public void testGetIncomingChannels_Plugin() {
+ Messenger messenger = getMessenger();
+ TestPlugin plugin1 = getPlugin();
+ TestPlugin plugin2 = getPlugin();
+ TestPlugin plugin3 = getPlugin();
+
+ messenger.registerIncomingPluginChannel(plugin1, "foo", new TestMessageListener("foo", "bar".getBytes()));
+ messenger.registerIncomingPluginChannel(plugin1, "bar", new TestMessageListener("foo", "bar".getBytes()));
+ messenger.registerIncomingPluginChannel(plugin2, "baz", new TestMessageListener("foo", "bar".getBytes()));
+ messenger.registerIncomingPluginChannel(plugin2, "qux", new TestMessageListener("foo", "bar".getBytes()));
+
+ assertEquals(messenger.getIncomingChannels(plugin1), "foo", "bar");
+ assertEquals(messenger.getIncomingChannels(plugin2), "baz", "qux");
+ assertEquals(messenger.getIncomingChannels(plugin3));
+ }
+
+ @Test
+ public void testGetIncomingChannelRegistrations_Plugin() {
+ Messenger messenger = getMessenger();
+ TestPlugin plugin1 = getPlugin();
+ TestPlugin plugin2 = getPlugin();
+ TestPlugin plugin3 = getPlugin();
+ PluginMessageListenerRegistration registration1 = messenger.registerIncomingPluginChannel(plugin1, "foo", new TestMessageListener("foo", "bar".getBytes()));
+ PluginMessageListenerRegistration registration2 = messenger.registerIncomingPluginChannel(plugin1, "bar", new TestMessageListener("foo", "bar".getBytes()));
+ PluginMessageListenerRegistration registration3 = messenger.registerIncomingPluginChannel(plugin2, "baz", new TestMessageListener("foo", "bar".getBytes()));
+ PluginMessageListenerRegistration registration4 = messenger.registerIncomingPluginChannel(plugin2, "qux", new TestMessageListener("foo", "bar".getBytes()));
+
+ assertEquals(messenger.getIncomingChannelRegistrations(plugin1), registration1, registration2);
+ assertEquals(messenger.getIncomingChannelRegistrations(plugin2), registration3, registration4);
+ assertEquals(messenger.getIncomingChannels(plugin3));
+ }
+
+ @Test
+ public void testGetIncomingChannelRegistrations_String() {
+ Messenger messenger = getMessenger();
+ TestPlugin plugin1 = getPlugin();
+ TestPlugin plugin2 = getPlugin();
+ PluginMessageListenerRegistration registration1 = messenger.registerIncomingPluginChannel(plugin1, "foo", new TestMessageListener("foo", "bar".getBytes()));
+ PluginMessageListenerRegistration registration2 = messenger.registerIncomingPluginChannel(plugin1, "bar", new TestMessageListener("foo", "bar".getBytes()));
+ PluginMessageListenerRegistration registration3 = messenger.registerIncomingPluginChannel(plugin2, "foo", new TestMessageListener("foo", "bar".getBytes()));
+ PluginMessageListenerRegistration registration4 = messenger.registerIncomingPluginChannel(plugin2, "bar", new TestMessageListener("foo", "bar".getBytes()));
+
+ assertEquals(messenger.getIncomingChannelRegistrations("foo"), registration1, registration3);
+ assertEquals(messenger.getIncomingChannelRegistrations("bar"), registration2, registration4);
+ assertEquals(messenger.getIncomingChannelRegistrations("baz"));
+ }
+
+ @Test
+ public void testGetIncomingChannelRegistrations_Plugin_String() {
+ Messenger messenger = getMessenger();
+ TestPlugin plugin1 = getPlugin();
+ TestPlugin plugin2 = getPlugin();
+ TestPlugin plugin3 = getPlugin();
+ PluginMessageListenerRegistration registration1 = messenger.registerIncomingPluginChannel(plugin1, "foo", new TestMessageListener("foo", "bar".getBytes()));
+ PluginMessageListenerRegistration registration2 = messenger.registerIncomingPluginChannel(plugin1, "foo", new TestMessageListener("foo", "bar".getBytes()));
+ PluginMessageListenerRegistration registration3 = messenger.registerIncomingPluginChannel(plugin1, "bar", new TestMessageListener("foo", "bar".getBytes()));
+ PluginMessageListenerRegistration registration4 = messenger.registerIncomingPluginChannel(plugin2, "bar", new TestMessageListener("foo", "bar".getBytes()));
+ PluginMessageListenerRegistration registration5 = messenger.registerIncomingPluginChannel(plugin2, "baz", new TestMessageListener("foo", "bar".getBytes()));
+ PluginMessageListenerRegistration registration6 = messenger.registerIncomingPluginChannel(plugin2, "baz", new TestMessageListener("foo", "bar".getBytes()));
+
+ assertEquals(messenger.getIncomingChannelRegistrations(plugin1, "foo"), registration1, registration2);
+ assertEquals(messenger.getIncomingChannelRegistrations(plugin1, "bar"), registration3);
+ assertEquals(messenger.getIncomingChannelRegistrations(plugin2, "bar"), registration4);
+ assertEquals(messenger.getIncomingChannelRegistrations(plugin2, "baz"), registration5, registration6);
+ assertEquals(messenger.getIncomingChannelRegistrations(plugin1, "baz"));
+ assertEquals(messenger.getIncomingChannelRegistrations(plugin3, "qux"));
+ }
+
+ private static <T> void assertEquals(Collection<T> actual, T... expected) {
+ assertThat("Size of the array", actual.size(), is(expected.length));
+ assertThat(actual, hasItems(expected));
+ }
+}
diff --git a/src/test/java/org/bukkit/plugin/messaging/TestMessageListener.java b/src/test/java/org/bukkit/plugin/messaging/TestMessageListener.java
new file mode 100644
index 00000000..98860ec1
--- /dev/null
+++ b/src/test/java/org/bukkit/plugin/messaging/TestMessageListener.java
@@ -0,0 +1,29 @@
+package org.bukkit.plugin.messaging;
+
+import org.bukkit.entity.Player;
+import static org.junit.Assert.*;
+
+public class TestMessageListener implements PluginMessageListener {
+ private final String channel;
+ private final byte[] message;
+ private boolean received = false;
+
+ public TestMessageListener(String channel, byte[] message) {
+ this.channel = channel;
+ this.message = message;
+ }
+
+ public void onPluginMessageReceived(String channel, Player player, byte[] message) {
+ assertEquals(this.channel, channel);
+ assertArrayEquals(this.message, message);
+ this.received = true;
+ }
+
+ public boolean hasReceived() {
+ return received;
+ }
+
+ public void reset() {
+ received = false;
+ }
+}
diff --git a/src/test/java/org/bukkit/plugin/messaging/TestPlayer.java b/src/test/java/org/bukkit/plugin/messaging/TestPlayer.java
new file mode 100644
index 00000000..5c392a87
--- /dev/null
+++ b/src/test/java/org/bukkit/plugin/messaging/TestPlayer.java
@@ -0,0 +1,605 @@
+package org.bukkit.plugin.messaging;
+
+import java.net.InetSocketAddress;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.UUID;
+import org.bukkit.Achievement;
+import org.bukkit.Effect;
+import org.bukkit.GameMode;
+import org.bukkit.Instrument;
+import org.bukkit.Location;
+import org.bukkit.Material;
+import org.bukkit.Note;
+import org.bukkit.Server;
+import org.bukkit.Statistic;
+import org.bukkit.World;
+import org.bukkit.block.Block;
+import org.bukkit.entity.Arrow;
+import org.bukkit.entity.Egg;
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.Player;
+import org.bukkit.entity.Snowball;
+import org.bukkit.entity.Vehicle;
+import org.bukkit.event.entity.EntityDamageEvent;
+import org.bukkit.event.player.PlayerTeleportEvent.TeleportCause;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.PlayerInventory;
+import org.bukkit.map.MapView;
+import org.bukkit.permissions.Permission;
+import org.bukkit.permissions.PermissionAttachment;
+import org.bukkit.permissions.PermissionAttachmentInfo;
+import org.bukkit.plugin.Plugin;
+import org.bukkit.util.Vector;
+
+public class TestPlayer implements Player {
+ public String getDisplayName() {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ public void setDisplayName(String name) {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ public String getPlayerListName() {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ public void setPlayerListName(String name) {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ public void setCompassTarget(Location loc) {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ public Location getCompassTarget() {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ public InetSocketAddress getAddress() {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ public void sendRawMessage(String message) {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ public void kickPlayer(String message) {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ public void chat(String msg) {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ public boolean performCommand(String command) {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ public boolean isSneaking() {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ public void setSneaking(boolean sneak) {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ public boolean isSprinting() {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ public void setSprinting(boolean sprinting) {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ public void saveData() {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ public void loadData() {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ public void setSleepingIgnored(boolean isSleeping) {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ public boolean isSleepingIgnored() {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ public void playNote(Location loc, byte instrument, byte note) {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ public void playNote(Location loc, Instrument instrument, Note note) {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ public void playEffect(Location loc, Effect effect, int data) {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ public void sendBlockChange(Location loc, Material material, byte data) {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ public boolean sendChunkChange(Location loc, int sx, int sy, int sz, byte[] data) {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ public void sendBlockChange(Location loc, int material, byte data) {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ public void sendMap(MapView map) {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ public void updateInventory() {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ public void awardAchievement(Achievement achievement) {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ public void incrementStatistic(Statistic statistic) {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ public void incrementStatistic(Statistic statistic, int amount) {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ public void incrementStatistic(Statistic statistic, Material material) {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ public void incrementStatistic(Statistic statistic, Material material, int amount) {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ public void setPlayerTime(long time, boolean relative) {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ public long getPlayerTime() {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ public long getPlayerTimeOffset() {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ public boolean isPlayerTimeRelative() {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ public void resetPlayerTime() {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ public void giveExp(int amount) {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ public float getExp() {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ public void setExp(float exp) {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ public int getExperience() {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ public void setExperience(int exp) {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ public int getLevel() {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ public void setLevel(int level) {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ public int getTotalExperience() {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ public void setTotalExperience(int exp) {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ public float getExhaustion() {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ public void setExhaustion(float value) {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ public float getSaturation() {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ public void setSaturation(float value) {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ public int getFoodLevel() {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ public void setFoodLevel(int value) {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ public Location getBedSpawnLocation() {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ public String getName() {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ public PlayerInventory getInventory() {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ public ItemStack getItemInHand() {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ public void setItemInHand(ItemStack item) {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ public boolean isSleeping() {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ public int getSleepTicks() {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ public GameMode getGameMode() {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ public void setGameMode(GameMode mode) {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ public int getHealth() {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ public void setHealth(int health) {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ public int getMaxHealth() {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ public double getEyeHeight() {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ public double getEyeHeight(boolean ignoreSneaking) {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ public Location getEyeLocation() {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ public List<Block> getLineOfSight(HashSet<Byte> transparent, int maxDistance) {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ public Block getTargetBlock(HashSet<Byte> transparent, int maxDistance) {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ public List<Block> getLastTwoTargetBlocks(HashSet<Byte> transparent, int maxDistance) {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ public Egg throwEgg() {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ public Snowball throwSnowball() {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ public Arrow shootArrow() {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ public boolean isInsideVehicle() {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ public boolean leaveVehicle() {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ public Vehicle getVehicle() {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ public int getRemainingAir() {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ public void setRemainingAir(int ticks) {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ public int getMaximumAir() {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ public void setMaximumAir(int ticks) {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ public void damage(int amount) {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ public void damage(int amount, Entity source) {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ public int getMaximumNoDamageTicks() {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ public void setMaximumNoDamageTicks(int ticks) {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ public int getLastDamage() {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ public void setLastDamage(int damage) {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ public int getNoDamageTicks() {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ public void setNoDamageTicks(int ticks) {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ public Player getKiller() {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ public Location getLocation() {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ public void setVelocity(Vector velocity) {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ public Vector getVelocity() {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ public World getWorld() {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ public boolean teleport(Location location) {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ public boolean teleport(Location location, TeleportCause cause) {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ public boolean teleport(Entity destination) {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ public boolean teleport(Entity destination, TeleportCause cause) {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ public List<Entity> getNearbyEntities(double x, double y, double z) {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ public int getEntityId() {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ public int getFireTicks() {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ public int getMaxFireTicks() {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ public void setFireTicks(int ticks) {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ public void remove() {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ public boolean isDead() {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ public Server getServer() {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ public Entity getPassenger() {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ public boolean setPassenger(Entity passenger) {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ public boolean isEmpty() {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ public boolean eject() {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ public float getFallDistance() {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ public void setFallDistance(float distance) {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ public void setLastDamageCause(EntityDamageEvent event) {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ public EntityDamageEvent getLastDamageCause() {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ public UUID getUniqueId() {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ public int getTicksLived() {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ public void setTicksLived(int value) {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ public boolean isPermissionSet(String name) {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ public boolean isPermissionSet(Permission perm) {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ public boolean hasPermission(String name) {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ public boolean hasPermission(Permission perm) {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ public PermissionAttachment addAttachment(Plugin plugin, String name, boolean value) {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ public PermissionAttachment addAttachment(Plugin plugin) {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ public PermissionAttachment addAttachment(Plugin plugin, String name, boolean value, int ticks) {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ public PermissionAttachment addAttachment(Plugin plugin, int ticks) {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ public void removeAttachment(PermissionAttachment attachment) {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ public void recalculatePermissions() {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ public Set<PermissionAttachmentInfo> getEffectivePermissions() {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ public boolean isOp() {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ public void setOp(boolean value) {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ public void sendMessage(String message) {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ public boolean isOnline() {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ public boolean isBanned() {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ public void setBanned(boolean banned) {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ public boolean isWhitelisted() {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ public void setWhitelisted(boolean value) {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ public Player getPlayer() {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ public long getFirstPlayed() {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ public long getLastPlayed() {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ public boolean hasPlayedBefore() {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ public Map<String, Object> serialize() {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ public void sendPluginMessage(Plugin source, String channel, byte[] message) {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ public Set<String> getListeningPluginChannels() {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+}
diff --git a/src/test/java/org/bukkit/plugin/messaging/TestPlugin.java b/src/test/java/org/bukkit/plugin/messaging/TestPlugin.java
new file mode 100644
index 00000000..060b742a
--- /dev/null
+++ b/src/test/java/org/bukkit/plugin/messaging/TestPlugin.java
@@ -0,0 +1,116 @@
+package org.bukkit.plugin.messaging;
+
+import com.avaje.ebean.EbeanServer;
+import java.io.File;
+import java.io.InputStream;
+import org.bukkit.Server;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.configuration.file.FileConfiguration;
+import org.bukkit.event.Event.Type;
+import org.bukkit.generator.ChunkGenerator;
+import org.bukkit.plugin.Plugin;
+import org.bukkit.plugin.PluginDescriptionFile;
+import org.bukkit.plugin.PluginLoader;
+import org.bukkit.util.config.Configuration;
+
+public class TestPlugin implements Plugin {
+ private boolean enabled = true;
+
+ public void setEnabled(boolean enabled) {
+ this.enabled = enabled;
+ }
+
+ public File getDataFolder() {
+ throw new UnsupportedOperationException("Not supported.");
+ }
+
+ public PluginDescriptionFile getDescription() {
+ throw new UnsupportedOperationException("Not supported.");
+ }
+
+ public Configuration getConfiguration() {
+ throw new UnsupportedOperationException("Not supported.");
+ }
+
+ public FileConfiguration getConfig() {
+ throw new UnsupportedOperationException("Not supported.");
+ }
+
+ public InputStream getResource(String filename) {
+ throw new UnsupportedOperationException("Not supported.");
+ }
+
+ public void saveConfig() {
+ throw new UnsupportedOperationException("Not supported.");
+ }
+
+ public void saveDefaultConfig() {
+ throw new UnsupportedOperationException("Not supported.");
+ }
+
+ public void saveResource(String resourcePath, boolean replace) {
+ throw new UnsupportedOperationException("Not supported.");
+ }
+
+ public void reloadConfig() {
+ throw new UnsupportedOperationException("Not supported.");
+ }
+
+ public PluginLoader getPluginLoader() {
+ throw new UnsupportedOperationException("Not supported.");
+ }
+
+ public Server getServer() {
+ throw new UnsupportedOperationException("Not supported.");
+ }
+
+ public boolean isEnabled() {
+ return enabled;
+ }
+
+ public void onDisable() {
+ throw new UnsupportedOperationException("Not supported.");
+ }
+
+ public void onLoad() {
+ throw new UnsupportedOperationException("Not supported.");
+ }
+
+ public void onEnable() {
+ throw new UnsupportedOperationException("Not supported.");
+ }
+
+ public boolean isNaggable() {
+ throw new UnsupportedOperationException("Not supported.");
+ }
+
+ public void setNaggable(boolean canNag) {
+ throw new UnsupportedOperationException("Not supported.");
+ }
+
+ public EbeanServer getDatabase() {
+ throw new UnsupportedOperationException("Not supported.");
+ }
+
+ public ChunkGenerator getDefaultWorldGenerator(String worldName, String id) {
+ throw new UnsupportedOperationException("Not supported.");
+ }
+
+ public long getTiming(Type type) {
+ throw new UnsupportedOperationException("Not supported.");
+ }
+
+ public void incTiming(Type type, long delta) {
+ throw new UnsupportedOperationException("Not supported.");
+ }
+
+ public void resetTimings() {
+ throw new UnsupportedOperationException("Not supported.");
+ }
+
+ public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
+ throw new UnsupportedOperationException("Not supported.");
+ }
+
+}