switch (type) {
                        case FILE:
                            File parentFile = root.getParentFile();
                            if (parentFile != null) {
                                outputDirectoriesToPreserve.add(parentFile);
                            }
                            break;
                        case DIRECTORY:

    }

    void assertHasProjects(String... paths) {
        assert contentXml.FileRef.size() == paths.length
        paths.each { path ->
            assertHasProject(file.parentFile.parentFile.file(path))
        }
    }

    void assertHasProject(File projectFile) {
        assert contentXml.FileRef*.@location*.replaceAll('absolute:', '').contains(projectFile.absolutePath)
    }

        when:
        cleanupAction(finder([cacheEntry.parentFile]), { true })
            .clean(cleanableStore, progressMonitor)

        then:
        1 * progressMonitor.incrementDeleted()
        cacheEntry.assertDoesNotExist()
        cacheEntry.parentFile.assertDoesNotExist()
        deletedFiles == [cacheEntry.parentFile]
    }

    def "deletes empty parent directories"() {
        given:

            getTempDir() >> tempDir
        }

        when:
        def generated = PCHUtils.generatePCHSourceFile(spec, sourceFile)

        then:
        generated.name == "test.${extension}"
        generated.parentFile == pchSourceDir
        generated.text == "#include \"test.h\""
        pchSourceDir.assertContainsDescendants("test.h", "test.${extension}")

        where:
        type              | extension

        if (!androidLock.exists()) {
            androidLock.parentFile.mkdirs()
            androidLock.createNewFile()
        }
        def androidFakeDependency = new File(gradleHome, "android/FakeDependency.jar")
        if (!androidFakeDependency.exists()) {
            androidFakeDependency.parentFile.mkdirs()
            new JarOutputStream(new FileOutputStream(androidFakeDependency)).close()

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package quotedprintable

import "io"

const lineMaxLen = 76

// A Writer is a quoted-printable writer that implements [io.WriteCloser].
type Writer struct {
	// Binary mode treats the writer's input as pure binary and processes end of
	// line bytes as binary data.
	Binary bool

	w    io.Writer
	i    int

        path.url == 'file://$ROOT_DIR$/../../a/b'
        path.relPath == '$ROOT_DIR$/../../a/b'
    }

    def createsRelativePathForASiblingOfRootDir() {
        factory.addPathVariable('ROOT_DIR', tmpDir.testDirectory)

        expect:
        def path = factory.relativePath('ROOT_DIR', tmpDir.testDirectory.parentFile.file('a'))

        def manifestFile = new File(projectDirectory, "META-INF/MANIFEST.MF")
        if (!manifestFile.parentFile.exists()) {
            def success = manifestFile.parentFile.mkdirs()
            if (!success) {
                throw new GradleException("Unable to create directory ${manifestFile.parentFile.absolutePath}")
            }
        }
        manifestFile.text = calculateManifest(projectVersion.get(), jarFile)

     */
    protected void publish(TestFile file, @DelegatesTo(value=Writer, strategy=Closure.DELEGATE_FIRST) Closure cl, byte[] content = null) {
        file.parentFile.mkdirs()
        def hashBefore = file.exists() ? Hashing.sha1().hashFile(file) : null
        def tmpFile = file.parentFile.file("${file.name}.tmp")

        if (content) {
            tmpFile.bytes = content
        } else if (isJarFile(file)) {

        newFolder().also { rootDir ->
            for ((path, bytes) in classEntriesFor(classes)) {
                File(rootDir, path).apply {
                    parentFile.mkdirs()
                    writeBytes(bytes)
                }
            }
        }
    )
}


internal
fun TestWithTempFiles.classPathWithPublicType(name: String) =