goext/termext/colors_test.go

package termext
 
import (
"git.blackforestbytes.com/BlackForestBytes/goext/tst"
"strings"
"testing"
)
 
const (
resetSeq = ""
redSeq = ""
greenSeq = ""
yellowSeq = ""
blueSeq = ""
purpleSeq = ""
cyanSeq = ""
graySeq = ""
whiteSeq = ""
)
 
func TestRedEmpty(t *testing.T) {
tst.AssertEqual(t, Red(""), redSeq+resetSeq)
}
 
func TestGreenEmpty(t *testing.T) {
tst.AssertEqual(t, Green(""), greenSeq+resetSeq)
}
 
func TestYellowEmpty(t *testing.T) {
tst.AssertEqual(t, Yellow(""), yellowSeq+resetSeq)
}
 
func TestBlueEmpty(t *testing.T) {
tst.AssertEqual(t, Blue(""), blueSeq+resetSeq)
}
 
func TestPurpleEmpty(t *testing.T) {
tst.AssertEqual(t, Purple(""), purpleSeq+resetSeq)
}
 
func TestCyanEmpty(t *testing.T) {
tst.AssertEqual(t, Cyan(""), cyanSeq+resetSeq)
}
 
func TestGrayEmpty(t *testing.T) {
tst.AssertEqual(t, Gray(""), graySeq+resetSeq)
}
 
func TestWhiteEmpty(t *testing.T) {
tst.AssertEqual(t, White(""), whiteSeq+resetSeq)
}
 
func TestColorsContainOriginalString(t *testing.T) {
input := "hello world"
tst.AssertTrue(t, strings.Contains(Red(input), input))
tst.AssertTrue(t, strings.Contains(Green(input), input))
tst.AssertTrue(t, strings.Contains(Yellow(input), input))
tst.AssertTrue(t, strings.Contains(Blue(input), input))
tst.AssertTrue(t, strings.Contains(Purple(input), input))
tst.AssertTrue(t, strings.Contains(Cyan(input), input))
tst.AssertTrue(t, strings.Contains(Gray(input), input))
tst.AssertTrue(t, strings.Contains(White(input), input))
}
 
func TestColorsEndWithReset(t *testing.T) {
tst.AssertTrue(t, strings.HasSuffix(Red("x"), resetSeq))
tst.AssertTrue(t, strings.HasSuffix(Green("x"), resetSeq))
tst.AssertTrue(t, strings.HasSuffix(Yellow("x"), resetSeq))
tst.AssertTrue(t, strings.HasSuffix(Blue("x"), resetSeq))
tst.AssertTrue(t, strings.HasSuffix(Purple("x"), resetSeq))
tst.AssertTrue(t, strings.HasSuffix(Cyan("x"), resetSeq))
tst.AssertTrue(t, strings.HasSuffix(Gray("x"), resetSeq))
tst.AssertTrue(t, strings.HasSuffix(White("x"), resetSeq))
}
 
func TestColorsStartWithCorrectSequence(t *testing.T) {
tst.AssertTrue(t, strings.HasPrefix(Red("x"), redSeq))
tst.AssertTrue(t, strings.HasPrefix(Green("x"), greenSeq))
tst.AssertTrue(t, strings.HasPrefix(Yellow("x"), yellowSeq))
tst.AssertTrue(t, strings.HasPrefix(Blue("x"), blueSeq))
tst.AssertTrue(t, strings.HasPrefix(Purple("x"), purpleSeq))
tst.AssertTrue(t, strings.HasPrefix(Cyan("x"), cyanSeq))
tst.AssertTrue(t, strings.HasPrefix(Gray("x"), graySeq))
tst.AssertTrue(t, strings.HasPrefix(White("x"), whiteSeq))
}
 
func TestColorsAreDistinct(t *testing.T) {
input := "value"
results := []string{
Red(input),
Green(input),
Yellow(input),
Blue(input),
Purple(input),
Cyan(input),
Gray(input),
White(input),
}
for i := 0; i < len(results); i++ {
for j := i + 1; j < len(results); j++ {
tst.AssertNotEqual(t, results[i], results[j])
}
}
}
 
func TestCleanStringEmpty(t *testing.T) {
tst.AssertEqual(t, CleanString(""), "")
}
 
func TestCleanStringWithoutColors(t *testing.T) {
input := "plain text without any colors"
tst.AssertEqual(t, CleanString(input), input)
}
 
func TestCleanStringMultipleColors(t *testing.T) {
input := Red("foo") + " " + Green("bar") + " " + Blue("baz")
tst.AssertEqual(t, CleanString(input), "foo bar baz")
}
 
func TestCleanStringNested(t *testing.T) {
input := Red(Green("inner"))
tst.AssertEqual(t, CleanString(input), "inner")
}
 
func TestCleanStringIdempotent(t *testing.T) {
input := Yellow("hello") + Purple("world")
cleaned := CleanString(input)
tst.AssertEqual(t, CleanString(cleaned), cleaned)
}
 
func TestCleanStringEmptyColorWraps(t *testing.T) {
tst.AssertEqual(t, CleanString(Red("")), "")
tst.AssertEqual(t, CleanString(Green("")), "")
tst.AssertEqual(t, CleanString(Yellow("")), "")
tst.AssertEqual(t, CleanString(Blue("")), "")
tst.AssertEqual(t, CleanString(Purple("")), "")
tst.AssertEqual(t, CleanString(Cyan("")), "")
tst.AssertEqual(t, CleanString(Gray("")), "")
tst.AssertEqual(t, CleanString(White("")), "")
}
 
func TestCleanStringPreservesNonAnsiContent(t *testing.T) {
input := "before " + Red("middle") + " after\nnewline\ttab"
expected := "before middle after\nnewline\ttab"
tst.AssertEqual(t, CleanString(input), expected)
}
 
func TestCleanStringRemovesBareResetSequence(t *testing.T) {
input := "abc" + resetSeq + "def"
tst.AssertEqual(t, CleanString(input), "abcdef")
}
 
func TestCleanStringUnicode(t *testing.T) {
input := Red("héllo wörld 你好 🌍")
tst.AssertEqual(t, CleanString(input), "héllo wörld 你好 🌍")
}
 
func TestColorRoundTrip(t *testing.T) {
cases := []string{"", "x", "hello", "multi\nline", "with spaces", "héllo", "🌈"}
wrappers := []func(string) string{Red, Green, Yellow, Blue, Purple, Cyan, Gray, White}
for _, c := range cases {
for _, w := range wrappers {
tst.AssertEqual(t, CleanString(w(c)), c)
}
}
}