File candidate = new File(exeName);
            if (candidate.isFile()) {
                return candidate;
            }
            return null;
        }
        for (File dir : getPath()) {
            File candidate = new File(dir, exeName);
            if (candidate.isFile()) {
                return candidate;
            }
        }

        return null;
    }

    }

    @Override
    public void execute(FileCopyDetails details) {
        RelativePath relativeSourcePath = details.getRelativeSourcePath();
        if (matcher.test(relativeSourcePath.getSegments(), relativeSourcePath.isFile())) {
            toApply.execute(details);
        }
    }

        executer.inDirectory(sample.dir.file(dsl))

        when:
        succeeds('copyLibs')

        then:
        sample.dir.file("$dsl/build/libs/jboss-system-4.2.2.GA.jar").isFile()

        where:
        dsl << ['groovy', 'kotlin']
    }

interface IgnoredConfigurationInputs {
    /**
     * Checks if the [file] should be excluded from the configuration inputs fingerprint if it participates
     * in file system checks, such as [File.exists], [File.isFile] etc.
     */
    fun isFileSystemCheckIgnoredFor(file: File): Boolean

    fun folder(path: String): File =
        existing(path).apply {
            assert(isDirectory)
        }

    fun file(path: String): File =
        existing(path).apply {
            assert(isFile)
        }

    private
    fun existing(path: String): File =
        File(root, path).canonicalFile.apply {
            assert(exists())
        }
}

    group = "build"
    with(allDistributionSpec())
    into(installDirectory)
}

fun validateInstallDir(installDir: Directory) = installDir.also { dir ->
    val dirFile = dir.asFile
    if (dirFile.isFile) {
        throw RuntimeException("Install directory $dir is not valid: it is actually a file")
    }
    if (dirFile.list()?.isEmpty() != false) {
        return@also
    }

            patternSet.exclude(excludeSpec);
            DirectoryFileTree fileTree = new DirectoryFileTree(baseDir, patternSet, fileSystem);
            fileTree.visitFrom(visitor, file, new RelativePath(file.isFile(), pathSegments.toArray(new String[0])), stopFlag);
        } else if (segment.contains("*") || segment.contains("?")) {
            PatternStep step = PatternStepFactory.getStep(segment, false);

            return DefaultFileMetadata.missing(AccessType.DIRECT);
        }
        if (f.isDirectory()) {
            return DefaultFileMetadata.directory(AccessType.DIRECT);
        }
        if (f.isFile()) {
            return DefaultFileMetadata.file(f.lastModified(), f.length(), AccessType.DIRECT);
        }
        throw new UncheckedIOException("Unsupported file type for " + f.getAbsolutePath());
    }

        if (regularFile == null) {
            return null;
        }
        final File file = regularFile.getAsFile();
        if (!file.isFile()) {
            return null;
        }
        return obtainFrom(file);
    }

    protected abstract T obtainFrom(File file);

    }

    @Override
    public boolean isSatisfiedBy(FileTreeElement element) {
        RelativePath relativePath = element.getRelativePath();
        return matcher.test(relativePath.getSegments(), relativePath.isFile());
    }