Conditionally implement Configuration Cache compatibility

I've figured out a way to get the JVM Aggregate Testing plugin to stay compatible with the configuration cache. Unfortunately, it involves the usage of an internal type. Here's what I'm doing to ensure that this doesn't backfire.

A private method queries the test suite's implementation for a `Property<JvmTestToolchain<?>>`. It uses that property to return a `Function<Test, Provider<TestFramework>>`. While `TestFramework` is also internal, it has been stabilized while the `JvmTestToolchain<?>` type is an internal implementation of `jvm-test-suite`, which is an incubating plugin.

The other thing is that this configuration cache compatibility can only be fulfilled if the participating project itself uses the `jvm-test-suite` plugin. I've already done the work to do this on our own projects, such as AccessTransformers, Unsafe, and Logging Utils.

Author: Jonathing

src/main/groovy/net/minecraftforge/testing/aggregate/AggregateTestExtensionImpl.java

@@ -4,20 +4,26 @@
  */
 package net.minecraftforge.testing.aggregate;
 
+import org.codehaus.groovy.runtime.InvokerHelper;
 import org.codehaus.groovy.runtime.StringGroovyMethods;
 import org.gradle.api.Project;
 import org.gradle.api.file.Directory;
 import org.gradle.api.file.ProjectLayout;
+import org.gradle.api.internal.tasks.testing.TestFramework;
 import org.gradle.api.model.ObjectFactory;
 import org.gradle.api.plugins.jvm.JvmTestSuite;
+import org.gradle.api.provider.Property;
 import org.gradle.api.provider.Provider;
 import org.gradle.api.tasks.TaskProvider;
 import org.gradle.api.tasks.testing.Test;
+import org.gradle.api.testing.toolchains.internal.JvmTestToolchain;
 import org.gradle.jvm.toolchain.JavaLanguageVersion;
 import org.gradle.jvm.toolchain.JavaToolchainService;
 import org.gradle.jvm.toolchain.JvmImplementation;
 import org.gradle.jvm.toolchain.JvmVendorSpec;
+import org.gradle.language.base.plugins.LifecycleBasePlugin;
 import org.gradle.testing.base.TestingExtension;
+import org.jetbrains.annotations.Nullable;
 import org.jetbrains.annotations.UnmodifiableView;
 
 import javax.inject.Inject;
@@ -26,6 +32,7 @@
 import java.util.List;
 import java.util.Map;
 import java.util.TreeMap;
+import java.util.function.Function;
 
 abstract class AggregateTestExtensionImpl implements AggregateTestExtensionInternal {
     private final Map<String, List<Integer>> jvms = new TreeMap<>(Comparator.naturalOrder());
@@ -67,18 +74,33 @@ private void finish(Project project) {
             var suites = testing.getSuites().withType(JvmTestSuite.class);
 
             for (var suite : suites) {
+                @Nullable var testToolchain = this.getTestToolchain(suite);
                 for (var target : suite.getTargets()) {
-                    this.configure(project, target.getTestTask().get());
+                    this.configure(project, target.getTestTask().get(), testToolchain);
                 }
             }
         } else {
+            this.problems.reportNotUsingJvmTestSuite();
             for (var test : project.getTasks().withType(Test.class)) {
-                this.configure(project, test);
+                this.configure(project, test, null);
             }
         }
     }
 
