import java.util.Collection;
import java.util.jar.JarInputStream;
import java.util.jar.Manifest;
import java.util.regex.Pattern;
import java.util.zip.ZipEntry;

@ServiceScope(Scope.UserHome.class)
public class JavaModuleDetector {

    private final Spec<? super File> classpathFilter = this::isNotModule;
    private final Spec<? super File> modulePathFilter = this::isModule;

    private final JavaModuleDetector javaModuleDetector;

    @Inject
    public DefaultTestTaskPropertiesService(
        PropertyWalker propertyWalker,
        FileCollectionFactory fileCollectionFactory,
        JavaForkOptionsFactory forkOptionsFactory,
        JvmVersionDetector jvmVersionDetector,
        JavaModuleDetector javaModuleDetector
    ) {
        this.propertyWalker = propertyWalker;

        Builder withInstantiator(Instantiator instantiator);

        Builder withObjectFactory(ObjectFactory objectFactory);

        Builder withJavaModuleDetector(JavaModuleDetector javaModuleDetector);

        Builder withBuildCancellationToken(BuildCancellationToken buildCancellationToken);

        Builder withExternalProcessStartedListener(ExternalProcessStartedListener externalProcessStartedListener);

        BuildCancellationToken buildCancellationToken,
        TemporaryFileProvider temporaryFileProvider,
        JavaModuleDetector javaModuleDetector,
        JavaForkOptions javaOptions
    ) {
        super(fileResolver, fileCollectionFactory, objectFactory, executor, buildCancellationToken, temporaryFileProvider, javaModuleDetector, javaOptions);
    }

    @Override
    public ExecResult execute() {
        ExecHandle execHandle = build();

import org.gradle.api.internal.tasks.JvmConstants;
import org.gradle.api.internal.tasks.compile.CompilationSourceDirs;
import org.gradle.api.tasks.compile.JavaCompile;
import org.gradle.internal.jvm.JavaModuleDetector;

import java.io.File;
import java.util.List;

@NonNullApi
public class EclipseClassPathUtil {

    public static boolean isInferModulePath(Project project) {

        return execFactory.forContext()
            .withFileResolver(fileResolver)
            .withFileCollectionFactory(fileCollectionFactory)
            .withInstantiator(instantiator)

    }

    def "supports module path"() {
        given:
        File libJar = new File("lib.jar")
        File moduleJar = new File("module.jar")
        JavaModuleDetector moduleDetector = Mock(JavaModuleDetector) {
            inferModulePath(_, _) >> new AbstractFileCollection() {
                String getDisplayName() { '' }

                Set<File> getFiles() { [moduleJar] }
            }

    @Rule
    TestNameTestDirectoryProvider tmpDir = new TestNameTestDirectoryProvider(JavaModuleDetectorTest)

    TestFileContentCacheFactory cacheFactory = new TestFileContentCacheFactory()
    JavaModuleDetector moduleDetector = new JavaModuleDetector(cacheFactory, TestFiles.fileCollectionFactory())

    def "detects modules on classpath"() {

import org.gradle.api.internal.project.ProjectInternal;
import org.gradle.api.internal.project.ProjectStateRegistry;
import org.gradle.api.plugins.JavaPlugin;
import org.gradle.internal.jvm.JavaModuleDetector;
import org.gradle.plugins.ide.eclipse.model.EclipseWtpComponent;
import org.gradle.plugins.ide.eclipse.model.FileReference;
import org.gradle.plugins.ide.eclipse.model.WbDependentModule;

import org.gradle.api.artifacts.result.UnresolvedDependencyResult;
import org.gradle.api.internal.project.ProjectInternal;
import org.gradle.api.plugins.WarPlugin;
import org.gradle.internal.jvm.JavaModuleDetector;
import org.gradle.plugins.ear.EarPlugin;
import org.gradle.plugins.ide.eclipse.model.AbstractClasspathEntry;
import org.gradle.plugins.ide.eclipse.model.AbstractLibrary;