// Copyright 2026 The TCell Authors // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. package tests import ( "fmt" "testing" "github.com/gdamore/tcell/v3/color" "github.com/gdamore/tcell/v3/vt" ) type MockTerm = vt.MockTerm type Row = vt.Row type Col = vt.Col type Coord = vt.Coord type Attr = vt.Attr // WriteF writes the string, and ensures it is fully flushed // before returning. func WriteF(t *testing.T, term MockTerm, str string, args ...any) { t.Helper() b := fmt.Appendf(nil, str, args...) for len(b) != 0 { if n, err := term.Write(b); err != nil { t.Fatalf("Failed to write: %v", err) } else { b = b[n:] } } if err := term.Drain(); err != nil { t.Fatalf("Failed to flush: %v", err) } } // ReadF reads content from the term and returns it as a string. func ReadF(t *testing.T, term MockTerm) string { t.Helper() buf := make([]byte, 128) n, err := term.Read(buf) if err != nil { t.Errorf("failed read: %v", err) return "" } return string(buf[:n]) } // VerifyF validates the condition, printing the message on failure. func VerifyF(t *testing.T, b bool, fmt string, args ...any) { t.Helper() if !b { t.Errorf("validation failure: "+fmt, args...) } } // AssertF validates the condition, and aborts the test if it fails. func AssertF(t *testing.T, b bool, fmt string, args ...any) { t.Helper() if !b { t.Fatalf("validation failure: "+fmt, args...) } } // MustClose closes or calls Fatalf. func MustClose(t *testing.T, term MockTerm) { t.Helper() err := term.Close() AssertF(t, err == nil, "close failed: %v", err) } // MustStart starts the terminal or calls Fatalf. func MustStart(t *testing.T, term MockTerm) { t.Helper() err := term.Start() AssertF(t, err == nil, "start failed: %v", err) } // CheckPos is verifies the current cursor position of terminal. func CheckPos(t *testing.T, term MockTerm, x Col, y Row) { t.Helper() VerifyF(t, term.Pos().X == x && term.Pos().Y == y, "bad position %d,%d (expected %d,%d)", term.Pos().X, term.Pos().Y, x, y) } // CheckContent verifies the content at a given cell of the terminal. func CheckContent(t *testing.T, term MockTerm, x Col, y Row, s string) { t.Helper() if actual := string(term.GetCell(Coord{X: x, Y: y}).C); actual != s { t.Errorf("bad content %d,%d (expected %q got %q)", x, y, s, actual) } } // CheckAttrs verifies the attributes of a given cell. func CheckAttrs(t *testing.T, term MockTerm, x Col, y Row, a Attr) { t.Helper() if actual := term.GetCell(Coord{X: x, Y: y}).S.Attr(); actual != a { t.Errorf("bad attr %d,%d (expected %x got %x)", x, y, a, actual) } } // CheckColors verifies the colors of a given cell. func CheckColors(t *testing.T, term MockTerm, x Col, y Row, fg color.Color, bg color.Color) { t.Helper() if actual := term.GetCell(Coord{X: x, Y: y}).S.Fg(); actual != fg { t.Errorf("bad foreground %d,%d (expected %s got %s)", x, y, fg.String(), actual.String()) } if actual := term.GetCell(Coord{X: x, Y: y}).S.Bg(); actual != bg { t.Errorf("bad background %d,%d (expected %s got %s)", x, y, bg.String(), actual.String()) } } // CheckRead verifies that a read matches. func CheckRead(t *testing.T, term MockTerm, want string) { t.Helper() result := ReadF(t, term) VerifyF(t, want == result, "wrong read %q != %q", result, want) }