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

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

        }
    }

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

	storageRESTVersionPrefix = SlashSeparator + storageRESTVersion
	storageRESTPrefix        = minioReservedBucketPath + "/storage"
)

const (
	storageRESTMethodHealth = "/health"

	storageRESTMethodAppendFile     = "/appendfile"
	storageRESTMethodCreateFile     = "/createfile"
	storageRESTMethodWriteAll       = "/writeall"
	storageRESTMethodReadVersion    = "/readversion"
	storageRESTMethodReadXL         = "/readxl"

	volume    string
	filePath  string
	shardSize int64 // This is the shard size of the erasure logic
	hash.Hash       // For bitrot hash
}

func (b *wholeBitrotWriter) Write(p []byte) (int, error) {
	err := b.disk.AppendFile(context.TODO(), b.volume, b.filePath, p)
	if err != nil {
		return 0, err
	}
	_, err = b.Hash.Write(p)
	if err != nil {
		return 0, err
	}
	return len(p), nil
}

        append(symbol.render(renderer))
        append(" fromClass ")
        append(containingDeclaration.classId?.asString())
        if (symbol.typeParameters.isNotEmpty()) {
            appendLine()
            withIndent {
                printCollection(symbol.typeParameters, separator = "\n") { typeParameter ->
                    val containingDeclarationForTypeParameter = typeParameter.getContainingSymbol()

	ListDir(ctx context.Context, origvolume, volume, dirPath string, count int) ([]string, error)
	ReadFile(ctx context.Context, volume string, path string, offset int64, buf []byte, verifier *BitrotVerifier) (n int64, err error)
	AppendFile(ctx context.Context, volume string, path string, buf []byte) (err error)
	CreateFile(ctx context.Context, origvolume, olume, path string, size int64, reader io.Reader) error

		return err
	}
	return d.disk.CreateFile(ctx, origvolume, volume, path, size, reader)
}

func (d *naughtyDisk) AppendFile(ctx context.Context, volume string, path string, buf []byte) error {
	if err := d.calcError(); err != nil {
		return err
	}
	return d.disk.AppendFile(ctx, volume, path, buf)
}

func libname(args []string, pkgs []*load.Package) (string, error) {
	var libname string
	appendName := func(arg string) {
		if libname == "" {
			libname = arg
		} else {
			libname += "," + arg
		}
	}
	var haveNonMeta bool
	for _, arg := range args {
		if search.IsMetaPackage(arg) {
			appendName(arg)
		} else {
			haveNonMeta = true
		}
	}

	"context"
	"crypto/rand"
	"io"
	"testing"

	"github.com/dustin/go-humanize"
)

type badDisk struct{ StorageAPI }

func (a badDisk) String() string {
	return "bad-disk"
}

func (a badDisk) AppendFile(ctx context.Context, volume string, path string, buf []byte) error {
	return errFaultyDisk
}

func (a badDisk) ReadFileStream(ctx context.Context, volume, path string, offset, length int64) (io.ReadCloser, error) {