Do Module Path / Classpath split for whitebox testing in doFirst

Author: jjohannes

samples/use-all-java-module-plugins/build-logic/build.gradle.kts

@@ -3,7 +3,7 @@ plugins {
 }
 
 dependencies {
-    implementation("org.gradlex:extra-java-module-info:1.5")
-    implementation("org.gradlex:java-module-dependencies:1.3.1")
+    implementation("org.gradlex:extra-java-module-info:1.7")
+    implementation("org.gradlex:java-module-dependencies:1.5.2")
     implementation("org.gradlex:java-module-testing:1.3.1")
 }

src/main/java/org/gradlex/javamodule/testing/JavaModuleTestingExtension.java

@@ -21,7 +21,6 @@
 import org.gradle.api.artifacts.Configuration;
 import org.gradle.api.artifacts.ConfigurationContainer;
 import org.gradle.api.artifacts.dsl.DependencyHandler;
-import org.gradle.api.file.FileCollection;
 import org.gradle.api.file.RegularFile;
 import org.gradle.api.plugins.jvm.JvmTestSuite;
 import org.gradle.api.provider.Provider;
@@ -31,12 +30,12 @@
 import org.gradle.api.tasks.TaskProvider;
 import org.gradle.api.tasks.compile.JavaCompile;
 import org.gradle.api.tasks.testing.Test;
-import org.gradle.internal.jvm.JavaModuleDetector;
 import org.gradle.jvm.tasks.Jar;
 import org.gradle.testing.base.TestSuite;
 import org.gradle.testing.base.TestingExtension;
 import org.gradlex.javamodule.testing.internal.ModuleInfoParser;
 import org.gradlex.javamodule.testing.internal.ModuleInfoRequiresParser;
+import org.gradlex.javamodule.testing.internal.actions.JavaCompileSetModulePathAction;
 import org.gradlex.javamodule.testing.internal.bridges.JavaModuleDependenciesBridge;
 import org.gradlex.javamodule.testing.internal.provider.WhiteboxTestCompileArgumentProvider;
 import org.gradlex.javamodule.testing.internal.provider.WhiteboxTestRuntimeArgumentProvider;
