diff --git a/src/functionalTest/java/codechicken/multipart/test/ForgeEnvironmentSmokeTest.java b/src/functionalTest/java/codechicken/multipart/test/ForgeEnvironmentSmokeTest.java index afda930..166a19d 100644 --- a/src/functionalTest/java/codechicken/multipart/test/ForgeEnvironmentSmokeTest.java +++ b/src/functionalTest/java/codechicken/multipart/test/ForgeEnvironmentSmokeTest.java @@ -1,5 +1,6 @@ package codechicken.multipart.test; +import static org.junit.jupiter.api.Assertions.assertArrayEquals; import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertFalse; import static org.junit.jupiter.api.Assertions.assertNotNull; @@ -15,11 +16,13 @@ import java.lang.reflect.Proxy; import java.util.Arrays; import java.util.BitSet; import java.util.Collections; +import java.util.LinkedList; import java.util.Set; import java.util.TreeSet; import net.minecraft.nbt.NBTTagCompound; import net.minecraft.server.MinecraftServer; +import net.minecraftforge.fluids.IFluidHandler; import org.junit.jupiter.api.Test; @@ -38,6 +41,7 @@ import codechicken.multipart.TFacePart; import codechicken.multipart.TMultiPart; import codechicken.multipart.TileMultipart; import codechicken.multipart.asm.MultipartMixinFactory; +import codechicken.multipart.scalatraits.TFluidHandlerTile; import codechicken.multipart.scalatraits.TSlottedTile; import codechicken.multipart.scalatraits.TTileChangeTile; import cpw.mods.fml.common.FMLCommonHandler; @@ -261,6 +265,67 @@ class ForgeEnvironmentSmokeTest { assertEquals(false, trait.getMethod("weakTileChanges").invoke(second), "State is per tile"); } + @Test + void generatesAndCachesFluidHandlerTileClass() throws Exception { + int traitId = MultipartMixinFactory.getId(TFluidHandlerTile.class.getName().replace('.', '/')); + assertFalse(traitId < 0); + + BitSet traits = new BitSet(); + traits.set(traitId); + Object first = MultipartMixinFactory.construct(traits, Nil$.MODULE$); + Object second = MultipartMixinFactory.construct(traits, Nil$.MODULE$); + Class trait = Class.forName("codechicken.multipart.scalatraits.TFluidHandlerTile"); + + assertTrue(first instanceof TileMultipart); + assertTrue(first instanceof IFluidHandler); + assertTrue(trait.isInterface()); + assertArrayEquals(new Class[] { IFluidHandler.class }, trait.getInterfaces()); + assertNotSame(first, second); + assertSame(first.getClass(), second.getClass()); + assertEquals(0, trait.getDeclaredFields().length); + Set signatures = new TreeSet<>(); + for (java.lang.reflect.Method method : trait.getDeclaredMethods()) { + signatures.add(method.getName() + org.objectweb.asm.Type.getMethodDescriptor(method)); + } + String prefix = "codechicken$multipart$scalatraits$TFluidHandlerTile$$super$"; + assertEquals( + new TreeSet<>( + Arrays.asList( + "bindPart(Lcodechicken/multipart/TMultiPart;)V", + "canDrain(Lnet/minecraftforge/common/util/ForgeDirection;" + + "Lnet/minecraftforge/fluids/Fluid;)Z", + "canFill(Lnet/minecraftforge/common/util/ForgeDirection;" + + "Lnet/minecraftforge/fluids/Fluid;)Z", + "clearParts()V", + "copyFrom(Lcodechicken/multipart/TileMultipart;)V", + "drain(Lnet/minecraftforge/common/util/ForgeDirection;IZ)" + + "Lnet/minecraftforge/fluids/FluidStack;", + "drain(Lnet/minecraftforge/common/util/ForgeDirection;" + + "Lnet/minecraftforge/fluids/FluidStack;Z)" + + "Lnet/minecraftforge/fluids/FluidStack;", + "fill(Lnet/minecraftforge/common/util/ForgeDirection;" + + "Lnet/minecraftforge/fluids/FluidStack;Z)I", + "getTankInfo(Lnet/minecraftforge/common/util/ForgeDirection;)" + + "[Lnet/minecraftforge/fluids/FluidTankInfo;", + "partRemoved(Lcodechicken/multipart/TMultiPart;I)V", + "tankList()Ljava/util/LinkedList;", + "tankList_$eq(Ljava/util/LinkedList;)V", + prefix + "bindPart(Lcodechicken/multipart/TMultiPart;)V", + prefix + "clearParts()V", + prefix + "copyFrom(Lcodechicken/multipart/TileMultipart;)V", + prefix + "partRemoved(Lcodechicken/multipart/TMultiPart;I)V")), + signatures); + + assertEquals(LinkedList.class, first.getClass().getDeclaredField("tankList").getType()); + LinkedList firstList = (LinkedList) trait.getMethod("tankList").invoke(first); + LinkedList secondList = (LinkedList) trait.getMethod("tankList").invoke(second); + assertNotSame(firstList, secondList, "State is per tile"); + + LinkedList replacement = new LinkedList<>(); + trait.getMethod("tankList_$eq", LinkedList.class).invoke(first, replacement); + assertSame(replacement, trait.getMethod("tankList").invoke(first)); + } + @Test void generatedJavaTraitOverridesPartialOcclusion() throws Exception { PartialPart existing = new PartialPart(voxel(0)); diff --git a/src/functionalTest/java/codechicken/multipart/test/TFluidHandlerTileFunctionalTest.java b/src/functionalTest/java/codechicken/multipart/test/TFluidHandlerTileFunctionalTest.java new file mode 100644 index 0000000..27a9f2f --- /dev/null +++ b/src/functionalTest/java/codechicken/multipart/test/TFluidHandlerTileFunctionalTest.java @@ -0,0 +1,302 @@ +package codechicken.multipart.test; + +import static org.junit.jupiter.api.Assertions.assertArrayEquals; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNotSame; +import static org.junit.jupiter.api.Assertions.assertSame; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.BitSet; +import java.util.LinkedList; +import java.util.List; + +import net.minecraftforge.common.util.ForgeDirection; +import net.minecraftforge.fluids.Fluid; +import net.minecraftforge.fluids.FluidRegistry; +import net.minecraftforge.fluids.FluidStack; +import net.minecraftforge.fluids.FluidTankInfo; +import net.minecraftforge.fluids.IFluidHandler; + +import org.junit.jupiter.api.Test; + +import codechicken.multipart.TMultiPart; +import codechicken.multipart.TileMultipart; +import codechicken.multipart.asm.MultipartMixinFactory; +import codechicken.multipart.scalatraits.TFluidHandlerTile; +import scala.collection.immutable.Nil$; + +/** Consumer-visible state and behavior of the generated fluid-handler trait. */ +class TFluidHandlerTileFunctionalTest { + + @Test + void copyFromSharesACompatibleTankListAndKeepsItForAPlainSource() throws Exception { + TileMultipart source = newFluidTile(); + TileMultipart target = newFluidTile(); + RecordingFluidPart part = part("source", FluidRegistry.WATER, 0, 0); + source.bindPart(part); + + target.copyFrom(source); + assertSame(tankList(source), tankList(target)); + assertEquals(Arrays.asList(part), tankList(target)); + + LinkedList retained = new LinkedList<>(); + setTankList(target, retained); + target.copyFrom(new TileMultipart()); + assertSame(retained, tankList(target)); + } + + @Test + void bindRemoveAndClearTrackOnlyFluidPartsInOrder() throws Exception { + TileMultipart tile = newFluidTile(); + RecordingFluidPart first = part("first", FluidRegistry.WATER, 0, 0); + RecordingFluidPart second = part("second", FluidRegistry.LAVA, 0, 0); + PlainPart plain = new PlainPart(); + tile.addPart_do(first); + tile.addPart_do(plain); + tile.addPart_do(second); + + assertEquals(Arrays.asList(first, second), tankList(tile)); + tile.partRemoved(first, 0); + assertEquals(Arrays.asList(second), tankList(tile)); + tile.partRemoved(plain, 0); + assertEquals(Arrays.asList(second), tankList(tile)); + + tile.clearParts(); + assertTrue(tankList(tile).isEmpty()); + assertTrue(tile.jPartList().isEmpty()); + } + + @Test + void tankInfoIsFlattenedInPartOrder() { + TileMultipart tile = newFluidTile(); + RecordingFluidPart first = part("first", FluidRegistry.WATER, 0, 0); + RecordingFluidPart second = part("second", FluidRegistry.LAVA, 0, 0); + FluidTankInfo water = info(FluidRegistry.WATER, 100, 1000); + FluidTankInfo lava = info(FluidRegistry.LAVA, 200, 2000); + FluidTankInfo empty = new FluidTankInfo(null, 3000); + first.tankInfo = new FluidTankInfo[] { water, empty }; + second.tankInfo = new FluidTankInfo[] { lava }; + tile.bindPart(first); + tile.bindPart(second); + + assertArrayEquals(new FluidTankInfo[] { water, empty, lava }, fluid(tile).getTankInfo(ForgeDirection.UP)); + assertEquals(2, first.tankInfoCalls); + assertEquals(2, second.tankInfoCalls); + assertEquals(Arrays.asList(ForgeDirection.UP, ForgeDirection.UP), first.tankInfoDirections); + } + + @Test + void fillWalksEveryHandlerWithADecreasingCopy() { + TileMultipart tile = newFluidTile(); + RecordingFluidPart first = part("first", FluidRegistry.WATER, 300, 0); + RecordingFluidPart second = part("second", FluidRegistry.WATER, 500, 0); + RecordingFluidPart third = part("third", FluidRegistry.WATER, 1000, 0); + RecordingFluidPart afterFull = part("after", FluidRegistry.WATER, 100, 0); + tile.bindPart(first); + tile.bindPart(second); + tile.bindPart(third); + tile.bindPart(afterFull); + FluidStack offered = new FluidStack(FluidRegistry.WATER, 1000); + + assertEquals(1000, fluid(tile).fill(ForgeDirection.DOWN, offered, false)); + assertEquals(1000, offered.amount); + assertEquals(Arrays.asList(1000), first.fillAmounts); + assertEquals(Arrays.asList(700), second.fillAmounts); + assertEquals(Arrays.asList(200), third.fillAmounts); + assertEquals(Arrays.asList(0), afterFull.fillAmounts); + assertEquals(Arrays.asList(false), first.fillActions); + assertNotSame(offered, first.fillStacks.get(0)); + assertTrue(offered.isFluidEqual(first.fillStacks.get(0))); + } + + @Test + void fillAndDrainCapabilityChecksStopAtTheFirstMatch() { + TileMultipart tile = newFluidTile(); + RecordingFluidPart first = part("first", FluidRegistry.WATER, 0, 0); + RecordingFluidPart match = part("match", FluidRegistry.WATER, 0, 0); + RecordingFluidPart skipped = part("skipped", FluidRegistry.WATER, 0, 0); + match.canFill = true; + match.canDrain = true; + skipped.canFill = true; + skipped.canDrain = true; + tile.bindPart(first); + tile.bindPart(match); + tile.bindPart(skipped); + + assertTrue(fluid(tile).canFill(ForgeDirection.EAST, FluidRegistry.WATER)); + assertTrue(fluid(tile).canDrain(ForgeDirection.WEST, FluidRegistry.WATER)); + assertEquals(1, first.canFillCalls); + assertEquals(1, match.canFillCalls); + assertEquals(0, skipped.canFillCalls); + assertEquals(1, first.canDrainCalls); + assertEquals(1, match.canDrainCalls); + assertEquals(0, skipped.canDrainCalls); + } + + @Test + void amountDrainSimulatesThenCommitsOnlyMatchingFluid() { + TileMultipart tile = newFluidTile(); + RecordingFluidPart first = part("first", FluidRegistry.WATER, 0, 300); + RecordingFluidPart mismatch = part("mismatch", FluidRegistry.LAVA, 0, 400); + RecordingFluidPart last = part("last", FluidRegistry.WATER, 0, 500); + tile.bindPart(first); + tile.bindPart(mismatch); + tile.bindPart(last); + + FluidStack drained = fluid(tile).drain(ForgeDirection.NORTH, 700, true); + + assertEquals(FluidRegistry.WATER, drained.getFluid()); + assertEquals(700, drained.amount); + assertEquals(Arrays.asList(700, 700), first.amountDrainAmounts); + assertEquals(Arrays.asList(false, true), first.amountDrainActions); + assertEquals(Arrays.asList(400), mismatch.amountDrainAmounts); + assertEquals(Arrays.asList(false), mismatch.amountDrainActions); + assertEquals(Arrays.asList(400, 400), last.amountDrainAmounts); + assertEquals(Arrays.asList(false, true), last.amountDrainActions); + } + + @Test + void stackDrainUsesDecreasingCopiesWithoutCommittingSimulation() { + TileMultipart tile = newFluidTile(); + RecordingFluidPart first = part("first", FluidRegistry.WATER, 0, 200); + RecordingFluidPart mismatch = part("mismatch", FluidRegistry.LAVA, 0, 300); + RecordingFluidPart last = part("last", FluidRegistry.WATER, 0, 400); + tile.bindPart(first); + tile.bindPart(mismatch); + tile.bindPart(last); + FluidStack requested = new FluidStack(FluidRegistry.WATER, 500); + + FluidStack drained = fluid(tile).drain(ForgeDirection.SOUTH, requested, false); + + assertEquals(FluidRegistry.WATER, drained.getFluid()); + assertEquals(500, drained.amount); + assertEquals(500, requested.amount); + assertEquals(Arrays.asList(500), first.stackDrainAmounts); + assertEquals(Arrays.asList(300), mismatch.stackDrainAmounts); + assertEquals(Arrays.asList(300), last.stackDrainAmounts); + assertEquals(Arrays.asList(false), first.stackDrainActions); + assertEquals(Arrays.asList(false), mismatch.stackDrainActions); + assertEquals(Arrays.asList(false), last.stackDrainActions); + assertNotSame(requested, first.stackDrainStacks.get(0)); + assertTrue(requested.isFluidEqual(first.stackDrainStacks.get(0))); + } + + private static TileMultipart newFluidTile() { + int traitId = MultipartMixinFactory.getId(TFluidHandlerTile.class.getName().replace('.', '/')); + BitSet traits = new BitSet(); + traits.set(traitId); + return (TileMultipart) MultipartMixinFactory.construct(traits, Nil$.MODULE$); + } + + private static IFluidHandler fluid(TileMultipart tile) { + return (IFluidHandler) tile; + } + + @SuppressWarnings("unchecked") + private static LinkedList tankList(TileMultipart tile) throws Exception { + return (LinkedList) tile.getClass().getMethod("tankList").invoke(tile); + } + + private static void setTankList(TileMultipart tile, LinkedList list) throws Exception { + tile.getClass().getMethod("tankList_$eq", LinkedList.class).invoke(tile, list); + } + + private static RecordingFluidPart part(String name, Fluid fluid, int fillLimit, int drainLimit) { + return new RecordingFluidPart(name, fluid, fillLimit, drainLimit); + } + + private static FluidTankInfo info(Fluid fluid, int amount, int capacity) { + return new FluidTankInfo(new FluidStack(fluid, amount), capacity); + } + + private static class PlainPart extends TMultiPart { + + @Override + public String getType() { + return "fluid_test:plain"; + } + } + + private static final class RecordingFluidPart extends PlainPart implements IFluidHandler { + + private final String name; + private final Fluid drainedFluid; + private final int fillLimit; + private final int drainLimit; + private final List fillAmounts = new ArrayList<>(); + private final List fillActions = new ArrayList<>(); + private final List fillStacks = new ArrayList<>(); + private final List amountDrainAmounts = new ArrayList<>(); + private final List amountDrainActions = new ArrayList<>(); + private final List stackDrainAmounts = new ArrayList<>(); + private final List stackDrainActions = new ArrayList<>(); + private final List stackDrainStacks = new ArrayList<>(); + private final List tankInfoDirections = new ArrayList<>(); + private FluidTankInfo[] tankInfo = new FluidTankInfo[0]; + private boolean canFill; + private boolean canDrain; + private int tankInfoCalls; + private int canFillCalls; + private int canDrainCalls; + + private RecordingFluidPart(String name, Fluid drainedFluid, int fillLimit, int drainLimit) { + this.name = name; + this.drainedFluid = drainedFluid; + this.fillLimit = fillLimit; + this.drainLimit = drainLimit; + } + + @Override + public String getType() { + return "fluid_test:" + name; + } + + @Override + public int fill(ForgeDirection from, FluidStack resource, boolean doFill) { + fillAmounts.add(resource.amount); + fillActions.add(doFill); + fillStacks.add(resource); + return Math.min(fillLimit, Math.max(0, resource.amount)); + } + + @Override + public FluidStack drain(ForgeDirection from, FluidStack resource, boolean doDrain) { + stackDrainAmounts.add(resource.amount); + stackDrainActions.add(doDrain); + stackDrainStacks.add(resource); + return drained(Math.min(drainLimit, resource.amount)); + } + + @Override + public FluidStack drain(ForgeDirection from, int maxDrain, boolean doDrain) { + amountDrainAmounts.add(maxDrain); + amountDrainActions.add(doDrain); + return drained(Math.min(drainLimit, maxDrain)); + } + + @Override + public boolean canFill(ForgeDirection from, Fluid fluid) { + canFillCalls++; + return canFill; + } + + @Override + public boolean canDrain(ForgeDirection from, Fluid fluid) { + canDrainCalls++; + return canDrain; + } + + @Override + public FluidTankInfo[] getTankInfo(ForgeDirection from) { + tankInfoCalls++; + tankInfoDirections.add(from); + return tankInfo; + } + + private FluidStack drained(int amount) { + return amount > 0 ? new FluidStack(drainedFluid, amount) : null; + } + } +}