*/
    @Console
    public boolean isListFiles() {
        return listFiles;
    }

    /**
     * Sets whether to log the files to be compiled. Defaults to {@code false}.
     */
    public void setListFiles(boolean listFiles) {
        this.listFiles = listFiles;
    }

    /**

    }

    private static def collectJars(TestFile file, Collection<File> acc = []) {
        if (file.name.endsWith('.jar')) {
            acc.add(file)
        }
        if (file.isDirectory()) {
            file.listFiles().each { f -> collectJars(f, acc) }
        }
        acc
    }

// tag::closure[]
tasks.register("list") {
    val projectDirectory = layout.projectDirectory
    doLast {
        var srcDir: File? = null

        val collection = projectDirectory.files({
            srcDir?.listFiles()
        })

        srcDir = projectDirectory.file("src").asFile
        println("Contents of ${srcDir.name}")
        collection.map { it.relativeTo(projectDirectory.asFile) }.sorted().forEach { println(it) }

        notifyListener(candidate);
        return candidate.isFile();
    }

    @Override
    public List<File> findScriptsIn(File dir) {
        File[] candidates = dir.listFiles();
        if (candidates == null || candidates.length == 0) {
            return emptyList();
        }
        List<File> found = new ArrayList<File>(candidates.length);
        for (File candidate : candidates) {

fun directoryChildrenNamesHash(file: File): HashCode {
    return file.list()?.let { entries ->
        val hasher = Hashing.newHasher()
        // This routine is used to snapshot results of File.list(), File.listFiles() and similar calls.
        // Technically, the relative order or entries is visible to the caller, so it might be considered when computing the hash.

            return new File[0];
        }
        final File libDir = new File(libPath);
        if (!libDir.exists()) {
            return new File[0];
        }
        return libDir.listFiles((file, name) -> name.startsWith(namePrefix));
    }

    public static File[] getPluginJarFiles(final String namePrefix) {
        return getPluginJarFiles((file, name) -> name.startsWith(namePrefix));
    }

                def resolveMainClassName() {
                    // Find first root package class with a name that ends with `Main`
                    def rootPackageFiles = classpath.files.collectMany { it.isDirectory() ? it.listFiles().toList() : [] }
                    def mainClassFile = rootPackageFiles.find { it.name.endsWith 'Main.class' }
                    mainClassFile.name.with {
                        take(length() - '.class'.length())

        if (shouldRemoveContentsOf(file, handling)) {
            File[] contents = file.listFiles();

            // Something else may have removed it
            if (contents == null) {
                return false;
            }

            boolean attemptedToDeleteAnything = false;

    static GradleDistribution previous
    private MavenFileRepository mavenRepo
    private TestFile gradleUserHomeDir

    boolean retryWithCleanProjectDir() {
        temporaryFolder.testDirectory.listFiles().each {
            it.deleteDir()
        }
        true
    }

    def cleanup() {
        executers.each { it.cleanup() }
    }

    void requireOwnGradleUserHomeDir() {

        then:
        configurationCache.assertStateLoaded()
        findReport()
    }

    private TestFile findReport() {
        def reportFile = file('build/reports/profile').listFiles().find { it.name ==~ /profile-.+.html/ }
        assert reportFile && reportFile.exists()
        reportFile
    }