project.sourceSets.create('custom')

        and:
        final someTask = project.task("someTask")
        project.sourceSets.custom.output.dir('some-dir', builtBy: someTask)

        then:
        def customClasses = project.tasks['customClasses']
        TaskDependencyMatchers.dependsOn('someTask', 'processCustomResources', 'compileCustomJava').matches(customClasses)
    }

                "Task `:a` of type `SomeTask`: cannot deserialize object of type 'org.gradle.api.Project' as these are not supported with the configuration cache.",
                "Task `:a` of type `SomeTask`: cannot deserialize object of type 'org.gradle.api.invocation.Gradle' as these are not supported with the configuration cache.",

    def "check scope when closure in ext"() {
        given:
        file('closure_in_ext.gradle') << """
allprojects {
    ext.someClosure = {
        project.name
    }

    task someTask {
        doLast {
            println someClosure()
            assert someClosure() == project.name
        }
    }
}
"""
        buildFile << """
apply from:'closure_in_ext.gradle'
"""

    @Issue("https://issues.gradle.org/browse/GRADLE-3094")
    def "can apply scala plugin"() {
        file("build.gradle") << """
            apply plugin: "scala"

            task someTask
        """

        expect:
        succeeds("someTask")
    }

    @Issue("https://github.com/gradle/gradle/issues/6558")
    def "can build in parallel with lazy tasks"() {
        createDirs("a", "b", "c", "d")

    SomeTask a = factory.create("a", SomeTask)
    SomeTask b = factory.create("b", SomeTask)
    SomeTask c = factory.create("c", SomeTask)
    SomeOtherTask d = factory.create("d", SomeOtherTask)

    static class SomeTask extends DefaultTask {}

    static class SomeOtherTask extends DefaultTask {}

    Class<SomeTask> type = SomeTask

        project.container(String, {}) instanceof FactoryNamedDomainObjectContainer
    }

}

class TaskContainerDynamicObject {
    Task someTask

    def someTask(Closure closure) {
        closure.call()
    }
}

class TestConvention {
    final static String METHOD_RESULT = 'methodResult'
    String name
    String conv

        [child1, child2, child3].each {
            it.configurations.create "testRuntime"
            it.configurations.create "conf"
            it.tasks.create "buildDependents"
            it.tasks.create "someTask"
        }

        when: dep.visitDependencies(context)

        then:
        4 * context.getTask() >> child1.tasks["buildDependents"]
        1 * checker.isDependent(child1, "testRuntime", child2) >> false

        buildFile << """
            class SomeTask extends DefaultTask {
                ${annotation}
                final RegularFileProperty prop = project.objects.fileProperty()

                @TaskAction
                void go() {
                    println "value: " + prop.get()
                }
            }

            task show(type: SomeTask) {
                prop = file("in.txt")

        failure.assertHasCause("broken task")
    }

    def "fails to get a task by name when it does not match the filtered type"() {
        buildFile << '''
            tasks.register("task1", SomeTask) {
                println "Configure ${path}"
            }

            tasks.create("other") {
                dependsOn tasks.withType(SomeOtherTask).getByName("task1")
            }
        '''

        outputContains("build dir 4: " + testDirectory.file("target"))
    }

    def "layout is available for injection"() {
        buildFile """
            class SomeTask extends DefaultTask {
                @Inject
                ProjectLayout getLayout() { null }

                @TaskAction
                void go() {