String applyTo = allProjects ? "allprojects" : "subprojects"
        buildFile.createFile().text = """
$applyTo {
    apply plugin:'java'
    apply plugin:'$ideName'
}
"""
        settingsFile.createFile().text = "rootProject.name='$projectName'\n"
        def proj = new Project(name: projectName, path: "", projectDir: getTestDirectory())

    protected void finalize() throws Throwable {
        maybeWarnAboutCleanUp();

        super.finalize();
    }

    public File createFile(String filename, String content, String encoding) throws IOException {
        File dir = createTempDir();
        return createFile(dir, filename, content, encoding);
    }

public class ManifestUtilTest extends Specification {
    @Rule
    final TestNameTestDirectoryProvider tmpDir = new TestNameTestDirectoryProvider(getClass())
    def jarFile = tmpDir.file("mydir/jarfile.jar").createFile()

    def "creates manifest classpath with relative urls"() {
        when:
        def classpathFiles = [tmpDir.file('mydir/jar1.jar'), tmpDir.file('mydir/nested/jar2.jar')]

        then:

        pch.includeString >> "header"
        pch.prefixHeaderFile >> temporaryFolder.file("prefixHeader").createFile()
        pch.objectFile >> temporaryFolder.file("pchObjectFile").createFile()
        pch.pchObjects >> TestFiles.empty()
        1 * objCCompiler.execute({ ObjectiveCCompileSpec spec ->
            assert spec.sourceFiles*.name == ["sourceFile"]

    @ToBeFixedForConfigurationCache
    def "reuses #service across continuous builds" () {
        def triggerFileName = "trigger"
        def triggerFile = file(triggerFileName).createFile()
        def idFileName = "build/${service}.id"
        def idFile = file(idFileName).createFile()
        buildFile << """
            import ${UnscopedCacheBuilderFactory.name}
            import ${WorkerProcessClassPathProvider.name}

    }

    def "can set static library file"() {
        given:
        def file = createFile()

        when:
        binary.staticLibraryFile = file

        then:
        binary.staticLibraryFile == file
        binary.linkFiles.files == [file] as Set

        and:
        binary.runtimeFiles.empty
    }

    def createFile() {
        def file = Stub(File) {
            exists() >> true

    def setup() {
        task = createTask(SourceTask.class)
    }

    def "can append to source"() {
        given:
        File file1 = temporaryFolder.file('file1.txt').createFile()
        File file2 = temporaryFolder.file('file2.txt').createFile()
        file2.createNewFile()

        task.source = file1
        task.source = task.source + project.layout.files(file2)

        expect:

        skipped ':producesLink'

        when:
        target.createFile()
        run 'producesLink'
        then:
        executedAndNotSkipped ':producesLink'
    }

    @Issue('https://github.com/gradle/gradle/issues/1365')
    def "broken symlink not produced by task is ignored"() {
        given:
        def input = file("input.txt").createFile()
        def outputDirectory = file("output")

        f2.parentFile.mkdirs()
        f2 << 'content'
    }
}
"""
    }

    def "uses the target of symlink for input file content"() {
        file("in-dir").createDir()
        def inFile = file("other").createFile()
        def link = file("in.txt")
        link.createLink("other")

        given:
        run("work")
        run("work")
        result.assertTasksSkipped(":work")

        when:

			switch name[3:] {
			case "\u00b2", "\u00b3", "\u00b9":
				return true
			}
			return false
		}
	}

	// Passing CONIN$ or CONOUT$ to CreateFile opens a console handle.
	// https://learn.microsoft.com/en-us/windows/win32/api/fileapi/nf-fileapi-createfilea#consoles
	//
	// While CONIN$ and CONOUT$ aren't documented as being files,
	// they behave the same as CON. For example, ./CONIN$ also opens the console input.