Update Neo and NG and make use of FML initialization for unit tests to remove the need for lazy codecs in ingredients

Author: pupnewfster

build.gradle

@@ -18,7 +18,7 @@ plugins {
     id('eclipse')
     id('idea')
     id('maven-publish')
-    id('net.neoforged.gradle.userdev') version('7.0.134')//https://projects.neoforged.net/neoforged/neogradle
+    id('net.neoforged.gradle.userdev') version('7.0.136')//https://projects.neoforged.net/neoforged/neogradle
 }
 
 tasks.named('wrapper', Wrapper).configure {
@@ -63,46 +63,35 @@ sourceSets {
             srcDirs += ['src/datagen/generated/mekanism']
         }
         compileClasspath += api.output
-        runtimeClasspath += api.output
     }
     test {
         //The test module has no resources
         resources.srcDirs = []
         //Add the api to the output, all other ones that need to will get added via setupExtraSourceSets
         compileClasspath += api.output
-        runtimeClasspath += api.output
     }
     gameTest {
         runs {
             modIdentifier = 'mekanismtests'
         }
         compileClasspath += api.output
-        runtimeClasspath += api.output
     }
 }
 
 configurations {
-    // Sets up a dependency configuration called 'localRuntime'.
-    // This configuration should be used instead of 'runtimeOnly' to declare
-    // a dependency that will be present for runtime testing but that is
-    // "optional", meaning it will not be pulled by dependents of this mod.
-    runtimeClasspath.extendsFrom(localRuntime)
-
+    //Make sure all our sub source set stuff extends the proper base methods so that
+    // they can see all the dependencies we have in dependencies including neo
+    extendConfigurations(implementation, apiImplementation, testImplementation)
+    extendConfigurations(compileOnly, apiCompileOnly, testCompileOnly)
+    extendConfigurations(runtimeOnly, apiRuntimeOnly)
+    extendConfigurations(localRuntime, apiLocalRuntime)
     datagenNonMod
 }
 
 //Add all extra source sets that the main sourceSet should have
 setupExtraSourceSets(sourceSets.main)
 setupExtraSourceSets(sourceSets.gameTest, false)
 
-configurations {
-    //Make sure all our sub source set stuff extends the proper base methods so that
-    // they can see all the dependencies we have in dependencies including forge
-    extendConfigurations(implementation, apiImplementation, testImplementation)
-    extendConfigurations(compileOnly, apiCompileOnly, testCompileOnly)
-    extendConfigurations(runtimeOnly, apiRuntimeOnly)
-}
-
 //Create sourceSets and configurations for each of the additional modules in src/$name and adds a reference to
 // the corresponding data gen's resource directory excluding the cache. It also adds the api and main mekanism
 // module to the dependencies of the source set we are setting up, and sets up all extra source sets that are
