}{
		{
			name:           "json output format matches a json printer",
			outputFormat:   "json",
			expectedOutput: "\"name\": \"foo\"",
		},
		{
			name:           "yaml output format matches a yaml printer",
			outputFormat:   "yaml",
			expectedOutput: "name: foo",
		},
		{
			name:          "output format for another printer does not match a json/yaml printer",
			outputFormat:  "jsonpath",
			expectNoMatch: true,
		},

    /**
     * Invoked after a failure header has been printed, and before any stack frames have been printed.
     */
    void beforeFrames();

    /**
     * Invoked before a given stack frame is printed.
     */
    void beforeFrame(StackTraceElement element, StackTraceRelevance relevance);

    /**
     * Invoked after all stack frames of a failure have been printed.
     */
    void afterFrames();

// check to be inherently fragile.
package format

import (
	"bytes"
	"fmt"
	"go/ast"
	"go/parser"
	"go/printer"
	"go/token"
	"io"
)

// Keep these in sync with cmd/gofmt/gofmt.go.
const (
	tabWidth    = 8
	printerMode = printer.UseSpaces | printer.TabIndent | printerNormalizeNumbers

	// printerNormalizeNumbers means to canonicalize number literal prefixes

import org.jetbrains.kotlin.analysis.api.types.KaDynamicType
import org.jetbrains.kotlin.analysis.utils.printer.PrettyPrinter
import org.jetbrains.kotlin.lexer.KtTokens


public interface KaDynamicTypeRenderer {
    public fun renderType(
        analysisSession: KaSession,
        type: KaDynamicType,
        typeRenderer: KaTypeRenderer,
        printer: PrettyPrinter,
    )

    public object AS_DYNAMIC_WORD : KaDynamicTypeRenderer {

//
//	w.Write(p.Printer().HTML(p.Parser().Parse(text)))
//
// If words may be non-nil, the longer replacement is:
//
//	parser := p.Parser()
//	parser.Words = words
//	w.Write(p.Printer().HTML(parser.Parse(d)))
func ToHTML(w io.Writer, text string, words map[string]string) {
	p := new(Package).Parser()
	p.Words = words
	d := p.Parse(text)
	pr := new(comment.Printer)
	w.Write(pr.HTML(d))
}

import org.jetbrains.kotlin.analysis.utils.printer.PrettyPrinter
import org.jetbrains.kotlin.renderer.render

public interface KaAnnotationArgumentsRenderer {
    public fun renderAnnotationArguments(
        analysisSession: KaSession,
        annotation: KaAnnotation,
        owner: KaAnnotated,
        annotationRenderer: KaAnnotationRenderer,
        printer: PrettyPrinter,
    )

		if strings.HasPrefix(line, "GLOBL ") {
			continue
		}

		// The general form of a test input line is:
		//	// comment
		//	INST args [// printed form] [// hex encoding]
		parts := strings.Split(line, "//")
		printed := strings.TrimSpace(parts[0])
		if printed == "" || strings.HasSuffix(printed, ":") { // empty or label
			continue
		}
		seq++

		var hexes string
		switch len(parts) {
		default:

					if w != nil && w.Block == b && !printed[w.ID] {
						continue outer
					}
				}
				p.value(v, live[v.ID])
				printed[v.ID] = true
				n++
			}
			if m == n {
				p.startDepCycle()
				for _, v := range b.Values {
					if printed[v.ID] {
						continue
					}
					p.value(v, live[v.ID])
					printed[v.ID] = true
					n++
				}
				p.endDepCycle()
			}

import org.jetbrains.kotlin.analysis.utils.printer.PrettyPrinter
import org.jetbrains.kotlin.types.Variance

public interface KaSuperTypeRenderer {
    public fun renderSuperType(
        analysisSession: KaSession,
        type: KaType,
        symbol: KaClassOrObjectSymbol,
        declarationRenderer: KaDeclarationRenderer,
        printer: PrettyPrinter,
    )

import org.jetbrains.kotlin.analysis.utils.printer.PrettyPrinter
import org.jetbrains.kotlin.types.Variance

public interface KaCallableReturnTypeRenderer {
    public fun renderReturnType(
        analysisSession: KaSession,
        symbol: KaCallableSymbol,
        declarationRenderer: KaDeclarationRenderer,
        printer: PrettyPrinter,
    )