val ktType = psiType!!.asKaType(useSitePosition ?: psiDeclaration)!!
                    appendLine("${PsiType::class.simpleName}: ${AnalysisApiPsiTypeProviderTestUtils.render(psiType)}")
                    appendLine("${KaType::class.simpleName}: ${AnalysisApiPsiTypeProviderTestUtils.render(analysisSession, ktType)}")
                }
            }
        }

            analyseForTest(whenExpression) {
                buildString {
                    for (missingCase in whenExpression.getMissingCases()) {
                        appendLine(missingCase::class.simpleName + " - " + missingCase.branchConditionText)
                    }
                }
            }
        }

        testServices.assertions.assertEqualsToTestDataFileSibling(actual)

            assert(module == providerModule)
            assert(module == mainModule.ktModule)

            val actualString = buildString {
                append("File: ").appendLine(mainFile.name)
                append("Module: ").append(module.moduleDescription).append(" (").append(module.javaClass.simpleName).append(")")
            }

        val testFileText = FileUtil.loadFile(File(filePath))
        val fileTextWithoutSymbolsData = testFileText.substringBeforeLast(SYMBOLS_TAG).trimEnd()
        appendLine(fileTextWithoutSymbolsData)
        appendLine()
        appendLine(SYMBOLS_TAG)
        append(rendered)
    }

    private const val SYMBOLS_TAG = "// SYMBOLS:"
}

            .map { getSessionKtModule(it).toString() }
            .distinct()
            .sorted()

        val actualText = buildString {
            appendLine("Module names of invalidated sessions:")
            invalidatedModuleDescriptions.forEach { appendLine(it) }
        }

        testServices.assertions.assertEqualsToTestDataFileSibling(
            actualText,

                            append(renderFrontendIndependentKClassNameOf(contextTestCase.element))
                            appendLine(':')
                            withIndent {
                                append(output)
                            }
                        } else {
                            append(output)

                    }
                }
            }
        }

        val actual = buildString {
            shortenings.forEach { (name, shortening) ->
                appendLine("with ${name}:")
                if (shortening.isEmpty) return@forEach
                renderShorteningResults(shortening)
            }
        }
        testServices.assertions.assertEqualsToTestDataFileSibling(actual)

        val actual = analyseForTest(ktDeclaration) {
            val declarationSymbol = ktDeclaration.getSymbol() as KaAnnotatedSymbol
            buildString {
                appendLine("${KtDeclaration::class.simpleName}: ${ktDeclaration::class.simpleName} ${ktDeclaration.name}")
                append(renderAnnotations(analysisSession, declarationSymbol.annotations))
            }
        }

            val classId = ClassId.fromString(classIdString)
            val renderer = DebugSymbolRenderer()
            fun renderAnnotation(application: KaAnnotation): String = buildString {
                appendLine("${KtDeclaration::class.simpleName}: ${ktDeclaration::class.simpleName} ${ktDeclaration.name}")
                append(renderer.renderAnnotationApplication(analysisSession, application))
            }

        }
    }

    private fun KaSession.renderForTests(
        element: KtElement,
        scopeContext: KaScopeContext,
        printPretty: Boolean = false,
    ): String = prettyPrint {
        appendLine("element: ${element.text}")
        renderForTests(analysisSession, scopeContext, this@prettyPrint, printPretty) { scopeKind ->