doFirst {
        // On daemon crash, read-only cache tests can leave read-only files around.
        // clean now takes care of those files as well
        testFiles.get().asFileTree.matching {
            include("**/read-only-cache/**")
        }.visit { this.file.setWritable(true) }
    }

        this.parameters = parameters
    }

    @SuppressWarnings("UnusedDeclaration")
    void execute(AntBuilderDelegate ant) {
        def source = parameters.source.asFileTree
        def showViolations = parameters.showViolations.get()
        def maxErrors = parameters.maxErrors.get()
        def maxWarnings = parameters.maxWarnings.get()

    def copiesFiles() {
        def fileCollection = Mock(ConfigurableFileCollection)
        def fileTree = Mock(FileTreeInternal)
        fileCollectionFactory.configurableFiles() >> fileCollection
        fileCollection.asFileTree >> fileTree
        fileTree.matching(_) >> fileTree
        resolver.resolve('dir') >> tmpDir.getTestDirectory()

        when:
        def result = fileOperations.copy { from 'file'; into 'dir' }

        file('other/c/other-one.txt').createFile()
        file('other/c/other-ignore.txt').createFile()
        buildFile """
            def files = files('files', 'other').asFileTree.matching {
                include("**/*.txt")
                exclude("**/*ignore*")
            }
            task copy(type: Copy) {
                from files
                into 'dest'

                    inputs.dir sources skipWhenEmpty()
                    outputs.dir "${outputDir}"
                    def outputDir = file("${outputDir}")
                    def sourceTree = files(sources).asFileTree
                    doLast {
                        outputDir.mkdirs()
                        sourceTree.visit { details ->
                            if (!details.directory) {

        1 * dependencySource.visitDependencies(_) >> { TaskDependencyResolveContext context -> context.add(dependency2) }

        def dependencies = collection.asFileTree.buildDependencies

        expect:
        dependencies.getDependencies(task) as List == [dependency1]
        dependencies.getDependencies(task) as List == [dependency2]
    }

                }
            }

            testing.suites.test.sources.runtimeClasspath =
                testing.suites.test.sources.output.plus(
                    renameJUnitJars.outputs.files.asFileTree.matching {
                        include '**/*.jar'
                    }
                )
        """

        addClasspathTest("""

            task incomingDependencies { dependsOn configurations.compile.incoming.dependencies }
            task copy { inputs.files configurations.compile.copy() }
            task filteredTree { inputs.files configurations.compile.asFileTree.matching { true } }
'''

        when:

                output = layout.buildDirectory.dir('dir')
                names = ['a.txt', 'b.txt', 'c.txt']
            }
            tasks.register("b", InputFilesTask) {
                inFiles.from task.output.map { it.asFileTree.matching { include 'a.*'; include 'c.txt' } }
                outFile = file("out.txt")
            }
        """

        when:
        run("b")

        then:

                            ${server.callFromBuild("zipFileSnapshottingStarted")}
                        }
                        countResolved++
                        it.asFileTree.matching {
                            include "src/**"
                            include "build.gradle"
                        }
                    })
                }

                @TaskAction