static tests = new HashSet()
    static tmpDirs = new HashSet()

    def setup() {
        //it's very important we try to access the test dir in the setup()
        tmp.testDirectory
    }

    def "testOne"() {
        when:
        tests << "testOne"
        tmpDirs << tmp.testDirectory

        then:
        tests.size() == tmpDirs.size()
    }

    def "testTwo"() {
        when:

    static tests = new HashSet()
    static tmpDirs = new HashSet()

    def setup() {
        //it's very important we try to access the test dir in the setup()
        temp.testDirectory
    }

    def "testOne"() {
        when:
        tests << "testOne"
        tmpDirs << temp.testDirectory

        then:
        tests.size() == tmpDirs.size()
    }

    def "testTwo"() {
        when:

        factory.addPathVariable('SUB_DIR', tmpDir.file('sub'))

        expect:
        def path = factory.path(tmpDir.file('sub', 'a'))
        path.url == 'file://$SUB_DIR$/a'
        path.relPath == '$SUB_DIR$/a'
    }

    def createsPathForARootDir() {
        factory.addPathVariable('SUB_DIR', tmpDir.file('sub'))
        factory.addPathVariable('ROOT_DIR', tmpDir.testDirectory)

}

func TestCanSupport(t *testing.T) {
	tmpDir, plug := getPlugin(t)
	defer os.RemoveAll(tmpDir)

	if !plug.CanSupport(getTestVolume(false, tmpDir, false, nil)) {
		t.Errorf("Expected true")
	}
}

func TestGetAccessModes(t *testing.T) {
	tmpDir, plug := getPersistentPlugin(t)
	defer os.RemoveAll(tmpDir)

	modes := plug.GetAccessModes()

        layout.buildDefinitionMissing

        cleanup: "temporary tree"
        tmpDir.deleteDir()
    }

    def "returns closest ancestor directory that contains a #settingsFilename file"() {
        given:
        def locator = buildLayoutFactoryFor()

        and:
        def currentDir = tmpDir.createDir("sub/current")
        def subDir = tmpDir.createDir("sub")
        def settingsFile = subDir.createFile(settingsFilename)

    def "adding an empty jar inside another jar changes the hashcode"() {
        given:
        def outerContent = tmpDir.createDir("outer")
        def outer = tmpDir.file("outer.jar")
        outerContent.zipTo(outer)
        def originalHash = zipHasher.hash(snapshotContext(outer))

        when:
        def innerContent = tmpDir.createDir("inner")
        def inner = outerContent.file("inner.jar")
        innerContent.zipTo(inner)

        when:
        permissions.chmod(tmpDir.createFile("file"), 0644)
        permissions.chmod(tmpDir.createDir("dir"), 0644)

        then:
        outputEventListener.toString() == WARN_MESSAGE
    }

    def "warns at most once"() {
        when:
        permissions.chmod(tmpDir.createFile("file"), 0644)
        permissions.getUnixMode(tmpDir.createDir("dir"))

    }

    def "deletes empty parent directories"() {
        def file1 = tmpDir.file('foo/bar/file1').createFile()
        tmpDir.file('foo/baz/file2').createFile()

        expect:
        StaleOutputCleaner.cleanOutputs(deleter, files(file1), tmpDir.testDirectory)
        !tmpDir.file('foo/bar').exists()
        tmpDir.file('foo/baz').exists()
    }

    def "deletes parent directories regardless of order"() {

    )

    def doesNotDeleteFilesInsideSymlinkDir() {
        Assume.assumeTrue(canCreateSymbolicLinkToDirectory())

        given:
        def keepTxt = tmpDir.createFile("originalDir", "keep.txt")
        def originalDir = keepTxt.parentFile
        def link = new File(tmpDir.getTestDirectory(), "link")

        when:
        createSymbolicLink(link, originalDir)

        then:
        link.exists()

        when:

        fileTree.matching(_) >> fileTree
        resolver.resolve('dir') >> tmpDir.getTestDirectory()

        when:
        def result = fileOperations.copy { from 'file'; into 'dir' }

        then:
        !result.didWork
    }

    def deletes() {
        def fileToBeDeleted = tmpDir.file("file")
        def fileCollection = Stub(FileCollectionInternal)