expect:
        inferClasspath(path) == ['lib.jar', 'classes']
        inferModulePath(path) == ['module.jar', 'classes-module', 'automaticModule.jar', 'mrjarModule.jar']
    }

    def "filters out directories that do not exist"() {
        def path = path('resources1', 'nothing')

        expect:
        inferClasspath(path) == []
        inferModulePath(path) == []
    }

    def "caches results of module detection"() {

        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")

    private final boolean inferModulePath;
    private final GradleApiSourcesResolver gradleApiSourcesResolver;
    private final Collection<Configuration> testConfigurations;

    public IdeDependencySet(DependencyHandler dependencyHandler, JavaModuleDetector javaModuleDetector, Collection<Configuration> plusConfigurations, Collection<Configuration> minusConfigurations, boolean inferModulePath, GradleApiSourcesResolver gradleApiSourcesResolver) {

        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()
    }

    private final Property<Boolean> inferModulePath;

    @Inject
    public DefaultModularitySpec(ObjectFactory objects) {
        inferModulePath = objects.property(Boolean.class).convention(true);
    }

    @Override
    public Property<Boolean> getInferModulePath() {
        return inferModulePath;
    }

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'

    def "incremental compilation works with modules #description"() {
        file("impl/build.gradle") << """
            def layout = project.layout
            tasks.compileJava {
                modularity.inferModulePath = $inferModulePath
                options.compilerArgs.addAll($compileArgs)
                doFirst {
                    $doFirst
                }
            }
        """

        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() {