func (f fakeFile) Mode() fs.FileMode  { return f.real.Mode() }
func (f fakeFile) ModTime() time.Time { return f.real.ModTime() }
func (f fakeFile) IsDir() bool        { return f.real.IsDir() }
func (f fakeFile) Sys() any           { return f.real.Sys() }

func (f fakeFile) String() string {
	return fs.FormatFileInfo(f)
}

// missingFile provides an fs.FileInfo for an overlaid file where the

        //delete marker file to make the previously downloaded installation undetectable
        def markerFile = findMarkerFile(executer.gradleUserHomeDir.file("jdks"))
        markerFile.delete()
        assert !markerFile.exists()

        and: "build runs again"
        jdkRepository.expectHead()
        executer

        }

        val pointersWithRendered = executeOnPooledThreadInReadAction {
            analyseForTest(mainFile) {
                val (symbols, symbolForPrettyRendering) = collectSymbols(mainFile, testServices)

                checkContainingFiles(symbols, mainFile, testServices)

                val pointerWithRenderedSymbol = symbols
                    .asSequence()

abstract class AbstractPackageScopeTest : AbstractScopeTestBase() {
    override fun KaSession.getScope(mainFile: KtFile, testServices: TestServices): KaScope =
        getSingleTestTargetSymbolOfType<KaPackageSymbol>(mainFile, testDataPath).getPackageScope()

    override fun getAllowedContainingFiles(mainFile: KtFile, testServices: TestServices): Set<KtFile> {

abstract class AbstractElementDiagnosticsTest : AbstractAnalysisApiBasedTest() {
    override fun doTestByMainFile(mainFile: KtFile, mainModule: KtTestModule, testServices: TestServices) {
        val targetDeclaration = testServices.expressionMarkerProvider.getSelectedElementOfType<KtElement>(mainFile)

        analyze(mainFile) {
            val diagnostics = targetDeclaration.getDiagnostics(KaDiagnosticCheckerFilter.EXTENDED_AND_COMMON_CHECKERS)

    val commentRegex = Regex("""/\* (.+@\(.+\)|null) \*/""")

    override fun doTestByMainFile(mainFile: KtFile, mainModule: KtTestModule, testServices: TestServices) {
        val original = mainFile.text
        val actual = buildString {
            mainFile.accept(object : KtTreeVisitorVoid() {
                override fun visitElement(element: PsiElement) {

        super.configureTest(builder)
        builder.useDirectives(Directives)
    }

    override fun doTestByMainFile(mainFile: KtFile, mainModule: KtTestModule, testServices: TestServices) {
        val elementsByMarker = collectElementsToResolve(mainFile, mainModule, testServices).groupBy { it.marker }
        val actual = prettyPrint {
            printMap(
                map = elementsByMarker,

abstract class AbstractAnalysisApiImportOptimizerTest : AbstractAnalysisApiBasedTest() {
    override fun doTestByMainFile(mainFile: KtFile, mainModule: KtTestModule, testServices: TestServices) {
        val importsAnalysis = analyseForTest(mainFile) {
            analyseImports(mainFile)
        }

        val importAnalysisRendered = buildString {
            val sortedUsedDeclarations = importsAnalysis.usedDeclarations

        val fakeFile = object : KtFile(KtClassFileViewProvider(psiManager, fileContent.file), isCompiled = true) {
            override fun getStub() = ktFileStub

            override fun isPhysical() = false
        }
        ktFileStub.psi = fakeFile
        createdFakeKtFiles.add(fakeFile)
        return ktFileStub
    }

    }

    override fun collectElementsToResolve(
        mainFile: KtFile,
        mainModule: KtTestModule,
        testServices: TestServices,
    ): Collection<ResolveTestCaseContext<KtReference?>> {
        val caretPositions = testServices.expressionMarkerProvider.getAllCarets(mainFile).ifEmpty {
            testServices.expressionMarkerProvider.getSelectedRangeOrNull(mainFile)?.let {
                CaretMarker(tag = "", offset = it.startOffset)