-    private void configure(Project project, Test test) {
+    // NOTE: Avoiding leaking the JvmTestToolchain type since it is part of an incubating plugin's internal implementation and could be removed.
+    //       While TestFramework is also internal, it has since been stabilized and is not expected to be removed.
+    @SuppressWarnings("unchecked")
+    private @Nullable Function<Test, Provider<TestFramework>> getTestToolchain(JvmTestSuite suite) {
+        try {
+            var testToolchain = (Property<JvmTestToolchain<?>>) InvokerHelper.getProperty(suite, "testToolchain");
+            return test -> testToolchain.map(t -> t.createTestFramework(test));
+        } catch (Exception e) {
+            this.problems.reportTestToolchainInaccessible(e, suite.getName());
+            return null;
+        }
+    }
+
+    private void configure(Project project, Test test, @Nullable Function<Test, Provider<TestFramework>> testToolchain) {
         if (this.jvms.isEmpty()) return;
 
         TaskProvider<? extends AggregateTest> testAll = project.getTasks().register("jvmAggregate" + StringGroovyMethods.capitalize(test.getName()), AggregateTestImpl.class, task -> {
@@ -91,7 +113,7 @@ private void configure(Project project, Test test) {
 
             for (int version : versions) {
                 var output = this.getLayout().getBuildDirectory().dir(AggregateTest.TEST_RESULTS_DIRECTORY + "/%s-%d".formatted(vendor, version)).map(this.problems.ensureFileLocation());
-                var task = this.register(project, test, vendor, version, output);
+                var task = this.register(project, testToolchain, test, vendor, version, output);
 
                 testAll.configure(testAllTask -> {
                     testAllTask.getInputs().dir(output);
@@ -101,19 +123,23 @@ private void configure(Project project, Test test) {
         }
     }
 
-    private TaskProvider<Test> register(Project project, Test test, String vendor, int version, Provider<Directory> output) {
+    private TaskProvider<Test> register(Project project, @Nullable Function<Test, Provider<TestFramework>> testToolchain, Test test, String vendor, int version, Provider<Directory> output) {
         var vendorSpec = JvmVendorSpec.of(vendor);
 
         return project.getTasks().register("testUsing" + StringGroovyMethods.capitalize(vendor) + version, Test.class, task -> {
             var description = test.getDescription();
             task.setDescription(description != null
                 ? "%s (using %s %s)".formatted(description, vendorSpec, version)
                 : "Runs '%s' using %s %s".formatted(test.getName(), vendorSpec, version));
-            task.notCompatibleWithConfigurationCache(
-                "JVM-specific tests need the test framework from the parent test task, which cannot be serialized."
-            );
+            if (testToolchain != null) {
+                task.getTestFrameworkProperty().set(testToolchain.apply(task));
+            } else {
+                task.getTestFrameworkProperty().set(test.getTestFrameworkProperty());
+                task.notCompatibleWithConfigurationCache(
+                    "JVM-specific tests need the test framework from the parent test task, which cannot be serialized."
+                );
+            }
 
-            task.getTestFrameworkProperty().set(test.getTestFrameworkProperty());
             task.setClasspath(test.getClasspath());
             task.setTestClassesDirs(test.getTestClassesDirs());
             task.getJavaLauncher().set(this.getJavaToolchains().launcherFor(spec -> {

src/main/groovy/net/minecraftforge/testing/aggregate/AggregateTestProblems.java

@@ -5,6 +5,7 @@
 package net.minecraftforge.testing.aggregate;
 
 import net.minecraftforge.gradleutils.shared.EnhancedProblems;
+import org.gradle.api.problems.Severity;
 
 import javax.inject.Inject;
 import java.io.Serial;
@@ -16,4 +17,27 @@ abstract class AggregateTestProblems extends EnhancedProblems {
     public AggregateTestProblems() {
         super(AggregateTestPlugin.NAME, AggregateTestPlugin.DISPLAY_NAME);
     }
+
+    void reportTestToolchainInaccessible(Exception e, String name) {
+        this.report("test-toolchain-inaccessible", "Test Toolchain could not be accessed", spec -> spec
+            .details("""
+                The '%s' test suite's testing toolchain could not be accessed.
+                While this is an internal Gradle property, it is used to avoid problems with the configuration cache.
+                The JVM Aggregate Testing plugin will continue to work, but it will not be compatible with the configuration cache."""
+                .formatted(name))
+            .withException(e)
+            .severity(Severity.WARNING)
+            .solution(HELP_MESSAGE));
+    }
+
+    void reportNotUsingJvmTestSuite() {
+        this.report("jvm-test-suite-plugin-not-found", "JVM Test Suite plugin not found", spec -> spec
+            .details("""
+                The JVM Test Suite plugin was not found in this project.
+                The JVM Aggregate Testing uses implementation details from this plugin to stay compatible with the configuration cache.
+                Consider using the JVM Test Suite plugin in your project, as aggregate testing is configured to work with it.""")
+            .severity(Severity.ADVICE)
+            .solution("Apply the `jvm-test-suite` plugin to your project.")
+            .solution(HELP_MESSAGE));
+    }
 }