Upstream Paper

src/test/java/org/bukkit/ArtTest.java

@@ -0,0 +1,69 @@
+package org.bukkit;
+
+import static org.junit.Assert.*;
+import static org.hamcrest.Matchers.*;
+
+import java.util.Collections;
+import java.util.EnumMap;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import net.minecraft.server.IRegistry;
+import net.minecraft.server.MinecraftKey;
+import net.minecraft.server.Paintings;
+
+import org.bukkit.craftbukkit.CraftArt;
+import org.junit.Test;
+
+import com.google.common.collect.Lists;
+import org.bukkit.support.AbstractTestingBase;
+
+public class ArtTest extends AbstractTestingBase {
+    private static final int UNIT_MULTIPLIER = 16;
+
+    @Test
+    public void verifyMapping() {
+        List<Art> arts = Lists.newArrayList(Art.values());
+
+        for (MinecraftKey key : IRegistry.MOTIVE.keySet()) {
+            Paintings enumArt = IRegistry.MOTIVE.get(key);
+            String name = key.getKey();
+            int width = enumArt.b() / UNIT_MULTIPLIER;
+            int height = enumArt.c() / UNIT_MULTIPLIER;
+
+            Art subject = CraftArt.NotchToBukkit(enumArt);
+
+            String message = String.format("org.bukkit.Art is missing '%s'", name);
+            assertNotNull(message, subject);
+
+            assertThat(Art.getByName(name), is(subject));
+            assertThat("Art." + subject + "'s width", subject.getBlockWidth(), is(width));
+            assertThat("Art." + subject + "'s height", subject.getBlockHeight(), is(height));
+
+            arts.remove(subject);
+        }
+
+        assertThat("org.bukkit.Art has too many arts", arts, is(Collections.EMPTY_LIST));
+    }
+
+    @Test
+    public void testCraftArtToNotch() {
+        Map<Paintings, Art> cache = new HashMap<>();
+        for (Art art : Art.values()) {
+            Paintings enumArt = CraftArt.BukkitToNotch(art);
+            assertNotNull(art.name(), enumArt);
+            assertThat(art.name(), cache.put(enumArt, art), is(nullValue()));
+        }
+    }
+
+    @Test
+    public void testCraftArtToBukkit() {
+        Map<Art, Paintings> cache = new EnumMap(Art.class);
+        for (Paintings enumArt : (Iterable<Paintings>) IRegistry.MOTIVE) { // Eclipse fail
+            Art art = CraftArt.NotchToBukkit(enumArt);
+            assertNotNull("Could not CraftArt.NotchToBukkit " + enumArt, art);
+            assertThat("Duplicate artwork " + enumArt, cache.put(art, enumArt), is(nullValue()));
+        }
+    }
+}

src/test/java/org/bukkit/BiomeTest.java

@@ -0,0 +1,26 @@
+package org.bukkit;
+
+import net.minecraft.server.BiomeBase;
+import net.minecraft.server.IRegistry;
+import org.bukkit.block.Biome;
+import org.bukkit.craftbukkit.block.CraftBlock;
+import org.bukkit.support.AbstractTestingBase;
+import org.junit.Assert;
+import org.junit.Test;
+
+public class BiomeTest extends AbstractTestingBase {
+
+    @Test
+    public void testBukkitToMinecraft() {
+        for (Biome biome : Biome.values()) {
+            Assert.assertNotNull("No NMS mapping for " + biome, CraftBlock.biomeToBiomeBase(biome));
+        }
+    }
+
+    @Test
+    public void testMinecraftToBukkit() {
+        for (Object biome : IRegistry.BIOME) {
+            Assert.assertNotNull("No Bukkit mapping for " + biome, CraftBlock.biomeBaseToBiome((BiomeBase) biome));
+        }
+    }
+}

src/test/java/org/bukkit/BlockDataConversionTest.java

@@ -0,0 +1,38 @@
+package org.bukkit;
+
+import java.util.ArrayList;
+import java.util.List;
+import net.minecraft.server.Block;
+import net.minecraft.server.IBlockData;
+import net.minecraft.server.IRegistry;
+import org.bukkit.craftbukkit.block.data.CraftBlockData;
+import org.bukkit.support.AbstractTestingBase;
+import org.junit.Assert;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+/**
+ * This test class ensures that all Blocks (as registered in IRegistry.BLOCK)
+ * can be converted into their CraftBlockData equivalent.
+ */
+@RunWith(Parameterized.class)
+public class BlockDataConversionTest extends AbstractTestingBase {
+
+    @Parameterized.Parameters(name = "{index}: {0}")
+    public static List<Object[]> args() {
+        List<Object[]> list = new ArrayList<>();
+        for (Block block : (Iterable<Block>) IRegistry.BLOCK) {
+            list.add(new Object[]{block.getBlockData()});
+        }
+        return list;
+    }
+
+    @Parameterized.Parameter(0) public IBlockData data;
+
+    @Test
+    public void testNotNull() {
+        Assert.assertNotNull(data);
+        Assert.assertNotNull(CraftBlockData.fromData(data));
+    }
+}

src/test/java/org/bukkit/BlockDataTest.java

