278 lines
9.7 KiB
Go
278 lines
9.7 KiB
Go
package ui
|
||
|
||
import (
|
||
"bytes"
|
||
"encoding/base64"
|
||
"image"
|
||
"image/png"
|
||
"math"
|
||
"math/rand"
|
||
"regexp"
|
||
"strings"
|
||
"testing"
|
||
|
||
"github.com/gdamore/tcell/v2"
|
||
)
|
||
|
||
// recorder collects what is written to the terminal.
|
||
type recorder struct{ cmds []string }
|
||
|
||
func (r *recorder) write(b []byte) error { r.cmds = append(r.cmds, string(b)); return nil }
|
||
|
||
func noisy(w, h int) *image.RGBA {
|
||
img := image.NewRGBA(image.Rect(0, 0, w, h))
|
||
rng := rand.New(rand.NewSource(1))
|
||
for i := range img.Pix {
|
||
img.Pix[i] = uint8(rng.Intn(256))
|
||
}
|
||
for i := 3; i < len(img.Pix); i += 4 {
|
||
img.Pix[i] = 255
|
||
}
|
||
return img
|
||
}
|
||
|
||
func TestKittyDiacriticsTable(t *testing.T) {
|
||
if len(kittyDiacritics) != 297 {
|
||
t.Fatalf("%d diacritics, the protocol defines 297", len(kittyDiacritics))
|
||
}
|
||
if kittyDiacritics[0] != 0x0305 || kittyDiacritics[296] != 0x1D244 {
|
||
t.Errorf("table ends are %U and %U", kittyDiacritics[0], kittyDiacritics[296])
|
||
}
|
||
for i := 1; i < len(kittyDiacritics); i++ {
|
||
if kittyDiacritics[i] <= kittyDiacritics[i-1] {
|
||
t.Fatalf("table not strictly ascending at %d", i)
|
||
}
|
||
}
|
||
}
|
||
|
||
func TestKittyUploadChunksAndEncodes(t *testing.T) {
|
||
rec := &recorder{}
|
||
k := newKittyGraphics(rec.write)
|
||
img := noisy(200, 300) // incompressible: far more than one 4096-byte chunk of base64
|
||
|
||
id, err := k.imageID(img, img.Bounds())
|
||
if err != nil || id != 1 {
|
||
t.Fatalf("id=%d err=%v", id, err)
|
||
}
|
||
if len(rec.cmds) < 3 {
|
||
t.Fatalf("only %d commands for a large image", len(rec.cmds))
|
||
}
|
||
re := regexp.MustCompile(`^\x1b_G([^;]*);(.*)\x1b\\$`)
|
||
var payload strings.Builder
|
||
for i, c := range rec.cmds {
|
||
m := re.FindStringSubmatch(c)
|
||
if m == nil {
|
||
t.Fatalf("command %d is not a graphics command: %q", i, c[:min(40, len(c))])
|
||
}
|
||
keys, data := m[1], m[2]
|
||
if len(data) > kittyChunk {
|
||
t.Errorf("chunk %d has %d bytes", i, len(data))
|
||
}
|
||
last := i == len(rec.cmds)-1
|
||
switch {
|
||
case i == 0 && !strings.HasPrefix(keys, "a=t,f=100,t=d,i=1,q=2,m=1"):
|
||
t.Errorf("first command keys = %q", keys)
|
||
case i > 0 && !last && keys != "m=1":
|
||
t.Errorf("middle command keys = %q", keys)
|
||
case last && !strings.HasSuffix(keys, "m=0"):
|
||
t.Errorf("last command keys = %q", keys)
|
||
}
|
||
payload.WriteString(data)
|
||
}
|
||
raw, err := base64.StdEncoding.DecodeString(payload.String())
|
||
if err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
decoded, err := png.Decode(bytes.NewReader(raw))
|
||
if err != nil || decoded.Bounds() != img.Bounds() {
|
||
t.Fatalf("payload is not the image as PNG: %v %v", decoded, err)
|
||
}
|
||
r, g, b, _ := decoded.At(17, 23).RGBA()
|
||
want := img.RGBAAt(17, 23)
|
||
if uint8(r>>8) != want.R || uint8(g>>8) != want.G || uint8(b>>8) != want.B {
|
||
t.Error("pixel data changed")
|
||
}
|
||
|
||
// The same image is not uploaded twice; another one gets the next id.
|
||
n := len(rec.cmds)
|
||
if again, _ := k.imageID(img, img.Bounds()); again != id || len(rec.cmds) != n {
|
||
t.Error("an uploaded image must be reused")
|
||
}
|
||
if other, _ := k.imageID(noisy(4, 4), image.Rect(0, 0, 4, 4)); other != 2 {
|
||
t.Errorf("second image id = %d", other)
|
||
}
|
||
}
|
||
|
||
func TestKittyPlacement(t *testing.T) {
|
||
rec := &recorder{}
|
||
k := newKittyGraphics(rec.write)
|
||
if err := k.place(7, 20, 15); err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
if len(rec.cmds) != 1 || rec.cmds[0] != "\x1b_Ga=p,U=1,i=7,c=20,r=15,q=2\x1b\\" {
|
||
t.Fatalf("first placement: %q", rec.cmds)
|
||
}
|
||
k.place(7, 20, 15) // unchanged: nothing to send
|
||
if len(rec.cmds) != 1 {
|
||
t.Errorf("unchanged placement sent %d commands", len(rec.cmds))
|
||
}
|
||
k.place(7, 10, 8) // a new size replaces the placement
|
||
if len(rec.cmds) != 3 || rec.cmds[1] != "\x1b_Ga=d,d=i,i=7,q=2\x1b\\" || rec.cmds[2] != "\x1b_Ga=p,U=1,i=7,c=10,r=8,q=2\x1b\\" {
|
||
t.Errorf("resize: %q", rec.cmds[1:])
|
||
}
|
||
|
||
rec.cmds = nil
|
||
small := noisy(2, 2)
|
||
id, _ := k.imageID(small, small.Bounds())
|
||
k.deleteAll()
|
||
if last := rec.cmds[len(rec.cmds)-1]; last != "\x1b_Ga=d,d=I,i="+itoa(int(id))+",q=2\x1b\\" {
|
||
t.Errorf("deleteAll sent %q", last)
|
||
}
|
||
if len(k.ids) != 0 || len(k.placed) != 0 {
|
||
t.Error("deleteAll must forget everything")
|
||
}
|
||
}
|
||
|
||
func TestPlaceholderCell(t *testing.T) {
|
||
ch, comb, style := placeholderCell(0x010203, 2, 5)
|
||
if ch != '\U0010EEEE' || len(comb) != 2 || comb[0] != kittyDiacritics[2] || comb[1] != kittyDiacritics[5] {
|
||
t.Errorf("cell = %U %U", ch, comb)
|
||
}
|
||
fg, _, _ := style.Decompose()
|
||
if r, g, b := fg.RGB(); r != 1 || g != 2 || b != 3 {
|
||
t.Errorf("the id must be in the foreground color, got %d,%d,%d", r, g, b)
|
||
}
|
||
}
|
||
|
||
func TestKittyTerminalDetection(t *testing.T) {
|
||
defer func(old func() bool) { sextantFontAvailable = old }(sextantFontAvailable)
|
||
sextantFontAvailable = func() bool { return false } // not what these cases are about
|
||
env := func(m map[string]string) func(string) string { return func(k string) string { return m[k] } }
|
||
for _, tc := range []struct {
|
||
name string
|
||
env map[string]string
|
||
want bool
|
||
}{
|
||
{"ghostty term", map[string]string{"TERM": "xterm-ghostty"}, true},
|
||
{"ghostty program", map[string]string{"TERM": "xterm-256color", "TERM_PROGRAM": "ghostty"}, true},
|
||
{"ghostty resources", map[string]string{"GHOSTTY_RESOURCES_DIR": "/x"}, true},
|
||
{"kitty", map[string]string{"TERM": "xterm-kitty"}, true},
|
||
{"kitty window", map[string]string{"KITTY_WINDOW_ID": "1"}, true},
|
||
{"plain xterm", map[string]string{"TERM": "xterm-256color"}, false},
|
||
{"wezterm has no placeholders", map[string]string{"TERM_PROGRAM": "WezTerm"}, false},
|
||
{"tmux swallows graphics", map[string]string{"TERM": "xterm-ghostty", "TMUX": "/tmp/x"}, false},
|
||
{"screen swallows graphics", map[string]string{"TERM": "screen-256color", "TERM_PROGRAM": "ghostty"}, false},
|
||
{"nothing", nil, false},
|
||
} {
|
||
if got := kittyTerminal(env(tc.env)); got != tc.want {
|
||
t.Errorf("%s: %v, want %v", tc.name, got, tc.want)
|
||
}
|
||
}
|
||
for _, tc := range []struct {
|
||
setting string
|
||
env map[string]string
|
||
wantGfx bool
|
||
wantName string
|
||
}{
|
||
{"auto", map[string]string{"TERM": "xterm-ghostty"}, true, "sextant"},
|
||
{"", map[string]string{"TERM": "xterm-256color"}, false, "quadrant"},
|
||
{"kitty", map[string]string{"TERM": "xterm-256color"}, true, "quadrant"},
|
||
{"sextant", map[string]string{"TERM": "xterm-ghostty"}, false, "sextant"},
|
||
{"quadrant", map[string]string{"TERM": "xterm-ghostty"}, false, "quadrant"},
|
||
} {
|
||
blocks, gfx := resolveCovers(tc.setting, env(tc.env))
|
||
if gfx != tc.wantGfx || blocks.name != tc.wantName {
|
||
t.Errorf("%q %v = %s/%v, want %s/%v", tc.setting, tc.env, blocks.name, gfx, tc.wantName, tc.wantGfx)
|
||
}
|
||
}
|
||
}
|
||
|
||
// trueColor makes a simulation screen report 24-bit color.
|
||
type trueColor struct{ tcell.SimulationScreen }
|
||
|
||
func (trueColor) Colors() int { return 1 << 24 }
|
||
|
||
func TestCoverViewGraphicsDrawsPlaceholders(t *testing.T) {
|
||
sim := tcell.NewSimulationScreen("")
|
||
if err := sim.Init(); err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
defer sim.Fini()
|
||
sim.SetSize(40, 20)
|
||
|
||
rec := &recorder{}
|
||
c := newCoverView(quadrantStyle, newKittyGraphics(rec.write), nil)
|
||
c.setImage(stripes(40, 60)) // 2:3, cells twice as tall as wide: 13 columns × 10 rows in a 30×10 box
|
||
c.SetRect(0, 0, 30, 10)
|
||
|
||
// Without true color the protocol is not used and blocks are drawn.
|
||
c.Draw(sim)
|
||
if len(rec.cmds) != 0 {
|
||
t.Fatalf("graphics commands sent without true color: %q", rec.cmds)
|
||
}
|
||
if ch, _, _, _ := sim.GetContent(29, 0); ch == placeholderRune {
|
||
t.Error("placeholders drawn without true color")
|
||
}
|
||
|
||
screen := trueColor{sim}
|
||
c.Draw(screen)
|
||
if len(rec.cmds) != 2 { // upload (one chunk) + placement
|
||
t.Fatalf("%d commands: %q", len(rec.cmds), rec.cmds)
|
||
}
|
||
if !strings.Contains(rec.cmds[1], "c=13,r=10") {
|
||
t.Errorf("placement = %q", rec.cmds[1])
|
||
}
|
||
// Right-aligned: columns 17..29, rows 0..9.
|
||
ch, comb, _, _ := sim.GetContent(17, 0)
|
||
if ch != placeholderRune || len(comb) < 2 || comb[0] != kittyDiacritics[0] || comb[1] != kittyDiacritics[0] {
|
||
t.Errorf("top left cell = %U %U", ch, comb)
|
||
}
|
||
ch, comb, _, _ = sim.GetContent(29, 9)
|
||
if ch != placeholderRune || comb[0] != kittyDiacritics[9] || comb[1] != kittyDiacritics[12] {
|
||
t.Errorf("bottom right cell = %U %U", ch, comb)
|
||
}
|
||
c.Draw(screen) // a second frame uploads nothing again
|
||
if len(rec.cmds) != 2 {
|
||
t.Errorf("redraw sent %d more commands", len(rec.cmds)-2)
|
||
}
|
||
|
||
// A cell aspect of 2.5 (taller cells) changes the footprint of the same box.
|
||
c.cellAspect = func() float64 { return 2.5 }
|
||
c.Draw(screen)
|
||
// The box is now 17×10 cells, a different shape: a new crop is uploaded, the
|
||
// old upload is removed, and the image is placed afresh.
|
||
var placements []string
|
||
for _, cmd := range rec.cmds[2:] {
|
||
placements = append(placements, cmd[:min(len(cmd), 30)])
|
||
}
|
||
last := rec.cmds[len(rec.cmds)-1]
|
||
if !strings.Contains(last, "c=17,r=10") || !strings.Contains(strings.Join(rec.cmds[2:], ""), "a=d,d=I,i=1") {
|
||
t.Errorf("after the cell aspect changed: %q", placements)
|
||
}
|
||
}
|
||
|
||
func TestCropToBox(t *testing.T) {
|
||
b := image.Rect(0, 0, 167, 250) // a 2:3 poster
|
||
// A box slightly narrower than the poster: the sides are trimmed.
|
||
got := cropToBox(b, 17, 13, 2.1) // box shape 17/(13*2.1) = 0.6227 < 0.668
|
||
if got.Dy() != 250 || got.Dx() >= 167 || got.Min.X != (167-got.Dx())/2 {
|
||
t.Errorf("narrow box: %v", got)
|
||
}
|
||
if shape := float64(got.Dx()) / float64(got.Dy()); math.Abs(shape-17.0/(13*2.1)) > 0.005 {
|
||
t.Errorf("cropped shape %.4f, want %.4f", shape, 17.0/(13*2.1))
|
||
}
|
||
// A box slightly wider: top and bottom are trimmed.
|
||
got = cropToBox(b, 18, 12, 2.1) // 18/(12*2.1) = 0.714 > 0.668
|
||
if got.Dx() != 167 || got.Dy() >= 250 || got.Min.Y != (250-got.Dy())/2 {
|
||
t.Errorf("wide box: %v", got)
|
||
}
|
||
// A box of exactly the poster's shape changes nothing.
|
||
if got := cropToBox(image.Rect(0, 0, 40, 60), 20, 15, 2); got != image.Rect(0, 0, 40, 60) {
|
||
t.Errorf("exact box: %v", got)
|
||
}
|
||
// Offsets of sub-images are respected.
|
||
if got := cropToBox(image.Rect(10, 20, 50, 80), 18, 10, 2); got.Min.X != 10 || got.Max.X != 50 || got.Min.Y < 20 || got.Max.Y > 80 || got.Dy() >= 60 {
|
||
t.Errorf("offset image: %v", got)
|
||
}
|
||
}
|