}
                }
            }
        }

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

                    }

                    is DeclarativeDocument.DocumentNode.PropertyNode -> appendLine("property(${node.name}, ${valueToString(node.value)})" + maybeSourceData(node))
                    is DeclarativeDocument.DocumentNode.ErrorNode -> appendLine("error(${node.errors.joinToString { errorString(it) }}" + maybeSourceData(node))
                }
            }

            val substitutor = createInheritanceTypeSubstitutor(baseClass.getClassOrObjectSymbol()!!, superClassSymbol)
            prettyPrint {
                appendLine("Substitutor: ${stringRepresentation(substitutor)}")
                if (substitutor != null) {
                    val functions = superClassSymbol.getDeclaredMemberScope().getAllSymbols()

                analyze(declaration) {
                    val ktType = declaration.getReturnKaType()
                    appendLine("${KaType::class.simpleName}: ${AnalysisApiPsiTypeProviderTestUtils.render(analysisSession, ktType)}")
                    val psiType = ktType.asPsiType(psiContext, allowErrorTypes = false)
                    appendLine("${PsiType::class.simpleName}: ${AnalysisApiPsiTypeProviderTestUtils.render(psiType)}")
                }
            }

                    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)