@@ -0,0 +1,172 @@
+package org.bukkit;
+
+import net.minecraft.server.BlockCake;
+import net.minecraft.server.BlockChest;
+import net.minecraft.server.Blocks;
+import net.minecraft.server.EnumDirection;
+import org.bukkit.block.BlockFace;
+import org.bukkit.block.data.BlockData;
+import org.bukkit.block.data.type.Cake;
+import org.bukkit.block.data.type.Chest;
+import org.bukkit.craftbukkit.block.data.CraftBlockData;
+import org.bukkit.support.AbstractTestingBase;
+import static org.hamcrest.Matchers.*;
+import org.junit.Assert;
+import org.junit.Test;
+
+public class BlockDataTest extends AbstractTestingBase {
+
+    @Test
+    public void testParsing() {
+        BlockData cakeTest = CraftBlockData.fromData(Blocks.CAKE.getBlockData().set(BlockCake.BITES, 3));
+
+        BlockData materialString = CraftBlockData.newData(Material.CAKE, "[bites=3]");
+        Assert.assertThat(materialString, is(cakeTest));
+
+        BlockData combined = CraftBlockData.newData(null, "cake[bites=3]");
+        Assert.assertThat(combined, is(cakeTest));
+
+        BlockData combinedMinecraft = CraftBlockData.newData(null, "minecraft:cake[bites=3]");
+        Assert.assertThat(combinedMinecraft, is(cakeTest));
+
+        BlockData inverted = CraftBlockData.newData(null, cakeTest.getAsString());
+        Assert.assertThat(inverted, is(cakeTest));
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void testBadMaterial() {
+        CraftBlockData.newData(null, "invalid");
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void testBadSyntax() {
+        CraftBlockData.newData(null, "minecraft:cake[bites=3");
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void testDoubleMaterial() {
+        CraftBlockData.newData(Material.CAKE, "minecraft:cake[bites=3]");
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void testMistake() {
+        BlockData cakeTest = CraftBlockData.fromData(Blocks.CAKE.getBlockData().set(BlockCake.BITES, 3));
+
+        CraftBlockData.newData(Material.CAKE, cakeTest.toString());
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void testItem() {
+        CraftBlockData.newData(Material.DIAMOND_AXE, null);
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void testItemParse() {
+        CraftBlockData.newData(null, "minecraft:diamond_axe");
+    }
+
+    @Test
+    public void testClone() {
+        Cake cakeTest = (Cake) CraftBlockData.fromData(Blocks.CAKE.getBlockData().set(BlockCake.BITES, 3));
+        Cake clone = (Cake) cakeTest.clone();
+
+        Assert.assertFalse("Clone did not return new object", cakeTest == clone);
+        Assert.assertThat("Clone is not equal", clone, is(cakeTest));
+
+        clone.setBites(1);
+        Assert.assertThat("Clone is not actually clone", clone, is(not(cakeTest)));
+    }
+
+    @Test
+    public void testMerge() {
+        Chest trueTarget = (Chest) CraftBlockData.newData(null, "minecraft:chest[facing=east,waterlogged=true]");
+        Chest falseTarget = (Chest) CraftBlockData.newData(null, "minecraft:chest[facing=east,waterlogged=false]");
+        Chest waterlogged = (Chest) CraftBlockData.newData(null, "minecraft:chest[waterlogged=true]");
+
+        BlockData candidate;
+
+        Assert.assertFalse("Target and match are not yet equal", trueTarget.equals(waterlogged));
+        candidate = trueTarget.merge(waterlogged);
+        Assert.assertTrue("Target and candidate are now equal", trueTarget.equals(candidate));
+
+        Assert.assertFalse("Target and match are not yet equal", falseTarget.equals(waterlogged));
+        candidate = falseTarget.merge(waterlogged);
+        Assert.assertFalse("Target and candidate are still not equal", falseTarget.equals(candidate));
+    }
+
+    @Test
+    public void testMergeAny() {
+        Chest trueTarget = (Chest) CraftBlockData.newData(null, "minecraft:chest[facing=east,waterlogged=true]");
+        Chest falseTarget = (Chest) CraftBlockData.newData(null, "minecraft:chest[facing=east,waterlogged=false]");
+        Chest any = (Chest) CraftBlockData.newData(null, "minecraft:chest");
+
+        BlockData candidate;
+
+        Assert.assertFalse("Target and match are not yet equal", trueTarget.equals(any));
+        candidate = trueTarget.merge(any);
+        Assert.assertTrue("Target and candidate are now equal", trueTarget.equals(candidate));
+
+        Assert.assertFalse("Target and match are not yet equal", falseTarget.equals(any));
+        candidate = falseTarget.merge(any);
+        Assert.assertTrue("Target and candidate are now equal", falseTarget.equals(candidate));
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void testCannotMerge1() {
+        Chest one = (Chest) CraftBlockData.newData(null, "minecraft:chest[facing=east,waterlogged=true]");
+        Chest two = (Chest) CraftBlockData.fromData(Blocks.CHEST.getBlockData());
+
+        one.merge(two);
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void testCannotMerge2() {
+        Chest one = (Chest) CraftBlockData.newData(null, "minecraft:chest[waterlogged=true]");
+        Chest two = (Chest) CraftBlockData.newData(null, "minecraft:chest[waterlogged=true]");
+
+        one.merge(two);
+
+        two.setFacing(BlockFace.NORTH);
+        one.merge(two);
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void testCannotMerge3() {
+        Chest one = (Chest) CraftBlockData.newData(null, "minecraft:chest[waterlogged=true]");
+        Chest two = (Chest) CraftBlockData.newData(null, "minecraft:trapped_chest[waterlogged=true]");
+
+        one.merge(two);
+    }
+
+    @Test
+    public void testMatch() {
+        Assert.assertTrue(CraftBlockData.newData(null, "minecraft:chest[facing=east,waterlogged=true]").matches(CraftBlockData.newData(null, "minecraft:chest[waterlogged=true]")));
+        Assert.assertFalse(CraftBlockData.newData(null, "minecraft:chest[facing=east,waterlogged=false]").matches(CraftBlockData.newData(null, "minecraft:chest[waterlogged=true]")));
+        Assert.assertTrue(CraftBlockData.newData(null, "minecraft:chest[facing=east,waterlogged=true]").matches(CraftBlockData.newData(null, "minecraft:chest")));
+        Assert.assertFalse(CraftBlockData.newData(null, "minecraft:trapped_chest[facing=east,waterlogged=false]").matches(CraftBlockData.newData(null, "minecraft:chest[waterlogged=true]")));
+        Assert.assertTrue(CraftBlockData.newData(null, "minecraft:chest[facing=east,waterlogged=true]").matches(CraftBlockData.newData(null, "minecraft:chest[waterlogged=true,facing=east]")));
+
+        Chest one = (Chest) CraftBlockData.fromData(Blocks.CHEST.getBlockData().set(BlockChest.FACING, EnumDirection.EAST));
+        Chest two = (Chest) CraftBlockData.newData(null, "minecraft:chest[waterlogged=false]");
+
+        Assert.assertTrue(one.matches(two));
+        Assert.assertFalse(two.matches(one));
+    }
+
+    @Test
+    public void testGetAsString() {
+        String dataString = "minecraft:chest[facing=east,waterlogged=true]";
+        BlockData data = CraftBlockData.newData(null, dataString);
+
+        Assert.assertThat(data.getAsString(true), is(dataString));
+        Assert.assertThat(data.getAsString(false), is("minecraft:chest[facing=east,type=single,waterlogged=true]"));
+    }
+
+    @Test
+    public void testGetAsString2() {
+        Chest data = (Chest) CraftBlockData.fromData(Blocks.CHEST.getBlockData().set(BlockChest.FACING, EnumDirection.EAST));
+
+        Assert.assertThat(data.getAsString(true), is("minecraft:chest[facing=east,type=single,waterlogged=false]"));
+        Assert.assertThat(data.getAsString(false), is("minecraft:chest[facing=east,type=single,waterlogged=false]"));
+    }
+}

src/test/java/org/bukkit/ChatTest.java

@@ -0,0 +1,41 @@
+package org.bukkit;
+
+import net.minecraft.server.EnumChatFormat;
+import net.minecraft.server.IChatBaseComponent;
+import org.bukkit.craftbukkit.util.CraftChatMessage;
+import org.junit.Assert;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+public class ChatTest {
+
+    @Test
+    public void testColors() {
+        for (ChatColor color : ChatColor.values()) {
+            Assert.assertNotNull(CraftChatMessage.getColor(color));
+            Assert.assertEquals(color, CraftChatMessage.getColor(CraftChatMessage.getColor(color)));
+        }
+
+        for (EnumChatFormat format : EnumChatFormat.values()) {
+            Assert.assertNotNull(CraftChatMessage.getColor(format));
+            Assert.assertEquals(format, CraftChatMessage.getColor(CraftChatMessage.getColor(format)));
+        }
+    }
+
+    @Test
+    public void testURLJsonConversion() {
+        IChatBaseComponent[] components;
+        components = CraftChatMessage.fromString("https://spigotmc.org/test Test Message");
+        assertEquals("{\"extra\":[{\"clickEvent\":{\"action\":\"open_url\",\"value\":\"https://spigotmc.org/test\"},\"text\":\"https://spigotmc.org/test\"},{\"text\":\" Test Message\"}],\"text\":\"\"}",
+                CraftChatMessage.toJSON(components[0]));
+
+        components = CraftChatMessage.fromString("123 " + ChatColor.GOLD + "https://spigotmc.org " + ChatColor.BOLD + "test");
+        assertEquals("{\"extra\":[{\"text\":\"123 \"},{\"color\":\"gold\",\"clickEvent\":{\"action\":\"open_url\",\"value\":\"https://spigotmc.org\"},\"text\":\"https://spigotmc.org\"},{\"color\":\"gold\",\"text\":\" \"},{\"bold\":true,\"color\":\"gold\",\"text\":\"test\"}],\"text\":\"\"}",
+                CraftChatMessage.toJSON(components[0]));
+
+        components = CraftChatMessage.fromString("multiCase http://SpigotMC.ORg/SpOngeBobMeEMeGoESHeRE");
+        assertEquals("{\"extra\":[{\"text\":\"multiCase \"},{\"clickEvent\":{\"action\":\"open_url\",\"value\":\"http://SpigotMC.ORg/SpOngeBobMeEMeGoESHeRE\"},\"text\":\"http://SpigotMC.ORg/SpOngeBobMeEMeGoESHeRE\"}],\"text\":\"\"}",
+                CraftChatMessage.toJSON(components[0]));
+    }
+}

src/test/java/org/bukkit/DyeColorsTest.java

@@ -0,0 +1,46 @@
+package org.bukkit;
+
+import static org.junit.Assert.*;
+import static org.hamcrest.Matchers.*;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import net.minecraft.server.EnumColor;
+
+import org.bukkit.support.AbstractTestingBase;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameter;
+import org.junit.runners.Parameterized.Parameters;
+
+@RunWith(Parameterized.class)
+public class DyeColorsTest extends AbstractTestingBase {
+
+    @Parameters(name= "{index}: {0}")
+    public static List<Object[]> data() {
+        List<Object[]> list = new ArrayList<Object[]>();
+        for (DyeColor dye : DyeColor.values()) {
+            list.add(new Object[] {dye});
+        }
+        return list;
+    }
+
+    @Parameter public DyeColor dye;
+
+    @Test
+    public void checkColor() {
+        Color color = dye.getColor();
+        float[] nmsColorArray = EnumColor.fromColorIndex(dye.getWoolData()).d();
+        Color nmsColor = Color.fromRGB((int) (nmsColorArray[0] * 255), (int) (nmsColorArray[1] * 255), (int) (nmsColorArray[2] * 255));
+        assertThat(color, is(nmsColor));
+    }
+
+    @Test
+    public void checkFireworkColor() {
+        Color color = dye.getFireworkColor();
+        int nmsColor = EnumColor.fromColorIndex(dye.getWoolData()).f();
+        assertThat(color, is(Color.fromRGB(nmsColor)));
+    }
+}

src/test/java/org/bukkit/EnchantmentTest.java

@@ -0,0 +1,25 @@
+package org.bukkit;
+
+import net.minecraft.server.IRegistry;
+import net.minecraft.server.MinecraftKey;
+import org.bukkit.craftbukkit.util.CraftNamespacedKey;
+import org.bukkit.enchantments.Enchantment;
+import org.bukkit.support.AbstractTestingBase;
+import org.junit.Assert;
+import org.junit.Test;
+
+public class EnchantmentTest extends AbstractTestingBase {
+
+    @Test
+    public void verifyMapping() {
+        for (MinecraftKey key : IRegistry.ENCHANTMENT.keySet()) {
+            net.minecraft.server.Enchantment nms = IRegistry.ENCHANTMENT.get(key);
+
+            Enchantment bukkitById = Enchantment.getByKey(CraftNamespacedKey.fromMinecraft(key));
+
+            Assert.assertFalse("Unknown enchant name for " + key, bukkitById.getName().startsWith("UNKNOWN"));
+
+            Assert.assertNotNull("Unknown target for " + key, bukkitById.getItemTarget());
+        }
+    }
+}

src/test/java/org/bukkit/GameRuleTest.java

@@ -0,0 +1,56 @@
+package org.bukkit;
+
+import java.util.Map;
+import java.util.TreeMap;
+import net.minecraft.server.GameRules;
+import org.junit.Assert;
+import org.junit.Test;
+
+public class GameRuleTest {
+
+    @Test
+    public void testBukkitRules() {
+        GameRule<?>[] rules = GameRule.values();
+
+        for (GameRule<?> rule : rules) {
+            GameRule<?> registeredRule = GameRule.getByName(rule.getName());
+            Assert.assertNotNull("Null GameRule", registeredRule);
+            Assert.assertEquals("Invalid GameRule equality", rule, registeredRule);
+        }
+    }
+
+    @Test
+    public void testMinecraftRules() {
+        TreeMap<String, GameRules.b> minecraftRules = GameRules.getGameRules();
+
+        for (Map.Entry<String, GameRules.b> entry : minecraftRules.entrySet()) {
+            GameRule<?> bukkitRule = GameRule.getByName(entry.getKey());
+
+            Assert.assertNotNull(bukkitRule);
+            Assert.assertEquals("Invalid GameRule Name", bukkitRule.getName(), entry.getKey());
+        }
+    }
+
+    @Test(expected = NullPointerException.class)
+    public void nullGameRuleName() {
+        GameRule.getByName(null);
+    }
+
+    @Test
+    public void emptyGameRuleName() {
+        Assert.assertNull(GameRule.getByName(""));
+    }
+
+    @Test
+    public void incorrectGameRuleName() {
+        Assert.assertNull(GameRule.getByName("doAnnounceAdvancements"));
+        Assert.assertNull(GameRule.getByName("sendCommandBlockFeedback"));
+    }
+
+    @Test
+    public void invalidCasing() {
+        Assert.assertNull(GameRule.getByName("CommandBlockOutput"));
+        Assert.assertNull(GameRule.getByName("spAwnRadius"));
+        Assert.assertNull(GameRule.getByName("rand0mTickSpeEd"));
+    }
+}

src/test/java/org/bukkit/LegacyTest.java

@@ -0,0 +1,92 @@
+package org.bukkit;
+
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.Set;
+import org.bukkit.craftbukkit.util.CraftLegacy;
+import org.bukkit.material.MaterialData;
+import org.bukkit.support.AbstractTestingBase;
+import org.junit.Assert;
+import org.junit.Test;
+
+public class LegacyTest extends AbstractTestingBase {
+
+    private final Set<Material> INVALIDATED_MATERIALS = new HashSet<>(Arrays.asList(Material.ACACIA_BUTTON, Material.ACACIA_PRESSURE_PLATE, Material.ACACIA_TRAPDOOR, Material.AIR, Material.ATTACHED_MELON_STEM, Material.ATTACHED_PUMPKIN_STEM,
+            Material.BIRCH_BUTTON, Material.BIRCH_PRESSURE_PLATE, Material.BIRCH_TRAPDOOR, Material.BLACK_WALL_BANNER, Material.BLUE_WALL_BANNER, Material.BROWN_WALL_BANNER, Material.BUBBLE_COLUMN, Material.CAVE_AIR, Material.CREEPER_WALL_HEAD,
+            Material.CYAN_WALL_BANNER, Material.DARK_OAK_BUTTON, Material.DARK_OAK_PRESSURE_PLATE, Material.DARK_OAK_TRAPDOOR, Material.DARK_PRISMARINE_SLAB, Material.DARK_PRISMARINE_STAIRS, Material.DEBUG_STICK, Material.DONKEY_SPAWN_EGG,
+            Material.DRAGON_WALL_HEAD, Material.DRIED_KELP, Material.DRIED_KELP_BLOCK, Material.ELDER_GUARDIAN_SPAWN_EGG, Material.EVOKER_SPAWN_EGG, Material.GRAY_WALL_BANNER, Material.GREEN_WALL_BANNER, Material.HUSK_SPAWN_EGG,
+            Material.JUNGLE_BUTTON, Material.JUNGLE_PRESSURE_PLATE, Material.JUNGLE_TRAPDOOR, Material.KELP, Material.KELP_PLANT, Material.LIGHT_BLUE_WALL_BANNER, Material.LIGHT_GRAY_WALL_BANNER, Material.LIME_WALL_BANNER, Material.LLAMA_SPAWN_EGG,
+            Material.MAGENTA_WALL_BANNER, Material.MULE_SPAWN_EGG, Material.ORANGE_WALL_BANNER, Material.PARROT_SPAWN_EGG, Material.PHANTOM_SPAWN_EGG, Material.PINK_WALL_BANNER, Material.PLAYER_WALL_HEAD, Material.POLAR_BEAR_SPAWN_EGG,
+            Material.POTTED_ACACIA_SAPLING, Material.POTTED_ALLIUM, Material.POTTED_AZURE_BLUET, Material.POTTED_BIRCH_SAPLING, Material.POTTED_BLUE_ORCHID, Material.POTTED_BROWN_MUSHROOM, Material.POTTED_DANDELION, Material.POTTED_DARK_OAK_SAPLING,
+            Material.POTTED_DEAD_BUSH, Material.POTTED_FERN, Material.POTTED_JUNGLE_SAPLING, Material.POTTED_OAK_SAPLING, Material.POTTED_ORANGE_TULIP, Material.POTTED_OXEYE_DAISY, Material.POTTED_PINK_TULIP, Material.POTTED_POPPY,
+            Material.POTTED_RED_MUSHROOM, Material.POTTED_RED_TULIP, Material.POTTED_SPRUCE_SAPLING, Material.POTTED_WHITE_TULIP, Material.PRISMARINE_BRICK_SLAB, Material.PRISMARINE_BRICK_STAIRS, Material.PRISMARINE_SLAB, Material.PRISMARINE_STAIRS,
+            Material.PUMPKIN, Material.PURPLE_WALL_BANNER, Material.RED_WALL_BANNER, Material.SEAGRASS, Material.SKELETON_HORSE_SPAWN_EGG, Material.SKELETON_WALL_SKULL, Material.SPRUCE_BUTTON, Material.SPRUCE_PRESSURE_PLATE, Material.SPRUCE_TRAPDOOR,
+            Material.STRAY_SPAWN_EGG, Material.STRIPPED_ACACIA_LOG, Material.STRIPPED_BIRCH_LOG, Material.STRIPPED_DARK_OAK_LOG, Material.STRIPPED_JUNGLE_LOG, Material.STRIPPED_OAK_LOG, Material.STRIPPED_SPRUCE_LOG, Material.TALL_SEAGRASS,
+            Material.TRIDENT, Material.TURTLE_EGG, Material.TURTLE_HELMET, Material.SCUTE, Material.TURTLE_SPAWN_EGG, Material.VEX_SPAWN_EGG, Material.VINDICATOR_SPAWN_EGG, Material.VOID_AIR, Material.WHITE_BED,
+            Material.WITHER_SKELETON_SPAWN_EGG, Material.WITHER_SKELETON_WALL_SKULL, Material.YELLOW_WALL_BANNER, Material.ZOMBIE_HORSE_SPAWN_EGG, Material.ZOMBIE_VILLAGER_SPAWN_EGG, Material.ZOMBIE_WALL_HEAD,
+            Material.COD_BUCKET, Material.COD_SPAWN_EGG, Material.PUFFERFISH_BUCKET, Material.PUFFERFISH_SPAWN_EGG, Material.SALMON_BUCKET, Material.SALMON_SPAWN_EGG,
+            Material.TROPICAL_FISH_BUCKET, Material.DROWNED_SPAWN_EGG, Material.SHULKER_BOX, Material.TROPICAL_FISH_SPAWN_EGG,
+            Material.BLUE_ICE, Material.BRAIN_CORAL, Material.BRAIN_CORAL_BLOCK, Material.BRAIN_CORAL_FAN, Material.BUBBLE_CORAL, Material.BUBBLE_CORAL_BLOCK, Material.BUBBLE_CORAL_FAN, Material.CONDUIT, Material.DEAD_BRAIN_CORAL_BLOCK,
+            Material.DEAD_BUBBLE_CORAL_BLOCK, Material.DEAD_FIRE_CORAL_BLOCK, Material.DEAD_HORN_CORAL_BLOCK, Material.DEAD_TUBE_CORAL_BLOCK, Material.DOLPHIN_SPAWN_EGG, Material.FIRE_CORAL, Material.FIRE_CORAL_BLOCK, Material.FIRE_CORAL_FAN,
+            Material.HEART_OF_THE_SEA, Material.HORN_CORAL, Material.HORN_CORAL_BLOCK, Material.HORN_CORAL_FAN, Material.NAUTILUS_SHELL, Material.PHANTOM_MEMBRANE, Material.SEA_PICKLE, Material.TUBE_CORAL, Material.TUBE_CORAL_BLOCK,
+            Material.TUBE_CORAL_FAN, Material.STRIPPED_ACACIA_WOOD, Material.STRIPPED_BIRCH_WOOD, Material.STRIPPED_DARK_OAK_WOOD, Material.STRIPPED_JUNGLE_WOOD, Material.STRIPPED_OAK_WOOD, Material.STRIPPED_SPRUCE_WOOD,
+            Material.ACACIA_WOOD, Material.BIRCH_WOOD, Material.DARK_OAK_WOOD, Material.JUNGLE_WOOD, Material.OAK_WOOD, Material.SPRUCE_WOOD,
+            Material.TUBE_CORAL_WALL_FAN, Material.BRAIN_CORAL_WALL_FAN, Material.BUBBLE_CORAL_WALL_FAN, Material.FIRE_CORAL_WALL_FAN, Material.HORN_CORAL_WALL_FAN, Material.DEAD_TUBE_CORAL_WALL_FAN, Material.DEAD_BRAIN_CORAL_WALL_FAN,
+            Material.DEAD_BUBBLE_CORAL_WALL_FAN, Material.DEAD_FIRE_CORAL_WALL_FAN, Material.DEAD_HORN_CORAL_WALL_FAN, Material.DEAD_TUBE_CORAL_FAN, Material.DEAD_BRAIN_CORAL_FAN, Material.DEAD_BUBBLE_CORAL_FAN, Material.DEAD_FIRE_CORAL_FAN,
+            Material.DEAD_HORN_CORAL_FAN, Material.DEAD_BRAIN_CORAL, Material.DEAD_BUBBLE_CORAL, Material.DEAD_FIRE_CORAL, Material.DEAD_HORN_CORAL, Material.DEAD_TUBE_CORAL,
+            //
+            Material.LEGACY_AIR, Material.LEGACY_DEAD_BUSH, Material.LEGACY_BURNING_FURNACE, Material.LEGACY_WALL_SIGN, Material.LEGACY_REDSTONE_TORCH_OFF, Material.LEGACY_SKULL, Material.LEGACY_REDSTONE_COMPARATOR_ON, Material.LEGACY_WALL_BANNER, Material.LEGACY_MONSTER_EGG));
+
+    private final Set<Material> INVERSION_FAILS = new HashSet<>(Arrays.asList(Material.LEGACY_DOUBLE_STEP, Material.LEGACY_GLOWING_REDSTONE_ORE, Material.LEGACY_DIODE_BLOCK_ON, Material.LEGACY_REDSTONE_LAMP_ON, Material.LEGACY_WOOD_DOUBLE_STEP,
+            Material.LEGACY_DAYLIGHT_DETECTOR_INVERTED, Material.LEGACY_DOUBLE_STONE_SLAB2, Material.LEGACY_PURPUR_DOUBLE_SLAB, Material.LEGACY_WHEAT, Material.LEGACY_SIGN, Material.LEGACY_WOOD_DOOR, Material.LEGACY_IRON_DOOR, Material.LEGACY_SUGAR_CANE,
+            Material.LEGACY_CAKE, Material.LEGACY_BED, Material.LEGACY_DIODE, Material.LEGACY_NETHER_STALK, Material.LEGACY_BREWING_STAND_ITEM, Material.LEGACY_CAULDRON_ITEM, Material.LEGACY_REDSTONE_COMPARATOR, Material.LEGACY_SPRUCE_DOOR_ITEM,
+            Material.LEGACY_BIRCH_DOOR_ITEM, Material.LEGACY_JUNGLE_DOOR_ITEM, Material.LEGACY_ACACIA_DOOR_ITEM, Material.LEGACY_DARK_OAK_DOOR_ITEM, Material.LEGACY_STATIONARY_LAVA, Material.LEGACY_STATIONARY_WATER));
+
+    @Test
+    public void toLegacyMaterial() {
+        for (Material material : Material.values()) {
+            if (!INVALIDATED_MATERIALS.contains(material) && !material.isLegacy()) {
+                MaterialData converted = CraftLegacy.toLegacyData(material);
+
+                Assert.assertNotEquals("Could not toLegacy " + material, Material.LEGACY_AIR, converted.getItemType());
+
+                if (!INVALIDATED_MATERIALS.contains(converted.getItemType())) {
+                    Assert.assertNotEquals("Could not fromLegacy(toLegacy) " + converted + "(" + material + ")", Material.AIR, CraftLegacy.fromLegacy(converted));
+                }
+                if (!INVERSION_FAILS.contains(material)) {
+                    Assert.assertEquals("Could not fromLegacy(toLegacy) " + converted + "(" + material + ")", material, CraftLegacy.fromLegacy(converted));
+                }
+            }
+        }
+
+        Assert.assertEquals("Could not toLegacy Air", Material.LEGACY_AIR, CraftLegacy.toLegacy(Material.AIR));
+    }
+
+    @Test
+    public void fromLegacyMaterial() {
+        for (Material material : Material.values()) {
+            if (!INVALIDATED_MATERIALS.contains(material) && material.isLegacy()) {
+                Material converted = CraftLegacy.fromLegacy(material);
+                Assert.assertNotEquals("Could not fromLegacy " + material, Material.AIR, converted);
+
+                Assert.assertNotEquals("Could not toLegacy(fromLegacy) " + converted + "(" + material + ")", Material.AIR, CraftLegacy.toLegacy(converted));
+                if (!INVERSION_FAILS.contains(material)) {
+                    Assert.assertEquals("Could not toLegacy(fromLegacy) " + converted + "(" + material + ")", material, CraftLegacy.toLegacy(converted));
+                }
+            }
+        }
+
+        Assert.assertEquals("Could not fromLegacy Air", Material.AIR, CraftLegacy.fromLegacy(Material.LEGACY_AIR));
+    }
+
+    @Test
+    public void testRestricted() {
+        for (Material material : CraftLegacy.values()) {
+            Assert.assertTrue("Must iterate only legacy materials", material.isLegacy());
+        }
+
+        for (Material material : CraftLegacy.modern_values()) {
+            Assert.assertFalse("Must iterate only modern materials", material.isLegacy());
+        }
+    }
+}

src/test/java/org/bukkit/LootTablesTest.java

@@ -0,0 +1,22 @@
+package org.bukkit;
+
+import org.bukkit.loot.LootTable;
+import org.bukkit.loot.LootTables;
+import org.bukkit.support.AbstractTestingBase;
+import org.junit.Assert;
+import org.junit.Test;
+
+public class LootTablesTest extends AbstractTestingBase {
+
+    @Test
+    public void testLootTablesEnumExists() {
+        LootTables[] tables = LootTables.values();
+
+        for (LootTables table : tables) {
+            LootTable lootTable = Bukkit.getLootTable(table.getKey());
+
+            Assert.assertNotNull("Unknown LootTable " + table.getKey(), lootTable);
+            Assert.assertEquals(lootTable.getKey(), table.getKey());
+        }
+    }
+}

src/test/java/org/bukkit/MaterialTest.java

@@ -0,0 +1,50 @@
+package org.bukkit;
+
+import static org.junit.Assert.*;
+import static org.hamcrest.Matchers.*;
+
+import java.util.Collections;
+import java.util.Map;
+
+import net.minecraft.server.IRegistry;
+import net.minecraft.server.Item;
+import net.minecraft.server.MinecraftKey;
+
+import org.bukkit.support.AbstractTestingBase;
+import org.junit.Test;
+
+import com.google.common.collect.Maps;
+import java.util.Iterator;
+import org.bukkit.craftbukkit.util.CraftMagicNumbers;
+
+public class MaterialTest extends AbstractTestingBase {
+
+    @Test
+    public void verifyMapping() {
+        Map<MinecraftKey, Material> materials = Maps.newHashMap();
+        for (Material material : Material.values()) {
+            if (INVALIDATED_MATERIALS.contains(material)) {
+                continue;
+            }
+
+            materials.put(CraftMagicNumbers.key(material), material);
+        }
+
+        Iterator<Item> items = IRegistry.ITEM.iterator();
+
+        while (items.hasNext()) {
+            Item item = items.next();
+            if (item == null) continue;
+
+            MinecraftKey id = IRegistry.ITEM.getKey(item);
+            String name = item.getName();
+
+            Material material = materials.remove(id);
+
+            assertThat("Missing " + name + "(" + id + ")", material, is(not(nullValue())));
+            assertNotNull("No item mapping for " + name, CraftMagicNumbers.getMaterial(item));
+        }
+
+        assertThat(materials, is(Collections.EMPTY_MAP));
+    }
+}

src/test/java/org/bukkit/NibbleArrayTest.java

@@ -0,0 +1,29 @@
+package org.bukkit;
+
+import java.util.Random;
+import net.minecraft.server.NibbleArray;
+import org.junit.Assert;
+import org.junit.Test;
+
+public class NibbleArrayTest {
+
+    private static final int NIBBLE_SIZE = 4096;
+
+    @Test
+    public void testNibble() {
+        Random random = new Random();
+        byte[] classic = new byte[NIBBLE_SIZE];
+        NibbleArray nibble = new NibbleArray();
+
+        for (int i = 0; i < classic.length; i++) {
+            byte number = (byte) (random.nextInt() & 0xF);
+
+            classic[i] = number;
+            nibble.a(i, number);
+        }
+
+        for (int i = 0; i < classic.length; i++) {
+            Assert.assertEquals("Nibble array mismatch", classic[i], nibble.a(i));
+        }
+    }
+}

src/test/java/org/bukkit/ParticleTest.java

@@ -0,0 +1,35 @@
+package org.bukkit;
+
+import net.minecraft.server.IRegistry;
+import org.bukkit.block.data.BlockData;
+import org.bukkit.craftbukkit.CraftParticle;
+import org.bukkit.craftbukkit.block.data.CraftBlockData;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.material.MaterialData;
+import org.bukkit.support.AbstractTestingBase;
+import org.junit.Assert;
+import org.junit.Test;
+
+public class ParticleTest extends AbstractTestingBase {
+
+    @Test
+    public void verifyMapping() {
+        for (Particle bukkit : Particle.values()) {
+            Object data = null;
+            if (bukkit.getDataType().equals(ItemStack.class)) {
+                data = new ItemStack(Material.STONE);
+            } else if (bukkit.getDataType() == MaterialData.class) {
+                data = new MaterialData(Material.LEGACY_STONE);
+            } else if (bukkit.getDataType() == Particle.DustOptions.class) {
+                data = new Particle.DustOptions(Color.BLACK, 0);
+            } else if (bukkit.getDataType() == BlockData.class) {
+                data = CraftBlockData.newData(Material.STONE, "");
+            }
+
+            Assert.assertNotNull("Missing Bukkit->NMS particle mapping for " + bukkit, CraftParticle.toNMS(bukkit, data));
+        }
+        for (net.minecraft.server.Particle nms : (Iterable<net.minecraft.server.Particle<?>>) IRegistry.PARTICLE_TYPE) { // Eclipse fail
+            Assert.assertNotNull("Missing NMS->Bukkit particle mapping for " + nms, CraftParticle.toBukkit(nms));
+        }
+    }
+}

src/test/java/org/bukkit/PerMaterialTest.java

@@ -0,0 +1,239 @@
+package org.bukkit;
+
+import static org.junit.Assert.*;
+import static org.hamcrest.Matchers.*;
+
+import java.util.List;
+
+import net.minecraft.server.BlockFalling;
+import net.minecraft.server.BlockFire;
+import net.minecraft.server.Item;
+import net.minecraft.server.ItemFood;
+import net.minecraft.server.ItemRecord;
+import net.minecraft.server.TileEntityFurnace;
+
+import org.bukkit.craftbukkit.inventory.CraftItemStack;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.support.AbstractTestingBase;
+import org.bukkit.support.Util;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameter;
+import org.junit.runners.Parameterized.Parameters;
+
+import com.google.common.collect.Lists;
+import java.util.Map;
+import net.minecraft.server.Block;
+import net.minecraft.server.BlockPosition;
+import net.minecraft.server.Blocks;
+import net.minecraft.server.EntityHuman;
+import net.minecraft.server.EnumDirection;
+import net.minecraft.server.EnumHand;
+import net.minecraft.server.IBlockData;
+import org.bukkit.craftbukkit.util.CraftMagicNumbers;
+import org.bukkit.enchantments.EnchantmentTarget;
+
+@RunWith(Parameterized.class)
+public class PerMaterialTest extends AbstractTestingBase {
+    private static Map<Block, Integer> fireValues;
+
+    @BeforeClass
+    public static void getFireValues() {
+        fireValues = Util.getInternalState(BlockFire.class, Blocks.FIRE, "flameChances");
+    }
+
+    @Parameters(name= "{index}: {0}")
+    public static List<Object[]> data() {
+        List<Object[]> list = Lists.newArrayList();
+        for (Material material : Material.values()) {
+            if (!material.isLegacy()) {
+                list.add(new Object[] {material});
+            }
+        }
+        return list;
+    }
+
+    @Parameter public Material material;
+
+    @Test
+    public void isBlock() {
+        if (material != Material.AIR && material != Material.CAVE_AIR && material != Material.VOID_AIR) {
+            assertThat(material.isBlock(), is(not(CraftMagicNumbers.getBlock(material) == null)));
+        }
+    }
+
+    @Test
+    public void isSolid() {
+        if (material == Material.AIR) {
+            assertFalse(material.isSolid());
+        } else if (material.isBlock()) {
+            assertThat(material.isSolid(), is(CraftMagicNumbers.getBlock(material).getBlockData().getMaterial().isSolid()));
+        } else {
+            assertFalse(material.isSolid());
+        }
+    }
+
+    @Test
+    public void isEdible() {
+        assertThat(material.isEdible(), is(CraftMagicNumbers.getItem(material) instanceof ItemFood));
+    }
+
+    @Test
+    public void isRecord() {
+        assertThat(material.isRecord(), is(CraftMagicNumbers.getItem(material) instanceof ItemRecord));
+    }
+
+    @Test
+    public void maxDurability() {
+        if (INVALIDATED_MATERIALS.contains(material)) return;
+
+        if (material == Material.AIR) {
+            assertThat((int) material.getMaxDurability(), is(0));
+        } else if (material.isBlock()){
+            Item item = CraftMagicNumbers.getItem(material);
+            assertThat((int) material.getMaxDurability(), is(item.getMaxDurability()));
+        }
+    }
+
+    @Test
+    public void maxStackSize() {
+        if (INVALIDATED_MATERIALS.contains(material)) return;
+
+        final ItemStack bukkit = new ItemStack(material);
+        final CraftItemStack craft = CraftItemStack.asCraftCopy(bukkit);
+        if (material == Material.AIR) {
+            final int MAX_AIR_STACK = 0 /* Why can't I hold all of these AIR? */;
+            assertThat(material.getMaxStackSize(), is(MAX_AIR_STACK));
+            assertThat(bukkit.getMaxStackSize(), is(MAX_AIR_STACK));
+            assertThat(craft.getMaxStackSize(), is(MAX_AIR_STACK));
+        } else {
+            assertThat(material.getMaxStackSize(), is(CraftMagicNumbers.getItem(material).getMaxStackSize()));
+            assertThat(bukkit.getMaxStackSize(), is(material.getMaxStackSize()));
+            assertThat(craft.getMaxStackSize(), is(material.getMaxStackSize()));
+        }
+    }
+
+    @Test
+    public void isTransparent() {
+        if (material == Material.AIR) {
+            assertTrue(material.isTransparent());
+        } else if (material.isBlock()) {
+            // assertThat(material.isTransparent(), is(not(CraftMagicNumbers.getBlock(material).getBlockData().getMaterial().blocksLight()))); // PAIL: not unit testable anymore (17w50a)
+        } else {
+            assertFalse(material.isTransparent());
+        }
+    }
+
+    @Test
+    public void isFlammable() {
+        if (material != Material.AIR && material.isBlock()) {
+            assertThat(material.isFlammable(), is(CraftMagicNumbers.getBlock(material).getBlockData().getMaterial().isBurnable()));
+        } else {
+            assertFalse(material.isFlammable());
+        }
+    }
+
+    @Test
+    public void isBurnable() {
+        if (material.isBlock()) {
+            Block block = CraftMagicNumbers.getBlock(material);
+            assertThat(material.isBurnable(), is(fireValues.containsKey(block) && fireValues.get(block) > 0));
+        } else {
+            assertFalse(material.isBurnable());
+        }
+    }
+
+    @Test
+    public void isFuel() {
+        assertThat(material.isFuel(), is(TileEntityFurnace.isFuel(new net.minecraft.server.ItemStack(CraftMagicNumbers.getItem(material)))));
+    }
+
+    @Test
+    public void isOccluding() {
+        if (material.isBlock()) {
+            assertThat(material.isOccluding(), is(CraftMagicNumbers.getBlock(material).isOccluding(CraftMagicNumbers.getBlock(material).getBlockData())));
+        } else {
+            assertFalse(material.isOccluding());
+        }
+    }
+
+    @Test
+    public void hasGravity() {
+        if (material.isBlock()) {
+            assertThat(material.hasGravity(), is(CraftMagicNumbers.getBlock(material) instanceof BlockFalling));
+        } else {
+            assertFalse(material.hasGravity());
+        }
+    }
+
+    @Test
+    public void usesDurability() {
+        if (!material.isBlock()) {
+            assertThat(EnchantmentTarget.BREAKABLE.includes(material), is(CraftMagicNumbers.getItem(material).usesDurability()));
+        } else {
+            assertFalse(EnchantmentTarget.BREAKABLE.includes(material));
+        }
+    }
+
+    @Test
+    public void testDurability() {
+        if (!material.isBlock()) {
+            assertThat(material.getMaxDurability(), is((short) CraftMagicNumbers.getItem(material).getMaxDurability()));
+        } else {
+            assertThat(material.getMaxDurability(), is((short) 0));
+        }
+    }
+
+    @Test
+    public void testBlock() {
+        if (material == Material.AIR) {
+            assertTrue(material.isBlock());
+        } else {
+            assertThat(material.isBlock(), is(equalTo(CraftMagicNumbers.getBlock(material) != null)));
+        }
+    }
+
+    @Test
+    public void testItem() {
+        if (material == Material.AIR) {
+            assertTrue(material.isItem());
+        } else {
+            assertThat(material.isItem(), is(equalTo(CraftMagicNumbers.getItem(material) != null)));
+        }
+    }
+
+    @Test
+    public void testInteractable() throws ReflectiveOperationException {
+        if (material.isBlock()) {
+            assertThat(material.isInteractable(),
+                    is(!CraftMagicNumbers.getBlock(material).getClass()
+                            .getMethod("interact", IBlockData.class, net.minecraft.server.World.class, BlockPosition.class, EntityHuman.class, EnumHand.class, EnumDirection.class, float.class, float.class, float.class)
+                            .getDeclaringClass().equals(Block.class)));
+        } else {
+            assertFalse(material.isInteractable());
+        }
+    }
+
+    @Test
+    public void testBlockHardness() {
+        if (material.isBlock()) {
+            assertThat(material.getHardness(), is(CraftMagicNumbers.getBlock(material).strength));
+        }
+    }
+
+    @Test
+    public void testBlastResistance() {
+        if (material.isBlock()) {
+            assertThat(material.getBlastResistance(), is(CraftMagicNumbers.getBlock(material).getDurability()));
+        }
+    }
+
+    @Test
+    public void testBlockDataCreation() {
+        if (material.isBlock()) {
+            assertNotNull(material.createBlockData());
+        }
+    }
+}

src/test/java/org/bukkit/SoundTest.java

@@ -0,0 +1,42 @@
+package org.bukkit;
+
+import net.minecraft.server.IRegistry;
+import net.minecraft.server.MinecraftKey;
+
+import static org.junit.Assert.*;
+import static org.hamcrest.Matchers.*;
+
+import org.bukkit.craftbukkit.CraftSound;
+import org.bukkit.support.AbstractTestingBase;
+import org.junit.Test;
+
+public class SoundTest extends AbstractTestingBase {
+
+    @Test
+    public void testGetSound() {
+        for (Sound sound : Sound.values()) {
+            assertThat(sound.name(), CraftSound.getSound(sound), is(not(nullValue())));
+        }
+    }
+
+    @Test
+    public void testReverse() {
+        for (MinecraftKey effect : IRegistry.SOUND_EVENT.keySet()) {
+            assertNotNull(effect + "", Sound.valueOf(effect.getKey().replace('.', '_').toUpperCase(java.util.Locale.ENGLISH)));
+        }
+    }
+
+    @Test
+    public void testCategory() {
+        for (SoundCategory category : SoundCategory.values()) {
+            assertNotNull(category + "", net.minecraft.server.SoundCategory.valueOf(category.name()));
+        }
+    }
+
+    @Test
+    public void testCategoryReverse() {
+        for (net.minecraft.server.SoundCategory category : net.minecraft.server.SoundCategory.values()) {
+            assertNotNull(category + "", SoundCategory.valueOf(category.name()));
+        }
+    }
+}

src/test/java/org/bukkit/StatisticsAndAchievementsTest.java

@@ -0,0 +1,60 @@
+package org.bukkit;
+
+import static org.junit.Assert.*;
+import static org.hamcrest.Matchers.*;
+
+import net.minecraft.server.EntityTypes;
+import net.minecraft.server.IRegistry;
+import net.minecraft.server.StatisticWrapper;
+
+import org.bukkit.entity.EntityType;
+import org.bukkit.craftbukkit.CraftStatistic;
+import org.bukkit.support.AbstractTestingBase;
+import org.junit.Test;
+
+import com.google.common.collect.HashMultiset;
+
+public class StatisticsAndAchievementsTest extends AbstractTestingBase {
+
+    @Test
+    @SuppressWarnings("unchecked")
+    public void verifyEntityMapping() throws Throwable {
+        for (Statistic statistic : Statistic.values()) {
+            if (statistic.getType() == Statistic.Type.ENTITY) {
+                for (EntityType entity : EntityType.values()) {
+                    if (entity.getName() != null) {
+                        assertNotNull(statistic + " missing for " + entity, CraftStatistic.getEntityStatistic(statistic, entity));
+                    }
+                }
+            }
+        }
+    }
+
+    @Test
+    @SuppressWarnings("unchecked")
+    public void verifyStatisticMapping() throws Throwable {
+        HashMultiset<Statistic> statistics = HashMultiset.create();
+        for (StatisticWrapper wrapper : (Iterable<StatisticWrapper<?>>) IRegistry.STATS) { // Eclipse fail
+            for (Object child : wrapper.a()) {
+                net.minecraft.server.Statistic<?> statistic = wrapper.b(child);
+                String message = String.format("org.bukkit.Statistic is missing: '%s'", statistic);
+
+                Statistic subject = CraftStatistic.getBukkitStatistic(statistic);
+                assertThat(message, subject, is(not(nullValue())));
+
+                if (wrapper.a() == IRegistry.BLOCK || wrapper.a() == IRegistry.ITEM) {
+                    assertNotNull("Material type map missing for " + child, CraftStatistic.getMaterialFromStatistic(statistic));
+                } else if (wrapper.a() == IRegistry.ENTITY_TYPE) {
+                    assertNotNull("Entity type map missing for " + EntityTypes.getName((EntityTypes<?>) child), CraftStatistic.getEntityTypeFromStatistic((net.minecraft.server.Statistic<EntityTypes<?>>) statistic));
+                }
+
+                statistics.add(subject);
+            }
+        }
+
+        for (Statistic statistic : Statistic.values()) {
+            String message = String.format("org.bukkit.Statistic.%s does not have a corresponding minecraft statistic", statistic.name());
+            assertThat(message, statistics.remove(statistic, statistics.count(statistic)), is(greaterThan(0)));
+        }
+    }
+}

src/test/java/org/bukkit/StructureTypeTest.java

@@ -0,0 +1,45 @@
+package org.bukkit;
+
+import java.util.Map;
+import net.minecraft.server.WorldGenFactory;
+import org.bukkit.support.AbstractTestingBase;
+import org.junit.Assert;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+/**
+ * This test makes sure that Bukkit always has Minecraft structure types up to
+ * date.
+ */
+public class StructureTypeTest extends AbstractTestingBase {
+
+    private static Map<String, StructureType> structures;
+
+    @BeforeClass
+    public static void setUp() {
+        structures = StructureType.getStructureTypes();
+    }
+
+    @Test
+    public void testMinecraftToBukkit() {
+        for (String key : WorldGenFactory.structureStartMap.keySet()) {
+            Assert.assertNotNull(structures.get(key));
+        }
+    }
+
+    @Test
+    public void testBukkit() {
+        for (Map.Entry<String, StructureType> entry : structures.entrySet()) {
+            Assert.assertNotNull(StructureType.getStructureTypes().get(entry.getKey()));
+            Assert.assertNotNull(StructureType.getStructureTypes().get(entry.getValue().getName()));
+        }
+    }
+
+    @Test
+    public void testBukkitToMinecraft() {
+        for (Map.Entry<String, StructureType> entry : structures.entrySet()) {
+            Assert.assertNotNull(WorldGenFactory.structureStartMap.get(entry.getKey()));
+            Assert.assertNotNull(WorldGenFactory.structureStartMap.get(entry.getValue().getName()));
+        }
+    }
+}

src/test/java/org/bukkit/WorldTypeTest.java

@@ -0,0 +1,19 @@
+package org.bukkit;
+
+import static org.junit.Assert.*;
+import static org.hamcrest.Matchers.*;
+
+import net.minecraft.server.WorldType;
+import org.junit.Test;
+
+public class WorldTypeTest {
+    @Test
+    public void testTypes() {
+        for (WorldType type : WorldType.types) {
+            if (type == null) continue;
+            if (type == WorldType.DEBUG_ALL_BLOCK_STATES) continue; // Doesn't work anyway
+
+            assertThat(type.name() + " has no Bukkit world", org.bukkit.WorldType.getByName(type.name()), is(not(nullValue())));
+        }
+    }
+}

src/test/java/org/bukkit/craftbukkit/generator/ChunkDataTest.java

@@ -0,0 +1,81 @@
+package org.bukkit.craftbukkit.generator;
+
+import org.bukkit.Material;
+import org.bukkit.block.data.BlockData;
+import org.bukkit.support.AbstractTestingBase;
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+public class ChunkDataTest extends AbstractTestingBase {
+
+    private static final BlockData RED_WOOL = Material.RED_WOOL.createBlockData();
+    private static final BlockData AIR = Material.AIR.createBlockData();
+
+    private boolean testSetBlock(CraftChunkData data, int x, int y, int z, BlockData type, BlockData expected) {
+        data.setBlock(x, y, z, type);
+        return expected.equals(data.getBlockData(x, y, z)) && expected.getMaterial().equals(data.getType(x, y, z));
+    }
+
+    private void testSetRegion(CraftChunkData data, int minx, int miny, int minz, int maxx, int maxy, int maxz, BlockData type) {
+        data.setRegion(minx, miny, minz, maxx, maxy, maxz, type);
+        for (int y = 0; y < data.getMaxHeight(); y++) {
+            for (int z = 0; z < 16; z++) {
+                for (int x = 0; x < 16; x++) {
+                    boolean inRegion = miny <= y && y < maxy && minx <= x && x < maxx && minz <= z && z < maxz;
+                    if (inRegion != type.equals(data.getBlockData(x, y, z))) {
+                        throw new IllegalStateException(
+                                "setRegion(" + minx + ", " + miny + ", " + minz + ", " + maxx + ", " + maxy + ", " + maxz + ", " + type + ")"
+                                + "-> block at " + x + ", " + y + ", " + z + " is " + data.getBlockData(x, y, z));
+                    }
+                }
+            }
+        }
+    }
+
+    @Test
+    public void testMaxHeight() {
+        CraftChunkData data = new CraftChunkData(128);
+        assertTrue("Could not set block above max height", testSetBlock(data, 0, 128, 0, RED_WOOL, AIR));
+        assertTrue("Could set block below max height", testSetBlock(data, 0, 127, 0, RED_WOOL, RED_WOOL));
+    }
+
+    @Test
+    public void testBoundsCheckingSingle() {
+        CraftChunkData data = new CraftChunkData(256);
+        assertTrue("Can set block inside chunk bounds", testSetBlock(data, 0, 0, 0, RED_WOOL, RED_WOOL));
+        assertTrue("Can set block inside chunk bounds", testSetBlock(data, 15, 255, 15, RED_WOOL, RED_WOOL));
+        assertTrue("Can no set block outside chunk bounds", testSetBlock(data, -1, 0, 0, RED_WOOL, AIR));
+        assertTrue("Can no set block outside chunk bounds", testSetBlock(data, 0, -1, 0, RED_WOOL, AIR));
+        assertTrue("Can no set block outside chunk bounds", testSetBlock(data, 0, 0, -1, RED_WOOL, AIR));
+        assertTrue("Can no set block outside chunk bounds", testSetBlock(data, 16, 0, 0, RED_WOOL, AIR));
+        assertTrue("Can no set block outside chunk bounds", testSetBlock(data, 0, 256, 0, RED_WOOL, AIR));
+        assertTrue("Can no set block outside chunk bounds", testSetBlock(data, 0, 0, 16, RED_WOOL, AIR));
+    }
+
+    @Test
+    public void testSetRegion() {
+        CraftChunkData data = new CraftChunkData(256);
+        testSetRegion(data, -100, 0, -100, 0, 256, 0, RED_WOOL); // exclusively outside
+        testSetRegion(data, 16, 256, 16, 0, 0, 0, RED_WOOL); // minimum >= maximum
+        testSetRegion(data, 0, 0, 0, 0, 0, 0, RED_WOOL); // minimum == maximum
+        testSetRegion(data, 0, 0, 0, 16, 16, 16, RED_WOOL); // Whole Chunk Section
+        data.setRegion(0, 0, 0, 16, 256, 16, AIR);
+        testSetRegion(data, 0, 8, 0, 16, 24, 16, RED_WOOL); // Start middle of this section, end middle of next 
+        data.setRegion(0, 0, 0, 16, 256, 16, AIR);
+        testSetRegion(data, 0, 4, 0, 16, 12, 16, RED_WOOL); // Start in this section, end in this section
+        data.setRegion(0, 0, 0, 16, 256, 16, AIR);
+        testSetRegion(data, 0, 0, 0, 16, 16, 1, RED_WOOL); // Whole Chunk Section
+        data.setRegion(0, 0, 0, 16, 256, 16, AIR);
+        testSetRegion(data, 0, 8, 0, 16, 24, 1, RED_WOOL); // Start middle of this section, end middle of next 
+        data.setRegion(0, 0, 0, 16, 256, 16, AIR);
+        testSetRegion(data, 0, 4, 0, 16, 12, 1, RED_WOOL); // Start in this section, end in this section
+        data.setRegion(0, 0, 0, 16, 256, 16, AIR);
+        testSetRegion(data, 0, 0, 0, 1, 16, 1, RED_WOOL); // Whole Chunk Section
+        data.setRegion(0, 0, 0, 16, 256, 16, AIR);
+        testSetRegion(data, 0, 8, 0, 1, 24, 1, RED_WOOL); // Start middle of this section, end middle of next 
+        data.setRegion(0, 0, 0, 16, 256, 16, AIR);
+        testSetRegion(data, 0, 4, 0, 1, 12, 1, RED_WOOL); // Start in this section, end in this section
+        data.setRegion(0, 0, 0, 16, 256, 16, AIR);
+        testSetRegion(data, 0, 0, 0, 1, 1, 1, RED_WOOL); // Set single block.
+    }
+}

src/test/java/org/bukkit/craftbukkit/inventory/CompositeSerialization.java

@@ -0,0 +1,62 @@
+package org.bukkit.craftbukkit.inventory;
+
+import static org.junit.Assert.*;
+import static org.hamcrest.Matchers.*;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.bukkit.Material;
+import org.bukkit.configuration.InvalidConfigurationException;
+import org.bukkit.configuration.file.YamlConfiguration;
+import org.bukkit.enchantments.Enchantment;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.support.AbstractTestingBase;
+import org.junit.Test;
+
+
+public class CompositeSerialization extends AbstractTestingBase {
+
+    public YamlConfiguration getConfig() {
+        return new YamlConfiguration();
+    }
+
+    @Test
+    public void testSaveRestoreCompositeList() throws InvalidConfigurationException {
+        YamlConfiguration out = getConfig();
+
+        List<ItemStack> stacks = new ArrayList<ItemStack>();
+        stacks.add(new ItemStack(Material.STONE));
+        stacks.add(new ItemStack(Material.GRASS));
+        stacks.add(new ItemStack(Material.DIRT));
+        stacks.add(new ItemStack(Material.COBBLESTONE, 17));
+        stacks.add(new ItemStack(Material.OAK_PLANKS, 63));
+        stacks.add(new ItemStack(Material.OAK_SAPLING, 1, (short) 1));
+        stacks.add(new ItemStack(Material.OAK_LEAVES, 32, (short) 2));
+
+        ItemStack item7 = new ItemStack(Material.IRON_SHOVEL);
+        item7.addUnsafeEnchantment(Enchantment.PROTECTION_FIRE, 1);
+        stacks.add(item7);
+
+        ItemStack item8 = new ItemStack(Material.IRON_PICKAXE);
+        item8.addUnsafeEnchantment(Enchantment.PROTECTION_FALL, 2);
+        item8.addUnsafeEnchantment(Enchantment.PROTECTION_EXPLOSIONS, 1);
+        item8.addUnsafeEnchantment(Enchantment.PROTECTION_PROJECTILE, 5);
+        item8.addUnsafeEnchantment(Enchantment.OXYGEN, 4);
+        stacks.add(item8);
+
+        out.set("composite-list.abc.def", stacks);
+        String yaml = out.saveToString();
+
+        YamlConfiguration in = new YamlConfiguration();
+        in.loadFromString(yaml);
+        List<?> raw = in.getList("composite-list.abc.def");
+
+        assertThat(stacks, hasSize(raw.size()));
+
+        for (int i = 0; i < 9; i++) {
+            assertThat(String.valueOf(i), (Object) stacks.get(i), is((Object) raw.get(i)));
+        }
+    }
+}
+

src/test/java/org/bukkit/craftbukkit/inventory/FactoryItemMaterialTest.java

@@ -0,0 +1,156 @@
+package org.bukkit.craftbukkit.inventory;
+
+import static org.junit.Assert.*;
+import static org.hamcrest.Matchers.*;
+
+import java.util.ArrayList;
+import java.util.List;
+import org.apache.commons.lang.ArrayUtils;
+
+import org.bukkit.Material;
+import org.bukkit.inventory.ItemFactory;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.meta.ItemMeta;
+import org.bukkit.support.AbstractTestingBase;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameter;
+import org.junit.runners.Parameterized.Parameters;
+
+@RunWith(Parameterized.class)
+public class FactoryItemMaterialTest extends AbstractTestingBase {
+    static final ItemFactory factory = CraftItemFactory.instance();
+    static final StringBuilder buffer = new StringBuilder();
+    static final Material[] materials;
+
+    static {
+        Material[] local_materials = Material.values();
+        List<Material> list = new ArrayList<Material>(local_materials.length);
+        for (Material material : local_materials) {
+            if (INVALIDATED_MATERIALS.contains(material)) {
+                continue;
+            }
+
+            list.add(material);
+        }
+        materials = list.toArray(new Material[list.size()]);
+    }
+
+    static String name(Enum<?> from, Enum<?> to) {
+        if (from.getClass() == to.getClass()) {
+            return buffer.delete(0, Integer.MAX_VALUE).append(from.getClass().getName()).append(' ').append(from.name()).append(" to ").append(to.name()).toString();
+        }
+        return buffer.delete(0, Integer.MAX_VALUE).append(from.getClass().getName()).append('(').append(from.name()).append(") to ").append(to.getClass().getName()).append('(').append(to.name()).append(')').toString();
+    }
+
+    @Parameters(name="Material[{index}]:{0}")
+    public static List<Object[]> data() {
+        List<Object[]> list = new ArrayList<Object[]>();
+        for (Material material : materials) {
+            list.add(new Object[] {material});
+        }
+        return list;
+    }
+
+    @Parameter(0) public Material material;
+
+    @Test
+    public void itemStack() {
+        ItemStack bukkitStack = new ItemStack(material);
+        CraftItemStack craftStack = CraftItemStack.asCraftCopy(bukkitStack);
+        ItemMeta meta = factory.getItemMeta(material);
+        if (meta == null) {
+            assertThat(material, is(Material.AIR));
+        } else {
+            assertTrue(factory.isApplicable(meta, bukkitStack));
+            assertTrue(factory.isApplicable(meta, craftStack));
+        }
+    }
+
+    @Test
+    public void generalCase() {
+        CraftMetaItem meta = (CraftMetaItem) factory.getItemMeta(material);
+        if (meta == null) {
+            assertThat(material, is(Material.AIR));
+        } else {
+            assertTrue(factory.isApplicable(meta, material));
+            assertTrue(meta.applicableTo(material));
+
+            meta = meta.clone();
+            assertTrue(factory.isApplicable(meta, material));
+            assertTrue(meta.applicableTo(material));
+        }
+    }
+
+    @Test
+    public void asMetaFor() {
+        final CraftMetaItem baseMeta = (CraftMetaItem) factory.getItemMeta(material);
+        if (baseMeta == null) {
+            assertThat(material, is(Material.AIR));
+            return;
+        }
+
+        for (Material other : materials) {
+            final ItemStack bukkitStack = new ItemStack(other);
+            final CraftItemStack craftStack = CraftItemStack.asCraftCopy(bukkitStack);
+            final CraftMetaItem otherMeta = (CraftMetaItem) factory.asMetaFor(baseMeta, other);
+
+            final String testName = name(material, other);
+
+            if (otherMeta == null) {
+                assertThat(testName, other, is(Material.AIR));
+                continue;
+            }
+
+            assertTrue(testName, factory.isApplicable(otherMeta, craftStack));
+            assertTrue(testName, factory.isApplicable(otherMeta, bukkitStack));
+            assertTrue(testName, factory.isApplicable(otherMeta, other));
+            assertTrue(testName, otherMeta.applicableTo(other));
+        }
+    }
+
+    @Test
+    public void blankEqualities() {
+        if (material == Material.AIR) {
+            return;
+        }
+        final CraftMetaItem baseMeta = (CraftMetaItem) factory.getItemMeta(material);
+        final CraftMetaItem baseMetaClone = baseMeta.clone();
+
+        final ItemStack baseMetaStack = new ItemStack(material);
+        baseMetaStack.setItemMeta(baseMeta);
+
+        assertThat(baseMeta, is(not(sameInstance(baseMetaStack.getItemMeta()))));
+
+        assertTrue(factory.equals(baseMeta, null));
+        assertTrue(factory.equals(null, baseMeta));
+
+        assertTrue(factory.equals(baseMeta, baseMetaClone));
+        assertTrue(factory.equals(baseMetaClone, baseMeta));
+
+        assertThat(baseMeta, is(not(sameInstance(baseMetaClone))));
+
+        assertThat(baseMeta, is(baseMetaClone));
+        assertThat(baseMetaClone, is(baseMeta));
+
+        for (Material other : materials) {
+            final String testName = name(material, other);
+
+            final CraftMetaItem otherMeta = (CraftMetaItem) factory.asMetaFor(baseMetaClone, other);
+
+            if (otherMeta == null) {
+                assertThat(testName, other, is(Material.AIR));
+                continue;
+            }
+
+            assertTrue(testName, factory.equals(baseMeta, otherMeta));
+            assertTrue(testName, factory.equals(otherMeta, baseMeta));
+
+            assertThat(testName, baseMeta, is(otherMeta));
+            assertThat(testName, otherMeta, is(baseMeta));
+
+            assertThat(testName, baseMeta.hashCode(), is(otherMeta.hashCode()));
+        }
+    }
+}

src/test/java/org/bukkit/craftbukkit/inventory/ItemFactoryTest.java

@@ -0,0 +1,47 @@
+package org.bukkit.craftbukkit.inventory;
+
+import static org.junit.Assert.*;
+import static org.hamcrest.Matchers.*;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.Modifier;
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipInputStream;
+
+import net.minecraft.server.IAnimal;
+import net.minecraft.server.IAttribute;
+
+import org.bukkit.support.AbstractTestingBase;
+import org.junit.Test;
+
+public class ItemFactoryTest extends AbstractTestingBase {
+
+    @Test
+    public void testKnownAttributes() throws Throwable {
+        final ZipInputStream nmsZipStream = new ZipInputStream(IAnimal.class/* Magic class that isn't imported! */.getProtectionDomain().getCodeSource().getLocation().openStream());
+        final Collection<String> names = new HashSet<String>();
+        for (ZipEntry clazzEntry; (clazzEntry = nmsZipStream.getNextEntry()) != null; ) {
+            final String entryName = clazzEntry.getName();
+            if (!(entryName.endsWith(".class") && entryName.startsWith("net/minecraft/server/"))) {
+                continue;
+            }
+
+            final Class<?> clazz = Class.forName(entryName.substring(0, entryName.length() - ".class".length()).replace('/', '.'));
+            assertThat(entryName, clazz, is(not(nullValue())));
+            for (final Field field : clazz.getDeclaredFields()) {
+                if (IAttribute.class.isAssignableFrom(field.getType()) && Modifier.isStatic(field.getModifiers())) {
+                    field.setAccessible(true);
+                    final String attributeName = ((IAttribute) field.get(null)).getName();
+                    assertThat("Logical error: duplicate name `" + attributeName + "' in " + clazz.getName(), names.add(attributeName), is(true));
+                    assertThat(clazz.getName(), CraftItemFactory.KNOWN_NBT_ATTRIBUTE_NAMES, hasItem(attributeName));
+                }
+            }
+        }
+
+        nmsZipStream.close();
+
+        assertThat("Extra values detected", CraftItemFactory.KNOWN_NBT_ATTRIBUTE_NAMES, is(names));
+    }
+}

src/test/java/org/bukkit/craftbukkit/inventory/ItemMetaCloneTest.java

@@ -0,0 +1,22 @@
+package org.bukkit.craftbukkit.inventory;
+
+import java.lang.reflect.Method;
+import org.bukkit.Material;
+import org.junit.Test;
+
+import static org.hamcrest.Matchers.*;
+import static org.junit.Assert.*;
+
+public class ItemMetaCloneTest {
+
+    @Test
+    public void testClone() throws Throwable {
+        for (Material material : ItemStackTest.COMPOUND_MATERIALS) {
+            Class<?> clazz = CraftItemFactory.instance().getItemMeta(material).getClass();
+
+            Method clone = clazz.getDeclaredMethod("clone");
+            assertNotNull("Class " + clazz + " does not override clone()", clone);
+            assertThat("Class " + clazz + " clone return type does not match", clone.getReturnType(), is(equalTo(clazz)));
+        }
+    }
+}

src/test/java/org/bukkit/craftbukkit/inventory/ItemMetaCustomValueTest.java

@@ -0,0 +1,327 @@
+package org.bukkit.craftbukkit.inventory;
+
+import java.io.StringReader;
+import java.lang.reflect.Array;
+import java.nio.ByteBuffer;
+import java.util.Arrays;
+import java.util.Map;
+import java.util.UUID;
+import net.minecraft.server.NBTBase;
+import net.minecraft.server.NBTTagCompound;
+import net.minecraft.server.NBTTagIntArray;
+import net.minecraft.server.NBTTagList;
+import org.bukkit.Bukkit;
+import org.bukkit.Material;
+import org.bukkit.NamespacedKey;
+import org.bukkit.configuration.file.YamlConfiguration;
+import org.bukkit.craftbukkit.inventory.tags.CraftCustomItemTagContainer;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.meta.ItemMeta;
+import org.bukkit.inventory.meta.tags.CustomItemTagContainer;
+import org.bukkit.inventory.meta.tags.ItemTagAdapterContext;
+import org.bukkit.inventory.meta.tags.ItemTagType;
+import org.bukkit.support.AbstractTestingBase;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotEquals;
+import static org.junit.Assert.assertTrue;
+import org.junit.Before;
+import org.junit.Test;
+
+public class ItemMetaCustomValueTest extends AbstractTestingBase {
+
+    private static NamespacedKey VALID_KEY;
+
+    @Before
+    public void setup() {
+        VALID_KEY = new NamespacedKey("test", "validkey");
+    }
+
+    /*
+        Sets a test
+     */
+    @Test(expected = IllegalArgumentException.class)
+    public void testSetNoAdapter() {
+        ItemMeta itemMeta = createNewItemMeta();
+        itemMeta.getCustomTagContainer().setCustomTag(VALID_KEY, new PrimitiveTagType<>(boolean.class), true);
+    }
+
+    /*
+        Contains a tag
+     */
+    @Test(expected = IllegalArgumentException.class)
+    public void testHasNoAdapter() {
+        ItemMeta itemMeta = createNewItemMeta();
+        itemMeta.getCustomTagContainer().setCustomTag(VALID_KEY, ItemTagType.INTEGER, 1); // We gotta set this so we at least try to compare it
+        itemMeta.getCustomTagContainer().hasCustomTag(VALID_KEY, new PrimitiveTagType<>(boolean.class));
+    }
+
+    /*
+        Getting a tag
+     */
+    @Test(expected = IllegalArgumentException.class)
+    public void testGetNoAdapter() {
+        ItemMeta itemMeta = createNewItemMeta();
+        itemMeta.getCustomTagContainer().setCustomTag(VALID_KEY, ItemTagType.INTEGER, 1); //We gotta set this so we at least try to compare it
+        itemMeta.getCustomTagContainer().getCustomTag(VALID_KEY, new PrimitiveTagType<>(boolean.class));
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void testGetWrongType() {
+        ItemMeta itemMeta = createNewItemMeta();
+        itemMeta.getCustomTagContainer().setCustomTag(VALID_KEY, ItemTagType.INTEGER, 1);
+        itemMeta.getCustomTagContainer().getCustomTag(VALID_KEY, ItemTagType.STRING);
+    }
+
+    @Test
+    public void testDifferentNamespace() {
+        NamespacedKey namespacedKeyA = new NamespacedKey("plugin-a", "damage");
+        NamespacedKey namespacedKeyB = new NamespacedKey("plugin-b", "damage");
+
+        ItemMeta meta = createNewItemMeta();
+        meta.getCustomTagContainer().setCustomTag(namespacedKeyA, ItemTagType.LONG, 15L);
+        meta.getCustomTagContainer().setCustomTag(namespacedKeyB, ItemTagType.LONG, 160L);
+
+        assertEquals(15L, (long) meta.getCustomTagContainer().getCustomTag(namespacedKeyA, ItemTagType.LONG));
+        assertEquals(160L, (long) meta.getCustomTagContainer().getCustomTag(namespacedKeyB, ItemTagType.LONG));
+    }
+
+    private ItemMeta createNewItemMeta() {
+        return Bukkit.getItemFactory().getItemMeta(Material.DIAMOND_PICKAXE);
+    }
+
+    private NamespacedKey requestKey(String keyName) {
+        return new NamespacedKey("test-plugin", keyName.toLowerCase());
+    }
+
+    /*
+        Removing a tag
+     */
+    @Test
+    public void testNBTTagStoring() {
+        CraftMetaItem itemMeta = createComplexItemMeta();
+
+        NBTTagCompound compound = new NBTTagCompound();
+        itemMeta.applyToItem(compound);
+
+        assertEquals(itemMeta, new CraftMetaItem(compound));
+    }
+
+    @Test
+    public void testMapStoring() {
+        CraftMetaItem itemMeta = createComplexItemMeta();
+
+        Map<String, Object> serialize = itemMeta.serialize();
+        assertEquals(itemMeta, new CraftMetaItem(serialize));
+    }
+
+    @Test
+    public void testYAMLStoring() {
+        ItemStack stack = new ItemStack(Material.DIAMOND);
+        CraftMetaItem meta = createComplexItemMeta();
+        stack.setItemMeta(meta);
+
+        YamlConfiguration configuration = new YamlConfiguration();
+        configuration.set("testpath", stack);
+
+        String configValue = configuration.saveToString();
+        YamlConfiguration loadedConfig = YamlConfiguration.loadConfiguration(new StringReader(configValue));
+
+        assertEquals(stack, loadedConfig.getSerializable("testpath", ItemStack.class));
+        assertNotEquals(new ItemStack(Material.DIAMOND), loadedConfig.getSerializable("testpath", ItemStack.class));
+    }
+
+    @Test
+    public void testCorrectType() {
+        ItemStack stack = new ItemStack(Material.DIAMOND);
+        CraftMetaItem meta = createComplexItemMeta();
+
+        meta.getCustomTagContainer().setCustomTag(requestKey("int"), ItemTagType.STRING, "1");
+        meta.getCustomTagContainer().setCustomTag(requestKey("double"), ItemTagType.STRING, "1.33");
+        stack.setItemMeta(meta);
+
+        YamlConfiguration configuration = new YamlConfiguration();
+        configuration.set("testpath", stack);
+
+        String configValue = configuration.saveToString();
+        YamlConfiguration loadedConfig = YamlConfiguration.loadConfiguration(new StringReader(configValue));
+        ItemStack newStack = loadedConfig.getSerializable("testpath", ItemStack.class);
+
+        assertTrue(newStack.getItemMeta().getCustomTagContainer().hasCustomTag(requestKey("int"), ItemTagType.STRING));
+        assertEquals(newStack.getItemMeta().getCustomTagContainer().getCustomTag(requestKey("int"), ItemTagType.STRING), "1");
+
+        assertTrue(newStack.getItemMeta().getCustomTagContainer().hasCustomTag(requestKey("double"), ItemTagType.STRING));
+        assertEquals(newStack.getItemMeta().getCustomTagContainer().getCustomTag(requestKey("double"), ItemTagType.STRING), "1.33");
+    }
+
+    private CraftMetaItem createComplexItemMeta() {
+        CraftMetaItem itemMeta = (CraftMetaItem) createNewItemMeta();
+        itemMeta.setDisplayName("Item Display Name");
+
+        itemMeta.getCustomTagContainer().setCustomTag(requestKey("custom-long"), ItemTagType.LONG, 4L); //Add random primitive values
+        itemMeta.getCustomTagContainer().setCustomTag(requestKey("custom-byte-array"), ItemTagType.BYTE_ARRAY, new byte[]{
+            0, 1, 2, 10
+        });
+        itemMeta.getCustomTagContainer().setCustomTag(requestKey("custom-string"), ItemTagType.STRING, "Hello there world");
+        itemMeta.getCustomTagContainer().setCustomTag(requestKey("custom-int"), ItemTagType.INTEGER, 3);
+        itemMeta.getCustomTagContainer().setCustomTag(requestKey("custom-double"), ItemTagType.DOUBLE, 3.123);
+
+        CustomItemTagContainer innerContainer = itemMeta.getCustomTagContainer().getAdapterContext().newTagContainer(); //Add a inner container
+        innerContainer.setCustomTag(VALID_KEY, ItemTagType.LONG, 5L);
+        itemMeta.getCustomTagContainer().setCustomTag(requestKey("custom-inner-compound"), ItemTagType.TAG_CONTAINER, innerContainer);
+
+        Map<String, NBTBase> rawMap = ((CraftCustomItemTagContainer) itemMeta.getCustomTagContainer()).getRaw(); //Adds a tag list as well (even tho is has no API yet)
+        NBTTagList nbtList = new NBTTagList();
+        nbtList.add(new NBTTagIntArray(Arrays.asList(1, 5, 3)));
+        nbtList.add(new NBTTagIntArray(Arrays.asList(42, 51)));
+        rawMap.put("nbttaglist", nbtList);
+        return itemMeta;
+    }
+
+    /*
+        Test complex object storage
+     */
+    @Test
+    public void storeUUIDOnItemTest() {
+        ItemMeta itemMeta = createNewItemMeta();
+        UUIDItemTagType uuidItemTagType = new UUIDItemTagType();
+        UUID uuid = UUID.fromString("434eea72-22a6-4c61-b5ef-945874a5c478");
+
+        itemMeta.getCustomTagContainer().setCustomTag(VALID_KEY, uuidItemTagType, uuid);
+        assertTrue(itemMeta.getCustomTagContainer().hasCustomTag(VALID_KEY, uuidItemTagType));
+        assertEquals(uuid, itemMeta.getCustomTagContainer().getCustomTag(VALID_KEY, uuidItemTagType));
+    }
+
+    @Test
+    public void encapsulatedContainers() {
+        NamespacedKey innerKey = new NamespacedKey("plugin-a", "inner");
+
+        ItemMeta meta = createNewItemMeta();
+        ItemTagAdapterContext context = meta.getCustomTagContainer().getAdapterContext();
+
+        CustomItemTagContainer thirdContainer = context.newTagContainer();
+        thirdContainer.setCustomTag(VALID_KEY, ItemTagType.LONG, 3L);
+
+        CustomItemTagContainer secondContainer = context.newTagContainer();
+        secondContainer.setCustomTag(VALID_KEY, ItemTagType.LONG, 2L);
+        secondContainer.setCustomTag(innerKey, ItemTagType.TAG_CONTAINER, thirdContainer);
+
+        meta.getCustomTagContainer().setCustomTag(VALID_KEY, ItemTagType.LONG, 1L);
+        meta.getCustomTagContainer().setCustomTag(innerKey, ItemTagType.TAG_CONTAINER, secondContainer);
+
+        assertEquals(3L, meta.getCustomTagContainer()
+                .getCustomTag(innerKey, ItemTagType.TAG_CONTAINER)
+                .getCustomTag(innerKey, ItemTagType.TAG_CONTAINER)
+                .getCustomTag(VALID_KEY, ItemTagType.LONG).longValue());
+
+        assertEquals(2L, meta.getCustomTagContainer()
+                .getCustomTag(innerKey, ItemTagType.TAG_CONTAINER)
+                .getCustomTag(VALID_KEY, ItemTagType.LONG).longValue());
+
+        assertEquals(1L, meta.getCustomTagContainer()
+                .getCustomTag(VALID_KEY, ItemTagType.LONG).longValue());
+    }
+
+    class UUIDItemTagType implements ItemTagType<byte[], UUID> {
+
+        @Override
+        public Class<byte[]> getPrimitiveType() {
+            return byte[].class;
+        }
+
+        @Override
+        public Class<UUID> getComplexType() {
+            return UUID.class;
+        }
+
+        @Override
+        public byte[] toPrimitive(UUID complex, ItemTagAdapterContext context) {
+            ByteBuffer bb = ByteBuffer.wrap(new byte[16]);
+            bb.putLong(complex.getMostSignificantBits());
+            bb.putLong(complex.getLeastSignificantBits());
+            return bb.array();
+        }
+
+        @Override
+        public UUID fromPrimitive(byte[] primitive, ItemTagAdapterContext context) {
+            ByteBuffer bb = ByteBuffer.wrap(primitive);
+            long firstLong = bb.getLong();
+            long secondLong = bb.getLong();
+            return new UUID(firstLong, secondLong);
+        }
+    }
+
+    @Test
+    public void testPrimitiveCustomTags() {
+        ItemMeta itemMeta = createNewItemMeta();
+
+        testPrimitiveCustomTag(itemMeta, ItemTagType.BYTE, (byte) 1);
+        testPrimitiveCustomTag(itemMeta, ItemTagType.SHORT, (short) 1);
+        testPrimitiveCustomTag(itemMeta, ItemTagType.INTEGER, 1);
+        testPrimitiveCustomTag(itemMeta, ItemTagType.LONG, 1L);
+        testPrimitiveCustomTag(itemMeta, ItemTagType.FLOAT, 1.34F);
+        testPrimitiveCustomTag(itemMeta, ItemTagType.DOUBLE, 151.123);
+
+        testPrimitiveCustomTag(itemMeta, ItemTagType.STRING, "test");
+
+        testPrimitiveCustomTag(itemMeta, ItemTagType.BYTE_ARRAY, new byte[]{
+            1, 4, 2, Byte.MAX_VALUE
+        });
+        testPrimitiveCustomTag(itemMeta, ItemTagType.INTEGER_ARRAY, new int[]{
+            1, 4, 2, Integer.MAX_VALUE
+        });
+        testPrimitiveCustomTag(itemMeta, ItemTagType.LONG_ARRAY, new long[]{
+            1L, 4L, 2L, Long.MAX_VALUE
+        });
+    }
+
+    private <T, Z> void testPrimitiveCustomTag(ItemMeta meta, ItemTagType<T, Z> type, Z value) {
+        NamespacedKey tagKey = new NamespacedKey("test", String.valueOf(type.hashCode()));
+
+        meta.getCustomTagContainer().setCustomTag(tagKey, type, value);
+        assertTrue(meta.getCustomTagContainer().hasCustomTag(tagKey, type));
+
+        Z foundValue = meta.getCustomTagContainer().getCustomTag(tagKey, type);
+        if (foundValue.getClass().isArray()) { // Compare arrays using reflection access
+            int length = Array.getLength(foundValue);
+            int originalLength = Array.getLength(value);
+            for (int i = 0; i < length && i < originalLength; i++) {
+                assertEquals(Array.get(value, i), Array.get(foundValue, i));
+            }
+        } else {
+            assertEquals(foundValue, value);
+        }
+
+        meta.getCustomTagContainer().removeCustomTag(tagKey);
+        assertFalse(meta.getCustomTagContainer().hasCustomTag(tagKey, type));
+    }
+
+    class PrimitiveTagType<T> implements ItemTagType<T, T> {
+
+        private final Class<T> primitiveType;
+
+        PrimitiveTagType(Class<T> primitiveType) {
+            this.primitiveType = primitiveType;
+        }
+
+        @Override
+        public Class<T> getPrimitiveType() {
+            return primitiveType;
+        }
+
+        @Override
+        public Class<T> getComplexType() {
+            return primitiveType;
+        }
+
+        @Override
+        public T toPrimitive(T complex, ItemTagAdapterContext context) {
+            return complex;
+        }
+
+        @Override
+        public T fromPrimitive(T primitive, ItemTagAdapterContext context) {
+            return primitive;
+        }
+    }
+}

src/test/java/org/bukkit/craftbukkit/inventory/ItemMetaImplementationOverrideTest.java

@@ -0,0 +1,80 @@
+package org.bukkit.craftbukkit.inventory;
+
+import static org.hamcrest.Matchers.*;
+import static org.junit.Assert.*;
+
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.Callable;
+
+import org.bukkit.Material;
+import org.bukkit.configuration.serialization.DelegateDeserialization;
+import org.bukkit.craftbukkit.Overridden;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameter;
+import org.junit.runners.Parameterized.Parameters;
+
+@RunWith(Parameterized.class)
+public class ItemMetaImplementationOverrideTest {
+    static final Class<CraftMetaItem> parent = CraftMetaItem.class;
+
+    @Parameters(name="[{index}]:{1}")
+    public static List<Object[]> data() {
+        final List<Object[]> testData = new ArrayList<Object[]>();
+        List<Class<? extends CraftMetaItem>> classes = new ArrayList<Class<? extends CraftMetaItem>>();
+
+        for (Material material : ItemStackTest.COMPOUND_MATERIALS) {
+            Class<? extends CraftMetaItem> clazz = CraftItemFactory.instance().getItemMeta(material).getClass().asSubclass(parent);
+            if (clazz != parent) {
+                classes.add(clazz);
+            }
+        }
+
+        List<Method> list = new ArrayList<Method>();
+
+        for (Method method: parent.getDeclaredMethods()) {
+            if (method.isAnnotationPresent(Overridden.class)) {
+                list.add(method);
+            }
+        }
+
+        for (final Class<?> clazz : classes) {
+            for (final Method method : list) {
+                testData.add(
+                    new Object[] {
+                        new Callable<Method>() {
+                            public Method call() throws Exception {
+                                return clazz.getDeclaredMethod(method.getName(), method.getParameterTypes());
+                            }
+                        },
+                        clazz.getSimpleName() + " contains " + method.getName()
+                    }
+                );
+            }
+
+            testData.add(
+                new Object[] {
+                    new Callable<DelegateDeserialization>() {
+                        public DelegateDeserialization call() throws Exception {
+                            return clazz.getAnnotation(DelegateDeserialization.class);
+                        }
+                    },
+                    clazz.getSimpleName() + " contains annotation " + DelegateDeserialization.class
+                }
+            );
+        }
+
+        return testData;
+    }
+
+    @Parameter(0) public Callable<?> test;
+    @Parameter(1) public String name;
+
+    @Test
+    public void testClass() throws Throwable {
+        assertThat(name, test.call(), is(not(nullValue())));
+    }
+}

src/test/java/org/bukkit/craftbukkit/inventory/ItemMetaTest.java

@@ -0,0 +1,423 @@
+package org.bukkit.craftbukkit.inventory;
+
+import static org.junit.Assert.*;
+import static org.hamcrest.Matchers.*;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections; // Paper
+import java.util.List;
+import java.util.UUID;
+
+import com.destroystokyo.paper.inventory.meta.ArmorStandMeta; // Paper
+import net.minecraft.server.Block;
+import net.minecraft.server.IRegistry;
+import net.minecraft.server.ITileEntity;
+import net.minecraft.server.Item;
+import net.minecraft.server.ItemBlock;
+import net.minecraft.server.ItemBlockWallable;
+import net.minecraft.server.NBTTagInt;
+
+import org.bukkit.Bukkit;
+import org.bukkit.Color;
+import org.bukkit.DyeColor;
+import org.bukkit.FireworkEffect;
+import org.bukkit.Material;
+import org.bukkit.FireworkEffect.Type;
+import org.bukkit.NamespacedKey;
+import org.bukkit.attribute.Attribute;
+import org.bukkit.attribute.AttributeModifier;
+import org.bukkit.block.banner.Pattern;
+import org.bukkit.block.banner.PatternType;
+import org.bukkit.craftbukkit.inventory.ItemStackTest.StackProvider;
+import org.bukkit.craftbukkit.inventory.ItemStackTest.StackWrapper;
+import org.bukkit.craftbukkit.inventory.ItemStackTest.BukkitWrapper;
+import org.bukkit.craftbukkit.inventory.ItemStackTest.CraftWrapper;
+import org.bukkit.enchantments.Enchantment;
+import org.bukkit.entity.EntityType;
+import org.bukkit.entity.TropicalFish;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.meta.BannerMeta;
+import org.bukkit.inventory.meta.BlockStateMeta;
+import org.bukkit.inventory.meta.BookMeta;
+import org.bukkit.inventory.meta.EnchantmentStorageMeta;
+import org.bukkit.inventory.meta.FireworkEffectMeta;
+import org.bukkit.inventory.meta.FireworkMeta;
+import org.bukkit.inventory.meta.ItemMeta;
+import org.bukkit.inventory.meta.KnowledgeBookMeta;
+import org.bukkit.inventory.meta.LeatherArmorMeta;
+import org.bukkit.inventory.meta.MapMeta;
+import org.bukkit.inventory.meta.PotionMeta;
+import org.bukkit.inventory.meta.SpawnEggMeta;
+import org.bukkit.inventory.meta.TropicalFishBucketMeta;
+import org.bukkit.potion.PotionEffectType;
+import org.bukkit.potion.PotionData;
+import org.bukkit.potion.PotionType;
+import org.bukkit.support.AbstractTestingBase;
+import org.junit.Test;
+
+public class ItemMetaTest extends AbstractTestingBase {
+
+    static final int MAX_FIREWORK_POWER = 127; // Please update ItemStackFireworkTest if/when this gets changed.
+
+    @Test(expected=IllegalArgumentException.class)
+    public void testPowerLimitExact() {
+        newFireworkMeta().setPower(MAX_FIREWORK_POWER + 1);
+    }
+
+    @Test(expected=IllegalArgumentException.class)
+    public void testPowerLimitMax() {
+        newFireworkMeta().setPower(Integer.MAX_VALUE);
+    }
+
+    @Test(expected=IllegalArgumentException.class)
+    public void testPowerLimitMin() {
+        newFireworkMeta().setPower(Integer.MIN_VALUE);
+    }
+
+    @Test(expected=IllegalArgumentException.class)
+    public void testPowerLimitNegative() {
+        newFireworkMeta().setPower(-1);
+    }
+
+    @Test
+    public void testPowers() {
+        for (int i = 0; i <= MAX_FIREWORK_POWER; i++) {
+            FireworkMeta firework = newFireworkMeta();
+            firework.setPower(i);
+            assertThat(String.valueOf(i), firework.getPower(), is(i));
+        }
+    }
+
+    @Test
+    public void testConflictingEnchantment() {
+        ItemMeta itemMeta = Bukkit.getItemFactory().getItemMeta(Material.DIAMOND_PICKAXE);
+        assertThat(itemMeta.hasConflictingEnchant(Enchantment.DURABILITY), is(false));
+
+        itemMeta.addEnchant(Enchantment.SILK_TOUCH, 1, false);
+        assertThat(itemMeta.hasConflictingEnchant(Enchantment.DURABILITY), is(false));
+        assertThat(itemMeta.hasConflictingEnchant(Enchantment.LOOT_BONUS_BLOCKS), is(true));
+        assertThat(itemMeta.hasConflictingEnchant(null), is(false));
+    }
+
+    @Test
+    public void testConflictingStoredEnchantment() {
+        EnchantmentStorageMeta itemMeta = (EnchantmentStorageMeta) Bukkit.getItemFactory().getItemMeta(Material.ENCHANTED_BOOK);
+        assertThat(itemMeta.hasConflictingStoredEnchant(Enchantment.DURABILITY), is(false));
+
+        itemMeta.addStoredEnchant(Enchantment.SILK_TOUCH, 1, false);
+        assertThat(itemMeta.hasConflictingStoredEnchant(Enchantment.DURABILITY), is(false));
+        assertThat(itemMeta.hasConflictingStoredEnchant(Enchantment.LOOT_BONUS_BLOCKS), is(true));
+        assertThat(itemMeta.hasConflictingStoredEnchant(null), is(false));
+    }
+
+    @Test
+    public void testConflictingEnchantments() {
+        ItemMeta itemMeta = Bukkit.getItemFactory().getItemMeta(Material.DIAMOND_PICKAXE);
+        itemMeta.addEnchant(Enchantment.DURABILITY, 6, true);
+        itemMeta.addEnchant(Enchantment.DIG_SPEED, 6, true);
+        assertThat(itemMeta.hasConflictingEnchant(Enchantment.LOOT_BONUS_BLOCKS), is(false));
+
+        itemMeta.addEnchant(Enchantment.SILK_TOUCH, 1, false);
+        assertThat(itemMeta.hasConflictingEnchant(Enchantment.LOOT_BONUS_BLOCKS), is(true));
+        assertThat(itemMeta.hasConflictingEnchant(null), is(false));
+    }
+
+    @Test
+    public void testConflictingStoredEnchantments() {
+        EnchantmentStorageMeta itemMeta = (EnchantmentStorageMeta) Bukkit.getItemFactory().getItemMeta(Material.ENCHANTED_BOOK);
+        itemMeta.addStoredEnchant(Enchantment.DURABILITY, 6, true);
+        itemMeta.addStoredEnchant(Enchantment.DIG_SPEED, 6, true);
+        assertThat(itemMeta.hasConflictingStoredEnchant(Enchantment.LOOT_BONUS_BLOCKS), is(false));
+
+        itemMeta.addStoredEnchant(Enchantment.SILK_TOUCH, 1, false);
+        assertThat(itemMeta.hasConflictingStoredEnchant(Enchantment.LOOT_BONUS_BLOCKS), is(true));
+        assertThat(itemMeta.hasConflictingStoredEnchant(null), is(false));
+    }
+
+    private static FireworkMeta newFireworkMeta() {
+        return ((FireworkMeta) Bukkit.getItemFactory().getItemMeta(Material.FIREWORK_ROCKET));
+    }
+
+    @Test
+    public void testCrazyEquality() {
+        CraftItemStack craft = CraftItemStack.asCraftCopy(new ItemStack(Material.STONE));
+        craft.setItemMeta(craft.getItemMeta());
+        ItemStack bukkit = new ItemStack(craft);
+        assertThat(craft, is(bukkit));
+        assertThat(bukkit, is((ItemStack) craft));
+    }
+
+    @Test
+    public void testTaggedButNotMeta() {
+        CraftItemStack craft = CraftItemStack.asCraftCopy(new ItemStack(Material.SHEARS));
+        craft.handle.setDamage(0);
+
+        assertThat("Should have NBT tag", CraftItemStack.hasItemMeta(craft.handle), is(true));
+        assertThat("NBT Tag should contain Damage", craft.handle.getTag().get("Damage"), instanceOf(NBTTagInt.class));
+        assertThat("But we should not have meta", craft.hasItemMeta(), is(false));
+
+        ItemStack pureBukkit = new ItemStack(Material.SHEARS);
+        assertThat("Bukkit and craft stacks should be similar", craft.isSimilar(pureBukkit), is(true));
+        assertThat("Bukkit and craft stacks should be equal", craft.equals(pureBukkit), is(true));
+        // Paper start - test additional ItemMeta damage cases
+        ItemStack clone = CraftItemStack.asBukkitCopy(CraftItemStack.asNMSCopy(craft));
+        assertThat("Bukkit and craft stacks should be similar", craft.isSimilar(clone), is(true));
+        assertThat("Bukkit and craft stacks should be equal", craft.equals(clone), is(true));
+
+        pureBukkit = new ItemStack(Material.DIAMOND_SWORD);
+        pureBukkit.setDurability((short) 2);
+        net.minecraft.server.ItemStack nms = CraftItemStack.asNMSCopy(pureBukkit);
+        ItemStack other = CraftItemStack.asBukkitCopy(nms);
+
+        assertThat("Bukkit and NMS ItemStack copies should be similar", pureBukkit.isSimilar(other), is(true));
+        assertThat("Bukkit and NMS ItemStack copies should be equal", pureBukkit.equals(other), is(true));
+    }
+
+    private void testItemMeta(ItemStack stack) {
+        assertThat("Should not have ItemMeta", stack.hasItemMeta(), is(false));
+
+        stack.setDurability((short) 0);
+        assertThat("ItemStack with zero durability should not have ItemMeta", stack.hasItemMeta(), is(false));
+
+        stack.setDurability((short) 2);
+        assertThat("ItemStack with non-zero durability should have ItemMeta", stack.hasItemMeta(), is(true));
+
+        stack.setLore(Collections.singletonList("Lore"));
+        assertThat("ItemStack with lore and durability should have ItemMeta", stack.hasItemMeta(), is(true));
+
+        stack.setDurability((short) 0);
+        assertThat("ItemStack with lore should have ItemMeta", stack.hasItemMeta(), is(true));
+
+        stack.setLore(null);
+    }
+
+    @Test
+    public void testHasItemMeta() {
+        ItemStack itemStack = new ItemStack(Material.SHEARS);
+
+        testItemMeta(itemStack);
+        testItemMeta(CraftItemStack.asCraftCopy(itemStack));
+    }
+    // Paper end
+
+    @Test
+    public void testBlockStateMeta() {
+        List<Block> queue = new ArrayList<>();
+
+        for (Item item : (Iterable<Item>) IRegistry.ITEM) { // Eclipse fail
+            if (item instanceof ItemBlock) {
+                queue.add(((ItemBlock) item).getBlock());
+            }
+            if (item instanceof ItemBlockWallable) {
+                queue.add(((ItemBlockWallable) item).wallBlock);
+            }
+        }
+
+        for (Block block : queue) {
+            if (block != null) {
+                ItemStack stack = CraftItemStack.asNewCraftStack(Item.getItemOf(block));
+
+                // Command blocks aren't unit testable atm
+                if (stack.getType() == Material.COMMAND_BLOCK || stack.getType() == Material.CHAIN_COMMAND_BLOCK || stack.getType() == Material.REPEATING_COMMAND_BLOCK) {
+                    return;
+                }
+
+                ItemMeta meta = stack.getItemMeta();
+                if (block instanceof ITileEntity) {
+                    assertTrue(stack + " has meta of type " + meta + " expected BlockStateMeta", meta instanceof BlockStateMeta);
+
+                    BlockStateMeta blockState = (BlockStateMeta) meta;
+                    assertNotNull(stack + " has null block state", blockState.getBlockState());
+
+                    blockState.setBlockState(blockState.getBlockState());
+                } else {
+                    assertTrue(stack + " has unexpected meta of type BlockStateMeta (but is not a tile)", !(meta instanceof BlockStateMeta));
+                }
+            }
+        }
+    }
+
+    @Test
+    public void testEachExtraData() {
+        final List<StackProvider> providers = Arrays.asList(
+            new StackProvider(Material.WRITABLE_BOOK) {
+                @Override ItemStack operate(final ItemStack cleanStack) {
+                    final BookMeta meta = (BookMeta) cleanStack.getItemMeta();
+                    meta.setAuthor("Some author");
+                    meta.setPages("Page 1", "Page 2");
+                    meta.setTitle("A title");
+                    cleanStack.setItemMeta(meta);
+                    return cleanStack;
+                }
+            },
+            new StackProvider(Material.WRITTEN_BOOK) {
+                @Override ItemStack operate(final ItemStack cleanStack) {
+                    final BookMeta meta = (BookMeta) cleanStack.getItemMeta();
+                    meta.setAuthor("Some author");
+                    meta.setPages("Page 1", "Page 2");
+                    meta.setTitle("A title");
+                    cleanStack.setItemMeta(meta);
+                    return cleanStack;
+                }
+            },
+            /* Skulls rely on a running server instance
+            new StackProvider(Material.SKULL_ITEM) {
+                @Override ItemStack operate(final ItemStack cleanStack) {
+                    final SkullMeta meta = (SkullMeta) cleanStack.getItemMeta();
+                    meta.setOwner("Notch");
+                    cleanStack.setItemMeta(meta);
+                    return cleanStack;
+                }
+            },
+            */
+            new StackProvider(Material.FILLED_MAP) {
+                @Override ItemStack operate(final ItemStack cleanStack) {
+                    final MapMeta meta = (MapMeta) cleanStack.getItemMeta();
+                    meta.setScaling(true);
+                    cleanStack.setItemMeta(meta);
+                    return cleanStack;
+                }
+            },
+            new StackProvider(Material.LEATHER_BOOTS) {
+                @Override ItemStack operate(final ItemStack cleanStack) {
+                    final LeatherArmorMeta meta = (LeatherArmorMeta) cleanStack.getItemMeta();
+                    meta.setColor(Color.FUCHSIA);
+                    cleanStack.setItemMeta(meta);
+                    return cleanStack;
+                }
+            },
+            new StackProvider(Material.POTION) {
+                @Override ItemStack operate(final ItemStack cleanStack) {
+                    final PotionMeta meta = (PotionMeta) cleanStack.getItemMeta();
+                    meta.setBasePotionData(new PotionData(PotionType.UNCRAFTABLE, false, false));
+                    meta.addCustomEffect(PotionEffectType.CONFUSION.createEffect(1, 1), false);
+                    cleanStack.setItemMeta(meta);
+                    return cleanStack;
+                }
+            },
+            new StackProvider(Material.FIREWORK_ROCKET) {
+                @Override ItemStack operate(final ItemStack cleanStack) {
+                    final FireworkMeta meta = (FireworkMeta) cleanStack.getItemMeta();
+                    meta.addEffect(FireworkEffect.builder().withColor(Color.GREEN).withFade(Color.OLIVE).with(Type.BALL_LARGE).build());
+                    cleanStack.setItemMeta(meta);
+                    return cleanStack;
+                }
+            },
+            new StackProvider(Material.ENCHANTED_BOOK) {
+                @Override ItemStack operate(final ItemStack cleanStack) {
+                    final EnchantmentStorageMeta meta = (EnchantmentStorageMeta) cleanStack.getItemMeta();
+                    meta.addStoredEnchant(Enchantment.ARROW_FIRE, 1, true);
+                    cleanStack.setItemMeta(meta);
+                    return cleanStack;
+                }
+            },
+            new StackProvider(Material.FIREWORK_STAR) {
+                @Override ItemStack operate(final ItemStack cleanStack) {
+                    final FireworkEffectMeta meta = (FireworkEffectMeta) cleanStack.getItemMeta();
+                    meta.setEffect(FireworkEffect.builder().withColor(Color.MAROON, Color.BLACK).with(Type.CREEPER).withFlicker().build());
+                    cleanStack.setItemMeta(meta);
+                    return cleanStack;
+                }
+            },
+            new StackProvider(Material.WHITE_BANNER) {
+                @Override ItemStack operate(ItemStack cleanStack) {
+                    final BannerMeta meta = (BannerMeta) cleanStack.getItemMeta();
+                    meta.setBaseColor(DyeColor.CYAN);
+                    meta.addPattern(new Pattern(DyeColor.WHITE, PatternType.BRICKS));
+                    cleanStack.setItemMeta(meta);
+                    return cleanStack;
+                }
+            },
+            /* No distinguishing features, add back with virtual entity API
+            new StackProvider(Material.ZOMBIE_SPAWN_EGG) {
+                @Override ItemStack operate(ItemStack cleanStack) {
+                    final SpawnEggMeta meta = (SpawnEggMeta) cleanStack.getItemMeta();
+                    meta.setSpawnedType(EntityType.ZOMBIE);
+                    cleanStack.setItemMeta(meta);
+                    return cleanStack;
+                }
+            },
+            */
+            new StackProvider(Material.KNOWLEDGE_BOOK) {
+                @Override ItemStack operate(ItemStack cleanStack) {
+                    final KnowledgeBookMeta meta = (KnowledgeBookMeta) cleanStack.getItemMeta();
+                    meta.addRecipe(new NamespacedKey("minecraft", "test"), new NamespacedKey("plugin", "test"));
+                    cleanStack.setItemMeta(meta);
+                    return cleanStack;
+                }
+            },
+            new StackProvider(Material.TROPICAL_FISH_BUCKET) {
+                @Override ItemStack operate(ItemStack cleanStack) {
+                    final TropicalFishBucketMeta meta = (TropicalFishBucketMeta) cleanStack.getItemMeta();
+                    meta.setBodyColor(DyeColor.ORANGE);
+                    meta.setPatternColor(DyeColor.BLACK);
+                    meta.setPattern(TropicalFish.Pattern.DASHER);
+                    cleanStack.setItemMeta(meta);
+                    return cleanStack;
+                }
+            },
+            // Paper start
+            new StackProvider(Material.ARMOR_STAND) {
+                @Override
+                ItemStack operate(ItemStack cleanStack) {
+                    final ArmorStandMeta meta = (ArmorStandMeta) cleanStack.getItemMeta();
+                    meta.setInvisible(true);
+                    cleanStack.setItemMeta(meta);
+                    return cleanStack;
+                }
+            }
+            // paper end
+        );
+
+        assertThat("Forgotten test?", providers, hasSize(ItemStackTest.COMPOUND_MATERIALS.length - 4/* Normal item meta, skulls, eggs and tile entities */));
+
+        for (final StackProvider provider : providers) {
+            downCastTest(new BukkitWrapper(provider));
+            downCastTest(new CraftWrapper(provider));
+        }
+    }
+
+    @Test
+    public void testAttributeModifiers() {
+        UUID sameUUID = UUID.randomUUID();
+        ItemMeta itemMeta = Bukkit.getItemFactory().getItemMeta(Material.DIAMOND_PICKAXE);
+        itemMeta.addAttributeModifier(Attribute.GENERIC_ATTACK_SPEED, new AttributeModifier(sameUUID, "Test Modifier", 10, AttributeModifier.Operation.ADD_NUMBER));
+
+        ItemMeta equalMeta = Bukkit.getItemFactory().getItemMeta(Material.DIAMOND_PICKAXE);
+        equalMeta.addAttributeModifier(Attribute.GENERIC_ATTACK_SPEED, new AttributeModifier(sameUUID, "Test Modifier", 10, AttributeModifier.Operation.ADD_NUMBER));
+
+        assertThat(itemMeta.equals(equalMeta), is(true));
+
+        ItemMeta itemMeta2 = Bukkit.getItemFactory().getItemMeta(Material.DIAMOND_PICKAXE);
+        itemMeta2.addAttributeModifier(Attribute.GENERIC_ATTACK_SPEED, new AttributeModifier(sameUUID, "Test Modifier", 10, AttributeModifier.Operation.ADD_NUMBER));
+
+        ItemMeta notEqualMeta2 = Bukkit.getItemFactory().getItemMeta(Material.DIAMOND_PICKAXE);
+        notEqualMeta2.addAttributeModifier(Attribute.GENERIC_ATTACK_SPEED, new AttributeModifier(sameUUID, "Test Modifier", 11, AttributeModifier.Operation.ADD_NUMBER));
+
+        assertThat(itemMeta2.equals(notEqualMeta2), is(false));
+    }
+
+    private void downCastTest(final StackWrapper provider) {
+        final String name = provider.toString();
+        final ItemStack blank = new ItemStack(Material.STONE);
+        final ItemStack craftBlank = CraftItemStack.asCraftCopy(blank);
+
+        downCastTest(name, provider.stack(), blank);
+        blank.setItemMeta(blank.getItemMeta());
+        downCastTest(name, provider.stack(), blank);
+
+        downCastTest(name, provider.stack(), craftBlank);
+        craftBlank.setItemMeta(craftBlank.getItemMeta());
+        downCastTest(name, provider.stack(), craftBlank);
+    }
+
+    private void downCastTest(final String name, final ItemStack stack, final ItemStack blank) {
+        assertThat(name, stack, is(not(blank)));
+        assertThat(name, stack.getItemMeta(), is(not(blank.getItemMeta())));
+
+        stack.setType(Material.STONE);
+
+        assertThat(name, stack, is(blank));
+    }
+}

src/test/java/org/bukkit/craftbukkit/inventory/ItemStackBookTest.java

@@ -0,0 +1,213 @@
+package org.bukkit.craftbukkit.inventory;
+
+import java.util.Arrays;
+import java.util.List;
+
+import org.bukkit.Material;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.meta.BookMeta;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
+
+import com.google.common.base.Joiner;
+
+@RunWith(Parameterized.class)
+public class ItemStackBookTest extends ItemStackTest {
+
+    @Parameters(name="[{index}]:{" + NAME_PARAMETER + "}")
+    public static List<Object[]> data() {
+        return StackProvider.compound(operators(), "%s %s", NAME_PARAMETER, Material.WRITTEN_BOOK, Material.WRITABLE_BOOK);
+    }
+
+    @SuppressWarnings("unchecked")
+    static List<Object[]> operators() {
+        return CompoundOperator.compound(
+            Joiner.on('+'),
+            NAME_PARAMETER,
+            Long.parseLong("1110", 2),
+            ItemStackLoreEnchantmentTest.operators(),
+            Arrays.asList(
+                new Object[] {
+                    new Operator() {
+                        public ItemStack operate(ItemStack cleanStack) {
+                            BookMeta meta = (BookMeta) cleanStack.getItemMeta();
+                            meta.addPage("Page 1", "Page 2");
+                            cleanStack.setItemMeta(meta);
+                            return cleanStack;
+                        }
+                    },
+                    new Operator() {
+                        public ItemStack operate(ItemStack cleanStack) {
+                            return cleanStack;
+                        }
+                    },
+                    "Pages vs. Null"
+                },
+                new Object[] {
+                    new Operator() {
+                        public ItemStack operate(ItemStack cleanStack) {
+                            BookMeta meta = (BookMeta) cleanStack.getItemMeta();
+                            meta.addPage("Page 1", "Page 2");
+                            cleanStack.setItemMeta(meta);
+                            return cleanStack;
+                        }
+                    },
+                    new Operator() {
+                        public ItemStack operate(ItemStack cleanStack) {
+                            cleanStack.setItemMeta(cleanStack.getItemMeta());
+                            return cleanStack;
+                        }
+                    },
+                    "Pages vs. blank"
+                },
+                new Object[] {
+                    new Operator() {
+                        public ItemStack operate(ItemStack cleanStack) {
+                            BookMeta meta = (BookMeta) cleanStack.getItemMeta();
+                            meta.addPage("Page 1", "Page 2");
+                            cleanStack.setItemMeta(meta);
+                            return cleanStack;
+                        }
+                    },
+                    new Operator() {
+                        public ItemStack operate(ItemStack cleanStack) {
+                            BookMeta meta = (BookMeta) cleanStack.getItemMeta();
+                            meta.addPage("Page 2", "Page 1");
+                            cleanStack.setItemMeta(meta);
+                            return cleanStack;
+                        }
+                    },
+                    "Pages switched"
+                },
+                new Object[] {
+                    new Operator() {
+                        public ItemStack operate(ItemStack cleanStack) {
+                            BookMeta meta = (BookMeta) cleanStack.getItemMeta();
+                            meta.addPage("Page 1", "Page 2");
+                            cleanStack.setItemMeta(meta);
+                            return cleanStack;
+                        }
+                    },
+                    new Operator() {
+                        public ItemStack operate(ItemStack cleanStack) {
+                            BookMeta meta = (BookMeta) cleanStack.getItemMeta();
+                            meta.addPage("Page 1");
+                            cleanStack.setItemMeta(meta);
+                            return cleanStack;
+                        }
+                    },
+                    "Pages short"
+                }
+            ),
+            Arrays.asList(
+                new Object[] {
+                    new Operator() {
+                        public ItemStack operate(ItemStack cleanStack) {
+                            BookMeta meta = (BookMeta) cleanStack.getItemMeta();
+                            meta.setAuthor("AnAuthor");
+                            cleanStack.setItemMeta(meta);
+                            return cleanStack;
+                        }
+                    },
+                    new Operator() {
+                        public ItemStack operate(ItemStack cleanStack) {
+                            return cleanStack;
+                        }
+                    },
+                    "Author vs. Null"
+                },
+                new Object[] {
+                    new Operator() {
+                        public ItemStack operate(ItemStack cleanStack) {
+                            BookMeta meta = (BookMeta) cleanStack.getItemMeta();
+                            meta.setAuthor("AnAuthor");
+                            cleanStack.setItemMeta(meta);
+                            return cleanStack;
+                        }
+                    },
+                    new Operator() {
+                        public ItemStack operate(ItemStack cleanStack) {
+                            cleanStack.setItemMeta(cleanStack.getItemMeta());
+                            return cleanStack;
+                        }
+                    },
+                    "Author vs. blank"
+                },
+                new Object[] {
+                    new Operator() {
+                        public ItemStack operate(ItemStack cleanStack) {
+                            BookMeta meta = (BookMeta) cleanStack.getItemMeta();
+                            meta.setAuthor("AnAuthor");
+                            cleanStack.setItemMeta(meta);
+                            return cleanStack;
+                        }
+                    },
+                    new Operator() {
+                        public ItemStack operate(ItemStack cleanStack) {
+                            BookMeta meta = (BookMeta) cleanStack.getItemMeta();
+                            meta.setAuthor("AnotherAuthor");
+                            cleanStack.setItemMeta(meta);
+                            return cleanStack;
+                        }
+                    },
+                    "Authors"
+                }
+            ),
+            Arrays.asList(
+                new Object[] {
+                    new Operator() {
+                        public ItemStack operate(ItemStack cleanStack) {
+                            BookMeta meta = (BookMeta) cleanStack.getItemMeta();
+                            meta.setTitle("Some title");
+                            cleanStack.setItemMeta(meta);
+                            return cleanStack;
+                        }
+                    },
+                    new Operator() {
+                        public ItemStack operate(ItemStack cleanStack) {
+                            return cleanStack;
+                        }
+                    },
+                    "Title vs. Null"
+                },
+                new Object[] {
+                    new Operator() {
+                        public ItemStack operate(ItemStack cleanStack) {
+                            BookMeta meta = (BookMeta) cleanStack.getItemMeta();
+                            meta.setTitle("Some title");
+                            cleanStack.setItemMeta(meta);
+                            return cleanStack;
+                        }
+                    },
+                    new Operator() {
+                        public ItemStack operate(ItemStack cleanStack) {
+                            cleanStack.setItemMeta(cleanStack.getItemMeta());
+                            return cleanStack;
+                        }
+                    },
+                    "title vs. blank"
+                },
+                new Object[] {
+                    new Operator() {
+                        public ItemStack operate(ItemStack cleanStack) {
+                            BookMeta meta = (BookMeta) cleanStack.getItemMeta();
+                            meta.setTitle("Some title");
+                            cleanStack.setItemMeta(meta);
+                            return cleanStack;
+                        }
+                    },
+                    new Operator() {
+                        public ItemStack operate(ItemStack cleanStack) {
+                            BookMeta meta = (BookMeta) cleanStack.getItemMeta();
+                            meta.setTitle("Different title");
+                            cleanStack.setItemMeta(meta);
+                            return cleanStack;
+                        }
+                    },
+                    "Titles"
+                }
+            )
+        );
+    }
+}

src/test/java/org/bukkit/craftbukkit/inventory/ItemStackEnchantStorageTest.java

@@ -0,0 +1,108 @@
+package org.bukkit.craftbukkit.inventory;
+
+import java.util.Arrays;
+import java.util.List;
+
+import org.bukkit.Material;
+import org.bukkit.enchantments.Enchantment;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.meta.EnchantmentStorageMeta;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
+
+import com.google.common.base.Joiner;
+
+@RunWith(Parameterized.class)
+public class ItemStackEnchantStorageTest extends ItemStackTest {
+
+    @Parameters(name="[{index}]:{" + NAME_PARAMETER + "}")
+    public static List<Object[]> data() {
+        return StackProvider.compound(operators(), "%s %s", NAME_PARAMETER, Material.ENCHANTED_BOOK);
+    }
+
+    @SuppressWarnings("unchecked")
+    static List<Object[]> operators() {
+        return CompoundOperator.compound(
+            Joiner.on('+'),
+            NAME_PARAMETER,
+            Long.parseLong("10", 2),
+            ItemStackLoreEnchantmentTest.operators(),
+            Arrays.asList(
+                new Object[] {
+                    new Operator() {
+                        public ItemStack operate(ItemStack cleanStack) {
+                            EnchantmentStorageMeta meta = (EnchantmentStorageMeta) cleanStack.getItemMeta();
+                            meta.addStoredEnchant(Enchantment.DURABILITY, 1, true);
+                            cleanStack.setItemMeta(meta);
+                            return cleanStack;
+                        }
+                    },
+                    new Operator() {
+                        public ItemStack operate(ItemStack cleanStack) {
+                            EnchantmentStorageMeta meta = (EnchantmentStorageMeta) cleanStack.getItemMeta();
+                            cleanStack.setItemMeta(meta);
+                            return cleanStack;
+                        }
+                    },
+                    "Enchantable vs Blank"
+                },
+                new Object[] {
+                    new Operator() {
+                        public ItemStack operate(ItemStack cleanStack) {
+                            EnchantmentStorageMeta meta = (EnchantmentStorageMeta) cleanStack.getItemMeta();
+                            meta.addStoredEnchant(Enchantment.KNOCKBACK, 1, true);
+                            cleanStack.setItemMeta(meta);
+                            return cleanStack;
+                        }
+                    },
+                    new Operator() {
+                        public ItemStack operate(ItemStack cleanStack) {
+                            return cleanStack;
+                        }
+                    },
+                    "Enchantable vs Null"
+                },
+                new Object[] {
+                    new Operator() {
+                        public ItemStack operate(ItemStack cleanStack) {
+                            EnchantmentStorageMeta meta = (EnchantmentStorageMeta) cleanStack.getItemMeta();
+                            meta.addStoredEnchant(Enchantment.DAMAGE_UNDEAD, 1, true);
+                            cleanStack.setItemMeta(meta);
+                            return cleanStack;
+                        }
+                    },
+                    new Operator() {
+                        public ItemStack operate(ItemStack cleanStack) {
+                            EnchantmentStorageMeta meta = (EnchantmentStorageMeta) cleanStack.getItemMeta();
+                            meta.addStoredEnchant(Enchantment.DAMAGE_UNDEAD, 1, true);
+                            meta.addStoredEnchant(Enchantment.FIRE_ASPECT, 1, true);
+                            cleanStack.setItemMeta(meta);
+                            return cleanStack;
+                        }
+                    },
+                    "Enchantable vs More"
+                },
+                new Object[] {
+                    new Operator() {
+                        public ItemStack operate(ItemStack cleanStack) {
+                            EnchantmentStorageMeta meta = (EnchantmentStorageMeta) cleanStack.getItemMeta();
+                            meta.addStoredEnchant(Enchantment.PROTECTION_FIRE, 1, true);
+                            cleanStack.setItemMeta(meta);
+                            return cleanStack;
+                        }
+                    },
+                    new Operator() {
+                        public ItemStack operate(ItemStack cleanStack) {
+                            EnchantmentStorageMeta meta = (EnchantmentStorageMeta) cleanStack.getItemMeta();
+                            meta.addEnchant(Enchantment.PROTECTION_FIRE, 2, true);
+                            cleanStack.setItemMeta(meta);
+                            return cleanStack;
+                        }
+                    },
+                    "Enchantable vs Other"
+                }
+            )
+        );
+    }
+}

src/test/java/org/bukkit/craftbukkit/inventory/ItemStackFireworkChargeTest.java

@@ -0,0 +1,128 @@
+package org.bukkit.craftbukkit.inventory;
+
+import java.util.Arrays;
+import java.util.List;
+
+import org.bukkit.Color;
+import org.bukkit.FireworkEffect;
+import org.bukkit.FireworkEffect.Type;
+import org.bukkit.Material;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.meta.FireworkEffectMeta;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
+
+import com.google.common.base.Joiner;
+
+@RunWith(Parameterized.class)
+public class ItemStackFireworkChargeTest extends ItemStackTest {
+
+    @Parameters(name="[{index}]:{" + NAME_PARAMETER + "}")
+    public static List<Object[]> data() {
+        return StackProvider.compound(operators(), "%s %s", NAME_PARAMETER, Material.FIREWORK_STAR);
+    }
+
+    @SuppressWarnings("unchecked")
+    static List<Object[]> operators() {
+        return CompoundOperator.compound(
+            Joiner.on('+'),
+            NAME_PARAMETER,
+            Long.parseLong("10", 2),
+            ItemStackLoreEnchantmentTest.operators(),
+            Arrays.asList(
+                new Object[] {
+                    new Operator() {
+                        public ItemStack operate(ItemStack cleanStack) {
+                            FireworkEffectMeta meta = (FireworkEffectMeta) cleanStack.getItemMeta();
+                            meta.setEffect(FireworkEffect.builder().withColor(Color.WHITE).build());
+                            cleanStack.setItemMeta(meta);
+                            return cleanStack;
+                        }
+                    },
+                    new Operator() {
+                        public ItemStack operate(ItemStack cleanStack) {
+                            FireworkEffectMeta meta = (FireworkEffectMeta) cleanStack.getItemMeta();
+                            meta.setEffect(FireworkEffect.builder().withColor(Color.BLACK).build());
+                            cleanStack.setItemMeta(meta);
+                            return cleanStack;
+                        }
+                    },
+                    "Effect Color 1 vs. Effect Color 2"
+                },
+                new Object[] {
+                    new Operator() {
+                        public ItemStack operate(ItemStack cleanStack) {
+                            FireworkEffectMeta meta = (FireworkEffectMeta) cleanStack.getItemMeta();
+                            meta.setEffect(FireworkEffect.builder().withColor(Color.WHITE).with(Type.CREEPER).build());
+                            cleanStack.setItemMeta(meta);
+                            return cleanStack;
+                        }
+                    },
+                    new Operator() {
+                        public ItemStack operate(ItemStack cleanStack) {
+                            FireworkEffectMeta meta = (FireworkEffectMeta) cleanStack.getItemMeta();
+                            meta.setEffect(FireworkEffect.builder().withColor(Color.WHITE).with(Type.BURST).build());
+                            cleanStack.setItemMeta(meta);
+                            return cleanStack;
+                        }
+                    },
+                    "Effect type 1 vs. Effect type 2"
+                },
+                new Object[] {
+                    new Operator() {
+                        public ItemStack operate(ItemStack cleanStack) {
+                            FireworkEffectMeta meta = (FireworkEffectMeta) cleanStack.getItemMeta();
+                            meta.setEffect(FireworkEffect.builder().withColor(Color.WHITE).withFade(Color.BLUE).build());
+                            cleanStack.setItemMeta(meta);
+                            return cleanStack;
+                        }
+                    },
+                    new Operator() {
+                        public ItemStack operate(ItemStack cleanStack) {
+                            FireworkEffectMeta meta = (FireworkEffectMeta) cleanStack.getItemMeta();
+                            meta.setEffect(FireworkEffect.builder().withColor(Color.WHITE).withFade(Color.RED).build());
+                            cleanStack.setItemMeta(meta);
+                            return cleanStack;
+                        }
+                    },
+                    "Effect fade 1 vs. Effect fade 2"
+                },
+                new Object[] {
+                    new Operator() {
+                        public ItemStack operate(ItemStack cleanStack) {
+                            FireworkEffectMeta meta = (FireworkEffectMeta) cleanStack.getItemMeta();
+                            meta.setEffect(FireworkEffect.builder().withColor(Color.WHITE).withFlicker().build());
+                            cleanStack.setItemMeta(meta);
+                            return cleanStack;
+                        }
+                    },
+                    new Operator() {
+                        public ItemStack operate(ItemStack cleanStack) {
+                            FireworkEffectMeta meta = (FireworkEffectMeta) cleanStack.getItemMeta();
+                            cleanStack.setItemMeta(meta);
+                            return cleanStack;
+                        }
+                    },
+                    "Effect vs. Null"
+                },
+                new Object[] {
+                    new Operator() {
+                        public ItemStack operate(ItemStack cleanStack) {
+                            FireworkEffectMeta meta = (FireworkEffectMeta) cleanStack.getItemMeta();
+                            meta.setEffect(FireworkEffect.builder().withColor(Color.WHITE).withTrail().build());
+                            cleanStack.setItemMeta(meta);
+                            return cleanStack;
+                        }
+                    },
+                    new Operator() {
+                        public ItemStack operate(ItemStack cleanStack) {
+                            return cleanStack;
+                        }
+                    },
+                    "Effect vs. None"
+                }
+            )
+        );
+    }
+}

src/test/java/org/bukkit/craftbukkit/inventory/ItemStackFireworkTest.java

@@ -0,0 +1,184 @@
+package org.bukkit.craftbukkit.inventory;
+
+import java.util.Arrays;
+import java.util.List;
+
+import org.bukkit.Color;
+import org.bukkit.FireworkEffect;
+import org.bukkit.Material;
+import org.bukkit.FireworkEffect.Type;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.meta.FireworkMeta;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
+
+import com.google.common.base.Joiner;
+
+@RunWith(Parameterized.class)
+public class ItemStackFireworkTest extends ItemStackTest {
+
+    @Parameters(name="[{index}]:{" + NAME_PARAMETER + "}")
+    public static List<Object[]> data() {
+        return StackProvider.compound(operators(), "%s %s", NAME_PARAMETER, Material.FIREWORK_ROCKET);
+    }
+
+    @SuppressWarnings("unchecked")
+    static List<Object[]> operators() {
+        return CompoundOperator.compound(
+            Joiner.on('+'),
+            NAME_PARAMETER,
+            Long.parseLong("110", 2),
+            ItemStackLoreEnchantmentTest.operators(),
+            Arrays.asList(
+                new Object[] {
+                    new Operator() {
+                        public ItemStack operate(ItemStack cleanStack) {
+                            FireworkMeta meta = (FireworkMeta) cleanStack.getItemMeta();
+                            meta.addEffect(FireworkEffect.builder().withColor(Color.WHITE).build());
+                            cleanStack.setItemMeta(meta);
+                            return cleanStack;
+                        }
+                    },
+                    new Operator() {
+                        public ItemStack operate(ItemStack cleanStack) {
+                            FireworkMeta meta = (FireworkMeta) cleanStack.getItemMeta();
+                            meta.addEffect(FireworkEffect.builder().withColor(Color.BLACK).build());
+                            meta.addEffect(FireworkEffect.builder().withColor(Color.GREEN).build());
+                            cleanStack.setItemMeta(meta);
+                            return cleanStack;
+                        }
+                    },
+                    "Effect Color 1 vs. Effect Color 2"
+                },
+                new Object[] {
+                    new Operator() {
+                        public ItemStack operate(ItemStack cleanStack) {
+                            FireworkMeta meta = (FireworkMeta) cleanStack.getItemMeta();
+                            meta.addEffect(FireworkEffect.builder().withColor(Color.WHITE).with(Type.CREEPER).build());
+                            cleanStack.setItemMeta(meta);
+                            return cleanStack;
+                        }
+                    },
+                    new Operator() {
+                        public ItemStack operate(ItemStack cleanStack) {
+                            FireworkMeta meta = (FireworkMeta) cleanStack.getItemMeta();
+                            meta.addEffect(FireworkEffect.builder().withColor(Color.WHITE).with(Type.BURST).build());
+                            cleanStack.setItemMeta(meta);
+                            return cleanStack;
+                        }
+                    },
+                    "Effect type 1 vs. Effect type 2"
+                },
+                new Object[] {
+                    new Operator() {
+                        public ItemStack operate(ItemStack cleanStack) {
+                            FireworkMeta meta = (FireworkMeta) cleanStack.getItemMeta();
+                            meta.addEffect(FireworkEffect.builder().withColor(Color.WHITE).withFade(Color.BLUE).build());
+                            cleanStack.setItemMeta(meta);
+                            return cleanStack;
+                        }
+                    },
+                    new Operator() {
+                        public ItemStack operate(ItemStack cleanStack) {
+                            FireworkMeta meta = (FireworkMeta) cleanStack.getItemMeta();
+                            meta.addEffect(FireworkEffect.builder().withColor(Color.WHITE).withFade(Color.RED).build());
+                            cleanStack.setItemMeta(meta);
+                            return cleanStack;
+                        }
+                    },
+                    "Effect fade 1 vs. Effect fade 2"
+                },
+                new Object[] {
+                    new Operator() {
+                        public ItemStack operate(ItemStack cleanStack) {
+                            FireworkMeta meta = (FireworkMeta) cleanStack.getItemMeta();
+                            meta.addEffect(FireworkEffect.builder().withColor(Color.WHITE).withFlicker().build());
+                            cleanStack.setItemMeta(meta);
+                            return cleanStack;
+                        }
+                    },
+                    new Operator() {
+                        public ItemStack operate(ItemStack cleanStack) {
+                            FireworkMeta meta = (FireworkMeta) cleanStack.getItemMeta();
+                            cleanStack.setItemMeta(meta);
+                            return cleanStack;
+                        }
+                    },
+                    "Effect vs. Null"
+                },
+                new Object[] {
+                    new Operator() {
+                        public ItemStack operate(ItemStack cleanStack) {
+                            FireworkMeta meta = (FireworkMeta) cleanStack.getItemMeta();
+                            meta.addEffect(FireworkEffect.builder().withColor(Color.WHITE).withTrail().build());
+                            cleanStack.setItemMeta(meta);
+                            return cleanStack;
+                        }
+                    },
+                    new Operator() {
+                        public ItemStack operate(ItemStack cleanStack) {
+                            return cleanStack;
+                        }
+                    },
+                    "Effect vs. None"
+                }
+            ),
+            Arrays.asList(
+                new Object[] {
+                    new Operator() {
+                        public ItemStack operate(ItemStack cleanStack) {
+                            FireworkMeta meta = (FireworkMeta) cleanStack.getItemMeta();
+                            meta.setPower(127);
+                            cleanStack.setItemMeta(meta);
+                            return cleanStack;
+                        }
+                    },
+                    new Operator() {
+                        public ItemStack operate(ItemStack cleanStack) {
+                            FireworkMeta meta = (FireworkMeta) cleanStack.getItemMeta();
+                            meta.setPower(100);
+                            cleanStack.setItemMeta(meta);
+                            return cleanStack;
+                        }
+                    },
+                    "Height vs. Other"
+                },
+                new Object[] {
+                    new Operator() {
+                        public ItemStack operate(ItemStack cleanStack) {
+                            FireworkMeta meta = (FireworkMeta) cleanStack.getItemMeta();
+                            meta.setPower(42);
+                            cleanStack.setItemMeta(meta);
+                            return cleanStack;
+                        }
+                    },
+                    new Operator() {
+                        public ItemStack operate(ItemStack cleanStack) {
+                            FireworkMeta meta = (FireworkMeta) cleanStack.getItemMeta();
+                            cleanStack.setItemMeta(meta);
+                            return cleanStack;
+                        }
+                    },
+                    "Height vs. Null"
+                },
+                new Object[] {
+                    new Operator() {
+                        public ItemStack operate(ItemStack cleanStack) {
+                            FireworkMeta meta = (FireworkMeta) cleanStack.getItemMeta();
+                            meta.setPower(10);
+                            cleanStack.setItemMeta(meta);
+                            return cleanStack;
+                        }
+                    },
+                    new Operator() {
+                        public ItemStack operate(ItemStack cleanStack) {
+                            return cleanStack;
+                        }
+                    },
+                    "Height vs. None"
+                }
+            )
+        );
+    }
+}

src/test/java/org/bukkit/craftbukkit/inventory/ItemStackLeatherTest.java

@@ -0,0 +1,89 @@
+package org.bukkit.craftbukkit.inventory;
+
+import java.util.Arrays;
+import java.util.List;
+
+import org.bukkit.Color;
+import org.bukkit.Material;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.meta.LeatherArmorMeta;
+
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
+
+import com.google.common.base.Joiner;
+
+@RunWith(Parameterized.class)
+public class ItemStackLeatherTest extends ItemStackTest {
+
+    @Parameters(name="[{index}]:{" + NAME_PARAMETER + "}")
+    public static List<Object[]> data() {
+        return StackProvider.compound(operators(), "%s %s", NAME_PARAMETER, Material.LEATHER_BOOTS, Material.LEATHER_CHESTPLATE, Material.LEATHER_HELMET, Material.LEATHER_LEGGINGS);
+    }
+
+    @SuppressWarnings("unchecked")
+    static List<Object[]> operators() {
+        return CompoundOperator.compound(
+            Joiner.on('+'),
+            NAME_PARAMETER,
+            Long.parseLong("10", 2),
+            ItemStackLoreEnchantmentTest.operators(),
+            Arrays.asList(
+                new Object[] {
+                    new Operator() {
+                        public ItemStack operate(ItemStack cleanStack) {
+                            LeatherArmorMeta meta = (LeatherArmorMeta) cleanStack.getItemMeta();
+                            meta.setColor(Color.FUCHSIA);
+                            cleanStack.setItemMeta(meta);
+                            return cleanStack;
+                        }
+                    },
+                    new Operator() {
+                        public ItemStack operate(ItemStack cleanStack) {
+                            return cleanStack;
+                        }
+                    },
+                    "Color vs Null"
+                },
+                new Object[] {
+                    new Operator() {
+                        public ItemStack operate(ItemStack cleanStack) {
+                            LeatherArmorMeta meta = (LeatherArmorMeta) cleanStack.getItemMeta();
+                            meta.setColor(Color.GRAY);
+                            cleanStack.setItemMeta(meta);
+                            return cleanStack;
+                        }
+                    },
+                    new Operator() {
+                        public ItemStack operate(ItemStack cleanStack) {
+                            LeatherArmorMeta meta = (LeatherArmorMeta) cleanStack.getItemMeta();
+                            cleanStack.setItemMeta(meta);
+                            return cleanStack;
+                        }
+                    },
+                    "Color vs Blank"
+                },
+                new Object[] {
+                    new Operator() {
+                        public ItemStack operate(ItemStack cleanStack) {
+                            LeatherArmorMeta meta = (LeatherArmorMeta) cleanStack.getItemMeta();
+                            meta.setColor(Color.MAROON);
+                            cleanStack.setItemMeta(meta);
+                            return cleanStack;
+                        }
+                    },
+                    new Operator() {
+                        public ItemStack operate(ItemStack cleanStack) {
+                            LeatherArmorMeta meta = (LeatherArmorMeta) cleanStack.getItemMeta();
+                            meta.setColor(Color.ORANGE);
+                            cleanStack.setItemMeta(meta);
+                            return cleanStack;
+                        }
+                    },
+                    "Color vs Other"
+                }
+            )
+        );
+    }
+}

src/test/java/org/bukkit/craftbukkit/inventory/ItemStackLoreEnchantmentTest.java

@@ -0,0 +1,297 @@
+package org.bukkit.craftbukkit.inventory;
+
+import java.util.Arrays;
+import java.util.List;
+
+import org.bukkit.enchantments.Enchantment;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.meta.ItemMeta;
+import org.bukkit.inventory.meta.Repairable;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
+
+import com.google.common.base.Joiner;
+
+@RunWith(Parameterized.class)
+public class ItemStackLoreEnchantmentTest extends ItemStackTest {
+
+    @Parameters(name="[{index}]:{" + NAME_PARAMETER + "}")
+    public static List<Object[]> data() {
+        return StackProvider.compound(operators(), "%s %s", NAME_PARAMETER, ItemStackTest.COMPOUND_MATERIALS);
+    }
+
+    @SuppressWarnings("unchecked")
+    static List<Object[]> operators() {
+        return CompoundOperator.compound(
+            Joiner.on('+'),
+            NAME_PARAMETER,
+            ~0l,
+            Arrays.asList(
+                new Object[] {
+                    new Operator() {
+                        public ItemStack operate(ItemStack cleanStack) {
+                            ItemMeta meta = cleanStack.getItemMeta();
+                            meta.setLore(Arrays.asList("First Lore", "Second Lore"));
+                            cleanStack.setItemMeta(meta);
+                            return cleanStack;
+                        }
+                    },
+                    new Operator() {
+                        public ItemStack operate(ItemStack cleanStack) {
+                            return cleanStack;
+                        }
+                    },
+                    "Lore vs Null"
+                },
+                new Object[] {
+                    new Operator() {
+                        public ItemStack operate(ItemStack cleanStack) {
+                            ItemMeta meta = cleanStack.getItemMeta();
+                            meta.setLore(Arrays.asList("Some lore"));
+                            cleanStack.setItemMeta(meta);
+                            return cleanStack;
+                        }
+                    },
+                    new Operator() {
+                        public ItemStack operate(ItemStack cleanStack) {
+                            ItemMeta meta = cleanStack.getItemMeta();
+                            cleanStack.setItemMeta(meta);
+                            return cleanStack;
+                        }
+                    },
+                    "Lore vs Blank"
+                },
+                new Object[] {
+                    new Operator() {
+                        public ItemStack operate(ItemStack cleanStack) {
+                            ItemMeta meta = cleanStack.getItemMeta();
+                            meta.setLore(Arrays.asList("Some more lore", "Another lore"));
+                            cleanStack.setItemMeta(meta);
+                            return cleanStack;
+                        }
+                    },
+                    new Operator() {
+                        public ItemStack operate(ItemStack cleanStack) {
+                            ItemMeta meta = cleanStack.getItemMeta();
+                            meta.setLore(Arrays.asList("Some more lore"));
+                            cleanStack.setItemMeta(meta);
+                            return cleanStack;
+                        }
+                    },
+                    "Lore vs Other"
+                }
+            ),
+            Arrays.asList(
+                new Object[] {
+                    new Operator() {
+                        public ItemStack operate(ItemStack cleanStack) {
+                            ItemMeta meta = cleanStack.getItemMeta();
+                            meta.setDisplayName("TestItemName");
+                            cleanStack.setItemMeta(meta);
+                            return cleanStack;
+                        }
+                    },
+                    new Operator() {
+                        public ItemStack operate(ItemStack cleanStack) {
+                            return cleanStack;
+                        }
+                    },
+                    "Name vs Null"
+                },
+                new Object[] {
+                    new Operator() {
+                        public ItemStack operate(ItemStack cleanStack) {
+                            ItemMeta meta = cleanStack.getItemMeta();
+                            meta.setDisplayName("AnotherItemName");
+                            cleanStack.setItemMeta(meta);
+                            return cleanStack;
+                        }
+                    },
+                    new Operator() {
+                        public ItemStack operate(ItemStack cleanStack) {
+                            ItemMeta meta = cleanStack.getItemMeta();
+                            cleanStack.setItemMeta(meta);
+                            return cleanStack;
+                        }
+                    },
+                    "Name vs Blank"
+                },
+                new Object[] {
+                    new Operator() {
+                        public ItemStack operate(ItemStack cleanStack) {
+                            ItemMeta meta = cleanStack.getItemMeta();
+                            meta.setDisplayName("The original ItemName");
+                            cleanStack.setItemMeta(meta);
+                            return cleanStack;
+                        }
+                    },
+                    new Operator() {
+                        public ItemStack operate(ItemStack cleanStack) {
+                            ItemMeta meta = cleanStack.getItemMeta();
+                            meta.setDisplayName("The other name");
+                            cleanStack.setItemMeta(meta);
+                            return cleanStack;
+                        }
+                    },
+                    "Name vs Other"
+                }
+            ),
+            Arrays.asList(
+                new Object[] {
+                    new Operator() {
+                        public ItemStack operate(ItemStack cleanStack) {
+                            cleanStack.addUnsafeEnchantment(Enchantment.DIG_SPEED, 2);
+                            return cleanStack;
+                        }
+                    },
+                    new Operator() {
+                        public ItemStack operate(ItemStack cleanStack) {
+                            return cleanStack;
+                        }
+                    },
+                    "EnchantStack vs Null"
+                },
+                new Object[] {
+                    new Operator() {
+                        public ItemStack operate(ItemStack cleanStack) {
+                            cleanStack.addUnsafeEnchantment(Enchantment.OXYGEN, 1);
+                            return cleanStack;
+                        }
+                    },
+                    new Operator() {
+                        public ItemStack operate(ItemStack cleanStack) {
+                            ItemMeta meta = cleanStack.getItemMeta();
+                            cleanStack.setItemMeta(meta);
+                            return cleanStack;
+                        }
+                    },
+                    "EnchantStack vs Blank"
+                },
+                new Object[] {
+                    new Operator() {
+                        public ItemStack operate(ItemStack cleanStack) {
+                            cleanStack.addUnsafeEnchantment(Enchantment.ARROW_DAMAGE, 1);
+                            return cleanStack;
+                        }
+                    },
+                    new Operator() {
+                        public ItemStack operate(ItemStack cleanStack) {
+                            cleanStack.addUnsafeEnchantment(Enchantment.ARROW_FIRE, 1);
+                            return cleanStack;
+                        }
+                    },
+                    "EnchantStack vs OtherEnchantStack"
+                },
+                new Object[] {
+                    new Operator() {
+                        public ItemStack operate(ItemStack cleanStack) {
+                            ItemMeta meta = cleanStack.getItemMeta();
+                            meta.addEnchant(Enchantment.DURABILITY, 1, true);
+                            cleanStack.setItemMeta(meta);
+                            return cleanStack;
+                        }
+                    },
+                    new Operator() {
+                        public ItemStack operate(ItemStack cleanStack) {
+                            ItemMeta meta = cleanStack.getItemMeta();
+                            cleanStack.setItemMeta(meta);
+                            return cleanStack;
+                        }
+                    },
+                    "Enchant vs Blank"
+                },
+                new Object[] {
+                    new Operator() {
+                        public ItemStack operate(ItemStack cleanStack) {
+                            ItemMeta meta = cleanStack.getItemMeta();
+                            meta.addEnchant(Enchantment.KNOCKBACK, 1, true);
+                            cleanStack.setItemMeta(meta);
+                            return cleanStack;
+                        }
+                    },
+                    new Operator() {
+                        public ItemStack operate(ItemStack cleanStack) {
+                            return cleanStack;
+                        }
+                    },
+                    "Enchant vs Null"
+                },
+                new Object[] {
+                    new Operator() {
+                        public ItemStack operate(ItemStack cleanStack) {
+                            ItemMeta meta = cleanStack.getItemMeta();
+                            meta.addEnchant(Enchantment.PROTECTION_FIRE, 1, true);
+                            cleanStack.setItemMeta(meta);
+                            return cleanStack;
+                        }
+                    },
+                    new Operator() {
+                        public ItemStack operate(ItemStack cleanStack) {
+                            ItemMeta meta = cleanStack.getItemMeta();
+                            meta.addEnchant(Enchantment.PROTECTION_FIRE, 2, true);
+                            cleanStack.setItemMeta(meta);
+                            return cleanStack;
+                        }
+                    },
+                    "Enchant vs Other"
+                }
+            ),
+            Arrays.asList(
+                new Object[] {
+                    new Operator() {
+                        public ItemStack operate(ItemStack cleanStack) {
+                            ItemMeta meta = cleanStack.getItemMeta();
+                            ((Repairable) meta).setRepairCost(42);
+                            cleanStack.setItemMeta(meta);
+                            return cleanStack;
+                        }
+                    },
+                    new Operator() {
+                        public ItemStack operate(ItemStack cleanStack) {
+                            return cleanStack;
+                        }
+                    },
+                    "Repair vs Null"
+                },
+                new Object[] {
+                    new Operator() {
+                        public ItemStack operate(ItemStack cleanStack) {
+                            ItemMeta meta = cleanStack.getItemMeta();
+                            ((Repairable) meta).setRepairCost(36);
+                            cleanStack.setItemMeta(meta);
+                            return cleanStack;
+                        }
+                    },
+                    new Operator() {
+                        public ItemStack operate(ItemStack cleanStack) {
+                            ItemMeta meta = cleanStack.getItemMeta();
+                            cleanStack.setItemMeta(meta);
+                            return cleanStack;
+                        }
+                    },
+                    "Repair vs Blank"
+                },
+                new Object[] {
+                    new Operator() {
+                        public ItemStack operate(ItemStack cleanStack) {
+                            ItemMeta meta = cleanStack.getItemMeta();
+                            ((Repairable) meta).setRepairCost(89);
+                            cleanStack.setItemMeta(meta);
+                            return cleanStack;
+                        }
+                    },
+                    new Operator() {
+                        public ItemStack operate(ItemStack cleanStack) {
+                            ItemMeta meta = cleanStack.getItemMeta();
+                            ((Repairable) meta).setRepairCost(88);
+                            cleanStack.setItemMeta(meta);
+                            return cleanStack;
+                        }
+                    },
+                    "Repair vs Other"
+                }
+            )
+        );
+    }
+}

src/test/java/org/bukkit/craftbukkit/inventory/ItemStackMapTest.java

@@ -0,0 +1,121 @@
+package org.bukkit.craftbukkit.inventory;
+
+import java.util.Arrays;
+import java.util.List;
+
+import org.bukkit.Material;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.meta.MapMeta;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
+
+import com.google.common.base.Joiner;
+
+@RunWith(Parameterized.class)
+public class ItemStackMapTest extends ItemStackTest {
+
+    @Parameters(name="[{index}]:{" + NAME_PARAMETER + "}")
+    public static List<Object[]> data() {
+        return StackProvider.compound(operators(), "%s %s", NAME_PARAMETER, Material.FILLED_MAP);
+    }
+
+    @SuppressWarnings("unchecked")
+    static List<Object[]> operators() {
+        return CompoundOperator.compound(
+            Joiner.on('+'),
+            NAME_PARAMETER,
+            Long.parseLong("10", 2),
+            ItemStackLoreEnchantmentTest.operators(),
+            Arrays.asList(
+                new Object[] {
+                    new Operator() {
+                        public ItemStack operate(ItemStack cleanStack) {
+                            MapMeta meta = (MapMeta) cleanStack.getItemMeta();
+                            meta.setScaling(true);
+                            cleanStack.setItemMeta(meta);
+                            return cleanStack;
+                        }
+                    },
+                    new Operator() {
+                        public ItemStack operate(ItemStack cleanStack) {
+                            MapMeta meta = (MapMeta) cleanStack.getItemMeta();
+                            meta.setScaling(false);
+                            cleanStack.setItemMeta(meta);
+                            return cleanStack;
+                        }
+                    },
+                    "Scale vs. Unscale"
+                },
+                new Object[] {
+                    new Operator() {
+                        public ItemStack operate(ItemStack cleanStack) {
+                            MapMeta meta = (MapMeta) cleanStack.getItemMeta();
+                            meta.setScaling(true);
+                            cleanStack.setItemMeta(meta);
+                            return cleanStack;
+                        }
+                    },
+                    new Operator() {
+                        public ItemStack operate(ItemStack cleanStack) {
+                            MapMeta meta = (MapMeta) cleanStack.getItemMeta();
+                            cleanStack.setItemMeta(meta);
+                            return cleanStack;
+                        }
+                    },
+                    "Scale vs. Blank"
+                },
+                new Object[] {
+                    new Operator() {
+                        public ItemStack operate(ItemStack cleanStack) {
+                            MapMeta meta = (MapMeta) cleanStack.getItemMeta();
+                            meta.setScaling(false);
+                            cleanStack.setItemMeta(meta);
+                            return cleanStack;
+                        }
+                    },
+                    new Operator() {
+                        public ItemStack operate(ItemStack cleanStack) {
+                            MapMeta meta = (MapMeta) cleanStack.getItemMeta();
+                            cleanStack.setItemMeta(meta);
+                            return cleanStack;
+                        }
+                    },
+                    "Unscale vs. Blank"
+                },
+                new Object[] {
+                    new Operator() {
+                        public ItemStack operate(ItemStack cleanStack) {
+                            MapMeta meta = (MapMeta) cleanStack.getItemMeta();
+                            meta.setScaling(true);
+                            cleanStack.setItemMeta(meta);
+                            return cleanStack;
+                        }
+                    },
+                    new Operator() {
+                        public ItemStack operate(ItemStack cleanStack) {
+                            return cleanStack;
+                        }
+                    },
+                    "Scale vs. None"
+                },
+                new Object[] {
+                    new Operator() {
+                        public ItemStack operate(ItemStack cleanStack) {
+                            MapMeta meta = (MapMeta) cleanStack.getItemMeta();
+                            meta.setScaling(false);
+                            cleanStack.setItemMeta(meta);
+                            return cleanStack;
+                        }
+                    },
+                    new Operator() {
+                        public ItemStack operate(ItemStack cleanStack) {
+                            return cleanStack;
+                        }
+                    },
+                    "Unscale vs. None"
+                }
+            )
+        );
+    }
+}

src/test/java/org/bukkit/craftbukkit/inventory/ItemStackPotionsTest.java

@@ -0,0 +1,146 @@
+package org.bukkit.craftbukkit.inventory;
+
+import java.util.Arrays;
+import java.util.List;
+
+import org.bukkit.Material;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.meta.PotionMeta;
+import org.bukkit.potion.PotionEffectType;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
+
+import com.google.common.base.Joiner;
+
+@RunWith(Parameterized.class)
+public class ItemStackPotionsTest extends ItemStackTest {
+
+    @Parameters(name="[{index}]:{" + NAME_PARAMETER + "}")
+    public static List<Object[]> data() {
+        return StackProvider.compound(operators(), "%s %s", NAME_PARAMETER, Material.POTION);
+    }
+
+    @SuppressWarnings("unchecked")
+    static List<Object[]> operators() {
+        return CompoundOperator.compound(
+            Joiner.on('+'),
+            NAME_PARAMETER,
+            Long.parseLong("10", 2),
+            ItemStackLoreEnchantmentTest.operators(),
+            Arrays.asList(
+                new Object[] {
+                    new Operator() {
+                        public ItemStack operate(ItemStack cleanStack) {
+                            final PotionMeta meta = (PotionMeta) cleanStack.getItemMeta();
+                            meta.addCustomEffect(PotionEffectType.CONFUSION.createEffect(1, 1), false);
+                            cleanStack.setItemMeta(meta);
+                            return cleanStack;
+                        }
+                    },
+                    new Operator() {
+                        public ItemStack operate(ItemStack cleanStack) {
+                            return cleanStack;
+                        }
+                    },
+                    "Potion vs Null"
+                },
+                new Object[] {
+                    new Operator() {
+                        public ItemStack operate(ItemStack cleanStack) {
+                            final PotionMeta meta = (PotionMeta) cleanStack.getItemMeta();
+                            meta.addCustomEffect(PotionEffectType.HARM.createEffect(2, 1), false);
+                            cleanStack.setItemMeta(meta);
+                            return cleanStack;
+                        }
+                    },
+                    new Operator() {
+                        public ItemStack operate(ItemStack cleanStack) {
+                            final PotionMeta meta = (PotionMeta) cleanStack.getItemMeta();
+                            cleanStack.setItemMeta(meta);
+                            return cleanStack;
+                        }
+                    },
+                    "Potion vs Blank"
+                },
+                new Object[] {
+                    new Operator() {
+                        public ItemStack operate(ItemStack cleanStack) {
+                            final PotionMeta meta = (PotionMeta) cleanStack.getItemMeta();
+                            meta.addCustomEffect(PotionEffectType.SLOW_DIGGING.createEffect(1, 1), false);
+                            cleanStack.setItemMeta(meta);
+                            return cleanStack;
+                        }
+                    },
+                    new Operator() {
+                        public ItemStack operate(ItemStack cleanStack) {
+                            final PotionMeta meta = (PotionMeta) cleanStack.getItemMeta();
+                            meta.addCustomEffect(PotionEffectType.FAST_DIGGING.createEffect(1, 1), false);
+                            cleanStack.setItemMeta(meta);
+                            return cleanStack;
+                        }
+                    },
+                    "Potion vs Harder"
+                },
+                new Object[] {
+                    new Operator() {
+                        public ItemStack operate(ItemStack cleanStack) {
+                            final PotionMeta meta = (PotionMeta) cleanStack.getItemMeta();
+                            meta.addCustomEffect(PotionEffectType.JUMP.createEffect(1, 1), false);
+                            cleanStack.setItemMeta(meta);
+                            return cleanStack;
+                        }
+                    },
+                    new Operator() {
+                        public ItemStack operate(ItemStack cleanStack) {
+                            final PotionMeta meta = (PotionMeta) cleanStack.getItemMeta();
+                            meta.addCustomEffect(PotionEffectType.JUMP.createEffect(1, 1), false);
+                            meta.addCustomEffect(PotionEffectType.REGENERATION.createEffect(1, 1), false);
+                            cleanStack.setItemMeta(meta);
+                            return cleanStack;
+                        }
+                    },
+                    "Potion vs Better"
+                },
+                new Object[] {
+                    new Operator() {
+                        public ItemStack operate(ItemStack cleanStack) {
+                            final PotionMeta meta = (PotionMeta) cleanStack.getItemMeta();
+                            meta.addCustomEffect(PotionEffectType.SPEED.createEffect(10, 1), false);
+                            cleanStack.setItemMeta(meta);
+                            return cleanStack;
+                        }
+                    },
+                    new Operator() {
+                        public ItemStack operate(ItemStack cleanStack) {
+                            final PotionMeta meta = (PotionMeta) cleanStack.getItemMeta();
+                            meta.addCustomEffect(PotionEffectType.SPEED.createEffect(5, 1), false);
+                            cleanStack.setItemMeta(meta);
+                            return cleanStack;
+                        }
+                    },
+                    "Potion vs Faster"
+                },
+                new Object[] {
+                    new Operator() {
+                        public ItemStack operate(ItemStack cleanStack) {
+                            final PotionMeta meta = (PotionMeta) cleanStack.getItemMeta();
+                            meta.addCustomEffect(PotionEffectType.INCREASE_DAMAGE.createEffect(1, 1), false);
+                            cleanStack.setItemMeta(meta);
+                            return cleanStack;
+                        }
+                    },
+                    new Operator() {
+                        public ItemStack operate(ItemStack cleanStack) {
+                            final PotionMeta meta = (PotionMeta) cleanStack.getItemMeta();
+                            meta.addCustomEffect(PotionEffectType.INCREASE_DAMAGE.createEffect(1, 2), false);
+                            cleanStack.setItemMeta(meta);
+                            return cleanStack;
+                        }
+                    },
+                    "Potion vs Stronger"
+                }
+            )
+        );
+    }
+}

src/test/java/org/bukkit/craftbukkit/inventory/ItemStackSkullTest.java

@@ -0,0 +1,88 @@
+package org.bukkit.craftbukkit.inventory;
+
+import java.util.Arrays;
+import java.util.List;
+
+import org.bukkit.Material;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.meta.SkullMeta;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
+
+import com.google.common.base.Joiner;
+
+@RunWith(Parameterized.class)
+public class ItemStackSkullTest extends ItemStackTest {
+
+    @Parameters(name="[{index}]:{" + NAME_PARAMETER + "}")
+    public static List<Object[]> data() {
+        return StackProvider.compound(operators(), "%s %s", NAME_PARAMETER, Material.PLAYER_HEAD);
+    }
+
+    @SuppressWarnings("unchecked")
+    static List<Object[]> operators() {
+        return CompoundOperator.compound(
+            Joiner.on('+'),
+            NAME_PARAMETER,
+            Long.parseLong("10", 2),
+            ItemStackLoreEnchantmentTest.operators(),
+            Arrays.asList(
+                new Object[] {
+                    new Operator() {
+                        public ItemStack operate(ItemStack cleanStack) {
+                            SkullMeta meta = (SkullMeta) cleanStack.getItemMeta();
+                            meta.setOwner("Notch");
+                            cleanStack.setItemMeta(meta);
+                            return cleanStack;
+                        }
+                    },
+                    new Operator() {
+                        public ItemStack operate(ItemStack cleanStack) {
+                            SkullMeta meta = (SkullMeta) cleanStack.getItemMeta();
+                            meta.setOwner("Dinnerbone");
+                            cleanStack.setItemMeta(meta);
+                            return cleanStack;
+                        }
+                    },
+                    "Name 1 vs. Name 2"
+                },
+                new Object[] {
+                    new Operator() {
+                        public ItemStack operate(ItemStack cleanStack) {
+                            SkullMeta meta = (SkullMeta) cleanStack.getItemMeta();
+                            meta.setOwner("Notch");
+                            cleanStack.setItemMeta(meta);
+                            return cleanStack;
+                        }
+                    },
+                    new Operator() {
+                        public ItemStack operate(ItemStack cleanStack) {
+                            SkullMeta meta = (SkullMeta) cleanStack.getItemMeta();
+                            meta.setOwner(null);
+                            cleanStack.setItemMeta(meta);
+                            return cleanStack;
+                        }
+                    },
+                    "Name vs. Null"
+                },
+                new Object[] {
+                    new Operator() {
+                        public ItemStack operate(ItemStack cleanStack) {
+                            SkullMeta meta = (SkullMeta) cleanStack.getItemMeta();
+                            meta.setOwner("Notch");
+                            cleanStack.setItemMeta(meta);
+                            return cleanStack;
+                        }
+                    },
+                    new Operator() {
+                        public ItemStack operate(ItemStack cleanStack) {
+                            return cleanStack;
+                        }
+                    },
+                    "Name vs. None"
+                }
+            )
+        );
+    }
+}

src/test/java/org/bukkit/craftbukkit/inventory/ItemStackTest.java

@@ -0,0 +1,493 @@
+package org.bukkit.craftbukkit.inventory;
+
+import static org.bukkit.support.Matchers.sameHash;
+import static org.junit.Assert.*;
+import static org.hamcrest.Matchers.*;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import org.bukkit.Material;
+import org.bukkit.configuration.InvalidConfigurationException;
+import org.bukkit.configuration.file.YamlConfiguration;
+import org.bukkit.inventory.ItemFactory;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.meta.ItemMeta;
+import org.bukkit.support.AbstractTestingBase;
+import org.bukkit.util.io.BukkitObjectInputStream;
+import org.bukkit.util.io.BukkitObjectOutputStream;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameter;
+import org.junit.runners.Parameterized.Parameters;
+import org.yaml.snakeyaml.external.biz.base64Coder.Base64Coder;
+
+import com.google.common.base.Joiner;
+import com.google.common.collect.ImmutableList;
+
+@RunWith(Parameterized.class)
+public class ItemStackTest extends AbstractTestingBase {
+    static abstract class StackProvider {
+        final Material material;
+
+        StackProvider(Material material) {
+            this.material = material;
+        }
+
+        ItemStack bukkit() {
+            return operate(cleanStack(material, false));
+        }
+
+        ItemStack craft() {
+            return operate(cleanStack(material, true));
+        }
+
+        abstract ItemStack operate(ItemStack cleanStack);
+
+        static ItemStack cleanStack(Material material, boolean craft) {
+            final ItemStack stack = new ItemStack(material);
+            return craft ? CraftItemStack.asCraftCopy(stack) : stack;
+        }
+
+        @Override
+        public String toString() {
+            return material.toString();
+        }
+
+        /**
+         * For each item in parameterList, it will apply nameFormat at nameIndex.
+         * For each item in parameterList for each item in materials, it will create a stack provider at each array index that contains an Operator.
+         *
+         * @param parameterList
+         * @param nameFormat
+         * @param nameIndex
+         * @param materials
+         * @return
+         */
+        static List<Object[]> compound(final List<Object[]> parameterList, final String nameFormat, final int nameIndex, final Material...materials) {
+            final List<Object[]> out = new ArrayList<Object[]>();
+            for (Object[] params : parameterList) {
+                final int len = params.length;
+                for (final Material material : materials) {
+                    final Object[] paramsOut = params.clone();
+                    for (int i = 0; i < len; i++) {
+                        final Object param = paramsOut[i];
+                        if (param instanceof Operator) {
+                            final Operator operator = (Operator) param;
+                            paramsOut[i] = new StackProvider(material) {
+                                @Override
+                                ItemStack operate(ItemStack cleanStack) {
+                                    return operator.operate(cleanStack);
+                                }
+                            };
+                        }
+                    }
+                    paramsOut[nameIndex] = String.format(nameFormat, paramsOut[nameIndex], material);
+                    out.add(paramsOut);
+                }
+            }
+            return out;
+        }
+    }
+
+    interface Operator {
+        ItemStack operate(ItemStack cleanStack);
+    }
+
+    static class CompoundOperator implements Operator {
+        static class RecursiveContainer {
+            final Joiner joiner;
+            final Object[] strings;
+            final int nameParameter;
+            final List<Object[]> stack;
+            final List<Object[]> out;
+            final List<Object[]>[] lists;
+
+            RecursiveContainer(Joiner joiner, Object[] strings, int nameParameter, List<Object[]> stack, List<Object[]> out, List<Object[]>[] lists) {
+                this.joiner = joiner;
+                this.strings = strings;
+                this.nameParameter = nameParameter;
+                this.stack = stack;
+                this.out = out;
+                this.lists = lists;
+            }
+        }
+        final Operator[] operators;
+
+        CompoundOperator(Operator...operators) {
+            this.operators = operators;
+        }
+
+        public ItemStack operate(ItemStack cleanStack) {
+            for (Operator operator : operators) {
+                operator.operate(cleanStack);
+            }
+            return cleanStack;
+        }
+
+        @Override
+        public String toString() {
+            return Arrays.toString(operators);
+        }
+
+
+        /**
+         * This combines different tests into one large collection, combining no two tests from the same list.
+         * @param joiner used to join names
+         * @param nameParameter index of the name parameter
+         * @param singletonBitmask a list of bits representing the 'singletons' located in your originalLists. Lowest order bits represent the first items in originalLists.
+         *      Singletons are exponentially linked with each other, such that,
+         *      the output will contain every unique subset of only items from the singletons,
+         *      as well as every unique subset that contains at least one item from each non-singleton.
+         * @param originalLists
+         * @return
+         */
+        static List<Object[]> compound(final Joiner joiner, final int nameParameter, final long singletonBitmask, final List<Object[]>...originalLists) {
+
+            final List<Object[]> out = new ArrayList<Object[]>();
+            final List<List<Object[]>> singletons = new ArrayList<List<Object[]>>();
+            final List<List<Object[]>> notSingletons = new ArrayList<List<Object[]>>();
+
+            { // Separate and prime the 'singletons'
+                int i = 0;
+                for (List<Object[]> list : originalLists) {
+                    (((singletonBitmask >>> i++) & 0x1) == 0x1 ? singletons : notSingletons).add(list);
+                }
+            }
+
+            for (final List<Object[]> primarySingleton : singletons) {
+                // Iterate over our singletons, to multiply the 'out' each time
+                for (final Object[] entry : out.toArray(EMPTY_ARRAY)) {
+                    // Iterate over a snapshot of 'out' to prevent CMEs / infinite iteration
+                    final int len = entry.length;
+                    for (final Object[] singleton : primarySingleton) {
+                        // Iterate over each item in our singleton for the current 'out' entry
+                        final Object[] toOut = entry.clone();
+                        for (int i = 0; i < len; i++) {
+                            // Iterate over each parameter
+                            if (i == nameParameter) {
+                                toOut[i] = joiner.join(toOut[i], singleton[i]);
+                            } else if (toOut[i] instanceof Operator) {
+                                final Operator op1 = (Operator) toOut[i];
+                                final Operator op2 = (Operator) singleton[i];
+                                toOut[i] = new Operator() {
+                                    public ItemStack operate(final ItemStack cleanStack) {
+                                        return op2.operate(op1.operate(cleanStack));
+                                    }
+                                };
+                            }
+                        }
+                        out.add(toOut);
+                    }
+                }
+                out.addAll(primarySingleton);
+            }
+
+            @SuppressWarnings("unchecked")
+            final List<Object[]>[] lists = new List[notSingletons.size() + 1];
+            notSingletons.toArray(lists);
+            lists[lists.length - 1] = out;
+
+            final RecursiveContainer methodParams = new RecursiveContainer(joiner, new Object[lists.length], nameParameter, new ArrayList<Object[]>(lists.length), new ArrayList<Object[]>(), lists);
+
+            recursivelyCompound(methodParams, 0);
+            methodParams.out.addAll(out);
+
+            return methodParams.out;
+        }
+
+        private static void recursivelyCompound(final RecursiveContainer methodParams, final int level) {
+            final List<Object[]> stack = methodParams.stack;
+
+            if (level == methodParams.lists.length) {
+                final Object[] firstParams = stack.get(0);
+                final int len = firstParams.length;
+                final int stackSize = stack.size();
+                final Object[] params = new Object[len];
+
+                for (int i = 0; i < len; i++) {
+                    final Object firstParam = firstParams[i];
+
+                    if (firstParam instanceof Operator) {
+                        final Operator[] operators = new Operator[stackSize];
+                        for (int j = 0; j < stackSize; j++) {
+                            operators[j] = (Operator) stack.get(j)[i];
+                        }
+
+                        params[i] = new CompoundOperator(operators);
+                    } else if (i == methodParams.nameParameter) {
+                        final Object[] strings = methodParams.strings;
+                        for (int j = 0; j < stackSize; j++) {
+                            strings[j] = stack.get(j)[i];
+                        }
+
+                        params[i] = methodParams.joiner.join(strings);
+                    } else {
+                        params[i] = firstParam;
+                    }
+                }
+
+                methodParams.out.add(params);
+            } else {
+                final int marker = stack.size();
+
+                for (final Object[] params : methodParams.lists[level]) {
+                    stack.add(params);
+                    recursivelyCompound(methodParams, level + 1);
+                    stack.remove(marker);
+                }
+            }
+        }
+    }
+
+    interface StackWrapper {
+        ItemStack stack();
+    }
+
+    static class CraftWrapper implements StackWrapper {
+        final StackProvider provider;
+
+        CraftWrapper(StackProvider provider) {
+            this.provider = provider;
+        }
+
+        public ItemStack stack() {
+            return provider.craft();
+        }
+
+        @Override
+        public String toString() {
+            return "Craft " + provider;
+        }
+    }
+
+    static class BukkitWrapper implements StackWrapper {
+        final StackProvider provider;
+
+        BukkitWrapper(StackProvider provider) {
+            this.provider = provider;
+        }
+
+        public ItemStack stack() {
+            return provider.bukkit();
+        }
+
+        @Override
+        public String toString() {
+            return "Bukkit " + provider;
+        }
+    }
+
+    static class NoOpProvider extends StackProvider {
+
+        NoOpProvider(Material material) {
+            super(material);
+        }
+
+        @Override
+        ItemStack operate(ItemStack cleanStack) {
+            return cleanStack;
+        }
+
+        @Override
+        public String toString() {
+            return "NoOp " + super.toString();
+        }
+    }
+
+    @Parameters(name="[{index}]:{" + NAME_PARAMETER + "}")
+    public static List<Object[]> data() {
+        return ImmutableList.of(); // TODO, test basic durability issues
+    }
+
+    static final Object[][] EMPTY_ARRAY = new Object[0][];
+    /**
+     * Materials that generate unique item meta types.
+     */
+    static final Material[] COMPOUND_MATERIALS;
+    static final int NAME_PARAMETER = 2;
+    static {
+        final ItemFactory factory = CraftItemFactory.instance();
+        final Map<Class<? extends ItemMeta>, Material> possibleMaterials = new HashMap<Class<? extends ItemMeta>, Material>();
+        ItemMeta meta;
+        for (final Material material : Material.values()) {
+            meta = factory.getItemMeta(material);
+            if (meta == null || possibleMaterials.containsKey(meta.getClass()))
+                continue;
+            possibleMaterials.put(meta.getClass(), material);
+
+        }
+        COMPOUND_MATERIALS = possibleMaterials.values().toArray(new Material[possibleMaterials.size()]);
+    }
+
+    @Parameter(0) public StackProvider provider;
+    @Parameter(1) public StackProvider unequalProvider;
+    @Parameter(NAME_PARAMETER) public String name;
+
+    @Test
+    public void testBukkitInequality() {
+        final StackWrapper bukkitWrapper = new CraftWrapper(provider);
+        testInequality(bukkitWrapper, new BukkitWrapper(unequalProvider));
+        testInequality(bukkitWrapper, new BukkitWrapper(new NoOpProvider(provider.material)));
+    }
+
+    @Test
+    public void testCraftInequality() {
+        final StackWrapper craftWrapper = new CraftWrapper(provider);
+        testInequality(craftWrapper, new CraftWrapper(unequalProvider));
+        testInequality(craftWrapper, new CraftWrapper(new NoOpProvider(provider.material)));
+    }
+
+    @Test
+    public void testMixedInequality() {
+        final StackWrapper craftWrapper = new CraftWrapper(provider);
+        testInequality(craftWrapper, new BukkitWrapper(unequalProvider));
+        testInequality(craftWrapper, new BukkitWrapper(new NoOpProvider(provider.material)));
+
+        final StackWrapper bukkitWrapper = new CraftWrapper(provider);
+        testInequality(bukkitWrapper, new CraftWrapper(unequalProvider));
+        testInequality(bukkitWrapper, new CraftWrapper(new NoOpProvider(provider.material)));
+    }
+
+    static void testInequality(StackWrapper provider, StackWrapper unequalProvider) {
+        final ItemStack stack = provider.stack();
+        final ItemStack stack2 = provider.stack();
+        assertThat(stack, allOf(equalTo(stack), sameHash(stack)));
+        assertThat(stack, is(not(sameInstance(stack2))));
+        assertThat(stack, allOf(equalTo(stack2), sameHash(stack2)));
+
+        final ItemStack unequalStack = unequalProvider.stack();
+        final ItemStack unequalStack2 = unequalProvider.stack();
+        assertThat(unequalStack, allOf(equalTo(unequalStack), sameHash(unequalStack)));
+        assertThat(unequalStack, is(not(sameInstance(unequalStack2))));
+        assertThat(unequalStack, allOf(equalTo(unequalStack2), sameHash(unequalStack2)));
+
+        assertThat(stack, is(not(unequalStack)));
+        assertThat(unequalStack, is(not(stack)));
+
+        final ItemStack newStack = new ItemStack(stack2);
+        assertThat(newStack, allOf(equalTo(stack), sameHash(stack)));
+        assertThat(newStack, is(not(unequalStack)));
+        assertThat(newStack.getItemMeta(), allOf(equalTo(stack.getItemMeta()), sameHash(stack.getItemMeta())));
+        assertThat(newStack.getItemMeta(), is(not(unequalStack.getItemMeta())));
+
+        final ItemStack craftStack = CraftItemStack.asCraftCopy(stack2);
+        assertThat(craftStack, allOf(equalTo(stack), sameHash(stack)));
+        assertThat(craftStack, is(not(unequalStack)));
+        assertThat(craftStack.getItemMeta(), allOf(equalTo(stack.getItemMeta()), sameHash(stack.getItemMeta())));
+        assertThat(craftStack.getItemMeta(), is(not(unequalStack.getItemMeta())));
+
+        final ItemStack newUnequalStack = new ItemStack(unequalStack2);
+        assertThat(newUnequalStack, allOf(equalTo(unequalStack), sameHash(unequalStack)));
+        assertThat(newUnequalStack, is(not(stack)));
+        assertThat(newUnequalStack.getItemMeta(), allOf(equalTo(unequalStack.getItemMeta()), sameHash(unequalStack.getItemMeta())));
+        assertThat(newUnequalStack.getItemMeta(), is(not(stack.getItemMeta())));
+
+        final ItemStack newUnequalCraftStack = CraftItemStack.asCraftCopy(unequalStack2);
+        assertThat(newUnequalCraftStack, allOf(equalTo(unequalStack), sameHash(unequalStack)));
+        assertThat(newUnequalCraftStack, is(not(stack)));
+        assertThat(newUnequalCraftStack.getItemMeta(), allOf(equalTo(unequalStack.getItemMeta()), sameHash(unequalStack.getItemMeta())));
+        assertThat(newUnequalCraftStack.getItemMeta(), is(not(stack.getItemMeta())));
+    }
+
+    @Test
+    public void testBukkitYamlDeserialize() throws Throwable {
+        testYamlDeserialize(new BukkitWrapper(provider), new BukkitWrapper(unequalProvider));
+    }
+
+    @Test
+    public void testCraftYamlDeserialize() throws Throwable {
+        testYamlDeserialize(new CraftWrapper(provider), new CraftWrapper(unequalProvider));
+    }
+
+    @Test
+    public void testBukkitStreamDeserialize() throws Throwable {
+        testStreamDeserialize(new BukkitWrapper(provider), new BukkitWrapper(unequalProvider));
+    }
+
+    @Test
+    public void testCraftStreamDeserialize() throws Throwable {
+        testStreamDeserialize(new CraftWrapper(provider), new CraftWrapper(unequalProvider));
+    }
+
+    static void testStreamDeserialize(StackWrapper provider, StackWrapper unequalProvider) throws Throwable {
+        final ItemStack stack = provider.stack();
+        final ItemStack unequalStack = unequalProvider.stack();
+
+        ByteArrayOutputStream out = new ByteArrayOutputStream();
+        ObjectOutputStream oos = null;
+        try {
+            oos = new BukkitObjectOutputStream(out);
+
+            oos.writeObject(stack);
+            oos.writeObject(unequalStack);
+        } finally {
+            if (oos != null) {
+                try {
+                    oos.close();
+                } catch (IOException ex) {
+                }
+            }
+        }
+
+        final String data = new String(Base64Coder.encode(out.toByteArray()));
+
+        ObjectInputStream ois = null;
+
+        final ItemStack readFirst;
+        final ItemStack readSecond;
+
+        try {
+            ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
+            ois = new BukkitObjectInputStream(in);
+
+            readFirst = (ItemStack) ois.readObject();
+            readSecond = (ItemStack) ois.readObject();
+        } finally {
+            if (ois != null) {
+                try {
+                    ois.close();
+                } catch (IOException ex) {
+                }
+            }
+        }
+
+        testEqualities(data, readFirst, readSecond, stack, unequalStack);
+    }
+
+    static void testYamlDeserialize(StackWrapper provider, StackWrapper unequalProvider) {
+        final ItemStack stack = provider.stack();
+        final ItemStack unequalStack = unequalProvider.stack();
+        final YamlConfiguration configOut = new YamlConfiguration();
+
+        configOut.set("provider", stack);
+        configOut.set("unequal", unequalStack);
+
+        final String out = '\n' + configOut.saveToString();
+        final YamlConfiguration configIn = new YamlConfiguration();
+
+        try {
+            configIn.loadFromString(out);
+        } catch (InvalidConfigurationException ex) {
+            throw new RuntimeException(out, ex);
+        }
+
+        testEqualities(out, configIn.getItemStack("provider"), configIn.getItemStack("unequal"), stack, unequalStack);
+    }
+
+    static void testEqualities(String information, ItemStack primaryRead, ItemStack unequalRead, ItemStack primaryOriginal, ItemStack unequalOriginal) {
+        assertThat(information, primaryRead, allOf(equalTo(primaryOriginal), sameHash(primaryOriginal)));
+        assertThat(information, unequalRead, allOf(equalTo(unequalOriginal), sameHash(unequalOriginal)));
+        assertThat(information, primaryRead, is(not(unequalOriginal)));
+        assertThat(information, primaryRead, is(not(unequalRead)));
+    }
+}

src/test/java/org/bukkit/craftbukkit/inventory/NMSCraftItemStackTest.java

@@ -0,0 +1,35 @@
+package org.bukkit.craftbukkit.inventory;
+
+import static org.junit.Assert.*;
+import static org.hamcrest.Matchers.*;
+
+import net.minecraft.server.Enchantments;
+
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.support.AbstractTestingBase;
+import org.junit.Test;
+
+public class NMSCraftItemStackTest extends AbstractTestingBase {
+
+    @Test
+    public void testCloneEnchantedItem() throws Exception {
+        net.minecraft.server.ItemStack nmsItemStack = new net.minecraft.server.ItemStack(net.minecraft.server.Items.POTION);
+        nmsItemStack.addEnchantment(Enchantments.DAMAGE_ALL, 1);
+        ItemStack itemStack = CraftItemStack.asCraftMirror(nmsItemStack);
+        ItemStack clone = itemStack.clone();
+        assertThat(clone.getType(), is(itemStack.getType()));
+        assertThat(clone.getAmount(), is(itemStack.getAmount()));
+        assertThat(clone.getDurability(), is(itemStack.getDurability()));
+        assertThat(clone.getEnchantments(), is(itemStack.getEnchantments()));
+        assertThat(clone.getData(), is(itemStack.getData()));
+        assertThat(clone, is(itemStack));
+    }
+
+    @Test
+    public void testCloneNullItem() throws Exception {
+        net.minecraft.server.ItemStack nmsItemStack = null;
+        ItemStack itemStack = CraftItemStack.asCraftMirror(nmsItemStack);
+        ItemStack clone = itemStack.clone();
+        assertThat(clone, is(itemStack));
+    }
+}

src/test/java/org/bukkit/craftbukkit/inventory/PlayerInventoryTest.java

@@ -0,0 +1,60 @@
+package org.bukkit.craftbukkit.inventory;
+
+import net.minecraft.server.ItemStack;
+import net.minecraft.server.Items;
+import net.minecraft.server.PlayerInventory;
+import org.bukkit.support.AbstractTestingBase;
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+public class PlayerInventoryTest extends AbstractTestingBase {
+
+    @Test
+    public void testCanHold() throws Exception {
+        ItemStack itemStackApple = new ItemStack(Items.APPLE);
+        ItemStack itemStack1Coal = new ItemStack(Items.COAL);
+        ItemStack itemStack32Coal = new ItemStack(Items.COAL, 32);
+        ItemStack itemStack63Coal = new ItemStack(Items.COAL, 63);
+        ItemStack itemStack64Coal = new ItemStack(Items.COAL, 64);
+
+        // keep one slot empty
+        PlayerInventory inventory = new PlayerInventory(null);
+        for (int i = 0; i < inventory.items.size() - 1; i++) {
+            inventory.setItem(i, itemStackApple);
+        }
+
+        // one slot empty
+        assertEquals(1, inventory.canHold(itemStack1Coal));
+        assertEquals(32, inventory.canHold(itemStack32Coal));
+        assertEquals(64, inventory.canHold(itemStack64Coal));
+
+        // no free space with a stack of the item to check in the inventory
+        inventory.setItem(inventory.items.size() - 1, itemStack64Coal);
+
+        assertEquals(0, inventory.canHold(itemStack1Coal));
+        assertEquals(0, inventory.canHold(itemStack32Coal));
+        assertEquals(0, inventory.canHold(itemStack64Coal));
+
+        // no free space without a stack of the item to check in the inventory
+        inventory.setItem(inventory.items.size() - 1, itemStackApple);
+
+        assertEquals(0, inventory.canHold(itemStack1Coal));
+        assertEquals(0, inventory.canHold(itemStack32Coal));
+        assertEquals(0, inventory.canHold(itemStack64Coal));
+
+        // free space for 32 items in one slot
+        inventory.setItem(inventory.items.size() - 1, itemStack32Coal);
+
+        assertEquals(1, inventory.canHold(itemStack1Coal));
+        assertEquals(32, inventory.canHold(itemStack32Coal));
+        assertEquals(32, inventory.canHold(itemStack64Coal));
+
+        // free space for 1 item in two slots
+        inventory.setItem(inventory.items.size() - 1, itemStack63Coal);
+        inventory.setItem(inventory.items.size() - 2, itemStack63Coal);
+
+        assertEquals(1, inventory.canHold(itemStack1Coal));
+        assertEquals(2, inventory.canHold(itemStack32Coal));
+        assertEquals(2, inventory.canHold(itemStack64Coal));
+    }
+}

src/test/java/org/bukkit/entity/EnderDragonPhaseTest.java

@@ -0,0 +1,50 @@
+package org.bukkit.entity;
+
+import net.minecraft.server.DragonControllerPhase;
+import org.bukkit.craftbukkit.entity.CraftEnderDragon;
+import org.junit.Assert;
+import org.junit.Test;
+
+import static junit.framework.TestCase.assertNotNull;
+
+public class EnderDragonPhaseTest {
+
+    @Test
+    public void testNotNull() {
+        for (EnderDragon.Phase phase : EnderDragon.Phase.values()) {
+            DragonControllerPhase dragonControllerPhase = CraftEnderDragon.getMinecraftPhase(phase);
+            assertNotNull(phase.name(), dragonControllerPhase);
+            assertNotNull(phase.name(), CraftEnderDragon.getBukkitPhase(dragonControllerPhase));
+        }
+    }
+    
+    @Test
+    public void testBukkitToMinecraft() {
+        Assert.assertEquals("CIRCLING", CraftEnderDragon.getMinecraftPhase(EnderDragon.Phase.CIRCLING), DragonControllerPhase.HOLDING_PATTERN);
+        Assert.assertEquals("STRAFING", CraftEnderDragon.getMinecraftPhase(EnderDragon.Phase.STRAFING), DragonControllerPhase.STRAFE_PLAYER);
+        Assert.assertEquals("FLY_TO_PORTAL", CraftEnderDragon.getMinecraftPhase(EnderDragon.Phase.FLY_TO_PORTAL), DragonControllerPhase.LANDING_APPROACH);
+        Assert.assertEquals("LAND_ON_PORTAL", CraftEnderDragon.getMinecraftPhase(EnderDragon.Phase.LAND_ON_PORTAL), DragonControllerPhase.LANDING);
+        Assert.assertEquals("LEAVE_PORTAL", CraftEnderDragon.getMinecraftPhase(EnderDragon.Phase.LEAVE_PORTAL), DragonControllerPhase.TAKEOFF);
+        Assert.assertEquals("BREATH_ATTACK", CraftEnderDragon.getMinecraftPhase(EnderDragon.Phase.BREATH_ATTACK), DragonControllerPhase.SITTING_FLAMING);
+        Assert.assertEquals("SEARCH_FOR_BREATH_ATTACK_TARGET", CraftEnderDragon.getMinecraftPhase(EnderDragon.Phase.SEARCH_FOR_BREATH_ATTACK_TARGET), DragonControllerPhase.SITTING_SCANNING);
+        Assert.assertEquals("ROAR_BEFORE_ATTACK", CraftEnderDragon.getMinecraftPhase(EnderDragon.Phase.ROAR_BEFORE_ATTACK), DragonControllerPhase.SITTING_ATTACKING);
+        Assert.assertEquals("CHARGE_PLAYER", CraftEnderDragon.getMinecraftPhase(EnderDragon.Phase.CHARGE_PLAYER), DragonControllerPhase.CHARGING_PLAYER);
+        Assert.assertEquals("DYING", CraftEnderDragon.getMinecraftPhase(EnderDragon.Phase.DYING), DragonControllerPhase.DYING);
+        Assert.assertEquals("HOVER", CraftEnderDragon.getMinecraftPhase(EnderDragon.Phase.HOVER), DragonControllerPhase.HOVER);
+    }
+
+    @Test
+    public void testMinecraftToBukkit() {
+        Assert.assertEquals("CIRCLING", CraftEnderDragon.getBukkitPhase(DragonControllerPhase.HOLDING_PATTERN), EnderDragon.Phase.CIRCLING);
+        Assert.assertEquals("STRAFING", CraftEnderDragon.getBukkitPhase(DragonControllerPhase.STRAFE_PLAYER), EnderDragon.Phase.STRAFING);
+        Assert.assertEquals("FLY_TO_PORTAL", CraftEnderDragon.getBukkitPhase(DragonControllerPhase.LANDING_APPROACH), EnderDragon.Phase.FLY_TO_PORTAL);
+        Assert.assertEquals("LAND_ON_PORTAL", CraftEnderDragon.getBukkitPhase(DragonControllerPhase.LANDING), EnderDragon.Phase.LAND_ON_PORTAL);
+        Assert.assertEquals("LEAVE_PORTAL", CraftEnderDragon.getBukkitPhase(DragonControllerPhase.TAKEOFF), EnderDragon.Phase.LEAVE_PORTAL);
+        Assert.assertEquals("BREATH_ATTACK", CraftEnderDragon.getBukkitPhase(DragonControllerPhase.SITTING_FLAMING), EnderDragon.Phase.BREATH_ATTACK);
+        Assert.assertEquals("SEARCH_FOR_BREATH_ATTACK_TARGET", CraftEnderDragon.getBukkitPhase(DragonControllerPhase.SITTING_SCANNING), EnderDragon.Phase.SEARCH_FOR_BREATH_ATTACK_TARGET);
+        Assert.assertEquals("ROAR_BEFORE_ATTACK", CraftEnderDragon.getBukkitPhase(DragonControllerPhase.SITTING_ATTACKING), EnderDragon.Phase.ROAR_BEFORE_ATTACK);
+        Assert.assertEquals("CHARGE_PLAYER", CraftEnderDragon.getBukkitPhase(DragonControllerPhase.CHARGING_PLAYER), EnderDragon.Phase.CHARGE_PLAYER);
+        Assert.assertEquals("DYING", CraftEnderDragon.getBukkitPhase(DragonControllerPhase.DYING), EnderDragon.Phase.DYING);
+        Assert.assertEquals("HOVER", CraftEnderDragon.getBukkitPhase(DragonControllerPhase.HOVER), EnderDragon.Phase.HOVER);
+    } 
+}

src/test/java/org/bukkit/entity/EntityTypesTest.java

@@ -0,0 +1,31 @@
+package org.bukkit.entity;
+
+import java.util.Arrays;
+import java.util.Set;
+import java.util.stream.Collectors;
+import net.minecraft.server.EntityTypes;
+import net.minecraft.server.IRegistry;
+import net.minecraft.server.MinecraftKey;
+import org.bukkit.support.AbstractTestingBase;
+import org.junit.Assert;
+import org.junit.Test;
+
+public class EntityTypesTest extends AbstractTestingBase {
+
+    @Test
+    public void testMaps() {
+        Set<EntityType> allBukkit = Arrays.stream(EntityType.values()).filter((b) -> b.getName() != null).collect(Collectors.toSet());
+
+        for (Object o : IRegistry.ENTITY_TYPE) {
+            EntityTypes<?> nms = (EntityTypes<?>) o; // Eclipse fail
+            MinecraftKey key = EntityTypes.getName(nms);
+
+            EntityType bukkit = EntityType.fromName(key.getKey());
+            Assert.assertNotNull("Missing nms->bukkit " + key, bukkit);
+
+            Assert.assertTrue("Duplicate entity nms->" + bukkit, allBukkit.remove(bukkit));
+        }
+
+        Assert.assertTrue("Unmapped bukkit entities " + allBukkit, allBukkit.isEmpty());
+    }
+}

src/test/java/org/bukkit/entity/TropicalFishTest.java

@@ -0,0 +1,45 @@
+package org.bukkit.entity;
+
+import static org.junit.Assert.*;
+import static org.hamcrest.Matchers.*;
+import org.bukkit.DyeColor;
+import org.bukkit.craftbukkit.entity.CraftTropicalFish;
+import org.bukkit.entity.TropicalFish.Pattern;
+
+import org.junit.Test;
+
+public class TropicalFishTest {
+
+    @Test
+    public void testVariants() {
+        testVariant(65536, DyeColor.ORANGE, DyeColor.WHITE, Pattern.KOB);
+        testVariant(917504, DyeColor.RED, DyeColor.WHITE, Pattern.KOB);
+        testVariant(918273, DyeColor.RED, DyeColor.WHITE, Pattern.BLOCKFISH);
+        testVariant(918529, DyeColor.RED, DyeColor.WHITE, Pattern.BETTY);
+        testVariant(16778497, DyeColor.WHITE, DyeColor.ORANGE, Pattern.CLAYFISH);
+        testVariant(50660352, DyeColor.LIME, DyeColor.LIGHT_BLUE, Pattern.BRINELY);
+        testVariant(50726144, DyeColor.PINK, DyeColor.LIGHT_BLUE, Pattern.SPOTTY);
+        testVariant(50790656, DyeColor.GRAY, DyeColor.LIGHT_BLUE, Pattern.SUNSTREAK);
+        testVariant(67108865, DyeColor.WHITE, DyeColor.YELLOW, Pattern.FLOPPER);
+        testVariant(67110144, DyeColor.WHITE, DyeColor.YELLOW, Pattern.SPOTTY);
+        testVariant(67371265, DyeColor.YELLOW, DyeColor.YELLOW, Pattern.STRIPEY);
+        testVariant(67764993, DyeColor.PURPLE, DyeColor.YELLOW, Pattern.BLOCKFISH);
+        testVariant(101253888, DyeColor.CYAN, DyeColor.PINK, Pattern.DASHER);
+        testVariant(117441025, DyeColor.WHITE, DyeColor.GRAY, Pattern.GLITTER);
+        testVariant(117441280, DyeColor.WHITE, DyeColor.GRAY, Pattern.DASHER);
+        testVariant(117441536, DyeColor.WHITE, DyeColor.GRAY, Pattern.BRINELY);
+        testVariant(117506305, DyeColor.ORANGE, DyeColor.GRAY, Pattern.STRIPEY);
+        testVariant(117899265, DyeColor.GRAY, DyeColor.GRAY, Pattern.FLOPPER);
+        testVariant(118161664, DyeColor.BLUE, DyeColor.GRAY, Pattern.SUNSTREAK);
+        testVariant(134217984, DyeColor.WHITE, DyeColor.LIGHT_GRAY, Pattern.SUNSTREAK);
+        testVariant(234882305, DyeColor.WHITE, DyeColor.RED, Pattern.CLAYFISH);
+        testVariant(235340288, DyeColor.GRAY, DyeColor.RED, Pattern.SNOOPER);
+    }
+
+    private void testVariant(int variant, DyeColor bodyColor, DyeColor patternColor, Pattern pattern) {
+        assertThat("variant write", CraftTropicalFish.getData(patternColor, bodyColor, pattern), is(variant));
+        assertThat("pattern colour read", CraftTropicalFish.getPatternColor(variant), is(patternColor));
+        assertThat("body colour read", CraftTropicalFish.getBodyColor(variant), is(bodyColor));
+        assertThat("pattern read", CraftTropicalFish.getPattern(variant), is(pattern));
+    }
+}

src/test/java/org/bukkit/map/MapTest.java

@@ -0,0 +1,62 @@
+
+package org.bukkit.map;
+
+import java.awt.Color;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import net.minecraft.server.MaterialMapColor;
+import org.junit.Assert;
+import org.junit.Test;
+
+public class MapTest {
+
+    private static final Logger logger = Logger.getLogger("MapTest");
+
+    private static final int[] modifiers = {180, 220, 255, 135};
+
+    @Test
+    public void testColors() {
+        MaterialMapColor[] nmsColors = MaterialMapColor.a;
+        Color[] bukkitColors = MapPalette.colors;
+
+        boolean fail = false;
+        for (int i = 0; i < nmsColors.length; i++) {
+            if (nmsColors[i] == null) {
+                break;
+            }
+            int rgb = nmsColors[i].rgb;
+
+            int r = (rgb >> 16) & 0xFF;
+            int g = (rgb >> 8) & 0xFF;
+            int b = rgb & 0xFF;
+
+            if (i + 1 > bukkitColors.length / 4) {
+                for (int modi : modifiers) {
+                    int mr = (r * modi) / 255;
+                    int mg = (g * modi) / 255;
+                    int mb = (b * modi) / 255;
+                    logger.log(Level.WARNING, "Missing color: c({0}, {1}, {2})", new Object[]{mr, mg, mb});
+                }
+                fail = true;
+            } else {
+                for (int j = 0; j < modifiers.length; j++) {
+                    int modi = modifiers[j];
+                    Color bukkit = bukkitColors[i * 4 + j];
+                    int mr = (r * modi) / 255;
+                    int mg = (g * modi) / 255;
+                    int mb = (b * modi) / 255;
+
+                    if (bukkit.getRed() != mr || bukkit.getGreen() != mg || bukkit.getBlue() != mb) {
+                        logger.log(Level.WARNING, "Incorrect color: {6} {7} c({0}, {1}, {2}) != c({3}, {4}, {5})", new Object[]{
+                            bukkit.getRed(), bukkit.getGreen(), bukkit.getBlue(),
+                            mr, mg, mb,
+                            i, j
+                        });
+                        fail = true;
+                    }
+                }
+            }
+        }
+        Assert.assertFalse(fail);
+    }
+}

src/test/java/org/bukkit/potion/PotionTest.java

@@ -0,0 +1,35 @@
+package org.bukkit.potion;
+
+import static org.junit.Assert.*;
+
+import java.util.EnumMap;
+import java.util.List;
+import java.util.Map;
+import net.minecraft.server.IRegistry;
+
+import net.minecraft.server.MobEffect;
+import net.minecraft.server.MobEffectList;
+import net.minecraft.server.PotionRegistry;
+import org.bukkit.support.AbstractTestingBase;
+import org.junit.Test;
+
+public class PotionTest extends AbstractTestingBase {
+    @Test
+    public void testEffectCompleteness() throws Throwable {
+        Map<PotionType, String> effects = new EnumMap(PotionType.class);
+        for (Object reg : IRegistry.POTION) {
+            List<MobEffect> eff = ((PotionRegistry)reg).a();
+            if (eff.size() != 1) continue;
+            int id = MobEffectList.getId(eff.get(0).getMobEffect());
+            PotionEffectType type = PotionEffectType.getById(id);
+            assertNotNull(String.valueOf(id), PotionEffectType.getById(id));
+
+            PotionType enumType = PotionType.getByEffect(type);
+            assertNotNull(type.getName(), enumType);
+
+            effects.put(enumType, enumType.name());
+        }
+
+        assertEquals(effects.entrySet().size(), PotionType.values().length - /* PotionTypes with no/shared Effects */ 6);
+    }
+}

src/test/java/org/bukkit/support/AbstractTestingBase.java

@@ -0,0 +1,53 @@
+package org.bukkit.support;
+
+import com.google.common.collect.ImmutableList;
+import java.util.Collections;
+import java.util.List;
+import net.minecraft.server.DispenserRegistry;
+import net.minecraft.server.EnumResourcePackType;
+import net.minecraft.server.LootTableRegistry;
+import net.minecraft.server.ResourceManager;
+import net.minecraft.server.ResourcePackVanilla;
+import net.minecraft.server.TagRegistry;
+import org.bukkit.Material;
+import org.bukkit.craftbukkit.util.CraftMagicNumbers;
+import org.junit.Assert;
+
+/**
+ *  If you are getting: java.lang.ExceptionInInitializerError
+ *    at net.minecraft.server.StatisticList.<clinit>(SourceFile:58)
+ *    at net.minecraft.server.Item.<clinit>(SourceFile:252)
+ *    at net.minecraft.server.Block.<clinit>(Block.java:577)
+ *
+ *  extend this class to solve it.
+ */
+public abstract class AbstractTestingBase {
+    // Materials that only exist in block form (or are legacy)
+    public static final List<Material> INVALIDATED_MATERIALS;
+
+    public static final LootTableRegistry LOOT_TABLE_REGISTRY;
+    public static final TagRegistry TAG_REGISTRY;
+
+    static {
+        DispenserRegistry.c();
+        // Set up resource manager
+        ResourceManager resourceManager = new ResourceManager(EnumResourcePackType.SERVER_DATA);
+        // add tags and loot tables for unit tests
+        resourceManager.a(TAG_REGISTRY = new TagRegistry());
+        resourceManager.a(LOOT_TABLE_REGISTRY = new LootTableRegistry());
+        // Register vanilla pack
+        resourceManager.a(Collections.singletonList(new ResourcePackVanilla("minecraft")));
+
+        DummyServer.setup();
+        DummyEnchantments.setup();
+
+        ImmutableList.Builder<Material> builder = ImmutableList.builder();
+        for (Material m : Material.values()) {
+            if (m.isLegacy() || CraftMagicNumbers.getItem(m) == null) {
+                builder.add(m);
+            }
+        }
+        INVALIDATED_MATERIALS = builder.build();
+        Assert.assertEquals("Expected 543 invalidated materials (got " + INVALIDATED_MATERIALS.size() + ")", 543, INVALIDATED_MATERIALS.size());
+    }
+}

src/test/java/org/bukkit/support/DummyEnchantments.java

@@ -0,0 +1,12 @@
+package org.bukkit.support;
+
+import net.minecraft.server.Enchantments;
+
+public class DummyEnchantments {
+    static {
+        Enchantments.DAMAGE_ALL.getClass();
+        org.bukkit.enchantments.Enchantment.stopAcceptingRegistrations();
+    }
+
+    public static void setup() {}
+}

src/test/java/org/bukkit/support/DummyServer.java

@@ -0,0 +1,111 @@
+package org.bukkit.support;
+
+import java.lang.reflect.InvocationHandler;
+import java.lang.reflect.Method;
+import java.lang.reflect.Proxy;
+import java.util.HashMap;
+import java.util.logging.Logger;
+
+import org.bukkit.Bukkit;
+import org.bukkit.Material;
+import org.bukkit.NamespacedKey;
+import org.bukkit.Server;
+import org.bukkit.craftbukkit.CraftLootTable;
+import org.bukkit.craftbukkit.block.data.CraftBlockData;
+import org.bukkit.craftbukkit.inventory.CraftItemFactory;
+import org.bukkit.craftbukkit.util.CraftMagicNumbers;
+import org.bukkit.craftbukkit.util.CraftNamespacedKey;
+import org.bukkit.craftbukkit.util.Versioning;
+
+public class DummyServer implements InvocationHandler {
+    private static interface MethodHandler {
+        Object handle(DummyServer server, Object[] args);
+    }
+    private static final HashMap<Method, MethodHandler> methods = new HashMap<Method, MethodHandler>();
+    static {
+        try {
+            methods.put(
+                    Server.class.getMethod("getItemFactory"),
+                    new MethodHandler() {
+                        public Object handle(DummyServer server, Object[] args) {
+                            return CraftItemFactory.instance();
+                        }
+                    }
+                );
+            methods.put(
+                    Server.class.getMethod("getName"),
+                    new MethodHandler() {
+                        public Object handle(DummyServer server, Object[] args) {
+                            return DummyServer.class.getName();
+                        }
+                    }
+                );
+            methods.put(
+                    Server.class.getMethod("getVersion"),
+                    new MethodHandler() {
+                        public Object handle(DummyServer server, Object[] args) {
+                            return DummyServer.class.getPackage().getImplementationVersion();
+                        }
+                    }
+                );
+            methods.put(
+                    Server.class.getMethod("getBukkitVersion"),
+                    new MethodHandler() {
+                        public Object handle(DummyServer server, Object[] args) {
+                            return Versioning.getBukkitVersion();
+                        }
+                    }
+                );
+            methods.put(
+                    Server.class.getMethod("getLogger"),
+                    new MethodHandler() {
+                        final Logger logger = Logger.getLogger(DummyServer.class.getCanonicalName());
+                        public Object handle(DummyServer server, Object[] args) {
+                            return logger;
+                        }
+                    }
+                );
+            methods.put(
+                    Server.class.getMethod("getUnsafe"),
+                    new MethodHandler() {
+                        public Object handle(DummyServer server, Object[] args) {
+                            return CraftMagicNumbers.INSTANCE;
+                        }
+                    }
+                );
+            methods.put(
+                    Server.class.getMethod("createBlockData", Material.class),
+                    new MethodHandler() {
+                        final Logger logger = Logger.getLogger(DummyServer.class.getCanonicalName());
+                        public Object handle(DummyServer server, Object[] args) {
+                            return CraftBlockData.newData((Material) args[0], null);
+                        }
+                    }
+                );
+            methods.put(Server.class.getMethod("getLootTable", NamespacedKey.class),
+                    new MethodHandler() {
+                        @Override
+                        public Object handle(DummyServer server, Object[] args) {
+                            NamespacedKey key = (NamespacedKey) args[0];
+                            return new CraftLootTable(key, AbstractTestingBase.LOOT_TABLE_REGISTRY.getLootTable(CraftNamespacedKey.toMinecraft(key)));
+                        }
+                    }
+                );
+            Bukkit.setServer(Proxy.getProxyClass(Server.class.getClassLoader(), Server.class).asSubclass(Server.class).getConstructor(InvocationHandler.class).newInstance(new DummyServer()));
+        } catch (Throwable t) {
+            throw new Error(t);
+        }
+    }
+
+    public static void setup() {}
+
+    private DummyServer() {};
+
+    public Object invoke(Object proxy, Method method, Object[] args) {
+        MethodHandler handler = methods.get(method);
+        if (handler != null) {
+            return handler.handle(this, args);
+        }
+        throw new UnsupportedOperationException(String.valueOf(method));
+    }
+}

src/test/java/org/bukkit/support/Matchers.java

@@ -0,0 +1,30 @@
+package org.bukkit.support;
+
+import org.hamcrest.BaseMatcher;
+import org.hamcrest.Description;
+import org.hamcrest.Matcher;
+
+public final class Matchers {
+
+    private Matchers() {}
+
+    public static <T> Matcher<T> sameHash(T value) {
+        return new SameHash<T>(value);
+    }
+
+    static class SameHash<T> extends BaseMatcher<T> {
+        private final int expected;
+
+        SameHash(T object) {
+            expected = object.hashCode();
+        }
+
+        public boolean matches(Object item) {
+            return item.hashCode() == expected;
+        }
+
+        public void describeTo(Description description) {
+            description.appendValue(expected);
+        }
+    }
+}

src/test/java/org/bukkit/support/Util.java

@@ -0,0 +1,31 @@
+package org.bukkit.support;
+
+import java.lang.reflect.Field;
+
+public class Util {
+    /*
+    public static <T> T getInternalState(Object object, String fieldName) {
+        return getInternalState(object.getClass(), object, fieldName);
+    }
+    */
+
+    @SuppressWarnings("unchecked")
+    public static <T> T getInternalState(Class<?> clazz, Object object, String fieldName) {
+        Field field;
+        try {
+            field = clazz.getDeclaredField(fieldName);
+        } catch (SecurityException e) {
+            throw new RuntimeException("Not allowed to access " + clazz, e);
+        } catch (NoSuchFieldException e) {
+            throw new RuntimeException("Unable to find field " + fieldName, e);
+        }
+
+        field.setAccessible(true);
+        try {
+            return (T) field.get(object);
+        } catch (IllegalArgumentException e) {
+        } catch (IllegalAccessException e) {
+        }
+        throw new RuntimeException("Unable to get internal value");
+    }
+}