From ce4f4af087f55bed13c5821dd631b520a7286e8c Mon Sep 17 00:00:00 2001 From: Nathan Adams Date: Fri, 13 Jan 2012 08:51:10 +0000 Subject: Implemented new Plugin Message API - see http://dinnerbone.com/blog/2012/01/13/minecraft-plugin-channels-messaging/ --- .../plugin/messaging/StandardMessengerTest.java | 288 ++++++++++ .../plugin/messaging/TestMessageListener.java | 29 + .../org/bukkit/plugin/messaging/TestPlayer.java | 605 +++++++++++++++++++++ .../org/bukkit/plugin/messaging/TestPlugin.java | 116 ++++ 4 files changed, 1038 insertions(+) create mode 100644 src/test/java/org/bukkit/plugin/messaging/StandardMessengerTest.java create mode 100644 src/test/java/org/bukkit/plugin/messaging/TestMessageListener.java create mode 100644 src/test/java/org/bukkit/plugin/messaging/TestPlayer.java create mode 100644 src/test/java/org/bukkit/plugin/messaging/TestPlugin.java (limited to 'src/test/java/org') 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 void assertEquals(Collection 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 getLineOfSight(HashSet transparent, int maxDistance) { + throw new UnsupportedOperationException("Not supported yet."); + } + + public Block getTargetBlock(HashSet transparent, int maxDistance) { + throw new UnsupportedOperationException("Not supported yet."); + } + + public List getLastTwoTargetBlocks(HashSet 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 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 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 serialize() { + throw new UnsupportedOperationException("Not supported yet."); + } + + public void sendPluginMessage(Plugin source, String channel, byte[] message) { + throw new UnsupportedOperationException("Not supported yet."); + } + + public Set 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."); + } + +} -- cgit v1.2.3