Outer.Inner.Deeper weMustGoDeeper = null
"""
        ]
    }

    private void checkScriptClassesInCache(boolean empty = false) {
        assertTrue(scriptCacheDir.isDirectory())
        assertTrue(cachedFile.isFile())
        checkEmptyScriptFlagSet(empty)
    }

    private void checkEmptyScriptInCache() {
        assertTrue(scriptCacheDir.isDirectory())
        checkEmptyScriptFlagSet(true)
    }

        @Override
        public File getFile() {
            throw new UnsupportedOperationException();
        }

        @Override
        public boolean isDirectory() {
            return !path.isFile();
        }

        @Override
        public long getLastModified() {
            return lastModified;
        }

        @Override
        public long getSize() {

        fileCollection.iterator() >> [fileToBeDeleted].iterator()
        fileToBeDeleted.touch()

        expect:
        fileOperations.delete('file') == true
        fileToBeDeleted.isFile() == false
    }

    def makesDir() {
        TestFile dirToBeCreated = tmpDir.file("parentDir", "dir")
        resolver.resolve('parentDir/dir') >> dirToBeCreated

        when:

            }
        """
    }

    static void assertHasImplementationClasspath(File pluginMetadata, List<File> expected) {
        assert pluginMetadata.exists() && pluginMetadata.isFile()
        assert !pluginMetadata.text.contains("#")
        def implementationClasspath = GUtil.loadProperties(pluginMetadata).getProperty(IMPLEMENTATION_CLASSPATH_PROP_KEY)
        assert !implementationClasspath.contains("\\")

            }
        }
    }

    private static Properties readProperties(File propertiesFile) {
        Properties properties = new Properties();

        if (propertiesFile.isFile()) {

            try {
                try (FileInputStream inputStream = new FileInputStream(propertiesFile)) {
                    properties.load(inputStream);
                }

        }
    }

    static FileCheck fileExists(String filePath) {
        new FileCheck(filePath, "exists")
    }

    static FileCheck fileIsFile(String filePath) {
        new FileCheck(filePath, "isFile")
    }

    static FileCheck fileIsDirectory(String filePath) {
        new FileCheck(filePath, "isDirectory")
    }

    static UndeclaredFileAccess directoryContent(String directoryPath) {

            result.output.contains(error)
        )
    }

    private
    fun assertTargetIsPreserved() {
        assertTrue((target.list()?.size ?: 0) > 0)
        assertTrue(target.walk().filter { it.isFile }.all { it.readText() == "stub" })
    }

    private
    fun createMinimalDistribution() {
        projectRoot.mkdir()
        File(projectRoot, "build.gradle.kts").writeText("""
        plugins {

        )
    }

    private
    fun generatedExtensionsJarFromGradleInstallation(gradleHomeDir: File): File =
        gradleHomeDir.resolve("lib")
            .listFiles { f -> f.isFile && f.name.startsWith("gradle-kotlin-dsl-extensions-") }!!
            .single()

        existing(relativePath).apply { assert(mkdirs()) }

    protected
    fun newOrExisting(fileName: String) =
        existing(fileName).let {
            when {
                it.isFile -> it
                else -> newFile(fileName)
            }
        }

    protected
    fun existing(relativePath: String): File =
        canonicalFile(relativePath)

    private

	}
	return real
}

// isdir reports whether p names an existing directory.
func isdir(p string) bool {
	fi, err := os.Stat(p)
	return err == nil && fi.IsDir()
}

// isfile reports whether p names an existing file.
func isfile(p string) bool {
	fi, err := os.Stat(p)
	return err == nil && fi.Mode().IsRegular()
}

// mtime returns the modification time of the file p.
func mtime(p string) time.Time {