return classpath.filter(classpathFilter);
    }

    public FileCollection inferModulePath(boolean inferModulePath, Collection<File> classpath) {
        return inferModulePath(inferModulePath, fileCollectionFactory.fixed(classpath));
    }

    public FileCollection inferModulePath(boolean inferModulePath, FileCollection classpath) {
        if (classpath == null) {
            return FileCollectionFactory.empty();
        }

plugins {
    `java-library`
}

repositories {
    mavenCentral()
}

// tag::disableModulePath[]
java {
    modularity.inferModulePath = false
}

tasks.compileJava {
    modularity.inferModulePath = false
}
// end::disableModulePath[]

dependencies {
    implementation("com.google.code.gson:gson:2.8.9")
    implementation("org.apache.commons:commons-lang3:3.10")
    implementation("commons-cli:commons-cli:1.4")

        then:
        project.tasks.getByName("compileJava").modularity.inferModulePath.get()
        project.tasks.getByName("compileTestJava").modularity.inferModulePath.get()
        project.tasks.getByName("test").modularity.inferModulePath.get()
        project.tasks.getByName("run").modularity.inferModulePath.get()
        project.tasks.getByName("startScripts").modularity.inferModulePath.get()
    }

plugins {
    id 'java-library'
}

repositories {
    mavenCentral()
}

// tag::disableModulePath[]
java {
    modularity.inferModulePath = false
}

tasks.named('compileJava') {
    modularity.inferModulePath = false
}
// end::disableModulePath[]

dependencies {
    implementation 'com.google.code.gson:gson:2.8.9'
    implementation 'org.apache.commons:commons-lang3:3.10'

        builder.mainClass.set("mainClass")
        builder.classpath(new File("file1.jar").canonicalFile)

        when:
        // turn off module support:
        builder.modularity.inferModulePath.set(false)

        then:
        !builder.getAllArguments().contains('--module')
    }

    def "throws reasonable error if module support is turned on without module detector service"() {
        given:

        this.classpath = classpath;
        this.dependenciesCreator = new EclipseDependenciesCreator(classpath, ideArtifactRegistry, gradleApiSourcesResolver, inferModulePath);
    }

    public List<ClasspathEntry> createEntries() {

        given:
        publishJavaModule('moda')
        consumingModuleInfo('requires moda')
        buildFile << """
            java.modularity.inferModulePath = false
        """

        when:
        fails ':compileJava'

        then:
        failure.assertHasErrorOutput 'module-info.java:1: error: module not found: moda'
    }

        given:
        buildFile.text = buildFile.text.replace('java-library', 'application')
        buildFile << """
            tasks.run.modularity.inferModulePath = false
            application {
                mainClass.set('consumer.MainModule')
                mainModule.set('consumer')
            }
        """
        publishJavaModule('moda')

            forkOptions.getWorkingDir(),
            executable,
            detectJavaVersion(executable),
            javaModuleDetector.inferClasspath(testIsModule, task.getClasspath()),
            javaModuleDetector.inferModulePath(testIsModule, task.getClasspath()),
            forkOptions.getAllJvmArgs(),
            DefaultProcessForkOptions.getActualEnvironment(forkOptions)
        );
    }

    }

    def "runs JUnit4 module test on classpath if module path inference is turned off"() {
        given:
        buildFile << """
            tasks.test.modularity.inferModulePath = false
            dependencies { testImplementation 'junit:junit:4.13' }
        """

        when:
        consumingModuleInfo('exports consumer')
        consumingModuleClass()