tasks.register('loadfile') {
    def resourceDirectory = file('./antLoadfileResources')
    doLast {
        def files = resourceDirectory.listFiles().sort()
        files.each { File file ->
            if (file.isFile()) {
                ant.loadfile(srcFile: file, property: file.name)
                println " *** $file.name ***"
                println "${ant.properties[file.name]}"
            }
        }
    }

tasks.register("loadfile") {
    val resourceDirectory = file("./antLoadfileResources")
    doLast {
        val files = resourceDirectory.listFiles().sorted()
        files.forEach { file ->
            if (file.isFile) {
                ant.withGroovyBuilder {
                    "loadfile"("srcFile" to file, "property" to file.name)
                }
                println(" *** ${file.name} ***")
                println("${ant.properties[file.name]}")

            logDir.listFiles { file ->
                file.isFile && file.name.matches(resolverLogFilenameRegex) && Date(file.lastModified()).before(expiration)
            }.forEach { it.delete() }
        }

    private
    fun readyForCleanup(logDir: File, cleanup: () -> Unit) =
        logDir.resolve(".cleanup").run {
            if (!isFile || (isFile && Date(lastModified()).before(daysAgo(cleanupAfterDays)))) {

            spec.classpath(files as Object[])
            spec.mainClass = SomeMain.name
            spec.args testFile.absolutePath
        }

        then:
        testFile.isFile()
        result.exitValue == 0
    }

    def javaexecWithNonZeroExitValueShouldThrowException() {
        when:
        factory.javaexec { spec ->
            spec.mainClass = 'org.gradle.UnknownMain'
        }

        executer.inDirectory(dslDir)

        when:
        succeeds(COPY_LIBS_TASK_NAME)

        then:
        dslDir.file('build/libs/httpclient-4.5.3.jar').isFile()
        dslDir.file('build/libs/commons-codec-1.11.jar').isFile()

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

    @UsesSample("dependencyManagement/managingTransitiveDependencies-forceForDependency")

                    }
                    assertTrue(files.add(details.relativePath.pathString))
                    assertTrue(details.relativePath.isFile())
                    assertTrue(details.file.file)
                    ByteArrayOutputStream outstr = new ByteArrayOutputStream()
                    details.copyTo(outstr)

    }

    def "toolchain service dependencies are satisfied"() {
        expect:
        project.extensions.getByType(JavaToolchainService).launcherFor(Actions.doNothing()).get().executablePath.asFile.isFile()
    }

}

func applyDefaults(pod *api.Pod, source string, isFile bool, nodeName types.NodeName) error {
	if len(pod.UID) == 0 {
		hasher := md5.New()
		hash.DeepHashObject(hasher, pod)
		// DeepHashObject resets the hash, so we should write the pod source
		// information AFTER it.
		if isFile {
			fmt.Fprintf(hasher, "host:%s", nodeName)
			fmt.Fprintf(hasher, "file:%s", source)
		} else {

            ant.loadfile(srcFile: file, property: file.name)
            println "I'm fond of $file.name"
        }
    }
}

File[] fileList(String dir) {
    file(dir).listFiles({file -> file.isFile() } as FileFilter).sort()

public class RelativePathTest {

    private void assertPathContains(RelativePath path, boolean isFile, String... expectedSegments) {
        String[] actualPaths = path.getSegments();
        assertArrayEquals(expectedSegments, actualPaths);
        assertEquals(isFile, path.isFile());
    }

    @Test
    public void testConstructors() {
        RelativePath path;