@@ -52,12 +51,10 @@ public abstract class JavaModuleTestingExtension {
     private static final Action<WhiteboxJvmTestSuite> NO_OP_ACTION = c -> {};
 
     private final Project project;
-    private final JavaModuleDetector moduleDetector;
 
     @Inject
-    public JavaModuleTestingExtension(Project project, JavaModuleDetector moduleDetector) {
+    public JavaModuleTestingExtension(Project project) {
         this.project = project;
-        this.moduleDetector = moduleDetector;
 
         TestingExtension testing = project.getExtensions().getByType(TestingExtension.class);
         testing.getSuites().withType(JvmTestSuite.class).configureEach(jvmTestSuite -> {
@@ -184,19 +181,16 @@ private void configureJvmTestSuiteForWhitebox(JvmTestSuite jvmTestSuite, Whitebo
             SourceSet sourcesUnderTest = whiteboxJvmTestSuite.getSourcesUnderTest().get();
 
             compileJava.setClasspath(sourcesUnderTest.getOutput().plus(configurations.getByName(testSources.getCompileClasspathConfigurationName())));
-            FileCollection syntheticModuleInfoFolders = JavaModuleDependenciesBridge.addRequiresRuntimeSupportOld(project, compileJava, sourcesUnderTest);
 
             WhiteboxTestCompileArgumentProvider argumentProvider = (WhiteboxTestCompileArgumentProvider) compileJava.getOptions().getCompilerArgumentProviders().stream()
                     .filter(p -> p instanceof WhiteboxTestCompileArgumentProvider).findFirst().orElseGet(() -> {
                         WhiteboxTestCompileArgumentProvider newProvider = new WhiteboxTestCompileArgumentProvider(
                                 sourcesUnderTest.getJava().getSrcDirs(),
                                 testSources.getJava().getSrcDirs(),
-                                compileJava,
-                                syntheticModuleInfoFolders,
-                                moduleDetector,
                                 moduleInfoParser,
                                 project.getObjects());
                         compileJava.getOptions().getCompilerArgumentProviders().add(newProvider);
+                        compileJava.doFirst(project.getObjects().newInstance(JavaCompileSetModulePathAction.class));
                         return newProvider;
                     });
             argumentProvider.testRequires(JavaModuleDependenciesBridge.getCompileClasspathModules(project, testSources));

src/main/java/org/gradlex/javamodule/testing/internal/actions/JavaCompileSetModulePathAction.java

@@ -0,0 +1,48 @@
+/*
+ * Copyright the GradleX team.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.gradlex.javamodule.testing.internal.actions;
+
+import org.gradle.api.Action;
+import org.gradle.api.NonNullApi;
+import org.gradle.api.Task;
+import org.gradle.api.file.FileCollection;
+import org.gradle.api.tasks.compile.JavaCompile;
+import org.gradle.internal.jvm.JavaModuleDetector;
+
+import javax.inject.Inject;
+import java.util.ArrayList;
+import java.util.List;
+
+@NonNullApi
+public abstract class JavaCompileSetModulePathAction implements Action<Task> {
+
+    @Inject
+    protected abstract JavaModuleDetector getJavaModuleDetector();
+
+    @Override
+    public void execute(Task task) {
+        JavaCompile javaCompile = (JavaCompile) task;
+        FileCollection classpathAndModulePath = javaCompile.getClasspath();
+        List<String> compilerArgs = new ArrayList<>(javaCompile.getOptions().getCompilerArgs());
+
+        // Since for Gradle this sources set does not look like a module, we have to define the module path ourselves
+        compilerArgs.add("--module-path");
+        compilerArgs.add(getJavaModuleDetector().inferModulePath(true, classpathAndModulePath).getAsPath());
+        javaCompile.setClasspath(getJavaModuleDetector().inferClasspath(true, classpathAndModulePath));
+        javaCompile.getOptions().setCompilerArgs(compilerArgs);
+    }
+}

src/main/java/org/gradlex/javamodule/testing/internal/bridges/JavaModuleDependenciesBridge.java

@@ -57,22 +57,6 @@ public static void addRequiresRuntimeSupport(Project project, SourceSet sourceSe
         }
     }
 
-    @Deprecated
-    public static FileCollection addRequiresRuntimeSupportOld(Project project, JavaCompile task, SourceSet sourceSet) {
-        Object javaModuleDependencies = project.getExtensions().findByName("javaModuleDependencies");
-        if (javaModuleDependencies == null) {
-            return project.getObjects().fileCollection();
-        }
-        try {
-            Method addRequiresRuntimeSupport = javaModuleDependencies.getClass().getMethod("addRequiresRuntimeSupport", JavaCompile.class, SourceSet.class);
-            return (FileCollection) addRequiresRuntimeSupport.invoke(javaModuleDependencies, task, sourceSet);
-        } catch (NoSuchMethodException e) {
-            return project.getObjects().fileCollection();
-        } catch (ReflectiveOperationException e) {
-            throw new RuntimeException(e);
-        }
-    }
-
     public static List<String> getRuntimeClasspathModules(Project project, SourceSet sourceSet) {
         return getClasspathModules("getRuntimeClasspathModules", project, sourceSet);
     }

src/main/java/org/gradlex/javamodule/testing/internal/provider/WhiteboxTestCompileArgumentProvider.java

@@ -29,26 +29,18 @@
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Set;
-import java.util.stream.Collectors;
 
 public class WhiteboxTestCompileArgumentProvider implements CommandLineArgumentProvider {
     private final Set<File> mainSourceFolders;
     private final Set<File> testSourceFolders;
-    private final JavaCompile task;
-    private final FileCollection syntheticModuleInfoFolders;
-    private final JavaModuleDetector moduleDetector;
     private final ModuleInfoParser moduleInfoParser;
 
     private final ListProperty<String> allTestRequires;
 
     public WhiteboxTestCompileArgumentProvider(
-            Set<File> mainSourceFolders, Set<File> testSourceFolders, JavaCompile task, FileCollection syntheticModuleInfoFolders,
-            JavaModuleDetector moduleDetector, ModuleInfoParser moduleInfoParser, ObjectFactory objects) {
+            Set<File> mainSourceFolders, Set<File> testSourceFolders, ModuleInfoParser moduleInfoParser, ObjectFactory objects) {
         this.mainSourceFolders = mainSourceFolders;
         this.testSourceFolders = testSourceFolders;
-        this.task = task;
-        this.syntheticModuleInfoFolders = syntheticModuleInfoFolders;
-        this.moduleDetector = moduleDetector;
         this.moduleInfoParser = moduleInfoParser;
         this.allTestRequires = objects.listProperty(String.class);
     }
@@ -66,14 +58,8 @@ public Iterable<String> asArguments() {
         String moduleName = moduleInfoParser.moduleName(mainSourceFolders);
         String testSources = testSourceFolders.iterator().next().getPath();
 
-        String cpSeparator = System.getProperty("path.separator");
         List<String> args = new ArrayList<>();
 
-        // Since for Gradle this sources set does not look like a module, we have to define the module path ourselves
-        args.add("--module-path");
-        args.add(moduleDetector.inferModulePath(true, task.getClasspath().plus(syntheticModuleInfoFolders)).getFiles().stream()
-                .map(File::getPath).collect(Collectors.joining(cpSeparator)));
-
         for (String testRequires : allTestRequires.get()) {
             args.add("--add-modules");
             args.add(testRequires);

src/test/groovy/org/gradlex/javamodule/testing/test/fixture/GradleBuild.groovy

@@ -31,7 +31,7 @@ class GradleBuild {
 
         settingsFile << '''
             pluginManagement {
-                plugins { id("org.gradlex.java-module-dependencies") version "1.3" }
+                plugins { id("org.gradlex.java-module-dependencies") version "1.5.2" }
             }
             dependencyResolutionManagement { repositories.mavenCentral() }
             includeBuild(".")
@@ -113,7 +113,7 @@ class GradleBuild {
                 .forwardOutput()
                 .withPluginClasspath()
                 .withProjectDir(projectDir)
-                .withArguments(Arrays.asList(args) + '-s')
+                .withArguments(Arrays.asList(args) + '-s' + '--configuration-cache')
                 .withDebug(ManagementFactory.getRuntimeMXBean().getInputArguments().toString().contains("-agentlib:jdwp")).with {
             gradleVersionUnderTest ? it.withGradleVersion(gradleVersionUnderTest) : it
         }