feat: improve recipe test system

set default tick time to 1
test all 'ingredients' separately

Author: marcus8448

build.gradle.kts

@@ -46,10 +46,10 @@ val isCI = System.getenv().getOrDefault("CI", "false") == "true";
 plugins {
     java
     `maven-publish`
-    id("fabric-loom") version("1.5-SNAPSHOT")
+    id("fabric-loom") version("1.6-SNAPSHOT")
     id("org.cadixdev.licenser") version("0.6.1")
     id("org.ajoberstar.grgit") version("5.2.1")
-    id("dev.galacticraft.mojarn") version("0.1.1")
+    id("dev.galacticraft.mojarn") version("0.1.2")
 }
 
 group = "dev.galacticraft"

gradle/wrapper/gradle-wrapper.jar

@@ -1,7 +1,7 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionSha256Sum=9631d53cf3e74bfa726893aee1f8994fee4e060c401335946dba2156f440f24c
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.6-bin.zip
+distributionSha256Sum=544c35d6bd849ae8a5ed0bcea39ba677dc40f49df7d1835561582da2009b961d
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.7-bin.zip
 networkTimeout=10000
 validateDistributionUrl=true
 zipStoreBase=GRADLE_USER_HOME

gradle/wrapper/gradle-wrapper.properties

@@ -26,12 +26,16 @@
 import dev.galacticraft.machinelib.api.gametest.annotation.BasicTest;
 import dev.galacticraft.machinelib.api.gametest.annotation.MachineTest;
 import dev.galacticraft.machinelib.api.machine.MachineType;
+import dev.galacticraft.machinelib.impl.gametest.GameTestUtils;
+import net.fabricmc.fabric.api.transfer.v1.fluid.FluidConstants;
 import net.minecraft.core.BlockPos;
 import net.minecraft.gametest.framework.GameTestAssertException;
 import net.minecraft.gametest.framework.GameTestGenerator;
 import net.minecraft.gametest.framework.GameTestHelper;
 import net.minecraft.gametest.framework.TestFunction;
 import net.minecraft.world.item.Item;
+import net.minecraft.world.item.Items;
+import net.minecraft.world.level.material.Fluid;
 import org.jetbrains.annotations.MustBeInvokedByOverriders;
 import org.jetbrains.annotations.NotNull;
 
