def "can visit directory hierarchy"() {
        given:
        def root = tmpDir.createDir("root")
        def subDir1 = root.createDir("sub-dir-1")
        subDir1.createFile("file.txt")
        def subDir2 = root.createDir("sub-dir-2")
        subDir2.createFile("file.txt")

        when:
        snapshot(root)

        then:
        1 * statisticsCollector.recordVisitHierarchy()

        then:

    def "updates modification time"() {
        given:
        def file = tmpDir.createFile("file")

        when:
        journal.setLastAccessTime(file, FIXED_TIMESTAMP)

        then:
        file.lastModified() == FIXED_TIMESTAMP
    }

    def "reads modification time"() {
        given:
        def file = tmpDir.createFile("file")
        file.lastModified = FIXED_TIMESTAMP

        when:

    def "deletes nothing by default"() {
        expect:
        delete.getDelete().isEmpty()
    }

    def "did work is true when something gets deleted"() {
        given:
        def file = temporaryFolder.createFile("someFile")

        when:
        delete.delete(file)
        execute(delete)

        then:
        delete.getDidWork()
        !file.exists()
    }

		name           string
		contents       string
		createFile     bool
		expectedResult *apiserver.EgressSelectorConfiguration
		expectedError  *string
	}{
		{
			name:           "empty",
			createFile:     true,
			contents:       ``,
			expectedResult: nil,
			expectedError:  strptr("invalid service configuration object \"\""),
		},
		{
			name:           "absent",
			createFile:     false,
			contents:       ``,

    def "set task selector description taken from task with path that has lowest ordering"() {
        temporaryFolder.createFile('settings.gradle') << '''
          rootProject.name = 'TestProject'
          include 'sub'
        '''

        temporaryFolder.createFile('build.gradle') << '''
          task alpha {
            description = 'ALPHA from root project'
          }
          task beta {}

    }

    def kitDir(String name, String... versions) {
        def dir = tmpDir.createDir(name)
        PLATFORMS.each { dir.createFile("bin/${it}/rc.exe") }
        versions.each { version ->
            dir.createFile("Include/${version}/um/windows.h")
            PLATFORMS.each { dir.createFile("Lib/${version}/um/${it}/kernel32.lib") }
        }
        return dir
    }

            fileCollection.from(sourceDirs.srcDirTrees)
            println("files = \${fileCollection.files.name.sort()}")
        """

        given:
        file("dir1/file1").createFile()
        file("dir1/file2").createFile()
        file("dir2/sub/file3").createFile()

        expect:
        succeeds()
        outputContains("files = [file1, file2, file3]")
    }

    def "can view the elements of file collection as a Provider"() {

        pch.objectFile >> temporaryFolder.file("pchObjectFile").createFile()
        pch.name >> "testPch"
        pch.projectPath >> ":"
        pch.includeString >> "header"
        pch.prefixHeaderFile >> temporaryFolder.file("prefixHeader").createFile()
        pch.pchObjects >> TestFiles.empty()
        1 * cCompiler.execute({ CCompileSpec spec ->

        def watchableHierarchy = file("watchable").createDir()
        def watchableContent = watchableHierarchy.file("some/dir/file.txt").createFile()
        def unsupportedFileSystemMountPoint = watchableHierarchy.file("unsupported")
        def unwatchableContent = unsupportedFileSystemMountPoint.file("some/file.txt").createFile()

        when:
        registerWatchableHierarchies([watchableHierarchy])

    def "should perform #authenticationType put get and list on an S3 bucket"() {
        setup:
        def fileContents = 'This is only a test'
        File file = temporaryFolder.createFile(FILE_NAME)
        file << fileContents
        def directSubdirectories = ['some-dir', 'second-dir', 'some-other-dir']
        directSubdirectories.each { temporaryFolder.createDir(it) }