@@ -127,21 +116,21 @@ for (String name : secondaryModules) {
 def setupExtraSourceSets(SourceSet base, boolean includeExtra = true) {
     //Expose the base module to junit
     project.sourceSets.test.compileClasspath += base.output
-    project.sourceSets.test.runtimeClasspath += base.output
     if (base != project.sourceSets.gameTest) {
         project.sourceSets.gameTest.compileClasspath += base.output
-        project.sourceSets.gameTest.runtimeClasspath += base.output
     }
     //Setup and extend configurations for alternate modules. First by making the implementation, compileOnly, runtimeOnly equivalents
     // for those modules extend the main ones
     def baseImplementation = project.configurations.maybeCreate(base.getTaskName(null, 'implementation'))
     def baseCompileOnly = project.configurations.maybeCreate(base.getTaskName(null, 'compileOnly'))
     def baseRuntimeOnly = project.configurations.maybeCreate(base.getTaskName(null, 'runtimeOnly'))
+    def baseLocalRuntime = project.configurations.maybeCreate(base.getTaskName(null, 'localRuntime'))
     if (base != project.sourceSets.main) {
         // If this is a secondary module then make the base tasks extend the builtin ones
         baseImplementation.extendsFrom(project.configurations.getByName('implementation'))
         baseCompileOnly.extendsFrom(project.configurations.getByName('compileOnly'))
         baseRuntimeOnly.extendsFrom(project.configurations.getByName('runtimeOnly'))
+        baseLocalRuntime.extendsFrom(project.configurations.getByName('localRuntime'))
     }
     if (includeExtra) {
         //And then setup and have all the extra sourceSets have their configurations extend the ones for the base module so that they can
@@ -157,6 +146,7 @@ def setupExtraSourceSets(SourceSet base, boolean includeExtra = true) {
             project.configurations.maybeCreate(extraSourceSet.getTaskName(null, 'implementation')).extendsFrom(*implExtends)
             project.configurations.maybeCreate(extraSourceSet.getTaskName(null, 'compileOnly')).extendsFrom(baseCompileOnly)
             project.configurations.maybeCreate(extraSourceSet.getTaskName(null, 'runtimeOnly')).extendsFrom(baseRuntimeOnly)
+            project.configurations.maybeCreate(extraSourceSet.getTaskName(null, 'localRuntime')).extendsFrom(baseLocalRuntime)
         }
     }
 }
@@ -348,6 +338,9 @@ runs {
         setupClientAcc(run)
         modSources.add((SourceSet) sourceSets.gameTest)
     }
+    junit {
+        unitTestSources.add((SourceSet) sourceSets.test)
+    }
     data {
         programArguments.addAll((String[]) ['--all', '--output', file('src/datagen/generated/').getAbsolutePath(),
                                             '--mod', 'mekanism', '--existing', file('src/main/resources/').getAbsolutePath()])
@@ -402,8 +395,9 @@ repositories { RepositoryHandler handler ->
     exclusiveRepo(handler, 'https://maven.parchmentmc.org/', 'org.parchmentmc.data')
 }
 
-tasks.named('test', Test) {
-    useJUnitPlatform()
+tasks.named('test').configure {
+    //Disable builtin test task as we use and build uses testJunit so there is no point in having it also attempt to run an empty test task
+    enabled(false)
 }
 
 dependencies {
@@ -413,7 +407,9 @@ dependencies {
     localRuntime(project(':annotation-processor'))
     annotationProcessor(project(':annotation-processor'))
 
-    gameTestImplementation("net.neoforged:testframework:${forge_version}")
+    def testFrameWork = "net.neoforged:testframework:${forge_version}"
+    gameTestImplementation(testFrameWork)
+    testImplementation(testFrameWork)
     testImplementation("org.junit.jupiter:junit-jupiter-api:${junit_version}")
     testRuntimeOnly("org.junit.jupiter:junit-jupiter-engine:${junit_version}")
     //We use https://github.com/quicktheories/QuickTheories to allow for implementing property based testing

gradle.properties

@@ -8,11 +8,11 @@ minecraft_version=1.20.6
 previous_minecraft_version=1.20.1
 previous_minor_minecraft_version=1.20.4
 loader_version_range=[3,)
-forge_version=20.6.78-beta
+forge_version=20.6.98-beta
 mod_version=10.5.20
 #This determines the minimum version of forge required to use Mekanism
 # Only bump it whenever we need access to a feature in forge that is not available in earlier versions
-forge_version_range=[20.6.78-beta,)
+forge_version_range=[20.6.94-beta,)
 minecraft_version_range=[1.20.6]
 #This specifies what type of release it will be uploaded to CurseForge and Modrinth as
 # options are: alpha, beta, release
@@ -22,9 +22,10 @@ release_type=beta
 junit_version=5.10.2
 quicktheories_version=0.26
 
-#Parchment settings
+#NeoGradle Settings
 neogradle.subsystems.parchment.minecraftVersion=1.20.6
 neogradle.subsystems.parchment.mappingsVersion=2024.05.01
+neogradle.subsystems.conventions.sourcesets.enabled=false
 
 #misc settings
 # recipe viewer, currently accepts: jei, emi, hybrid

src/api/java/mekanism/api/recipes/ingredients/FluidStackIngredient.java

@@ -8,7 +8,6 @@
 import net.minecraft.network.codec.StreamCodec;
 import net.neoforged.neoforge.fluids.FluidStack;
 import net.neoforged.neoforge.fluids.crafting.SizedFluidIngredient;
-import net.neoforged.neoforge.network.codec.NeoForgeStreamCodecs;
 import org.jetbrains.annotations.ApiStatus.Internal;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
@@ -26,21 +25,16 @@ public final class FluidStackIngredient implements InputIngredient<@NotNull Flui
     /**
      * A codec which can (de)encode fluid stack ingredients.
      *
-     * @implNote This must be a lazily initialized so that this class can be loaded in tests
      * @since 10.6.0
      */
-    public static final Codec<FluidStackIngredient> CODEC = Codec.lazyInitialized(() -> SizedFluidIngredient.FLAT_CODEC.xmap(
-          FluidStackIngredient::new, FluidStackIngredient::ingredient
-    ));
+    public static final Codec<FluidStackIngredient> CODEC = SizedFluidIngredient.FLAT_CODEC.xmap(FluidStackIngredient::new, FluidStackIngredient::ingredient);
     /**
      * A stream codec which can be used to encode and decode fluid stack ingredients over the network.
      *
-     * @implNote This must be a lazily initialized so that this class can be loaded in tests
      * @since 10.6.0
      */
-    public static final StreamCodec<RegistryFriendlyByteBuf, FluidStackIngredient> STREAM_CODEC = NeoForgeStreamCodecs.lazy(() ->
-          SizedFluidIngredient.STREAM_CODEC.map(FluidStackIngredient::new, FluidStackIngredient::ingredient)
-    );
+    public static final StreamCodec<RegistryFriendlyByteBuf, FluidStackIngredient> STREAM_CODEC = SizedFluidIngredient.STREAM_CODEC
+          .map(FluidStackIngredient::new, FluidStackIngredient::ingredient);
 
     /**
      * Creates a Fluid Stack Ingredient that matches a given ingredient and amount. Prefer calling via

src/api/java/mekanism/api/recipes/ingredients/ItemStackIngredient.java

@@ -8,7 +8,6 @@
 import net.minecraft.network.codec.StreamCodec;
 import net.minecraft.world.item.ItemStack;
 import net.neoforged.neoforge.common.crafting.SizedIngredient;
-import net.neoforged.neoforge.network.codec.NeoForgeStreamCodecs;
 import org.jetbrains.annotations.ApiStatus.Internal;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
@@ -26,21 +25,16 @@ public final class ItemStackIngredient implements InputIngredient<@NotNull ItemS
     /**
      * A codec which can (de)encode item stack ingredients.
      *
-     * @implNote This must be a lazily initialized so that this class can be loaded in tests
      * @since 10.6.0
      */
-    public static final Codec<ItemStackIngredient> CODEC = Codec.lazyInitialized(() -> SizedIngredient.FLAT_CODEC.xmap(
-          ItemStackIngredient::new, ItemStackIngredient::ingredient
-    ));
+    public static final Codec<ItemStackIngredient> CODEC = SizedIngredient.FLAT_CODEC.xmap(ItemStackIngredient::new, ItemStackIngredient::ingredient);
     /**
      * A stream codec which can be used to encode and decode item stack ingredients over the network.
      *
-     * @implNote This must be a lazily initialized so that this class can be loaded in tests
      * @since 10.6.0
      */
-    public static final StreamCodec<RegistryFriendlyByteBuf, ItemStackIngredient> STREAM_CODEC = NeoForgeStreamCodecs.lazy(() ->
-          SizedIngredient.STREAM_CODEC.map(ItemStackIngredient::new, ItemStackIngredient::ingredient)
-    );
+    public static final StreamCodec<RegistryFriendlyByteBuf, ItemStackIngredient> STREAM_CODEC = SizedIngredient.STREAM_CODEC
+          .map(ItemStackIngredient::new, ItemStackIngredient::ingredient);
 
     /**
      * Creates an Item Stack Ingredient that matches a given ingredient and amount. Prefer calling via

src/test/java/mekanism/api/MekanismClassInit.java

@@ -0,0 +1,38 @@
+package mekanism.api;
+
+import mekanism.api.energy.IEnergyConversionHelper;
+import mekanism.api.gear.IModuleHelper;
+import mekanism.api.radial.IRadialDataHelper;
+import mekanism.api.radiation.IRadiationManager;
+import mekanism.api.security.IBlockSecurityUtils;
+import mekanism.api.security.IEntitySecurityUtils;
+import mekanism.api.security.IItemSecurityUtils;
+import mekanism.api.security.ISecurityUtils;
+import mekanism.api.text.ITooltipHelper;
+import mekanism.common.Mekanism;
+import net.neoforged.fml.common.Mod;
+
+/**
+ * Add an extra injection point for all our service loaders to force load them while we know for a fact we are using the transforming class loader, as there seems to be
+ * some issue with {@link net.neoforged.fml.junit.JUnitService}, and presumably the fact it doesn't use {@link org.junit.platform.launcher.LauncherInterceptor} which
+ * causes all the test methods to actually be executed using the app class loader.
+ */
+@Mod(Mekanism.MODID)
+public class MekanismClassInit {//TODO: Remove this as soon as possible
+
+    public MekanismClassInit() {
+        forceInit(IMekanismAccess.INSTANCE);
+        forceInit(IModuleHelper.INSTANCE);
+        forceInit(IRadialDataHelper.INSTANCE);
+        forceInit(IRadiationManager.INSTANCE);
+        forceInit(ISecurityUtils.INSTANCE);
+        forceInit(IBlockSecurityUtils.INSTANCE);
+        forceInit(IItemSecurityUtils.INSTANCE);
+        forceInit(IEntitySecurityUtils.INSTANCE);
+        forceInit(ITooltipHelper.INSTANCE);
+        forceInit(IEnergyConversionHelper.INSTANCE);
+    }
+
+    private void forceInit(Object obj) {
+    }
+}

src/tools/java/mekanism/tools/common/item/ItemMekanismSword.java

@@ -4,15 +4,10 @@
 import mekanism.tools.common.material.MaterialCreator;
 import mekanism.tools.common.util.ToolsUtils;
 import net.minecraft.network.chat.Component;
-import net.minecraft.world.entity.EquipmentSlotGroup;
-import net.minecraft.world.entity.ai.attributes.AttributeModifier;
-import net.minecraft.world.entity.ai.attributes.Attributes;
 import net.minecraft.world.item.Item;
 import net.minecraft.world.item.ItemStack;
 import net.minecraft.world.item.SwordItem;
-import net.minecraft.world.item.Tier;
 import net.minecraft.world.item.TooltipFlag;
-import net.minecraft.world.item.component.ItemAttributeModifiers;
 import org.jetbrains.annotations.NotNull;
 
 public class ItemMekanismSword extends SwordItem {
@@ -26,17 +21,4 @@ public void appendHoverText(@NotNull ItemStack stack, @NotNull Item.TooltipConte
         super.appendHoverText(stack, context, tooltip, flag);
         ToolsUtils.addDurability(tooltip, stack);
     }
-
-    /**
-     * Like {@link SwordItem#createAttributes(Tier, int, float)} but supports float based attack damages.
-     */
-    @NotNull
-    private static ItemAttributeModifiers createAttributes(Tier tier, float attackDamage, float attackSpeed) {
-        return ItemAttributeModifiers.builder()
-              .add(Attributes.ATTACK_DAMAGE, new AttributeModifier(BASE_ATTACK_DAMAGE_UUID, "Weapon modifier", attackDamage + tier.getAttackDamageBonus(),
-                    AttributeModifier.Operation.ADD_VALUE), EquipmentSlotGroup.MAINHAND)
-              .add(Attributes.ATTACK_SPEED, new AttributeModifier(BASE_ATTACK_SPEED_UUID, "Weapon modifier", attackSpeed, AttributeModifier.Operation.ADD_VALUE),
-                    EquipmentSlotGroup.MAINHAND
-              ).build();
-    }
 }