bubbletea/cursed_renderer_test.go
Meng Yan b681f23559
fix(renderer): flush queued view before insert above (#1741)
Co-authored-by: Drew Smirnoff <drew@charm.land>
Signed-off-by: Meng Yan <yanmxa@gmail.com>
Signed-off-by: Drew Smirnoff <drew@charm.land>
2026-11-20 18:56:54 +04:00

693 lines
21 KiB
Go
Raw Blame History

This file contains invisible Unicode characters

This file contains invisible Unicode characters that are indistinguishable to humans but may be processed differently by a computer. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

package tea
import (
"bytes"
"fmt"
"image/color"
"io"
"strings"
"testing"
"time"
"github.com/charmbracelet/x/ansi"
)
func TestCursedRendererEnablesUnicodeModeForGraphemeWidth(t *testing.T) {
t.Parallel()
var out bytes.Buffer
r := newCursedRenderer(&out, []string{"TERM=xterm-256color"}, 10, 3)
r.start()
r.setWidthMethod(ansi.GraphemeWidth)
r.render(NewView("hello"))
if _, err := r.flush(false); err != nil {
t.Fatal(err)
}
if !strings.Contains(out.String(), ansi.SetModeUnicodeCore) {
t.Fatalf("grapheme rendering did not enable Unicode mode; output %q", out.String())
}
}
func TestCursedRendererWcWidthDoesNotEnableUnicodeMode(t *testing.T) {
t.Parallel()
var out bytes.Buffer
r := newCursedRenderer(&out, []string{"TERM=xterm-256color"}, 10, 3)
r.start()
r.setWidthMethod(ansi.WcWidth)
r.render(NewView("hello"))
if _, err := r.flush(false); err != nil {
t.Fatal(err)
}
out.Reset()
if err := r.close(); err != nil {
t.Fatal(err)
}
if got := strings.Contains(out.String(), ansi.ResetModeUnicodeCore); got != false {
t.Fatalf("close reset Unicode mode = %v, want false; output %q", got, out.String())
}
// Discard shutdown output so only the resume sequence can satisfy the assertion.
out.Reset()
r.start()
if _, err := r.flush(false); err != nil {
t.Fatal(err)
}
if got := strings.Contains(out.String(), ansi.SetModeUnicodeCore); got != false {
t.Fatalf("resume enabled Unicode mode = %v, want false; output %q", got, out.String())
}
}
func TestCursedRendererResumeRestoresUnicodeMode(t *testing.T) {
t.Parallel()
var out bytes.Buffer
r := newCursedRenderer(&out, []string{"TERM=xterm-256color"}, 10, 3)
r.start()
r.setWidthMethod(ansi.GraphemeWidth)
r.render(NewView("hello"))
if _, err := r.flush(false); err != nil {
t.Fatal(err)
}
out.Reset()
if err := r.close(); err != nil {
t.Fatal(err)
}
if got := strings.Contains(out.String(), ansi.ResetModeUnicodeCore); got != true {
t.Fatalf("close reset Unicode mode = %v, want true; output %q", got, out.String())
}
// Discard shutdown output so only the resume sequence can satisfy the assertion.
out.Reset()
r.start()
if _, err := r.flush(false); err != nil {
t.Fatal(err)
}
if got := strings.Contains(out.String(), ansi.SetModeUnicodeCore); got != true {
t.Fatalf("resume enabled Unicode mode = %v, want true; output %q", got, out.String())
}
}
func TestCursedRendererSkipsUnchangedView(t *testing.T) {
t.Parallel()
var out bytes.Buffer
r := newCursedRenderer(&out, []string{"TERM=xterm-256color"}, 4, 3)
r.start()
r.render(NewView("hello"))
if _, err := r.flush(false); err != nil {
t.Fatal(err)
}
out.Reset()
if drawn, err := r.flush(false); err != nil || drawn || out.Len() != 0 {
t.Fatalf("unchanged view: drawn=%v, err=%v, output=%q", drawn, err, out.String())
}
}
func TestCursedRendererDrawsChangedEmptyAndTallViews(t *testing.T) {
t.Parallel()
for _, tt := range []struct {
name string
before, after View
}{
{"empty inline becomes nonempty", View{}, NewView("new")},
{"empty alt screen becomes nonempty", View{AltScreen: true}, View{Content: "new", AltScreen: true}},
{"tall inline changes visible rows", NewView("a\nb\nc\nd\ne"), NewView("a\nb\nx\ny\nz")},
} {
t.Run(tt.name, func(t *testing.T) {
var out bytes.Buffer
r := newCursedRenderer(&out, []string{"TERM=xterm-256color"}, 4, 3)
r.start()
r.render(tt.before)
if _, err := r.flush(false); err != nil {
t.Fatal(err)
}
out.Reset()
r.render(tt.after)
if drawn, err := r.flush(false); err != nil || !drawn || out.Len() == 0 {
t.Fatalf("changed view: drawn=%v, err=%v, output=%q", drawn, err, out.String())
}
})
}
}
func TestCursedRendererSkipsUnchangedEmptyAndTallViews(t *testing.T) {
t.Parallel()
for _, tt := range []struct {
name string
view View
}{
{"empty inline", View{}},
{"empty alt screen", View{AltScreen: true}},
{"tall inline", NewView("a\nb\nc\nd\ne\nf\ng")},
} {
t.Run(tt.name, func(t *testing.T) {
var out bytes.Buffer
r := newCursedRenderer(&out, []string{"TERM=xterm-256color"}, 4, 3)
r.start()
r.render(tt.view)
if _, err := r.flush(false); err != nil {
t.Fatal(err)
}
// Measure only the second flush, after the initial frame is drawn.
out.Reset()
if drawn, err := r.flush(false); err != nil || drawn || out.Len() != 0 {
t.Fatalf("unchanged view: drawn=%v, err=%v, output=%q", drawn, err, out.String())
}
})
}
}
type mouseRaceModel struct {
i int
}
func (m *mouseRaceModel) Init() Cmd { return nil }
func (m *mouseRaceModel) Update(msg Msg) (Model, Cmd) {
switch msg.(type) {
case MouseClickMsg, MouseMotionMsg, MouseWheelMsg:
m.i++
}
return m, nil
}
func (m *mouseRaceModel) View() View {
return View{
Content: fmt.Sprintf("tick-%d\n", m.i),
MouseMode: MouseModeCellMotion,
}
}
// Fixes: https://github.com/charmbracelet/bubbletea/issues/1690
func TestCursedRenderer_mouseVsFlush(t *testing.T) {
t.Parallel()
pr, pw := io.Pipe()
defer func() { _ = pw.Close() }()
m := &mouseRaceModel{}
p := NewProgram(
m,
WithContext(t.Context()),
WithInput(pr),
WithOutput(io.Discard),
WithEnvironment([]string{
"TERM=xterm-256color",
"TERM_PROGRAM=Apple_Terminal",
}),
WithoutSignals(),
WithWindowSize(80, 24),
)
runDone := make(chan struct{})
go func() {
defer close(runDone)
_, _ = p.Run()
}()
time.Sleep(150 * time.Millisecond)
const iterations = 100
for i := range iterations {
switch i % 4 {
case 0:
p.Send(MouseClickMsg{X: i % 80, Y: i % 24, Button: MouseLeft})
case 1:
p.Send(MouseMotionMsg{X: i % 80, Y: i % 24})
case 2:
p.Send(MouseWheelMsg{X: 0, Y: 0, Button: MouseWheelUp})
default:
p.Send(MouseReleaseMsg{X: i % 80, Y: i % 24, Button: MouseLeft})
}
}
p.Quit()
select {
case <-runDone:
case <-time.After(5 * time.Second):
t.Fatal("program did not exit after Quit")
}
}
// uncomparableColor is a color.Color implementation whose dynamic type is
// uncomparable (it contains a slice), so comparing two values with == panics.
type uncomparableColor struct {
rgba color.RGBA
pad []int
}
func (c uncomparableColor) RGBA() (r, g, b, a uint32) {
return c.rgba.RGBA()
}
// Fixes: https://github.com/charmbracelet/bubbletea/issues/1848
func TestCursedRenderer_uncomparableViewColors(t *testing.T) {
t.Parallel()
var out bytes.Buffer
r := newCursedRenderer(&out, []string{"TERM=xterm-256color"}, 80, 24)
r.start()
red := color.RGBA{R: 0xff, A: 0xff}
view := NewView("hello")
view.AltScreen = true
view.ForegroundColor = uncomparableColor{rgba: red, pad: []int{1}}
view.BackgroundColor = uncomparableColor{rgba: red, pad: []int{2}}
view.Cursor = &Cursor{Color: uncomparableColor{rgba: red, pad: []int{3}}}
// Render the same view twice. The second flush takes the viewEquals
// early-return path, which compares the color.Color interface values.
for range 2 {
r.render(view)
if _, err := r.flush(false); err != nil {
t.Fatal(err)
}
}
}
// Colors are compared by value: the same color, whatever its type, doesn't
// redraw the view, while a different color or a reset does.
func TestCursedRenderer_viewColorChanges(t *testing.T) {
t.Parallel()
red := color.RGBA{R: 0xff, A: 0xff}
blue := color.RGBA{B: 0xff, A: 0xff}
for _, tt := range []struct {
name string
set func(*View, color.Color)
code string
reset string
}{
{"foreground", func(v *View, c color.Color) { v.ForegroundColor = c }, "10", "110"},
{"background", func(v *View, c color.Color) { v.BackgroundColor = c }, "11", "111"},
{"cursor", func(v *View, c color.Color) { v.Cursor = NewCursor(0, 0); v.Cursor.Color = c }, "12", "112"},
} {
t.Run(tt.name, func(t *testing.T) {
t.Parallel()
var out bytes.Buffer
r := newCursedRenderer(&out, []string{"TERM=xterm-256color"}, 80, 24)
render := func(c color.Color) bool {
t.Helper()
view := NewView("hello")
tt.set(&view, c)
r.render(view)
drew, err := r.flush(false)
if err != nil {
t.Fatal(err)
}
return drew
}
render(uncomparableColor{rgba: red, pad: []int{1}})
if want := "\x1b]" + tt.code + ";#ff0000\a"; !strings.Contains(out.String(), want) {
t.Fatalf("missing red color sequence %q in %q", want, out.String())
}
out.Reset()
if render(uncomparableColor{rgba: red, pad: []int{2}}) || out.Len() != 0 {
t.Fatalf("unchanged color redrew the view: %q", out.String())
}
if render(red) || out.Len() != 0 {
t.Fatalf("the same color of another type redrew the view: %q", out.String())
}
render(uncomparableColor{rgba: blue})
if want := "\x1b]" + tt.code + ";#0000ff\a"; !strings.Contains(out.String(), want) {
t.Fatalf("missing blue color sequence %q in %q", want, out.String())
}
out.Reset()
render(nil)
if want := "\x1b]" + tt.reset + "\a"; !strings.Contains(out.String(), want) {
t.Fatalf("missing color reset %q in %q", want, out.String())
}
})
}
}
func assertInOrder(t *testing.T, got string, wants ...string) {
t.Helper()
rest := got
for _, want := range wants {
idx := strings.Index(rest, want)
if idx < 0 {
t.Fatalf("expected %q to appear after the previous sequences in %q", want, got)
}
rest = rest[idx+len(want):]
}
}
func TestCursedRenderer_restoresKittyKeyboardStack(t *testing.T) {
t.Parallel()
var out bytes.Buffer
r := newCursedRenderer(&out, []string{"TERM=xterm-256color"}, 80, 24)
r.start()
view := NewView("hello")
view.KeyboardEnhancements.ReportEventTypes = true
pushMain := ansi.PushKittyKeyboard(keyboardEnhancementsFlags(view.KeyboardEnhancements))
pop := ansi.PopKittyKeyboard(1)
render := func(v View) {
t.Helper()
r.render(v)
if _, err := r.flush(false); err != nil {
t.Fatal(err)
}
}
render(view)
// Stop the renderer (as on suspend or ExecProcess) and start it again:
// close pops the stack entry, start pushes it back.
if err := r.close(); err != nil {
t.Fatal(err)
}
r.start()
// Enter and leave the alt screen. The terminal keeps a separate Kitty
// keyboard stack per screen, so each screen gets its own push and pop.
view.AltScreen = true
render(view)
view.AltScreen = false
render(view)
if err := r.close(); err != nil {
t.Fatal(err)
}
got := out.String()
// The flags are pushed once per screen activation: the first flush,
// the flush after the renderer was restarted, and on each screen
// switch. start() itself does not write to [out].
if n := strings.Count(got, pushMain); n != 4 {
t.Fatalf("expected kitty keyboard protocol to be pushed 4 times with %q (%d times), got %q", pushMain, n, got)
}
// One pop per stop/start cycle and per screen switch: closing pops the
// current screen's entry, and switching screens pops the entry of the
// screen being left.
if n := strings.Count(got, pop); n != 4 {
t.Fatalf("expected kitty keyboard protocol to be popped 4 times with %q (%d times), got %q", pop, n, got)
}
// Every pop must come after a push: the stack is balanced when pushes
// and pops alternate. The resumed flush pushes twice in a row (once in
// start(), once in flush()), and both entries are popped afterwards.
assertInOrder(t, got,
pushMain, pop, // close pops the entry pushed by the first flush
pop, // entering the alt screen pops the resumed entry
pushMain, pop, // leaving the alt screen
pushMain, pop, // the resumed main screen entry and the final close
)
if strings.Contains(got, ansi.KittyKeyboard(0, 1)) {
t.Fatalf("expected kitty keyboard protocol not to be reset in-place with %q, got %q", ansi.KittyKeyboard(0, 1), got)
}
}
func TestCursedRenderer_updatesKittyKeyboardFlagsInPlace(t *testing.T) {
t.Parallel()
var out bytes.Buffer
r := newCursedRenderer(&out, []string{"TERM=xterm-256color"}, 80, 24)
render := func(v View) {
t.Helper()
r.render(v)
if _, err := r.flush(false); err != nil {
t.Fatal(err)
}
}
view := NewView("hello")
render(view)
// Changing the enhancement flags without switching screens updates the
// current stack entry in place instead of pushing a new one.
changed := view
changed.KeyboardEnhancements.ReportEventTypes = true
render(changed)
wantUpdate := ansi.KittyKeyboard(keyboardEnhancementsFlags(changed.KeyboardEnhancements), 1)
got := out.String()
if !strings.Contains(got, wantUpdate) {
t.Fatalf("expected kitty keyboard flags to be updated in place with %q, got %q", wantUpdate, got)
}
assertInOrder(t, got,
ansi.PushKittyKeyboard(keyboardEnhancementsFlags(view.KeyboardEnhancements)),
wantUpdate,
)
if strings.Contains(got, ansi.PopKittyKeyboard(1)) {
t.Fatalf("expected kitty keyboard protocol not to be popped with %q, got %q", ansi.PopKittyKeyboard(1), got)
}
if n := strings.Count(got, ansi.PushKittyKeyboard(0)); n > 1 {
t.Fatalf("expected kitty keyboard protocol to be pushed once, got %d pushes in %q", n, got)
}
}
func TestCursedRenderer_insertAboveBeforeFirstFlush(t *testing.T) {
t.Parallel()
var output bytes.Buffer
renderer := newCursedRenderer(&output, []string{"TERM=xterm-256color"}, 80, 24)
renderer.render(NewView("footer"))
if err := renderer.insertAbove("startup"); err != nil {
t.Fatal(err)
}
// The one-line view is drawn first, then the line is inserted above it,
// making room for one line rather than for the terminal's height.
got := output.String()
frame := "\r" + ansi.EraseScreenBelow + "footer"
insert := "\r\n" + ansi.CursorUp(1) +
ansi.InsertLine(1) + ansi.EraseLineRight + "startup" + "\r\n"
if !strings.HasSuffix(got, frame+insert) {
t.Fatalf("unexpected insertAbove output:\nwant suffix: %q\n got: %q", frame+insert, got)
}
}
// Fixes: https://github.com/charmbracelet/bubbletea/issues/1780
func TestCursedRenderer_resizeStaleFrame(t *testing.T) {
t.Parallel()
var out bytes.Buffer
r := newCursedRenderer(&out, []string{"TERM=xterm-256color"}, 80, 24)
// Render the initial frame at 80x24.
initialView := NewView("initial 80x24 content")
initialView.AltScreen = true
r.render(initialView)
if _, err := r.flush(false); err != nil {
t.Fatal(err)
}
out.Reset()
// Simulate window resize: resize() is called first, updating dimensions.
r.resize(100, 30)
// In the race window, the 60Hz ticker fires flush() BEFORE render() provides the new View.
// flush() must NOT output the stale initialView at the new 100x30 size.
if _, err := r.flush(false); err != nil {
t.Fatal(err)
}
if out.Len() > 0 {
t.Fatalf("expected no output during stale resize race window, got %q", out.String())
}
// Now render() provides the new View matching the new 100x30 size.
newView := NewView("resized 100x30 content")
newView.AltScreen = true
r.render(newView)
// The subsequent flush() must draw the new view.
if _, err := r.flush(false); err != nil {
t.Fatal(err)
}
if !strings.Contains(out.String(), "resized 100x30 content") {
t.Fatalf("expected output to contain resized view, got %q", out.String())
}
}
// Fixes: https://github.com/charmbracelet/bubbletea/issues/1802
//
// insertAbove must measure wrapped lines with the active screen buffer's
// width method. When the terminal never answers the Unicode-core query the
// buffer stays on WcWidth, but insertAbove used grapheme semantics, so wide
// grapheme clusters inserted the wrong number of lines.
func TestCursedRenderer_insertAboveUsesActiveWidthMethod(t *testing.T) {
t.Parallel()
insertNewlines := func(method ansi.Method, s string) int {
var out bytes.Buffer
r := newCursedRenderer(&out, []string{"TERM=xterm-256color"}, 8, 4)
r.setWidthMethod(method)
if got := r.cellbuf.WidthMethod(); got != method {
t.Fatalf("expected width method %v, got %v", method, got)
}
if err := r.insertAbove(s); err != nil {
t.Fatal(err)
}
// One "\n" per inserted line, plus the trailing newline after each
// printed line.
return bytes.Count(out.Bytes(), []byte("\n"))
}
// "👨‍👩‍👧‍👦" is a single grapheme cluster (width 2) made of four wide
// codepoints (width 8), so the wrapped-line count differs per method.
// With an 8-column buffer: grapheme width 8 fits in 1 row, wcwidth 14
// wraps to 2 rows.
const line = "👨‍👩‍👧‍👦aaaaaa"
// WcWidth fallback: 1 line + (14-1)/8 extra -> 2 inserted lines, 3 newlines.
if got := insertNewlines(ansi.WcWidth, line); got != 3 {
t.Errorf("WcWidth: expected 3 newlines, got %d", got)
}
// GraphemeWidth (Unicode-core mode): 1 line + (8-1)/8 extra -> 1 inserted
// line, 2 newlines.
if got := insertNewlines(ansi.GraphemeWidth, line); got != 2 {
t.Errorf("GraphemeWidth: expected 2 newlines, got %d", got)
}
}
func TestCursedRenderer_insertAboveLineBoundaries(t *testing.T) {
t.Parallel()
const width = 40
tests := []struct {
name string
line string
rows int
}{
{name: "short", line: strings.Repeat("-", width-2) + "#", rows: 1},
{name: "exact width", line: strings.Repeat("-", width-1) + "#", rows: 1},
{name: "one cell over", line: strings.Repeat("-", width) + "#", rows: 2},
{name: "two exact rows", line: strings.Repeat("-", 2*width-1) + "#", rows: 2},
{name: "three exact rows", line: strings.Repeat("-", 3*width-1) + "#", rows: 3},
{name: "wide characters", line: strings.Repeat("界", width-1) + "-#", rows: 2},
{name: "styled", line: "\x1b[31m" + strings.Repeat("-", 2*width-1) + "#" + ansi.ResetStyle, rows: 2},
{name: "multiple lines", line: strings.Repeat("-", width-1) + "#\n" + strings.Repeat("-", 2*width-1) + "#", rows: 3},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
t.Parallel()
var out bytes.Buffer
r := newCursedRenderer(&out, []string{"TERM=xterm-256color"}, width, 2)
r.render(NewView("view\nview"))
if _, err := r.flush(false); err != nil {
t.Fatal(err)
}
out.Reset()
r.scr.SetPosition(0, 0)
if err := r.insertAbove(tt.line); err != nil {
t.Fatal(err)
}
got := out.String()
prefix := "\r" + ansi.CursorDown(1) + strings.Repeat("\n", tt.rows) + ansi.CursorUp(tt.rows+1) + ansi.InsertLine(tt.rows)
if !strings.HasPrefix(got, prefix) {
t.Fatalf("expected room for %d terminal rows with prefix %q, got %q", tt.rows, prefix, got)
}
for _, line := range strings.Split(tt.line, "\n") {
if ansi.StringWidth(line)%width == 0 && strings.Contains(got, line+ansi.EraseLineRight) {
t.Fatalf("erasing at the right margin would delete the inserted line's last cell, got %q", got)
}
}
})
}
}
func TestCursedRenderer_insertAboveFlushesQueuedView(t *testing.T) {
var output bytes.Buffer
r := newCursedRenderer(
&output,
[]string{"TERM=xterm-256color", "TERM_PROGRAM=Apple_Terminal"},
80,
24,
)
r.render(NewView("stale frame\nstale row"))
if _, err := r.flush(false); err != nil {
t.Fatalf("flush initial view: %v", err)
}
output.Reset()
r.render(NewView("current frame"))
if err := r.insertAbove("committed block"); err != nil {
t.Fatalf("insert above: %v", err)
}
if r.lastView == nil || r.lastView.Content != "current frame" {
t.Fatalf("insertAbove did not flush the queued view: %#v", r.lastView)
}
written := output.String()
currentAt := strings.Index(written, "current frame")
committedAt := strings.Index(written, "committed block")
if currentAt < 0 || committedAt < 0 {
t.Fatalf("output missing markers (current=%d, committed=%d): %q", currentAt, committedAt, written)
}
if currentAt > committedAt {
t.Fatalf("inserted scrollback before flushing current frame: %q", written)
}
}
// Fixes: https://github.com/charmbracelet/bubbletea/issues/1881
func TestCursedRenderer_insertAboveAfterLeavingAltScreen(t *testing.T) {
t.Parallel()
var out bytes.Buffer
r := newCursedRenderer(&out, []string{"TERM=xterm-256color"}, 80, 24)
alt := NewView("alt screen view")
alt.AltScreen = true
r.render(alt)
if _, err := r.flush(false); err != nil {
t.Fatal(err)
}
// The update leaves the alt screen and prints a line before the next
// frame is drawn. The line must be printed on the normal screen, after
// leaving the alt screen, or it is lost with it.
r.render(NewView("inline view"))
if err := r.insertAbove("printed line"); err != nil {
t.Fatal(err)
}
if _, err := r.flush(false); err != nil {
t.Fatal(err)
}
got := out.String()
assertInOrder(t, got, ansi.SetModeAltScreenSaveCursor, ansi.ResetModeAltScreenSaveCursor, "inline view", "printed line")
if n := strings.Count(got, "printed line"); n != 1 {
t.Fatalf("expected the line to be printed once, got %d times in %q", n, got)
}
}
func TestCursedRenderer_insertAboveBeforeEnteringAltScreen(t *testing.T) {
t.Parallel()
var out bytes.Buffer
r := newCursedRenderer(&out, []string{"TERM=xterm-256color"}, 80, 24)
r.render(NewView("inline view"))
if _, err := r.flush(false); err != nil {
t.Fatal(err)
}
// The update enters the alt screen and prints a line before the next
// frame is drawn. The line is printed on the normal screen, before
// entering the alt screen, so it's still there after leaving it.
alt := NewView("alt screen view")
alt.AltScreen = true
r.render(alt)
if err := r.insertAbove("printed line"); err != nil {
t.Fatal(err)
}
if _, err := r.flush(false); err != nil {
t.Fatal(err)
}
assertInOrder(t, out.String(), "inline view", "printed line", ansi.SetModeAltScreenSaveCursor, "alt screen view")
}