def "returns single task with type"() {
        def copyTask = Mock(Copy)
        when:
        tasks.add(copyTask)

        then:
        tasks.findSingleTaskWithType(Copy) == copyTask
    }

    def "fails finding single task with type where multiple exist"() {
        def copyTask1 = Mock(Copy)
        def copyTask2 = Mock(Copy)
        when:
        tasks.add(copyTask1)
        tasks.add(copyTask2)

        and:

        when:
        run "copyTask"
        then:
        executedAndNotSkipped(":copyTask")
        !copyOfExcludedFile.exists()

        when:
        excludedFile.text = "changed"
        run "copyTask"
        then:
        skipped(":copyTask")

        when:
        settingsFile.text = ""
        excludedFile.text = "changedAgain"
        run "copyTask"
        then:

        configurationCacheRun spec.copyTask

        then:
        configurationCache.assertStateStored()
        !spec.excludedFilesCopies.any { it.exists() }
        spec.includedFilesCopies.every { it.exists() }

        when:
        configurationCacheRun spec.copyTask

        then:
        configurationCache.assertStateLoaded()
        result.assertTaskSkipped(":$spec.copyTask")

        when:

    // up-to-date check for inputs, plus add copyTask as dependency
    inputs.files(copyTask)
        .withPropertyName("inputs")
        .withPathSensitivity(PathSensitivity.RELATIVE)
    outputs.dir('some-dir') // up-to-date check for outputs
        .withPropertyName("outputDir")
    doLast {
        copy {
            // Copy the output of copyTask
            from copyTask
            into 'some-dir'
        }
    }

    // up-to-date check for inputs, plus add copyTask as dependency
    inputs.files(copyTask)
        .withPropertyName("inputs")
        .withPathSensitivity(PathSensitivity.RELATIVE)
    outputs.dir("some-dir") // up-to-date check for outputs
        .withPropertyName("outputDir")
    doLast {
        copy {
            // Copy the output of copyTask
            from(copyTask)
            into("some-dir")
        }

            ]
        ].combinations().collect { language, locations ->
            new Spec(locations, language)
        }
    }

    static class Spec {

        final String copyTask = "copyTask"

        private final List<DefaultExcludesLocation> locations

        private final ScriptLanguage scriptLanguage

        private final List<TestFile> excludedFiles = new ArrayList<>()

[.multi-language-sample]
=====
[source, kotlin]
----
tasks.register<Copy>("copyTask") {
    from("source")
    into("target")
    include("*.war")
}
----
=====
[.multi-language-sample]
=====
[source, groovy]
----
tasks.register(Copy, "copyTask") {
    from("source")
    into("target")
    include("*.war")
}

----
=====

        buildScript """
            task copyTask(type: Copy) {
                into "out"
                from "b", {
                    includeEmptyDirs = false
                }
                from "a"
                from "c", {}
            }
        """

        when:
        succeeds "copyTask"

        then:
        executedAndNotSkipped(":copyTask")

This example task copies `*.war` files from the `source` directory to the `target` directory using the `Copy` built-in task:

[source]
----
tasks.register("copyTask",Copy) {
    from("source")
    into("target")
    include("*.war")
}
----

    @UsesSample("files/copy")
    def "can use copy task with #dsl dsl"() {
        given:
        def dslDir = sample.dir.file(dsl)
        executer.inDirectory(dslDir)

        when:
        succeeds('copyTask')

        then:
        def outputDir = dslDir.file("build/explodedWar")
        outputDir.file('web.xml').isFile()
        outputDir.file('index-staging.html').isFile()