for i, tt := range tests {
		var in, testOut string
		j := strings.Index(tt.in, "ℙ")
		if j < 0 {
			in = tt.in
			testOut = tt.in
		} else {
			in = tt.in[:j] + tt.in[j+len("ℙ"):]
			testOut = tt.in[:j]
		}
		d := strings.Index(tt.in, "𝔻")
		if d >= 0 {
			in = in[:d] + in[d+len("𝔻"):]
			testOut = testOut[d+len("𝔻"):]
		}
		r := strings.NewReader(in)

	for i, tt := range tests {
		beforeP, afterP, _ := strings.Cut(tt.in, "ℙ")
		in := beforeP + afterP
		testOut := beforeP

		if beforeD, afterD, ok := strings.Cut(beforeP, "𝔻"); ok {
			in = beforeD + afterD + afterP
			testOut = afterD
		}

		r := strings.NewReader(in)
		buf, err := read(r)
		if err != nil {
			if tt.err == "" {

        containsEvent(STARTED, DefaultTestMethodDescriptor, 'TestSuite > LightTest > org.company.SystemOutTest > testOut')
        containsEvent(FINISHED, DefaultTestMethodDescriptor, 'TestSuite > LightTest > org.company.SystemOutTest > testOut')
        containsEvent(FINISHED, DefaultTestClassDescriptor, 'TestSuite > LightTest > org.company.SystemOutTest')

)

func TestDump(t *testing.T) {
	if testing.Short() {
		t.Skip("skipping test in short mode")
	}

	ast, _ := ParseFile(*src_, func(err error) { t.Error(err) }, nil, CheckBranches)

	if ast != nil {
		Fdump(testOut(), ast)
	}

    }

    def "replaces #description at the start of content"() {
        when:
        input = testIn

        then:
        output == testOut

        where:
        description | testIn | testOut
        "line comment" | "// Comment on first line\nAnother line" | "\nAnother line"
        "inline comment" | "/* inline comment at the start */of the line" | " of the line"

)

func TestPrint(t *testing.T) {
	if testing.Short() {
		t.Skip("skipping test in short mode")
	}

	ast, _ := ParseFile(*src_, func(err error) { t.Error(err) }, nil, 0)

	if ast != nil {
		Fprint(testOut(), ast, LineForm)
		fmt.Println()
	}
}

type shortBuffer struct {
	buf []byte
}

func (w *shortBuffer) Write(data []byte) (n int, err error) {
	w.buf = append(w.buf, data...)
	n = len(data)

	architecture, ctxt := setArch(goarch)
	architecture.Init(ctxt)
	lexer := lex.NewLexer(input)
	parser := NewParser(ctxt, architecture, lexer)
	pList := new(obj.Plist)
	var ok bool
	testOut = new(strings.Builder) // The assembler writes test output to this buffer.
	ctxt.Bso = bufio.NewWriter(os.Stdout)
	ctxt.IsAsm = true
	defer ctxt.Bso.Flush()
	failed := false

				return
			}
			p.labels[label] = prog
		}
		p.pendingLabels = p.pendingLabels[0:0]
	}
	prog.Pc = p.pc
	if *flags.Debug {
		fmt.Println(p.lineNum, prog)
	}
	if testOut != nil {
		fmt.Fprintln(testOut, prog)
	}
}

// validSymbol checks that addr represents a valid name for a pseudo-op.
func (p *Parser) validSymbol(pseudo string, addr *obj.Addr, offsetOk bool) bool {

	RET

// func testBGEZ(a int64) (r bool)
TEXT ·testBGEZ(SB),NOSPLIT,$0-9
	MOV	a+0(FP), X5
	MOV	$1, X6
	BGEZ	X5, b
	MOV	$0, X6
b:
	MOV	X6, r+8(FP)
	RET

// func testBGT(a, b int64) (r bool)
TEXT ·testBGT(SB),NOSPLIT,$0-17
	MOV	a+0(FP), X5
	MOV	b+8(FP), X6
	MOV	$1, X7
	BGT	X5, X6, b
	MOV	$0, X7
b:
	MOV	X7, r+16(FP)
	RET

// func testBGTU(a, b int64) (r bool)

		{"BGEU", -1, 0, testBGEU, testGoBGEU, true},
		{"BGEU", 1, 0, testBGEU, testGoBGEU, true},
		{"BGT", 0, 1, testBGT, testGoBGT, false},
		{"BGT", 0, 0, testBGT, testGoBGT, false},
		{"BGT", 0, -1, testBGT, testGoBGT, true},
		{"BGT", -1, 0, testBGT, testGoBGT, false},
		{"BGT", 1, 0, testBGT, testGoBGT, true},
		{"BGTU", 0, 1, testBGTU, testGoBGTU, false},
		{"BGTU", 0, 0, testBGTU, testGoBGTU, false},