From 48cbb7ff3e0a5516efd0153885f33d59f595301a Mon Sep 17 00:00:00 2001 From: Algent Date: Sun, 30 Aug 2026 13:50:31 +0200 Subject: [PATCH] test: characterize inventory tile trait Pin flattened slot routing, sided access, AE2-style rebuild calls, and the generated TIInventoryTile/JInventoryTile interfaces before the Java port. --- .../test/ForgeEnvironmentSmokeTest.java | 139 +++++++ .../test/TIInventoryTileFunctionalTest.java | 342 ++++++++++++++++++ 2 files changed, 481 insertions(+) create mode 100644 src/functionalTest/java/codechicken/multipart/test/TIInventoryTileFunctionalTest.java diff --git a/src/functionalTest/java/codechicken/multipart/test/ForgeEnvironmentSmokeTest.java b/src/functionalTest/java/codechicken/multipart/test/ForgeEnvironmentSmokeTest.java index 166a19d..297e32b 100644 --- a/src/functionalTest/java/codechicken/multipart/test/ForgeEnvironmentSmokeTest.java +++ b/src/functionalTest/java/codechicken/multipart/test/ForgeEnvironmentSmokeTest.java @@ -12,6 +12,7 @@ import java.io.ByteArrayInputStream; import java.io.ByteArrayOutputStream; import java.io.DataInputStream; import java.io.DataOutputStream; +import java.lang.reflect.Modifier; import java.lang.reflect.Proxy; import java.util.Arrays; import java.util.BitSet; @@ -20,6 +21,8 @@ import java.util.LinkedList; import java.util.Set; import java.util.TreeSet; +import net.minecraft.inventory.IInventory; +import net.minecraft.inventory.ISidedInventory; import net.minecraft.nbt.NBTTagCompound; import net.minecraft.server.MinecraftServer; import net.minecraftforge.fluids.IFluidHandler; @@ -41,7 +44,9 @@ import codechicken.multipart.TFacePart; import codechicken.multipart.TMultiPart; import codechicken.multipart.TileMultipart; import codechicken.multipart.asm.MultipartMixinFactory; +import codechicken.multipart.scalatraits.JInventoryTile; import codechicken.multipart.scalatraits.TFluidHandlerTile; +import codechicken.multipart.scalatraits.TIInventoryTile; import codechicken.multipart.scalatraits.TSlottedTile; import codechicken.multipart.scalatraits.TTileChangeTile; import cpw.mods.fml.common.FMLCommonHandler; @@ -326,6 +331,140 @@ class ForgeEnvironmentSmokeTest { assertSame(replacement, trait.getMethod("tankList").invoke(first)); } + @Test + void generatesAndCachesInventoryTileClassWithBothPublicTraitInterfaces() throws Exception { + int traitId = MultipartMixinFactory.getId(JInventoryTile.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 inventoryTrait = Class.forName("codechicken.multipart.scalatraits.TIInventoryTile"); + Class javaTrait = Class.forName("codechicken.multipart.scalatraits.JInventoryTile"); + + assertTrue(first instanceof TileMultipart); + assertTrue(first instanceof TIInventoryTile); + assertTrue(first instanceof ISidedInventory); + assertTrue(javaTrait.isInstance(first)); + assertTrue(inventoryTrait.isInterface()); + assertTrue(javaTrait.isInterface()); + assertArrayEquals(new Class[] { ISidedInventory.class }, inventoryTrait.getInterfaces()); + assertArrayEquals(new Class[] { TIInventoryTile.class }, javaTrait.getInterfaces()); + assertNotSame(first, second); + assertSame(first.getClass(), second.getClass()); + assertEquals(0, inventoryTrait.getDeclaredFields().length); + assertEquals(0, javaTrait.getDeclaredFields().length); + + Set inventorySignatures = new TreeSet<>(); + for (java.lang.reflect.Method method : inventoryTrait.getDeclaredMethods()) { + inventorySignatures.add(method.getName() + org.objectweb.asm.Type.getMethodDescriptor(method)); + } + String inventoryPrefix = "codechicken$multipart$scalatraits$TIInventoryTile$$super$"; + assertEquals( + new TreeSet<>( + Arrays.asList( + "bindPart(Lcodechicken/multipart/TMultiPart;)V", + "canExtractItem(ILnet/minecraft/item/ItemStack;I)Z", + "canInsertItem(ILnet/minecraft/item/ItemStack;I)Z", + "clearParts()V", + "closeInventory()V", + "copyFrom(Lcodechicken/multipart/TileMultipart;)V", + "decrStackSize(II)Lnet/minecraft/item/ItemStack;", + "getAccessibleSlotsFromSide(I)[I", + "getInventoryName()Ljava/lang/String;", + "getInventoryStackLimit()I", + "getSizeInventory()I", + "getStackInSlot(I)Lnet/minecraft/item/ItemStack;", + "getStackInSlotOnClosing(I)Lnet/minecraft/item/ItemStack;", + "hasCustomInventoryName()Z", + "invList()Ljava/util/LinkedList;", + "invList_$eq(Ljava/util/LinkedList;)V", + "isItemValidForSlot(ILnet/minecraft/item/ItemStack;)Z", + "isUseableByPlayer(Lnet/minecraft/entity/player/EntityPlayer;)Z", + "openInventory()V", + "partRemoved(Lcodechicken/multipart/TMultiPart;I)V", + "rebuildSlotMap()V", + "setInventorySlotContents(ILnet/minecraft/item/ItemStack;)V", + "slotMap()[Lscala/Tuple2;", + "slotMap_$eq([Lscala/Tuple2;)V", + inventoryPrefix + "bindPart(Lcodechicken/multipart/TMultiPart;)V", + inventoryPrefix + "clearParts()V", + inventoryPrefix + "copyFrom(Lcodechicken/multipart/TileMultipart;)V", + inventoryPrefix + "partRemoved(Lcodechicken/multipart/TMultiPart;I)V")), + inventorySignatures); + + Set javaSignatures = new TreeSet<>(); + for (java.lang.reflect.Method method : javaTrait.getDeclaredMethods()) { + javaSignatures.add(method.getName() + org.objectweb.asm.Type.getMethodDescriptor(method)); + } + String javaPrefix = "codechicken$multipart$scalatraits$JInventoryTile$$"; + assertEquals( + new TreeSet<>( + Arrays.asList( + "bindPart(Lcodechicken/multipart/TMultiPart;)V", + "canExtractItem(ILnet/minecraft/item/ItemStack;I)Z", + "canInsertItem(ILnet/minecraft/item/ItemStack;I)Z", + "clearParts()V", + "closeInventory()V", + "copyFrom(Lcodechicken/multipart/TileMultipart;)V", + "decrStackSize(II)Lnet/minecraft/item/ItemStack;", + "getAccessibleSlotsFromSide(I)[I", + "getInventoryName()Ljava/lang/String;", + "getInventoryStackLimit()I", + "getSizeInventory()I", + "getStackInSlot(I)Lnet/minecraft/item/ItemStack;", + "getStackInSlotOnClosing(I)Lnet/minecraft/item/ItemStack;", + "hasCustomInventoryName()Z", + "invList()Ljava/util/LinkedList;", + "invList_$eq(Ljava/util/LinkedList;)V", + "isItemValidForSlot(ILnet/minecraft/item/ItemStack;)Z", + "isUseableByPlayer(Lnet/minecraft/entity/player/EntityPlayer;)Z", + "openInventory()V", + "partRemoved(Lcodechicken/multipart/TMultiPart;I)V", + "rebuildSlotMap()V", + "setInventorySlotContents(ILnet/minecraft/item/ItemStack;)V", + "slotMap()[Lscala/Tuple2;", + "slotMap_$eq([Lscala/Tuple2;)V", + javaPrefix + "invList()Ljava/util/LinkedList;", + javaPrefix + "invList_$eq(Ljava/util/LinkedList;)V", + javaPrefix + "slotMap()[Lscala/Tuple2;", + javaPrefix + "slotMap_$eq([Lscala/Tuple2;)V", + inventoryPrefix + "bindPart(Lcodechicken/multipart/TMultiPart;)V", + inventoryPrefix + "clearParts()V", + inventoryPrefix + "copyFrom(Lcodechicken/multipart/TileMultipart;)V", + inventoryPrefix + "partRemoved(Lcodechicken/multipart/TMultiPart;I)V", + javaPrefix + "super$bindPart(Lcodechicken/multipart/TMultiPart;)V", + javaPrefix + "super$clearParts()V", + javaPrefix + "super$copyFrom(Lcodechicken/multipart/TileMultipart;)V", + javaPrefix + "super$partRemoved(Lcodechicken/multipart/TMultiPart;I)V")), + javaSignatures); + + String fieldPrefix = "codechicken$multipart$scalatraits$JInventoryTile$$"; + java.lang.reflect.Field listField = first.getClass().getDeclaredField(fieldPrefix + "invList"); + java.lang.reflect.Field mapField = first.getClass().getDeclaredField(fieldPrefix + "slotMap"); + assertEquals(LinkedList.class, listField.getType()); + assertEquals(scala.Tuple2[].class, mapField.getType()); + assertTrue(Modifier.isPrivate(listField.getModifiers())); + assertTrue(Modifier.isPrivate(mapField.getModifiers())); + + LinkedList firstList = (LinkedList) javaTrait.getMethod("invList").invoke(first); + LinkedList secondList = (LinkedList) javaTrait.getMethod("invList").invoke(second); + Object[] firstMap = (Object[]) javaTrait.getMethod("slotMap").invoke(first); + Object[] secondMap = (Object[]) javaTrait.getMethod("slotMap").invoke(second); + assertTrue(firstList.isEmpty()); + assertEquals(0, firstMap.length); + assertNotSame(firstList, secondList, "Each generated tile must initialize its inventory list"); + assertNotSame(firstMap, secondMap, "Each generated tile must initialize its slot map"); + + LinkedList replacementList = new LinkedList<>(); + scala.Tuple2[] replacementMap = new scala.Tuple2[0]; + javaTrait.getMethod("invList_$eq", LinkedList.class).invoke(first, replacementList); + javaTrait.getMethod("slotMap_$eq", scala.Tuple2[].class).invoke(first, (Object) replacementMap); + assertSame(replacementList, javaTrait.getMethod("invList").invoke(first)); + assertSame(replacementMap, javaTrait.getMethod("slotMap").invoke(first)); + } + @Test void generatedJavaTraitOverridesPartialOcclusion() throws Exception { PartialPart existing = new PartialPart(voxel(0)); diff --git a/src/functionalTest/java/codechicken/multipart/test/TIInventoryTileFunctionalTest.java b/src/functionalTest/java/codechicken/multipart/test/TIInventoryTileFunctionalTest.java new file mode 100644 index 0000000..5e6ec52 --- /dev/null +++ b/src/functionalTest/java/codechicken/multipart/test/TIInventoryTileFunctionalTest.java @@ -0,0 +1,342 @@ +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.assertNotSame; +import static org.junit.jupiter.api.Assertions.assertSame; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import java.util.Arrays; +import java.util.BitSet; +import java.util.LinkedList; + +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.init.Items; +import net.minecraft.inventory.IInventory; +import net.minecraft.inventory.ISidedInventory; +import net.minecraft.item.ItemStack; + +import org.junit.jupiter.api.Test; + +import codechicken.multipart.TMultiPart; +import codechicken.multipart.TileMultipart; +import codechicken.multipart.asm.MultipartMixinFactory; +import codechicken.multipart.scalatraits.JInventoryTile; +import codechicken.multipart.scalatraits.TIInventoryTile; +import scala.Tuple2; +import scala.collection.immutable.Nil$; + +/** Consumer-visible state and behavior of the generated inventory trait. */ +class TIInventoryTileFunctionalTest { + + @Test + void copyFromSharesACompatibleInventoryListAndRebuildsTheSlotMap() { + TileMultipart source = newInventoryTile(); + TileMultipart target = newInventoryTile(); + InventoryPart part = new InventoryPart("source", 2); + source.bindPart(part); + + TIInventoryTile sourceInventory = inventory(source); + TIInventoryTile targetInventory = inventory(target); + Tuple2[] sourceMap = sourceInventory.slotMap(); + target.copyFrom(source); + + assertSame(sourceInventory.invList(), targetInventory.invList()); + assertNotSame(sourceMap, targetInventory.slotMap()); + assertEquals(2, targetInventory.getSizeInventory()); + + LinkedList retainedList = targetInventory.invList(); + Tuple2[] retainedMap = targetInventory.slotMap(); + target.copyFrom(new TileMultipart()); + assertSame(retainedList, targetInventory.invList()); + assertSame(retainedMap, targetInventory.slotMap()); + } + + @Test + void bindRemoveAndClearTrackOnlyInventoriesInOrder() { + TileMultipart tile = newInventoryTile(); + InventoryPart first = new InventoryPart("first", 1); + InventoryPart second = new InventoryPart("second", 2); + PlainPart plain = new PlainPart(); + tile.addPart_do(first); + tile.addPart_do(plain); + tile.addPart_do(second); + + TIInventoryTile inventory = inventory(tile); + assertEquals(Arrays.asList(first, second), inventory.invList()); + assertEquals(3, inventory.getSizeInventory()); + + tile.partRemoved(first, 0); + assertEquals(Arrays.asList(second), inventory.invList()); + assertEquals(2, inventory.getSizeInventory()); + tile.partRemoved(plain, 0); + assertEquals(Arrays.asList(second), inventory.invList()); + + tile.clearParts(); + assertTrue(inventory.invList().isEmpty()); + assertEquals(0, inventory.slotMap().length); + assertTrue(tile.jPartList().isEmpty()); + } + + @Test + void flattenedSlotsRouteInventoryOperationsToLocalSlots() { + TileMultipart tile = newInventoryTile(); + InventoryPart first = new InventoryPart("first", 1); + InventoryPart second = new InventoryPart("second", 2); + ItemStack apple = new ItemStack(Items.apple); + ItemStack stick = new ItemStack(Items.stick); + ItemStack decremented = new ItemStack(Items.coal, 4); + ItemStack closing = new ItemStack(Items.bowl); + first.stacks[0] = apple; + second.stacks[1] = stick; + second.decrementResult = decremented; + second.closingResult = closing; + second.valid = false; + tile.bindPart(first); + tile.bindPart(second); + + TIInventoryTile inventory = inventory(tile); + assertEquals(3, inventory.getSizeInventory()); + assertSame(apple, inventory.getStackInSlot(0)); + assertSame(stick, inventory.getStackInSlot(2)); + assertSame(decremented, inventory.decrStackSize(1, 4)); + assertEquals(0, second.lastDecrementSlot); + assertEquals(4, second.lastDecrementAmount); + assertSame(closing, inventory.getStackInSlotOnClosing(2)); + assertEquals(1, second.lastClosingSlot); + + ItemStack replacement = new ItemStack(Items.diamond); + inventory.setInventorySlotContents(1, replacement); + assertSame(replacement, second.stacks[0]); + assertFalse(inventory.isItemValidForSlot(2, replacement)); + assertEquals(1, second.lastValiditySlot); + assertSame(replacement, second.lastValidityStack); + } + + @Test + void directTraitCallRebuildsTheMapAfterInventorySizeChanges() { + TileMultipart tile = newInventoryTile(); + InventoryPart part = new InventoryPart("resizable", 1); + tile.bindPart(part); + TIInventoryTile api = (TIInventoryTile) tile; + assertEquals(1, api.getSizeInventory()); + + part.resize(3); + api.rebuildSlotMap(); + + assertEquals(3, api.getSizeInventory()); + assertSame(part, api.slotMap()[2]._1()); + assertEquals(2, ((Number) api.slotMap()[2]._2()).intValue()); + } + + @Test + void tileInventoryMetadataAndLifecycleRemainFixed() { + TileMultipart tile = newInventoryTile(); + InventoryPart part = new InventoryPart("metadata", 1); + tile.bindPart(part); + TIInventoryTile inventory = inventory(tile); + + assertEquals("Multipart Inventory", inventory.getInventoryName()); + assertFalse(inventory.hasCustomInventoryName()); + assertEquals(64, inventory.getInventoryStackLimit()); + assertTrue(inventory.isUseableByPlayer(null)); + inventory.openInventory(); + inventory.closeInventory(); + assertEquals(0, part.openCalls); + assertEquals(0, part.closeCalls); + } + + @Test + void accessibleSlotsIncludeOnlySidedInventoriesWithGlobalOffsets() { + TileMultipart tile = newInventoryTile(); + InventoryPart plainFirst = new InventoryPart("plain_first", 2); + SidedInventoryPart sidedFirst = new SidedInventoryPart("sided_first", 1, new int[] { 0 }); + InventoryPart plainSecond = new InventoryPart("plain_second", 1); + SidedInventoryPart sidedSecond = new SidedInventoryPart("sided_second", 3, new int[] { 2, 0 }); + tile.bindPart(plainFirst); + tile.bindPart(sidedFirst); + tile.bindPart(plainSecond); + tile.bindPart(sidedSecond); + + assertArrayEquals(new int[] { 2, 6, 4 }, inventory(tile).getAccessibleSlotsFromSide(5)); + assertEquals(5, sidedFirst.lastAccessibleSide); + assertEquals(5, sidedSecond.lastAccessibleSide); + } + + @Test + void sidedInsertAndExtractChecksReceiveLocalSlotsWhilePlainInventoriesAllowBoth() { + TileMultipart tile = newInventoryTile(); + InventoryPart plain = new InventoryPart("plain", 2); + SidedInventoryPart sided = new SidedInventoryPart("sided", 2, new int[0]); + sided.insertResult = false; + sided.extractResult = true; + tile.bindPart(plain); + tile.bindPart(sided); + TIInventoryTile inventory = inventory(tile); + ItemStack stack = new ItemStack(Items.apple); + + assertTrue(inventory.canInsertItem(1, stack, 3)); + assertTrue(inventory.canExtractItem(0, stack, 4)); + assertFalse(inventory.canInsertItem(3, stack, 5)); + assertTrue(inventory.canExtractItem(2, stack, 1)); + assertEquals(1, sided.lastInsertSlot); + assertEquals(5, sided.lastInsertSide); + assertEquals(0, sided.lastExtractSlot); + assertEquals(1, sided.lastExtractSide); + } + + private static TileMultipart newInventoryTile() { + int traitId = MultipartMixinFactory.getId(JInventoryTile.class.getName().replace('.', '/')); + BitSet traits = new BitSet(); + traits.set(traitId); + return (TileMultipart) MultipartMixinFactory.construct(traits, Nil$.MODULE$); + } + + private static TIInventoryTile inventory(TileMultipart tile) { + return (TIInventoryTile) tile; + } + + private static class PlainPart extends TMultiPart { + + @Override + public String getType() { + return "inventory_test:plain"; + } + } + + private static class InventoryPart extends PlainPart implements IInventory { + + private final String name; + private ItemStack[] stacks; + private ItemStack decrementResult; + private ItemStack closingResult; + private boolean valid = true; + private int lastDecrementSlot = -1; + private int lastDecrementAmount = -1; + private int lastClosingSlot = -1; + private int lastValiditySlot = -1; + private ItemStack lastValidityStack; + private int openCalls; + private int closeCalls; + + private InventoryPart(String name, int size) { + this.name = name; + stacks = new ItemStack[size]; + } + + @Override + public String getType() { + return "inventory_test:" + name; + } + + @Override + public int getSizeInventory() { + return stacks.length; + } + + @Override + public ItemStack getStackInSlot(int slot) { + return stacks[slot]; + } + + @Override + public ItemStack decrStackSize(int slot, int amount) { + lastDecrementSlot = slot; + lastDecrementAmount = amount; + return decrementResult; + } + + @Override + public ItemStack getStackInSlotOnClosing(int slot) { + lastClosingSlot = slot; + return closingResult; + } + + @Override + public void setInventorySlotContents(int slot, ItemStack stack) { + stacks[slot] = stack; + } + + @Override + public String getInventoryName() { + return name; + } + + @Override + public boolean hasCustomInventoryName() { + return true; + } + + @Override + public int getInventoryStackLimit() { + return 1; + } + + @Override + public void markDirty() {} + + @Override + public boolean isUseableByPlayer(EntityPlayer player) { + return false; + } + + @Override + public void openInventory() { + openCalls++; + } + + @Override + public void closeInventory() { + closeCalls++; + } + + @Override + public boolean isItemValidForSlot(int slot, ItemStack stack) { + lastValiditySlot = slot; + lastValidityStack = stack; + return valid; + } + + private void resize(int size) { + stacks = Arrays.copyOf(stacks, size); + } + } + + private static final class SidedInventoryPart extends InventoryPart implements ISidedInventory { + + private final int[] accessibleSlots; + private boolean insertResult; + private boolean extractResult; + private int lastAccessibleSide = -1; + private int lastInsertSlot = -1; + private int lastInsertSide = -1; + private int lastExtractSlot = -1; + private int lastExtractSide = -1; + + private SidedInventoryPart(String name, int size, int[] accessibleSlots) { + super(name, size); + this.accessibleSlots = accessibleSlots; + } + + @Override + public int[] getAccessibleSlotsFromSide(int side) { + lastAccessibleSide = side; + return accessibleSlots; + } + + @Override + public boolean canInsertItem(int slot, ItemStack stack, int side) { + lastInsertSlot = slot; + lastInsertSide = side; + return insertResult; + } + + @Override + public boolean canExtractItem(int slot, ItemStack stack, int side) { + lastExtractSlot = slot; + lastExtractSide = side; + return extractResult; + } + } +}