ZacharyZhang-NY
b4b4d67b92
A cross-cutting pass, each fix with a test that failed first. Veils: MyGo still hands a key to a base that turned off this frame, so every element key now goes through pixel.Shortcut, which an archtest enforces. Input handlers record and the build applies them only while enabled; the editor turns away a veil-frame letter or copy; value bases get a copy and keep only enabled turns. Popups give a held focus back to their opener when the veil lifts. Motion: S5 is enforced at the clock. Every Tick, Since, Step, Toward and Shot runs at 4-15 fps; blinks keep 1 Hz on 4 fps steps, fast animations step at 15, and drawn time is quantized to frames. Clocks stepping back: Since holds at zero without overflow, and k.Elapsed moves a stored start to now, so nothing goes negative, runs backward or indexes out of range. Also: logs count typed text instead of holding it, gallery names use glyphs the font has, removable rows are keyed, components take their own Options (archtest), and sweeps over all 508 demos check veiled keys, clicks, wheels, the clock stepping back and names.
449 lines
12 KiB
Go
449 lines
12 KiB
Go
package text_test
|
|
|
|
import (
|
|
"image"
|
|
"slices"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/egoist/mygo/ui"
|
|
|
|
"git.zacharyzhang.com/ZacharyZhang-NY/8bitMyGoUI/pixel"
|
|
"git.zacharyzhang.com/ZacharyZhang-NY/8bitMyGoUI/text"
|
|
)
|
|
|
|
type clock struct{ t time.Time }
|
|
|
|
func (c *clock) now() time.Time { return c.t }
|
|
|
|
func (c *clock) add(d time.Duration) { c.t = c.t.Add(d) }
|
|
|
|
func view(w, h int, clk *clock, build func(c *ui.Context)) *ui.Tester {
|
|
return ui.NewTester(func(c *ui.Context) {
|
|
pixel.Use(c, pixel.Settings{Palette: pixel.SpringDay, Now: clk.now})
|
|
build(c)
|
|
}, w, h)
|
|
}
|
|
|
|
func newClock() *clock { return &clock{time.Unix(1_000_000, 0)} }
|
|
|
|
// slot is the palette slot of dot x, y.
|
|
func slot(t *testing.T, img *image.RGBA, x, y int) pixel.Slot {
|
|
t.Helper()
|
|
c := img.RGBAAt(2*x, 2*y)
|
|
for s, pc := range pixel.SpringDay.Colors {
|
|
if pc.R == c.R && pc.G == c.G && pc.B == c.B {
|
|
return pixel.Slot(s)
|
|
}
|
|
}
|
|
t.Fatalf("dot %d,%d off the palette: %v", x, y, c)
|
|
return 0
|
|
}
|
|
|
|
// count is how many dots in a box hold s.
|
|
func count(t *testing.T, img *image.RGBA, x, y, w, h int, s pixel.Slot) int {
|
|
n := 0
|
|
for j := range h {
|
|
for i := range w {
|
|
if slot(t, img, x+i, y+j) == s {
|
|
n++
|
|
}
|
|
}
|
|
}
|
|
return n
|
|
}
|
|
|
|
func find(t *testing.T, tt *ui.Tester, label string) ui.Rect {
|
|
t.Helper()
|
|
r, ok := tt.Find(label)
|
|
if !ok {
|
|
t.Fatalf("no %q in %q", label, tt.Texts())
|
|
}
|
|
return r
|
|
}
|
|
|
|
func TestHeadingLevels(t *testing.T) {
|
|
tt := view(600, 300, newClock(), func(c *ui.Context) {
|
|
ui.Column(c).Children(func() {
|
|
text.Heading(c, "BIG", text.HeadingOptions{})
|
|
text.Heading(c, "small", text.HeadingOptions{Level: 3})
|
|
})
|
|
})
|
|
if r := find(t, tt, "BIG"); r.W != float32((pixel.Measure("BIG")*3+1)*2) || r.H != float32((pixel.LineHeight*3+1)*2) {
|
|
t.Fatalf("level 1 box %v", r)
|
|
}
|
|
if r := find(t, tt, "small"); r.H != float32((pixel.LineHeight+1)*2) {
|
|
t.Fatalf("level 3 box %v", r)
|
|
}
|
|
defer func() {
|
|
if recover() == nil {
|
|
t.Fatal("level 4 did not panic")
|
|
}
|
|
}()
|
|
view(100, 100, newClock(), func(c *ui.Context) { text.Heading(c, "x", text.HeadingOptions{Level: 4}) })
|
|
}
|
|
|
|
func TestParagraphAlignAndLimit(t *testing.T) {
|
|
words := "one two three four five six seven eight nine ten"
|
|
tt := view(400, 300, newClock(), func(c *ui.Context) {
|
|
ui.Column(c).Width(200).Children(func() {
|
|
text.Paragraph(c, words, text.ParagraphOptions{MaxLines: 1})
|
|
text.Paragraph(c, "hi", text.ParagraphOptions{Align: text.Center})
|
|
text.Paragraph(c, "hi", text.ParagraphOptions{Align: text.Right})
|
|
})
|
|
})
|
|
img := tt.Image()
|
|
if r := find(t, tt, words); r.H != pixel.LineHeight*2 {
|
|
t.Fatalf("MaxLines 1 paragraph is %v DIPs tall", r.H)
|
|
}
|
|
left := func(row int) int {
|
|
for x := range 100 {
|
|
for y := row; y < row+pixel.LineHeight; y++ {
|
|
if slot(t, img, x, y) == pixel.Ink {
|
|
return x
|
|
}
|
|
}
|
|
}
|
|
return -1
|
|
}
|
|
w := pixel.Measure("hi")
|
|
if c, r := left(16), left(32); c < (100-w)/2 || c > (100-w)/2+2 || r < 100-w || r > 100-w+2 {
|
|
t.Fatalf("centered ink at %d, right ink at %d, for width %d", c, r, w)
|
|
}
|
|
}
|
|
|
|
func TestTypewriterGlyphs(t *testing.T) {
|
|
clk := newClock()
|
|
s, done := "AAAA\nBBBB", 0
|
|
tt := view(200, 100, clk, func(c *ui.Context) {
|
|
ui.Box(c).Width(float32(2 * (4*pixel.Measure("A") + 8))).Children(func() {
|
|
if text.Typewriter(c, s, text.TypewriterOptions{CPS: 10}).Done {
|
|
done++
|
|
}
|
|
})
|
|
})
|
|
w := 4 * pixel.Measure("A")
|
|
ink := func(y int) int { return count(t, tt.Image(), 0, y, w, pixel.LineHeight, pixel.Ink) }
|
|
clk.add(400 * time.Millisecond)
|
|
tt.Frame()
|
|
if ink(0) == 0 || ink(pixel.LineHeight) != 0 || done != 0 {
|
|
t.Fatalf("at 4 of 8 glyphs: line inks %d, %d, done %d", ink(0), ink(pixel.LineHeight), done)
|
|
}
|
|
clk.add(300 * time.Millisecond)
|
|
tt.Frame()
|
|
if ink(pixel.LineHeight) == 0 || done != 0 {
|
|
t.Fatalf("at 7 of 8 glyphs: second line ink %d, done %d", ink(pixel.LineHeight), done)
|
|
}
|
|
clk.add(100 * time.Millisecond)
|
|
tt.Frame()
|
|
if done != 1 {
|
|
t.Fatal("the eighth glyph did not finish the text")
|
|
}
|
|
// A box-wide line would push the mark out.
|
|
s = "AAAAA"
|
|
tt.Frame()
|
|
if err := tt.Click(s); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
img := tt.Image()
|
|
if count(t, img, 0, 0, w+8, 3*pixel.LineHeight, pixel.Accent) == 0 {
|
|
clk.add(500 * time.Millisecond)
|
|
tt.Frame()
|
|
img = tt.Image()
|
|
}
|
|
if count(t, img, 0, 0, w+8, 3*pixel.LineHeight, pixel.Accent) == 0 {
|
|
t.Fatal("the done mark never showed")
|
|
}
|
|
if n := count(t, img, w+8, 0, 20, 3*pixel.LineHeight, pixel.Accent); n != 0 {
|
|
t.Fatalf("the done mark left the box: %d dots outside", n)
|
|
}
|
|
}
|
|
|
|
func TestTypewriter(t *testing.T) {
|
|
clk := newClock()
|
|
s, done := "ABCDEFGHIJ", 0
|
|
opts := text.TypewriterOptions{CPS: 10}
|
|
tt := view(400, 200, clk, func(c *ui.Context) {
|
|
if text.Typewriter(c, s, opts).Done {
|
|
done++
|
|
}
|
|
})
|
|
clk.add(500 * time.Millisecond)
|
|
tt.Frame()
|
|
if done != 0 {
|
|
t.Fatal("half the time showed the whole text")
|
|
}
|
|
clk.add(600 * time.Millisecond)
|
|
tt.Frame()
|
|
if done != 1 {
|
|
t.Fatalf("after the whole time done fired %d times", done)
|
|
}
|
|
s = "NEW LINE"
|
|
tt.Frame()
|
|
if err := tt.Click(s); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if done != 2 {
|
|
t.Fatal("a click did not complete a new line")
|
|
}
|
|
s = "THIRD"
|
|
tt.Frame()
|
|
tt.Key(0, ui.KeyEnter)
|
|
if done != 3 {
|
|
t.Fatal("Enter did not complete the line")
|
|
}
|
|
s, opts.Disabled = "FOURTH", true
|
|
tt.Frame()
|
|
_ = tt.Click(s)
|
|
if done != 3 {
|
|
t.Fatal("a disabled typewriter completed on a click")
|
|
}
|
|
s, opts.Disabled = "FIFTH", false
|
|
tt.SetPreferences(ui.Preferences{ReduceMotion: true})
|
|
if done != 4 {
|
|
t.Fatal("Reduce Motion did not show the whole line at once")
|
|
}
|
|
}
|
|
|
|
func TestMarqueeScrollsAndPauses(t *testing.T) {
|
|
clk := newClock()
|
|
tt := view(400, 100, clk, func(c *ui.Context) {
|
|
text.Marquee(c, "HELLO", text.MarqueeOptions{Width: 60})
|
|
})
|
|
// last is the rightmost ink column inside the window.
|
|
last := func() int {
|
|
img := tt.Image()
|
|
if count(t, img, 60, 0, 140, pixel.LineHeight, pixel.Ink) != 0 {
|
|
t.Fatal("the marquee drew outside its window")
|
|
}
|
|
for x := 59; x >= 0; x-- {
|
|
if count(t, img, x, 0, 1, pixel.LineHeight, pixel.Ink) > 0 {
|
|
return x
|
|
}
|
|
}
|
|
return -1
|
|
}
|
|
// Steps come at 15 a second, a dot each.
|
|
r0 := last()
|
|
clk.add(10 * time.Second / 15)
|
|
tt.Frame()
|
|
r1 := last()
|
|
tt.Move(10, 10)
|
|
clk.add(10 * time.Second / 15)
|
|
tt.Frame()
|
|
r2 := last()
|
|
tt.Move(300, 90)
|
|
tt.Frame()
|
|
clk.add(5 * time.Second / 15)
|
|
tt.Frame()
|
|
if r3 := last(); r0 < 0 || r0-r1 != 10 || r2 != r1 || r1-r3 != 5 {
|
|
t.Fatalf("ends at %d, %d (10 steps), %d (hovered), %d (5 more)", r0, r1, r2, r3)
|
|
}
|
|
tt.SetPreferences(ui.Preferences{ReduceMotion: true})
|
|
clk.add(time.Second)
|
|
tt.Frame()
|
|
if last() != r0 {
|
|
t.Fatal("under Reduce Motion the text is not shown at rest")
|
|
}
|
|
}
|
|
|
|
func TestBlinkUnderReduceMotion(t *testing.T) {
|
|
clk := newClock()
|
|
tt := view(200, 100, clk, func(c *ui.Context) { text.BlinkText(c, "ON", text.BlinkTextOptions{}) })
|
|
ink := func() int { return count(t, tt.Image(), 0, 0, 30, pixel.LineHeight, pixel.Ink) }
|
|
if ink() == 0 {
|
|
t.Fatal("step 0 hid the text")
|
|
}
|
|
clk.add(500 * time.Millisecond)
|
|
tt.Frame()
|
|
if ink() != 0 {
|
|
t.Fatal("step 1 showed the text")
|
|
}
|
|
tt.SetPreferences(ui.Preferences{ReduceMotion: true})
|
|
if ink() == 0 {
|
|
t.Fatal("Reduce Motion hid the text")
|
|
}
|
|
}
|
|
|
|
func TestLinkOpens(t *testing.T) {
|
|
opts := text.LinkOptions{}
|
|
clicks := 0
|
|
tt := view(300, 100, newClock(), func(c *ui.Context) {
|
|
if text.Link(c, "Docs", "https://example.com/docs", opts).Clicked {
|
|
clicks++
|
|
}
|
|
})
|
|
if err := tt.Click("Docs"); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
tt.Key(0, ui.KeyEnter)
|
|
if clicks != 2 || len(tt.OpenedURLs()) != 2 || tt.OpenedURLs()[0] != "https://example.com/docs" {
|
|
t.Fatalf("clicks %d, opened %q", clicks, tt.OpenedURLs())
|
|
}
|
|
opts.Disabled = true
|
|
tt.Frame()
|
|
_ = tt.Click("Docs")
|
|
if len(tt.OpenedURLs()) != 2 {
|
|
t.Fatal("a disabled link opened")
|
|
}
|
|
}
|
|
|
|
func TestSevenSegmentLightsSegments(t *testing.T) {
|
|
tt := view(200, 100, newClock(), func(c *ui.Context) {
|
|
text.SevenSegment(c, "1", text.SevenSegmentOptions{})
|
|
})
|
|
img := tt.Image()
|
|
if count(t, img, 6, 1, 1, 4, pixel.Bad) != 4 || count(t, img, 6, 6, 1, 4, pixel.Bad) != 4 {
|
|
t.Fatal("1 did not light b and c")
|
|
}
|
|
if count(t, img, 1, 0, 5, 1, pixel.Bad) != 0 || count(t, img, 1, 0, 5, 1, pixel.Faint) == 0 {
|
|
t.Fatal("1 lit a, or left no ghost")
|
|
}
|
|
}
|
|
|
|
func TestOdometerAndMicroPanics(t *testing.T) {
|
|
for name, build := range map[string]func(c *ui.Context){
|
|
"negative": func(c *ui.Context) { text.Odometer(c, -1, text.OdometerOptions{}) },
|
|
"overflow": func(c *ui.Context) { text.Odometer(c, 1000, text.OdometerOptions{Digits: 3}) },
|
|
"micro rune": func(c *ui.Context) { text.MicroText(c, "é", text.MicroTextOptions{}) },
|
|
"big scale": func(c *ui.Context) { text.ShadowText(c, "x", text.ShadowTextOptions{Scale: 5}) },
|
|
"seven rune": func(c *ui.Context) { text.SevenSegment(c, "x", text.SevenSegmentOptions{}) },
|
|
"paragraph 9": func(c *ui.Context) { text.Paragraph(c, "x", text.ParagraphOptions{Align: 9}) },
|
|
} {
|
|
func() {
|
|
defer func() {
|
|
if recover() == nil {
|
|
t.Errorf("%s did not panic", name)
|
|
}
|
|
}()
|
|
view(200, 100, newClock(), build)
|
|
}()
|
|
}
|
|
}
|
|
|
|
func TestOdometerRollsToValue(t *testing.T) {
|
|
clk := newClock()
|
|
value := 5
|
|
tt := view(300, 100, clk, func(c *ui.Context) { text.Odometer(c, value, text.OdometerOptions{Digits: 2}) })
|
|
digits := func() []pixel.Slot {
|
|
img := tt.Image()
|
|
var out []pixel.Slot
|
|
for y := range pixel.LineHeight + 2 {
|
|
for x := range 20 {
|
|
out = append(out, slot(t, img, x, y))
|
|
}
|
|
}
|
|
return out
|
|
}
|
|
five := digits()
|
|
value = 6
|
|
tt.Frame()
|
|
// One step at 15 fps, S5's fastest.
|
|
clk.add(67 * time.Millisecond)
|
|
tt.Frame()
|
|
mid := digits()
|
|
clk.add(time.Second)
|
|
tt.Frame()
|
|
six := digits()
|
|
if slices.Equal(six, five) || slices.Equal(mid, five) || slices.Equal(mid, six) {
|
|
t.Fatal("the odometer did not roll from 5 through a step to 6")
|
|
}
|
|
}
|
|
|
|
func TestScrambleSettles(t *testing.T) {
|
|
clk := newClock()
|
|
tt := view(300, 100, clk, func(c *ui.Context) {
|
|
ui.Column(c).Children(func() {
|
|
text.ScrambleText(c, "AB", text.ScrambleTextOptions{})
|
|
pixel.Text(c, "AB", pixel.TextOptions{})
|
|
})
|
|
})
|
|
same := func() bool {
|
|
img := tt.Image()
|
|
for y := range pixel.LineHeight {
|
|
for x := range pixel.Measure("AB") {
|
|
if slot(t, img, x, y) != slot(t, img, x, y+pixel.LineHeight) {
|
|
return false
|
|
}
|
|
}
|
|
}
|
|
return true
|
|
}
|
|
if same() {
|
|
t.Fatal("scramble started settled")
|
|
}
|
|
clk.add(400 * time.Millisecond)
|
|
tt.Frame()
|
|
if !same() {
|
|
t.Fatal("after 6 steps the text had not settled")
|
|
}
|
|
}
|
|
|
|
func TestKbdOutlineRainbow(t *testing.T) {
|
|
tt := view(400, 200, newClock(), func(c *ui.Context) {
|
|
ui.Column(c).AlignItems(ui.Start).Children(func() {
|
|
ui.Row(c).Children(func() {
|
|
text.Kbd(c, "A", text.KbdOptions{})
|
|
text.Kbd(c, "B", text.KbdOptions{Pressed: true})
|
|
})
|
|
text.OutlineText(c, "I", text.OutlineTextOptions{})
|
|
text.RainbowText(c, "AB", text.RainbowTextOptions{})
|
|
})
|
|
})
|
|
img := tt.Image()
|
|
a, b := find(t, tt, "A"), find(t, tt, "B")
|
|
if slot(t, img, int(a.X/2)+4, 0) != pixel.Edge || slot(t, img, int(b.X/2)+4, 0) == pixel.Edge {
|
|
t.Fatal("the pressed key did not sink")
|
|
}
|
|
o := find(t, tt, "I")
|
|
ox, oy := int(o.X/2), int(o.Y/2)
|
|
for y := range int(o.H / 2) {
|
|
for x := range int(o.W / 2) {
|
|
if slot(t, img, ox+x, oy+y) != pixel.Lit {
|
|
continue
|
|
}
|
|
for _, d := range [][2]int{{-1, 0}, {1, 0}, {0, -1}, {0, 1}} {
|
|
if n := slot(t, img, ox+x+d[0], oy+y+d[1]); n != pixel.Lit && n != pixel.Edge {
|
|
t.Fatalf("outline gap beside %d,%d", x, y)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
r := find(t, tt, "AB")
|
|
wa := pixel.Measure("A")
|
|
if count(t, img, int(r.X/2), int(r.Y/2), wa, pixel.LineHeight, pixel.Bad) == 0 || count(t, img, int(r.X/2)+wa, int(r.Y/2), pixel.Measure("B"), pixel.LineHeight, pixel.Warn) == 0 {
|
|
t.Fatal("rainbow did not give A Bad and B Warn")
|
|
}
|
|
}
|
|
|
|
func TestTypewriterStaysDoneAcrossWraps(t *testing.T) {
|
|
clk := newClock()
|
|
width, done := float32(80), 0
|
|
tt := view(400, 200, clk, func(c *ui.Context) {
|
|
ui.Box(c).Width(width).Children(func() {
|
|
if text.Typewriter(c, "AAAA BBBB", text.TypewriterOptions{}).Done {
|
|
done++
|
|
}
|
|
})
|
|
pixel.Text(c, "AAAA BBBB", pixel.TextOptions{})
|
|
})
|
|
_ = tt.Click("AAAA BBBB")
|
|
if r, _ := tt.Find("AAAA BBBB"); done != 1 || r.H != 2*pixel.LineHeight*2 {
|
|
t.Fatalf("narrow: done %d, box %v", done, r)
|
|
}
|
|
width = 200
|
|
tt.Frame()
|
|
img := tt.Image()
|
|
w := pixel.Measure("AAAA BBBB")
|
|
for y := range pixel.LineHeight {
|
|
for x := range w {
|
|
if slot(t, img, x, y) != slot(t, img, x, pixel.LineHeight+y) {
|
|
t.Fatalf("after widening, dot %d,%d differs from the full text", x, y)
|
|
}
|
|
}
|
|
}
|
|
if done != 1 {
|
|
t.Fatalf("done fired %d times", done)
|
|
}
|
|
}
|