@Override
    public Iterator<File> iterator() {
        return getFiles().iterator();
    }

    @Override
    public String getAsPath() {
        showGetAsPathDeprecationWarning();
        return GUtil.asPath(this);
    }

    private void showGetAsPathDeprecationWarning() {
        List<String> filesAsPaths = this.getFiles().stream()
            .map(File::getPath)

    final library = new SwiftGreeterWithOptionalFeature()
    final application = new SwiftMainWithOptionalFeature(library.withFeatureDisabled()) {
        @Override
        List<SourceFile> getFiles() {
            return super.getFiles().collect {
                sourceFile(it.path, it.name, "import Greeter\n${it.content}")
            }
        }
    }

    AppElement withFeatureEnabled() {

                    attributes {
                        attributes.attribute(TargetJvmVersion.TARGET_JVM_VERSION_ATTRIBUTE, targetJvmVersion)
                    }
                    withFiles {
                        removeAllFiles()
                        addFile("guava-$version-$jarName.jar", "../$version-$jarName/guava-$version-$jarName.jar")
                    }
                }
            }

    def "can visit broken symlink"() {
        given:
        def rootDir = tmpDir.createDir("root")
        rootDir.file('brokenSymlink').createLink("linkTarget")
        assert rootDir.listFiles()*.exists() == [false]

        when:
        snapshot(rootDir)

        then:
        1 * statisticsCollector.recordVisitHierarchy()

        then:

    String getSampleName() {
        "workerApi/workerDaemon"
    }

    @Override
    void assertSampleSpecificOutcome(String dsl) {
        workerExecutorSample(dsl).file("sources").listFiles().each { File sourceFile ->
            result.assertOutputContains("Reversed ${sourceFile.size()} bytes from ${sourceFile.name}")
        }
    }

            }
        }

        // Wait for all asynchronous work submitted to this queue to complete before continuing
        workQueue.await()
        logger.lifecycle("Created ${outputDir.get().asFile.listFiles().length} reversed files in ${projectLayout.projectDirectory.asFile.relativePath(outputDir.get().asFile)}")

        // end::wait-for-completion[]
    }
}

task reverseFiles(type: ReverseFiles) {

    protected TestFile unpackDistribution(type = getDistributionLabel(), TestFile into = testDirectory) {
        TestFile zip = getZip(type)
        zip.usingNativeTools().unzipTo(into)
        assert into.listFiles().size() == 1
        into.listFiles()[0]
    }

    protected TestFile getZip(String type = getDistributionLabel()) {
        switch (type) {
            case 'bin':
                buildContext.binDistribution

            .willBecomeAnErrorInGradle9()
            .withUpgradeGuideSection(8, "deprecate_self_resolving_dependency")
            .nagUser();

        return source.getFiles();
    }

    @Override
    @Deprecated
    public Set<File> resolve(boolean transitive) {
        DeprecationLogger.deprecate("Directly resolving a file collection dependency's files")

    }

    @Override
    protected String getConfiguredModule() {
        return "idea.module"
    }

    @Override
    protected String projectName(String path) {
        File iml = file(path).listFiles().find { it.name.endsWith("iml") }
        assert iml != null
        return iml.name - ".iml"
    }

    @TaskAction
    fun run() {
        val bundleFile = projectLayout.buildDirectory.file("bundle.js").get().asFile
        val scriptsFiles = projectLayout.projectDirectory.dir("scripts").asFile.listFiles()

        bundleFile.outputStream().use { stream ->
            scriptsFiles.sorted().forEach {
                stream.write(it.readBytes())
            }
        }
    }
}

// tag::bundle-task[]