plugins {
                id 'groovy'
            }
            sourceSets {
                mySources
            }

            tasks.named('compileMySourcesJava') {
                classpath += files(sourceSets.mySources.groovy.classesDirectory)
            }
            tasks.named('compileMySourcesGroovy') {
                classpath = sourceSets.mySources.compileClasspath
            }
            dependencies {

        eclipsePlugin.apply(project)
        project.apply(plugin: 'java')

        project.sourceSets.main.output.dir 'generated-folder'
        project.sourceSets.main.output.dir 'ws-generated'

        project.sourceSets.test.output.dir 'generated-test'
        project.sourceSets.test.output.dir 'test-resources'

        project.sourceSets.test.output.dir '../some/external/dir'

        then:

    private final SourceSetContainer testSourceSets;
    private SourceSet pluginSourceSet;
    private boolean automatedPublishing = true;

    private final NamedDomainObjectContainer<PluginDeclaration> plugins;

    public GradlePluginDevelopmentExtension(Project project, SourceSet pluginSourceSet, SourceSet testSourceSet) {
        this(project, pluginSourceSet, new SourceSet[] {testSourceSet});
    }

            apply plugin: "scala-base"

            sourceSets {
               custom
            }

            ${mavenCentralRepository()}

            dependencies {
               customImplementation "${scalaDependency(version.toString())}"
            }

            task scaladoc(type: ScalaDoc) {
               classpath = sourceSets.custom.runtimeClasspath
            }

            task verify {

    }

    @Test void appliesMappingsToNewSourceSet() {
        def sourceSet = project.sourceSets.create('custom')
        assertThat(sourceSet.groovy.displayName, equalTo("custom Groovy source"))
        assertThat(sourceSet.groovy.srcDirs, equalTo(toLinkedSet(project.file("src/custom/groovy"))))
    }

    @Test void addsCompileTaskToNewSourceSet() {
        project.sourceSets.create('custom')

        def classpathFiles = classpath.files
        // ...
    }
}
// end::task-type[]

tasks.register("someTaskType", SomeTask) {
    classpath.from(sourceSets.main.compileClasspath)
}

// tag::ad-hoc-task[]
tasks.register('someTask') {
    def classpath = sourceSets.main.compileClasspath // <1>
    doLast {
        def classpathFiles = classpath.files
    }
}

    // Groovy only needs the declared dependencies
    // (and not longer the output of compileJava)
    classpath = sourceSets.main.compileClasspath
}
tasks.named('compileJava') {
    // Java also depends on the result of Groovy compilation
    // (which automatically makes it depend of compileGroovy)
    classpath += files(sourceSets.main.groovy.classesDirectory)
}

dependencies {
    testImplementation("junit:junit:4.13")
}

// tag::custom-src-dirs[]
sourceSets {
    main {
        java {
            setSrcDirs(listOf("src"))
        }
    }

    test {
        java {
            setSrcDirs(listOf("test"))
        }
    }
}
// end::custom-src-dirs[]

// tag::custom-extra-src-dir[]
sourceSets {
    main {
        java {
            srcDir("thirdParty/src/main/java")

            }
            getBuilder().item(component, componentRenderer);
        }
    }

    public void renderSourceSets(Collection<LanguageSourceSet> sourceSets) {
        Set<LanguageSourceSet> additionalSourceSets = collectAdditionalSourceSets(sourceSets);
        outputCollection(additionalSourceSets, "Additional source sets", sourceSetRenderer, "source sets");
    }

        given:
        buildFile << """
            plugins {
                id("java-base")
            }

            sourceSets {
                sources
            }

            task verify {
                assert sourceSets.sources.output.classesDirs instanceof ConfigurableFileCollection
            }
        """

        expect:
        succeeds "verify"
    }