val readWriteAccess = expressionAtCaret.readWriteAccess(true)

        val actual = buildString {
            appendLine("expression: ${expressionAtCaret.text}")
            appendLine("access type: $readWriteAccess")
        }

        testServices.assertions.assertEqualsToTestDataFileSibling(actual)
    }

                buildString {
                    appendLine("ALL:")
                    allOverriddenSymbols.forEach { appendLine("  $it") }
                    appendLine("DIRECT:")
                    directlyOverriddenSymbols.forEach { appendLine("  $it") }
                }
            }
        }
        testServices.assertions.assertEqualsToTestDataFileSibling(actual)

                expressionAtCaret.getReceiverKtType()?.render(position = Variance.INVARIANT)
            }
        }

        val actual = buildString {
            appendLine("expression: ${expressionAtCaret.text}")
            appendLine("receiver:: type: $type")
        }
        testServices.assertions.assertEqualsToTestDataFileSibling(actual)
    }

                expression.evaluate()
            }
        }
        val actual = buildString {
            appendLine("expression: ${expression.text}")
            appendLine("constant: ${constantValue?.renderAsKotlinConstant() ?: "NOT_EVALUATED"}")
            appendLine("constantValueKind: ${constantValue?.constantValueKind ?: "NOT_EVALUATED"}")
        }

                    fun List<KaType>.print(name: String) {
                        appendLine(name)
                        for (type in this) {
                            appendLine(type.render(KaTypeRendererForDebug.WITH_QUALIFIED_NAMES, position = Variance.INVARIANT))
                        }
                        appendLine()
                    }
                    directSuperTypes.print("[direct super types]")

                    expectedSymbol.psi?.containingFile?.name + " : " + expectedSymbol.render(renderer)
                }
            }
        }

        val actual = buildString {
            appendLine("expected symbols:")
            appendLine(expectedSymbolText)
        }

        testServices.assertions.assertEqualsToTestDataFileSibling(actual)
    }

            appendLine("""println("STDOUT from $origin")""")
            appendLine("""System.err.println("STDERR from $origin")""")
            if (logger) {
                appendLine("""logger.lifecycle("LIFECYCLE log from $origin")""")
                appendLine("""logger.warn("WARN log from $origin")""")
                appendLine("""logger.error("ERROR log from $origin")""")
            }

                        appendLine(declaration.getNameWithPositionString())
                    } else {
                        analyseForTest(declaration) {
                            val returnType = declaration.getReturnKaType()
                            append(declaration.getNameWithPositionString())
                            append(" : ")
                            appendLine(returnType.render(position = Variance.INVARIANT))

                val isDirectSubClass = subClassSymbol.isDirectSubClassOf(superClassSymbol)

                buildString {
                    appendLine("IS_SUBCLASS: $isSubClass")
                    appendLine("IS_DIRECT_SUBCLASS: $isDirectSubClass")
                }
            }
        }
        testServices.assertions.assertEqualsToTestDataFileSibling(actual)
    }

                DebugSymbolRenderer().renderType(analysisSession, expectedType)
            }
        }

        val actual = buildString {
            appendLine("expression: ${expressionAtCaret.text}")
            appendLine("expected type: $actualExpectedTypeText")
        }

        testServices.assertions.assertEqualsToTestDataFileSibling(actual)
    }