buf = append(buf, ", "...)
	buf = appendInt(buf, hour, 0)
	buf = append(buf, ", "...)
	buf = appendInt(buf, minute, 0)
	buf = append(buf, ", "...)
	buf = appendInt(buf, second, 0)
	buf = append(buf, ", "...)
	buf = appendInt(buf, t.Nanosecond(), 0)
	buf = append(buf, ", "...)
	switch loc := t.Location(); loc {
	case UTC, nil:
		buf = append(buf, "time.UTC"...)
	case Local:

            val symbol = expressionAtCaret.getTypeParameterSymbol()
            val ktType = buildTypeParameterType(symbol)
            buildString {
                appendLine("${KtTypeParameter::class.simpleName}: ${expressionAtCaret.text}")
                appendLine("${KaType::class.simpleName}: ${ktType.render(position = Variance.INVARIANT)}")
            }
        }

        testServices.assertions.assertEqualsToTestDataFileSibling(actual)

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

        val actual = analyseForTest(expressionAtCaret) {
            val ktType = expressionAtCaret.getKtType()
            buildString {
                appendLine("${KtTypeReference::class.simpleName}: ${expressionAtCaret.text}")
                appendLine("${KaType::class.simpleName}: ${ktType.render(position = Variance.INVARIANT)}")
            }
        }

        testServices.assertions.assertEqualsToTestDataFileSibling(actual)

                    }

                    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))
                }
            }

            ?: fail("Expected main module '${mainModule.ktModule}' to be '${KtLibraryModule::class.simpleName}'")

        val actual = StringBuilder()
        actual.appendLine("klib declarations:")

        analyze(libraryModule) {
            val binaryRoot = libraryModule.getBinaryRoots().singleOrNull() ?: fail("Expected single binary root")

                }
                ktType?.render(renderer, position = Variance.INVARIANT)
            }
        }
        val actual = buildString {
            appendLine("expression: ${expression.text}")
            appendLine("type: $type")
        }
        testServices.assertions.assertEqualsToTestDataFileSibling(actual)
    }

    override fun configureTest(builder: TestConfigurationBuilder) {

                        append(diagnostic.factoryName).append(": ")
                        diagnostic.textRanges.joinTo(this)
                        appendLine()
                    }
                } else {
                    appendLine("No diagnostics found")
                }
            }

            testServices.assertions.assertEqualsToTestDataFileSibling(actualText)
        }
    }

            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)}")
                }
            }