@@ -72,12 +76,20 @@ protected MachineGameTest(MachineType<Machine, ?> type) {
                 tests.add(this.createTest(machineTest.batch(), machineTest.group(), method.getName(), machineTest.structure(), machineTest.workTime(), machineTest.setupTime(), helper -> {
                     Machine machine = this.createMachine(helper);
 
-                    Runnable runnable = this.invokeTestMethod(method, machine, helper);
-                    if (runnable != null) {
-                        helper.runAfterDelay(machineTest.workTime(), () -> {
-                            runnable.run();
-                            helper.succeed();
-                        });
+                    try {
+                        Runnable runnable = GameTestUtils.invokeUnorderedArguments(this, method, machine, helper, new MachineTestContext(MACHINE_POS, helper));
+                        if (runnable != null) {
+                            helper.runAfterDelay(machineTest.workTime(), () -> {
+                                try {
+                                    runnable.run();
+                                    helper.succeed();
+                                } catch (AssertionError e) {
+                                    GameTestUtils.unwrapAssertions(helper, MACHINE_POS, e, machineTest.captureAssertions());
+                                }
+                            });
+                        }
+                    } catch (AssertionError e) {
+                        GameTestUtils.unwrapAssertions(helper, MACHINE_POS, e, machineTest.captureAssertions());
                     }
                 }));
             }
@@ -86,10 +98,10 @@ protected MachineGameTest(MachineType<Machine, ?> type) {
         return tests;
     }
 
-    public TestFunction createChargeFromEnergyItemTest(int slot, Item infiniteBattery) {
+    public TestFunction createChargeFromEnergyItemTest(int slot, Item energyProvider) {
         return this.createTest("chargeFromItem", STRUCTURE_3x3, 2, 1, helper -> {
             Machine machine = this.createMachine(helper);
-            machine.itemStorage().getSlot(slot).set(infiniteBattery, 1);
+            machine.itemStorage().getSlot(slot).set(energyProvider, 1);
             helper.runAfterDelay(1, () -> {
                 if (machine.energyStorage().isEmpty()) {
                     helper.fail("Machine did not charge from the stack!", machine.getBlockPos());
@@ -100,12 +112,12 @@ public TestFunction createChargeFromEnergyItemTest(int slot, Item infiniteBatter
         });
     }
 
-    public TestFunction createDrainToEnergyItemTest(int slot, Item battery) {
+    public TestFunction createDrainToEnergyItemTest(int slot, Item energyConsumer) {
         return this.createTest("drainToItem", STRUCTURE_3x3, 2, 1, helper -> {
             Machine machine = this.createMachine(helper);
 
             machine.energyStorage().setEnergy(machine.energyStorage().getCapacity());
-            machine.itemStorage().getSlot(slot).set(battery, 1);
+            machine.itemStorage().getSlot(slot).set(energyConsumer, 1);
 
             helper.runAfterDelay(1, () -> {
                 if (machine.energyStorage().isFull()) {
@@ -117,6 +129,37 @@ public TestFunction createDrainToEnergyItemTest(int slot, Item battery) {
         });
     }
 
+    public TestFunction createTakeFromFluidItemTest(int slot, Item fluidProvider, int tank) {
+        return this.createTest("takeFluidFromItem", STRUCTURE_3x3, 2, 1, helper -> {
+            Machine machine = this.createMachine(helper);
+            machine.itemStorage().getSlot(slot).set(fluidProvider, 1);
+            helper.runAfterDelay(1, () -> {
+                if (machine.fluidStorage().getSlot(tank).isEmpty()) {
+                    helper.fail("Machine did not take fluid from the stack!", machine.getBlockPos());
+                } else {
+                    helper.succeed();
+                }
+            });
+        });
+    }
+
+    public TestFunction createDrainFluidIntoItemTest(int slot, Fluid fluid, int tank) {
+        return this.createTest("drainFluidIntoItem", STRUCTURE_3x3, 2, 1, helper -> {
+            Machine machine = this.createMachine(helper);
+
+            machine.fluidStorage().getSlot(tank).set(fluid, FluidConstants.BUCKET);
+            machine.itemStorage().getSlot(slot).set(Items.BUCKET, 1);
+
+            helper.runAfterDelay(1, () -> {
+                if (machine.energyStorage().isFull()) {
+                    helper.fail("Machine did not drain fluid into the stack!", BlockPos.ZERO);
+                } else {
+                    helper.succeed();
+                }
+            });
+        });
+    }
+
     protected Machine createMachine(GameTestHelper helper) {
         helper.setBlock(MACHINE_POS, this.type.getBlock());
         return (Machine) helper.getBlockEntity(MACHINE_POS);

src/main/java/dev/galacticraft/machinelib/api/gametest/MachineGameTest.java

@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) 2021-2024 Team Galacticraft
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+package dev.galacticraft.machinelib.api.gametest;
+
+import net.minecraft.core.BlockPos;
+import net.minecraft.gametest.framework.GameTestAssertPosException;
+import net.minecraft.gametest.framework.GameTestHelper;
+
+import java.text.MessageFormat;
+import java.util.ArrayList;
+import java.util.List;
+
+public class MachineTestContext {
+    private final BlockPos pos;
+    private final GameTestHelper helper;
+    private final List<String> logs = new ArrayList<>();
+
+    public MachineTestContext(BlockPos pos, GameTestHelper helper) {
+        this.pos = pos;
+        this.helper = helper;
+    }
+
+    public GameTestHelper helper() {
+        return this.helper;
+    }
+
+    public void log(String message) {
+        this.logs.add(message);
+    }
+
+    public void assertTrue(boolean b, String message) {
+        if (!b) {
+            throw this.fail(message);
+        }
+    }
+
+    public GameTestAssertPosException fail(String message, Object... objects) {
+        return new GameTestAssertPosException(new MessageFormat(message).format(objects), this.helper.absolutePos(this.pos), this.pos, this.helper.getTick());
+    }
+
+    public GameTestAssertPosException fail(String message) {
+        return new GameTestAssertPosException(message, this.helper.absolutePos(this.pos), this.pos, this.helper.getTick());
+    }
+}

src/main/java/dev/galacticraft/machinelib/api/gametest/MachineTestContext.java

@@ -24,10 +24,12 @@
 
 import dev.galacticraft.machinelib.api.block.entity.RecipeMachineBlockEntity;
 import dev.galacticraft.machinelib.api.gametest.annotation.MachineTest;
+import dev.galacticraft.machinelib.api.gametest.recipe.IngredientSupplier;
 import dev.galacticraft.machinelib.api.machine.MachineType;
 import dev.galacticraft.machinelib.api.storage.MachineItemStorage;
 import net.minecraft.gametest.framework.GameTestAssertException;
 import net.minecraft.gametest.framework.GameTestGenerator;
+import net.minecraft.gametest.framework.GameTestHelper;
 import net.minecraft.gametest.framework.TestFunction;
 import net.minecraft.world.Container;
 import net.minecraft.world.item.Items;
@@ -47,112 +49,96 @@
  * @see RecipeMachineBlockEntity
  */
 public abstract class RecipeGameTest<C extends Container, R extends Recipe<C>, Machine extends RecipeMachineBlockEntity<C, R>> extends MachineGameTest<Machine> {
-    private final int inputSlotsStart;
-    private final int inputSlotsLength;
     private final int outputSlotsStart;
     private final int outputSlotsLength;
+    protected final int recipeRuntime;
 
-    protected RecipeGameTest(@NotNull MachineType<Machine, ?> type, int inputSlot, int outputSlot) {
-        this(type, inputSlot, 1, outputSlot);
+    private final List<IngredientSupplier<C, R, Machine>> conditions;
+
+    protected RecipeGameTest(@NotNull MachineType<Machine, ?> type, List<IngredientSupplier<C, R, Machine>> conditions, int recipeRuntime) {
+        this(type, conditions, -1, 0, recipeRuntime);
     }
 
-    protected RecipeGameTest(@NotNull MachineType<Machine, ?> type, int inputSlotsStart, int inputSlotsLength, int outputSlot) {
-        this(type, inputSlotsStart, inputSlotsLength, outputSlot, 1);
+    protected RecipeGameTest(@NotNull MachineType<Machine, ?> type, List<IngredientSupplier<C, R, Machine>> conditions, int outputSlot, int recipeRuntime) {
+        this(type, conditions, outputSlot, 1, recipeRuntime);
     }
 
-    protected RecipeGameTest(@NotNull MachineType<Machine, ?> type, int inputSlotsStart, int inputSlotsLength, int outputSlotsStart, int outputSlotsLength) {
+    protected RecipeGameTest(@NotNull MachineType<Machine, ?> type, List<IngredientSupplier<C, R, Machine>> conditions, int outputSlotsStart, int outputSlotsLength, int recipeRuntime) {
         super(type);
 
-        this.inputSlotsStart = inputSlotsStart;
-        this.inputSlotsLength = inputSlotsLength;
         this.outputSlotsStart = outputSlotsStart;
         this.outputSlotsLength = outputSlotsLength;
+        this.recipeRuntime = recipeRuntime;
+        this.conditions = conditions;
     }
 
-    protected abstract void fulfillRunRequirements(@NotNull Machine machine);
-    protected abstract int getRecipeRuntime();
-    protected abstract void createValidRecipe(@NotNull MachineItemStorage storage);
-
     protected boolean anyRecipeCrafted(@NotNull MachineItemStorage storage) {
         return !storage.isEmpty(this.outputSlotsStart, this.outputSlotsLength);
     }
 
-    protected void createInvalidRecipe(@NotNull MachineItemStorage storage) {
-        for (int i = 0; i < this.inputSlotsLength; i++) {
-            storage.getSlot(this.inputSlotsStart + i).set(Items.BARRIER, 1);
-        }
-    }
-
     protected void fillOutputSlots(@NotNull MachineItemStorage storage) {
         for (int i = 0; i < this.outputSlotsLength; i++) {
             storage.getSlot(this.outputSlotsStart + i).set(Items.BARRIER, 1);
         }
     }
 
-    @MachineTest(group = "recipe", workTime = 1)
+    protected void fulfillRunConditions(Machine machine) {
+        for (IngredientSupplier<C, R, Machine> condition : this.conditions) {
+            condition.fulfillRunRequirements(machine);
+        }
+    }
+
+    @MachineTest(group = "recipe")
     public Runnable initialize(Machine machine) {
-        this.fulfillRunRequirements(machine);
-        this.createValidRecipe(machine.itemStorage());
+        this.fulfillRunConditions(machine);
         return () -> {
             if (machine.getActiveRecipe() == null) {
                 throw new GameTestAssertException("Failed to find recipe!");
             }
         };
     }
 
-    @MachineTest(group = "recipe", workTime = 1)
-    public Runnable invalid(Machine machine) {
-        this.fulfillRunRequirements(machine);
-        this.createInvalidRecipe(machine.itemStorage());
-        return () -> {
-            if (machine.getActiveRecipe() != null) {
-                throw new GameTestAssertException("Crafting something despite recipe being invalid!");
-            }
-        };
-    }
-
-    @MachineTest(group = "recipe", workTime = 1)
+    @MachineTest(group = "recipe")
     public Runnable full(Machine machine) {
-        this.fulfillRunRequirements(machine);
+        this.fulfillRunConditions(machine);
         this.fillOutputSlots(machine.itemStorage());
-        this.createValidRecipe(machine.itemStorage());
+
         return () -> {
             if (machine.getActiveRecipe() != null) {
                 throw new GameTestAssertException("Crafting something despite the output being full!");
             }
         };
     }
 
-    @MachineTest(group = "recipe", workTime = 1)
-    public Runnable craft(Machine machine) {
-        this.fulfillRunRequirements(machine);
-        this.fillOutputSlots(machine.itemStorage());
-        this.createValidRecipe(machine.itemStorage());
-        return () -> {
-            if (machine.getActiveRecipe() != null) {
-                throw new GameTestAssertException("Crafting something despite the output being full!");
+    protected void tryCraft(GameTestHelper helper) {
+        Machine machine = createMachine(helper);
+
+        fulfillRunConditions(machine);
+
+        helper.runAfterDelay(this.recipeRuntime, () -> {
+            if (!this.anyRecipeCrafted(machine.itemStorage())) {
+                helper.fail("Failed to craft recipe!", machine.getBlockPos());
+            } else {
+                helper.succeed();
             }
-        };
+        });
     }
 
-//    @InstantTest(group = "recipe")
-//    public Runnable recipeNoResources(Machine machine) {
-//        this.createValidRecipe(machine.itemStorage());
-//        return () -> {
-//            if (machine.getMaxProgress() != 0) { //fixme: recipe detection works differently
-//                throw new GameTestAssertException("Machine is crafting a recipe, despite not having relevant resources (e.g. energy)!");
-//            }
-//        };
-//    }
-
-    @MachineTest(group = "recipe", workTime = 1)
-    public Runnable resourcesNoRecipe(Machine machine) {
-        this.fulfillRunRequirements(machine);
-        return () -> {
-            if (machine.getActiveRecipe() != null) {
-                throw new GameTestAssertException("Machine is doing something, despite not having a recipe!");
+    protected void tryCraftPartial(GameTestHelper helper, int ignored) {
+        Machine machine = createMachine(helper);
+
+        for (int i = 0; i < this.conditions.size(); i++) {
+            if (i == ignored) continue;
+            this.conditions.get(i).fulfillRunRequirements(machine);
+        }
+
+        helper.runAfterDelay(this.recipeRuntime, () -> {
+            if (this.anyRecipeCrafted(machine.itemStorage())) {
+                helper.fail("Partial recipe %s crafted!".formatted(ignored), machine.getBlockPos());
+            } else {
+                helper.succeed();
             }
-        };
+        });
     }
 
     @Override
@@ -161,18 +147,12 @@ public Runnable resourcesNoRecipe(Machine machine) {
     public @NotNull List<TestFunction> registerTests() {
         List<TestFunction> tests = super.registerTests();
         // variable runtime
-        tests.add(this.createTest("recipe", "craft", STRUCTURE_3x3, this.getRecipeRuntime(), 1, helper -> {
-            Machine machine = createMachine(helper);
-            this.fulfillRunRequirements(machine);
-            this.createValidRecipe(machine.itemStorage());
-            helper.runAfterDelay(this.getRecipeRuntime(), () -> {
-                if (!this.anyRecipeCrafted(machine.itemStorage())) {
-                    helper.fail("Failed to craft recipe!", machine.getBlockPos());
-                } else {
-                    helper.succeed();
-                }
-            });
-        }));
+        tests.add(this.createTest("recipe", "craft", STRUCTURE_3x3, this.recipeRuntime, 1, this::tryCraft));
+
+        for (int i = 0; i < this.conditions.size(); i++) {
+            int finalI = i;
+            tests.add(this.createTest("recipe", "craft.partial." + i, STRUCTURE_3x3, this.recipeRuntime, 1, helper -> this.tryCraftPartial(helper, finalI)));
+        }
         return tests;
     }
 }