mirror of
https://github.com/GTNewHorizons/ForgeMultipart.git
synced 2026-11-22 05:02:32 +00:00
test: characterize fluid handler trait
Freeze ordered tank state and fluid distribution behavior. Pin capability short-circuiting and the exact generated interface. All checks run against the untouched Scala trait.
This commit is contained in:
1 parent
bef35139fb
commit
cad4b1cef0
2 files changed
+367
No files matched your search
@@ -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<String> 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<IFluidHandler> 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));
|
||||
|
||||
+302
@@ -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<IFluidHandler> 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<IFluidHandler> tankList(TileMultipart tile) throws Exception {
|
||||
return (LinkedList<IFluidHandler>) tile.getClass().getMethod("tankList").invoke(tile);
|
||||
}
|
||||
|
||||
private static void setTankList(TileMultipart tile, LinkedList<IFluidHandler> 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<Integer> fillAmounts = new ArrayList<>();
|
||||
private final List<Boolean> fillActions = new ArrayList<>();
|
||||
private final List<FluidStack> fillStacks = new ArrayList<>();
|
||||
private final List<Integer> amountDrainAmounts = new ArrayList<>();
|
||||
private final List<Boolean> amountDrainActions = new ArrayList<>();
|
||||
private final List<Integer> stackDrainAmounts = new ArrayList<>();
|
||||
private final List<Boolean> stackDrainActions = new ArrayList<>();
|
||||
private final List<FluidStack> stackDrainStacks = new ArrayList<>();
|
||||
private final List<ForgeDirection> 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;
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user