429 lines
27 KiB
Java
429 lines
27 KiB
Java
package org.bukkit.materials;
|
|
|
|
import static org.bukkit.support.MatcherAssert.*;
|
|
import static org.hamcrest.Matchers.*;
|
|
import org.bukkit.CropState;
|
|
import org.bukkit.Material;
|
|
import org.bukkit.NetherWartsState;
|
|
import org.bukkit.TreeSpecies;
|
|
import org.bukkit.block.BlockFace;
|
|
import org.bukkit.material.Comparator;
|
|
import org.bukkit.material.Crops;
|
|
import org.bukkit.material.Diode;
|
|
import org.bukkit.material.Door;
|
|
import org.bukkit.material.Hopper;
|
|
import org.bukkit.material.Leaves;
|
|
import org.bukkit.material.Mushroom;
|
|
import org.bukkit.material.NetherWarts;
|
|
import org.bukkit.material.Sapling;
|
|
import org.bukkit.material.Tree;
|
|
import org.bukkit.material.Wood;
|
|
import org.bukkit.material.WoodenStep;
|
|
import org.bukkit.material.types.MushroomBlockTexture;
|
|
import org.junit.jupiter.api.Test;
|
|
|
|
@Deprecated(forRemoval = true)
|
|
public class MaterialDataTest {
|
|
|
|
@Test
|
|
public void testDoor() {
|
|
@SuppressWarnings("deprecation")
|
|
Door door = new Door();
|
|
assertThat(door.getItemType(), equalTo(Material.LEGACY_WOODEN_DOOR), "Constructed with default door type");
|
|
assertThat(door.isTopHalf(), equalTo(false), "Constructed with default top or bottom");
|
|
assertThat(door.getFacing(), equalTo(BlockFace.WEST), "Constructed with default direction");
|
|
assertThat(door.isOpen(), equalTo(false), "Constructed with default open state");
|
|
|
|
Material[] types = new Material[]{Material.LEGACY_WOODEN_DOOR,
|
|
Material.LEGACY_IRON_DOOR_BLOCK, Material.LEGACY_SPRUCE_DOOR,
|
|
Material.LEGACY_BIRCH_DOOR, Material.LEGACY_JUNGLE_DOOR,
|
|
Material.LEGACY_ACACIA_DOOR, Material.LEGACY_DARK_OAK_DOOR};
|
|
BlockFace[] directions = new BlockFace[]{BlockFace.WEST, BlockFace.NORTH, BlockFace.EAST, BlockFace.SOUTH};
|
|
boolean[] openStates = new boolean[]{false, true};
|
|
boolean[] hingeStates = new boolean[]{false, true};
|
|
for (Material type : types) {
|
|
// Test bottom half
|
|
for (BlockFace facing : directions) {
|
|
door = new Door(type, facing);
|
|
assertThat(door.getItemType(), equalTo(type), "Constructed with correct door type");
|
|
assertThat(door.isTopHalf(), equalTo(false), "Constructed with default top or bottom");
|
|
assertThat(door.getFacing(), equalTo(facing), "Constructed with correct direction");
|
|
assertThat(door.isOpen(), equalTo(false), "Constructed with default open state");
|
|
|
|
for (boolean openState : openStates) {
|
|
door = new Door(type, facing, openState);
|
|
assertThat(door.getItemType(), equalTo(type), "Constructed with correct door type");
|
|
assertThat(door.isTopHalf(), equalTo(false), "Constructed with default top or bottom");
|
|
assertThat(door.getFacing(), equalTo(facing), "Constructed with correct direction");
|
|
assertThat(door.isOpen(), equalTo(openState), "Constructed with correct open state");
|
|
}
|
|
}
|
|
|
|
// Test top half
|
|
for (boolean hingeState : hingeStates) {
|
|
door = new Door(type, hingeState);
|
|
assertThat(door.getItemType(), equalTo(type), "Constructed with correct door type");
|
|
assertThat(door.isTopHalf(), equalTo(true), "Constructed with default top or bottom");
|
|
assertThat(door.getHinge(), equalTo(hingeState), "Constructed with correct direction");
|
|
}
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void testWood() {
|
|
Wood wood = new Wood();
|
|
assertThat(wood.getItemType(), equalTo(Material.LEGACY_WOOD), "Constructed with default wood type");
|
|
assertThat(wood.getSpecies(), equalTo(TreeSpecies.GENERIC), "Constructed with default tree species");
|
|
|
|
TreeSpecies[] allSpecies = TreeSpecies.values();
|
|
for (TreeSpecies species : allSpecies) {
|
|
wood = new Wood(species);
|
|
assertThat(wood.getItemType(), equalTo(Material.LEGACY_WOOD), "Constructed with default wood type");
|
|
assertThat(wood.getSpecies(), equalTo(species), "Constructed with correct tree species");
|
|
}
|
|
|
|
Material[] types = new Material[]{Material.LEGACY_WOOD, Material.LEGACY_WOOD_DOUBLE_STEP};
|
|
for (Material type : types) {
|
|
wood = new Wood(type);
|
|
assertThat(wood.getItemType(), equalTo(type), "Constructed with correct wood type");
|
|
assertThat(wood.getSpecies(), equalTo(TreeSpecies.GENERIC), "Constructed with default tree species");
|
|
|
|
for (TreeSpecies species : allSpecies) {
|
|
wood = new Wood(type, species);
|
|
assertThat(wood.getItemType(), equalTo(type), "Constructed with correct wood type");
|
|
assertThat(wood.getSpecies(), equalTo(species), "Constructed with correct tree species");
|
|
}
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void testTree() {
|
|
Tree tree = new Tree();
|
|
assertThat(tree.getItemType(), equalTo(Material.LEGACY_LOG), "Constructed with default tree type");
|
|
assertThat(tree.getSpecies(), equalTo(TreeSpecies.GENERIC), "Constructed with default tree species");
|
|
assertThat(tree.getDirection(), equalTo(BlockFace.UP), "Constructed with default direction");
|
|
|
|
tree = new Tree(Material.LEGACY_LOG);
|
|
assertThat(tree.getItemType(), equalTo(Material.LEGACY_LOG), "Constructed with correct tree type");
|
|
assertThat(tree.getSpecies(), equalTo(TreeSpecies.GENERIC), "Constructed with default tree species");
|
|
assertThat(tree.getDirection(), equalTo(BlockFace.UP), "Constructed with default direction");
|
|
|
|
Material[] types = new Material[]{Material.LEGACY_LOG, Material.LEGACY_LOG_2};
|
|
TreeSpecies[][] allSpecies = new TreeSpecies[][]{
|
|
{TreeSpecies.GENERIC, TreeSpecies.REDWOOD, TreeSpecies.BIRCH, TreeSpecies.JUNGLE},
|
|
{TreeSpecies.ACACIA, TreeSpecies.DARK_OAK}
|
|
};
|
|
BlockFace[] allDirections = new BlockFace[]{BlockFace.UP, BlockFace.WEST, BlockFace.NORTH, BlockFace.SELF};
|
|
for (int t = 0; t < types.length; t++) {
|
|
for (TreeSpecies species : allSpecies[t]) {
|
|
tree = new Tree(types[t], species);
|
|
assertThat(tree.getItemType(), equalTo(types[t]), "Constructed with correct tree type");
|
|
assertThat(tree.getSpecies(), equalTo(species), "Constructed with correct tree species");
|
|
assertThat(tree.getDirection(), equalTo(BlockFace.UP), "Constructed with default direction");
|
|
|
|
// check item type is fixed automatically for invalid type-species combo
|
|
tree = new Tree(types[types.length - 1 - t], species);
|
|
assertThat(tree.getItemType(), equalTo(types[t]), "Constructed with fixed tree type");
|
|
assertThat(tree.getSpecies(), equalTo(species), "Constructed with correct tree species");
|
|
assertThat(tree.getDirection(), equalTo(BlockFace.UP), "Constructed with default direction");
|
|
for (BlockFace dir : allDirections) {
|
|
tree = new Tree(types[t], species, dir);
|
|
assertThat(tree.getItemType(), equalTo(types[t]), "Constructed with correct tree type");
|
|
assertThat(tree.getSpecies(), equalTo(species), "Constructed with correct tree species");
|
|
assertThat(tree.getDirection(), equalTo(dir), "Constructed with correct direction");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void testLeaves() {
|
|
Leaves leaves = new Leaves();
|
|
assertThat(leaves.getItemType(), equalTo(Material.LEGACY_LEAVES), "Constructed with default leaf type");
|
|
assertThat(leaves.getSpecies(), equalTo(TreeSpecies.GENERIC), "Constructed with default tree species");
|
|
assertThat(leaves.isDecayable(), equalTo(true), "Constructed with default decayable");
|
|
assertThat(leaves.isDecaying(), equalTo(false), "Constructed with default decaying");
|
|
|
|
leaves = new Leaves(Material.LEGACY_LEAVES);
|
|
assertThat(leaves.getItemType(), equalTo(Material.LEGACY_LEAVES), "Constructed with correct leaf type");
|
|
assertThat(leaves.getSpecies(), equalTo(TreeSpecies.GENERIC), "Constructed with default tree species");
|
|
assertThat(leaves.isDecayable(), equalTo(true), "Constructed with default decayable");
|
|
assertThat(leaves.isDecaying(), equalTo(false), "Constructed with default decaying");
|
|
|
|
Material[] types = new Material[]{Material.LEGACY_LEAVES, Material.LEGACY_LEAVES_2};
|
|
TreeSpecies[][] allSpecies = new TreeSpecies[][]{
|
|
{TreeSpecies.GENERIC, TreeSpecies.REDWOOD, TreeSpecies.BIRCH, TreeSpecies.JUNGLE},
|
|
{TreeSpecies.ACACIA, TreeSpecies.DARK_OAK}
|
|
};
|
|
boolean[] decayable = new boolean[]{true, false};
|
|
boolean[] decaying = new boolean[]{true, false};
|
|
for (int t = 0; t < types.length; t++) {
|
|
for (TreeSpecies species : allSpecies[t]) {
|
|
leaves = new Leaves(types[t], species);
|
|
assertThat(leaves.getItemType(), equalTo(types[t]), "Constructed with correct leaf type");
|
|
assertThat(leaves.getSpecies(), equalTo(species), "Constructed with correct tree species");
|
|
assertThat(leaves.isDecayable(), equalTo(true), "Constructed with default decayable");
|
|
assertThat(leaves.isDecaying(), equalTo(false), "Constructed with default decaying");
|
|
|
|
// check item type is fixed automatically for invalid type-species combo
|
|
leaves = new Leaves(types[types.length - 1 - t], species);
|
|
assertThat(leaves.getItemType(), equalTo(types[t]), "Constructed with fixed leaf type");
|
|
assertThat(leaves.getSpecies(), equalTo(species), "Constructed with correct tree species");
|
|
assertThat(leaves.isDecayable(), equalTo(true), "Constructed with default decayable");
|
|
assertThat(leaves.isDecaying(), equalTo(false), "Constructed with default decaying");
|
|
for (boolean isDecayable : decayable) {
|
|
leaves = new Leaves(types[t], species, isDecayable);
|
|
assertThat(leaves.getItemType(), equalTo(types[t]), "Constructed with correct wood type");
|
|
assertThat(leaves.getSpecies(), equalTo(species), "Constructed with correct tree species");
|
|
assertThat(leaves.isDecayable(), equalTo(isDecayable), "Constructed with correct decayable");
|
|
assertThat(leaves.isDecaying(), equalTo(false), "Constructed with default decaying");
|
|
for (boolean isDecaying : decaying) {
|
|
leaves = new Leaves(types[t], species, isDecayable);
|
|
leaves.setDecaying(isDecaying);
|
|
assertThat(leaves.getItemType(), equalTo(types[t]), "Constructed with correct wood type");
|
|
assertThat(leaves.getSpecies(), equalTo(species), "Constructed with correct tree species");
|
|
assertThat(leaves.isDecayable(), equalTo(isDecaying || isDecayable), "Constructed with correct decayable");
|
|
assertThat(leaves.isDecaying(), equalTo(isDecaying), "Constructed with correct decaying");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void testWoodenStep() {
|
|
WoodenStep woodenStep = new WoodenStep();
|
|
assertThat(woodenStep.getItemType(), equalTo(Material.LEGACY_WOOD_STEP), "Constructed with default step type");
|
|
assertThat(woodenStep.getSpecies(), equalTo(TreeSpecies.GENERIC), "Constructed with default tree species");
|
|
assertThat(woodenStep.isInverted(), equalTo(false), "Constructed with default inversion");
|
|
|
|
TreeSpecies[] allSpecies = TreeSpecies.values();
|
|
boolean[] inversion = new boolean[]{true, false};
|
|
for (TreeSpecies species : allSpecies) {
|
|
woodenStep = new WoodenStep(species);
|
|
assertThat(woodenStep.getItemType(), equalTo(Material.LEGACY_WOOD_STEP), "Constructed with default step type");
|
|
assertThat(woodenStep.getSpecies(), equalTo(species), "Constructed with correct tree species");
|
|
assertThat(woodenStep.isInverted(), equalTo(false), "Constructed with default inversion");
|
|
for (boolean isInverted : inversion) {
|
|
woodenStep = new WoodenStep(species, isInverted);
|
|
assertThat(woodenStep.getItemType(), equalTo(Material.LEGACY_WOOD_STEP), "Constructed with default step type");
|
|
assertThat(woodenStep.getSpecies(), equalTo(species), "Constructed with correct tree species");
|
|
assertThat(woodenStep.isInverted(), equalTo(isInverted), "Constructed with correct inversion");
|
|
}
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void testSapling() {
|
|
Sapling sapling = new Sapling();
|
|
assertThat(sapling.getItemType(), equalTo(Material.LEGACY_SAPLING), "Constructed with default sapling type");
|
|
assertThat(sapling.getSpecies(), equalTo(TreeSpecies.GENERIC), "Constructed with default tree species");
|
|
assertThat(sapling.isInstantGrowable(), equalTo(false), "Constructed with default growable");
|
|
|
|
TreeSpecies[] allSpecies = TreeSpecies.values();
|
|
boolean[] growable = new boolean[]{true, false};
|
|
for (TreeSpecies species : allSpecies) {
|
|
sapling = new Sapling(species);
|
|
assertThat(sapling.getItemType(), equalTo(Material.LEGACY_SAPLING), "Constructed with default sapling type");
|
|
assertThat(sapling.getSpecies(), equalTo(species), "Constructed with correct tree species");
|
|
assertThat(sapling.isInstantGrowable(), equalTo(false), "Constructed with default growable");
|
|
for (boolean isInstantGrowable : growable) {
|
|
sapling = new Sapling(species, isInstantGrowable);
|
|
assertThat(sapling.getItemType(), equalTo(Material.LEGACY_SAPLING), "Constructed with default sapling type");
|
|
assertThat(sapling.getSpecies(), equalTo(species), "Constructed with correct tree species");
|
|
assertThat(sapling.isInstantGrowable(), equalTo(isInstantGrowable), "Constructed with correct growable");
|
|
}
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void testMushroom() {
|
|
Material[] mushroomTypes = new Material[]{Material.LEGACY_HUGE_MUSHROOM_1, Material.LEGACY_HUGE_MUSHROOM_2};
|
|
BlockFace[] setFaces = new BlockFace[]{BlockFace.SELF, BlockFace.UP, BlockFace.NORTH,
|
|
BlockFace.SOUTH, BlockFace.EAST, BlockFace.WEST, BlockFace.NORTH_EAST, BlockFace.NORTH_WEST,
|
|
BlockFace.SOUTH_EAST, BlockFace.SOUTH_WEST};
|
|
MushroomBlockTexture[] textures = MushroomBlockTexture.values();
|
|
for (Material type : mushroomTypes) {
|
|
Mushroom mushroom = new Mushroom(type);
|
|
assertThat(mushroom.getItemType(), equalTo(type), "Constructed with correct mushroom type");
|
|
assertThat(mushroom.getBlockTexture(), equalTo(MushroomBlockTexture.ALL_PORES), "Constructed with default pores face");
|
|
|
|
for (int f = 0; f < setFaces.length; f++) {
|
|
mushroom = new Mushroom(type, setFaces[f]);
|
|
assertThat(mushroom.getItemType(), equalTo(type), "Constructed with correct mushroom type");
|
|
assertThat(mushroom.getBlockTexture(), equalTo(MushroomBlockTexture.getCapByFace(setFaces[f])), "Constructed with correct texture");
|
|
}
|
|
|
|
for (MushroomBlockTexture texture : textures) {
|
|
mushroom = new Mushroom(type, texture);
|
|
assertThat(mushroom.getItemType(), equalTo(type), "Constructed with correct mushroom type");
|
|
assertThat(mushroom.getBlockTexture(), equalTo(texture), "Constructed with correct texture");
|
|
}
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void testCrops() {
|
|
Crops crops = new Crops();
|
|
assertThat(crops.getItemType(), equalTo(Material.LEGACY_CROPS), "Constructed with default crops type");
|
|
assertThat(crops.getState(), equalTo(CropState.SEEDED), "Constructed with default crop state");
|
|
|
|
CropState[] allStates = CropState.values();
|
|
for (CropState state : allStates) {
|
|
crops = new Crops(state);
|
|
assertThat(crops.getItemType(), equalTo(Material.LEGACY_CROPS), "Constructed with default crops type");
|
|
assertThat(crops.getState(), equalTo(state), "Constructed with correct crop state");
|
|
}
|
|
|
|
// The crops which fully implement all crop states
|
|
Material[] allCrops = new Material[]{Material.LEGACY_CROPS, Material.LEGACY_CARROT, Material.LEGACY_POTATO};
|
|
for (Material crop : allCrops) {
|
|
crops = new Crops(crop);
|
|
assertThat(crops.getItemType(), equalTo(crop), "Constructed with correct crops type");
|
|
assertThat(crops.getState(), equalTo(CropState.SEEDED), "Constructed with default crop state");
|
|
|
|
for (CropState state : allStates) {
|
|
crops = new Crops(crop, state);
|
|
assertThat(crops.getItemType(), equalTo(crop), "Constructed with correct crops type");
|
|
assertThat(crops.getState(), equalTo(state), "Constructed with correct crop state");
|
|
}
|
|
}
|
|
|
|
// Beetroot are crops too, but they only have four states
|
|
// Setting different crop states for beetroot will return the following when retrieved back
|
|
CropState[] beetrootStates = new CropState[]{CropState.SEEDED, CropState.SEEDED, CropState.SMALL, CropState.SMALL, CropState.TALL, CropState.TALL, CropState.RIPE, CropState.RIPE};
|
|
assertThat(beetrootStates.length, equalTo(allStates.length), "Beetroot state translations match size");
|
|
crops = new Crops(Material.LEGACY_BEETROOT_BLOCK);
|
|
assertThat(crops.getItemType(), equalTo(Material.LEGACY_BEETROOT_BLOCK), "Constructed with correct crops type");
|
|
assertThat(crops.getState(), equalTo(CropState.SEEDED), "Constructed with default crop state");
|
|
for (int s = 0; s < beetrootStates.length; s++) {
|
|
crops = new Crops(Material.LEGACY_BEETROOT_BLOCK, allStates[s]);
|
|
assertThat(crops.getItemType(), equalTo(Material.LEGACY_BEETROOT_BLOCK), "Constructed with correct crops type");
|
|
assertThat(crops.getState(), equalTo(beetrootStates[s]), "Constructed with correct crop state");
|
|
}
|
|
|
|
// In case you want to treat NetherWarts as Crops, although they really aren't
|
|
crops = new Crops(Material.LEGACY_NETHER_WARTS);
|
|
NetherWarts warts = new NetherWarts();
|
|
assertThat(crops.getItemType(), equalTo(warts.getItemType()), "Constructed with correct crops type");
|
|
assertThat(crops.getState(), equalTo(CropState.SEEDED), "Constructed with default crop state");
|
|
assertThat(warts.getState(), equalTo(NetherWartsState.SEEDED), "Constructed with default wart state");
|
|
allStates = new CropState[]{CropState.SEEDED, CropState.SMALL, CropState.TALL, CropState.RIPE};
|
|
NetherWartsState[] allWartStates = NetherWartsState.values();
|
|
assertThat(allWartStates.length, equalTo(allStates.length), "Nether Warts state translations match size");
|
|
for (int s = 0; s < allStates.length; s++) {
|
|
crops = new Crops(Material.LEGACY_NETHER_WARTS, allStates[s]);
|
|
warts = new NetherWarts(allWartStates[s]);
|
|
assertThat(crops.getItemType(), equalTo(warts.getItemType()), "Constructed with correct crops type");
|
|
assertThat(crops.getState(), equalTo(allStates[s]), "Constructed with correct crop state");
|
|
assertThat(warts.getState(), equalTo(allWartStates[s]), "Constructed with correct wart state");
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void testDiode() {
|
|
Diode diode = new Diode();
|
|
assertThat(diode.getItemType(), equalTo(Material.LEGACY_DIODE_BLOCK_ON), "Constructed with backward compatible diode state");
|
|
assertThat(diode.isPowered(), equalTo(true), "Constructed with backward compatible powered");
|
|
assertThat(diode.getDelay(), equalTo(1), "Constructed with default delay");
|
|
assertThat(diode.getFacing(), equalTo(BlockFace.NORTH), "Constructed with default direction");
|
|
|
|
BlockFace[] directions = new BlockFace[]{BlockFace.NORTH, BlockFace.EAST, BlockFace.SOUTH, BlockFace.WEST};
|
|
int[] delays = new int[]{1, 2, 3, 4};
|
|
boolean[] states = new boolean[]{false, true};
|
|
for (BlockFace direction : directions) {
|
|
diode = new Diode(direction);
|
|
assertThat(diode.getItemType(), equalTo(Material.LEGACY_DIODE_BLOCK_OFF), "Constructed with default diode state");
|
|
assertThat(diode.isPowered(), equalTo(false), "Constructed with default powered");
|
|
assertThat(diode.getDelay(), equalTo(1), "Constructed with default delay");
|
|
assertThat(diode.getFacing(), equalTo(direction), "Constructed with correct direction");
|
|
for (int delay : delays) {
|
|
diode = new Diode(direction, delay);
|
|
assertThat(diode.getItemType(), equalTo(Material.LEGACY_DIODE_BLOCK_OFF), "Constructed with default diode state");
|
|
assertThat(diode.isPowered(), equalTo(false), "Constructed with default powered");
|
|
assertThat(diode.getDelay(), equalTo(delay), "Constructed with correct delay");
|
|
assertThat(diode.getFacing(), equalTo(direction), "Constructed with correct direction");
|
|
for (boolean state : states) {
|
|
diode = new Diode(direction, delay, state);
|
|
assertThat(diode.getItemType(), equalTo(state ? Material.LEGACY_DIODE_BLOCK_ON : Material.LEGACY_DIODE_BLOCK_OFF), "Constructed with correct diode state");
|
|
assertThat(diode.isPowered(), equalTo(state), "Constructed with default powered");
|
|
assertThat(diode.getDelay(), equalTo(delay), "Constructed with correct delay");
|
|
assertThat(diode.getFacing(), equalTo(direction), "Constructed with correct direction");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void testComparator() {
|
|
Comparator comparator = new Comparator();
|
|
assertThat(comparator.getItemType(), equalTo(Material.LEGACY_REDSTONE_COMPARATOR_OFF), "Constructed with default comparator state");
|
|
assertThat(comparator.isPowered(), equalTo(false), "Constructed with default powered");
|
|
assertThat(comparator.isBeingPowered(), equalTo(false), "Constructed with default being powered");
|
|
assertThat(comparator.isSubtractionMode(), equalTo(false), "Constructed with default mode");
|
|
assertThat(comparator.getFacing(), equalTo(BlockFace.NORTH), "Constructed with default direction");
|
|
|
|
BlockFace[] directions = new BlockFace[]{BlockFace.NORTH, BlockFace.EAST, BlockFace.SOUTH, BlockFace.WEST};
|
|
boolean[] modes = new boolean[]{false, true};
|
|
boolean[] states = new boolean[]{false, true};
|
|
for (BlockFace direction : directions) {
|
|
comparator = new Comparator(direction);
|
|
assertThat(comparator.getItemType(), equalTo(Material.LEGACY_REDSTONE_COMPARATOR_OFF), "Constructed with default comparator state");
|
|
assertThat(comparator.isPowered(), equalTo(false), "Constructed with default powered");
|
|
assertThat(comparator.isBeingPowered(), equalTo(false), "Constructed with default being powered");
|
|
assertThat(comparator.isSubtractionMode(), equalTo(false), "Constructed with default mode");
|
|
assertThat(comparator.getFacing(), equalTo(direction), "Constructed with correct direction");
|
|
for (boolean mode : modes) {
|
|
comparator = new Comparator(direction, mode);
|
|
assertThat(comparator.getItemType(), equalTo(Material.LEGACY_REDSTONE_COMPARATOR_OFF), "Constructed with default comparator state");
|
|
assertThat(comparator.isPowered(), equalTo(false), "Constructed with default powered");
|
|
assertThat(comparator.isBeingPowered(), equalTo(false), "Constructed with default being powered");
|
|
assertThat(comparator.isSubtractionMode(), equalTo(mode), "Constructed with correct mode");
|
|
assertThat(comparator.getFacing(), equalTo(direction), "Constructed with correct direction");
|
|
for (boolean state : states) {
|
|
comparator = new Comparator(direction, mode, state);
|
|
assertThat(comparator.getItemType(), equalTo(state ? Material.LEGACY_REDSTONE_COMPARATOR_ON : Material.LEGACY_REDSTONE_COMPARATOR_OFF), "Constructed with correct comparator state");
|
|
assertThat(comparator.isPowered(), equalTo(state), "Constructed with correct powered");
|
|
assertThat(comparator.isBeingPowered(), equalTo(false), "Constructed with default being powered");
|
|
assertThat(comparator.isSubtractionMode(), equalTo(mode), "Constructed with correct mode");
|
|
assertThat(comparator.getFacing(), equalTo(direction), "Constructed with correct direction");
|
|
|
|
// Check if the game sets the fourth bit, that block data is still interpreted correctly
|
|
comparator.setData((byte) ((comparator.getData() & 0x7) | 0x8));
|
|
assertThat(comparator.getItemType(), equalTo(state ? Material.LEGACY_REDSTONE_COMPARATOR_ON : Material.LEGACY_REDSTONE_COMPARATOR_OFF), "Constructed with correct comparator state");
|
|
assertThat(comparator.isPowered(), equalTo(state), "Constructed with correct powered");
|
|
assertThat(comparator.isBeingPowered(), equalTo(true), "Constructed with correct being powered");
|
|
assertThat(comparator.isSubtractionMode(), equalTo(mode), "Constructed with correct mode");
|
|
assertThat(comparator.getFacing(), equalTo(direction), "Constructed with correct direction");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void testHopper() {
|
|
Hopper hopper = new Hopper();
|
|
assertThat(hopper.getItemType(), equalTo(Material.LEGACY_HOPPER), "Constructed with default hopper type");
|
|
assertThat(hopper.isActive(), equalTo(true), "Constructed with default active state");
|
|
assertThat(hopper.isPowered(), equalTo(false), "Constructed with default powered state");
|
|
assertThat(hopper.getFacing(), equalTo(BlockFace.DOWN), "Constructed with default direction");
|
|
|
|
BlockFace[] directions = new BlockFace[]{BlockFace.DOWN, BlockFace.NORTH, BlockFace.SOUTH, BlockFace.WEST, BlockFace.EAST};
|
|
boolean[] activeStates = new boolean[]{true, false};
|
|
for (BlockFace direction : directions) {
|
|
hopper = new Hopper(direction);
|
|
assertThat(hopper.getItemType(), equalTo(Material.LEGACY_HOPPER), "Constructed with default hopper type");
|
|
assertThat(hopper.isActive(), equalTo(true), "Constructed with default active state");
|
|
assertThat(hopper.isPowered(), equalTo(false), "Constructed with correct powered state");
|
|
assertThat(hopper.getFacing(), equalTo(direction), "Constructed with correct direction");
|
|
for (boolean isActive : activeStates) {
|
|
hopper = new Hopper(direction, isActive);
|
|
assertThat(hopper.getItemType(), equalTo(Material.LEGACY_HOPPER), "Constructed with default hopper type");
|
|
assertThat(hopper.isActive(), equalTo(isActive), "Constructed with correct active state");
|
|
assertThat(hopper.isPowered(), equalTo(!isActive), "Constructed with correct powered state");
|
|
assertThat(hopper.getFacing(), equalTo(direction), "Constructed with correct direction");
|
|
}
|
|
}
|
|
}
|
|
}
|