2022-04-07 03:15:01 +03:00
|
|
|
package lipgloss
|
|
|
|
|
|
|
|
import (
|
2024-03-14 17:56:02 +03:00
|
|
|
"os"
|
2022-10-14 20:59:10 +03:00
|
|
|
"reflect"
|
2023-11-27 22:33:38 +03:00
|
|
|
"strings"
|
2022-04-07 03:15:01 +03:00
|
|
|
"testing"
|
|
|
|
)
|
|
|
|
|
2022-04-07 05:05:58 +03:00
|
|
|
func TestStyleRender(t *testing.T) {
|
2024-03-29 20:23:39 +03:00
|
|
|
r := NewRenderer(TrueColor, true)
|
2023-08-01 15:23:15 +03:00
|
|
|
r.SetHasDarkBackground(true)
|
2022-04-07 05:05:58 +03:00
|
|
|
t.Parallel()
|
|
|
|
|
|
|
|
tt := []struct {
|
|
|
|
style Style
|
|
|
|
expected string
|
|
|
|
}{
|
|
|
|
{
|
2023-08-01 15:23:15 +03:00
|
|
|
r.NewStyle().Foreground(Color("#5A56E0")),
|
2024-03-14 17:56:02 +03:00
|
|
|
"\x1b[38;2;89;86;224mhello\x1b[m",
|
2022-04-07 05:05:58 +03:00
|
|
|
},
|
2022-11-18 23:57:57 +03:00
|
|
|
{
|
2023-08-01 15:23:15 +03:00
|
|
|
r.NewStyle().Foreground(AdaptiveColor{Light: "#fffe12", Dark: "#5A56E0"}),
|
2024-03-14 17:56:02 +03:00
|
|
|
"\x1b[38;2;89;86;224mhello\x1b[m",
|
2022-11-18 23:57:57 +03:00
|
|
|
},
|
2022-04-07 05:05:58 +03:00
|
|
|
{
|
2023-08-01 15:23:15 +03:00
|
|
|
r.NewStyle().Bold(true),
|
2024-03-14 17:56:02 +03:00
|
|
|
"\x1b[1mhello\x1b[m",
|
2022-04-07 05:05:58 +03:00
|
|
|
},
|
|
|
|
{
|
2023-08-01 15:23:15 +03:00
|
|
|
r.NewStyle().Italic(true),
|
2024-03-14 17:56:02 +03:00
|
|
|
"\x1b[3mhello\x1b[m",
|
2022-04-07 05:05:58 +03:00
|
|
|
},
|
|
|
|
{
|
2023-08-01 15:23:15 +03:00
|
|
|
r.NewStyle().Underline(true),
|
2024-03-14 17:56:02 +03:00
|
|
|
"\x1b[4;4mh\x1b[m\x1b[4;4me\x1b[m\x1b[4;4ml\x1b[m\x1b[4;4ml\x1b[m\x1b[4;4mo\x1b[m",
|
2022-04-07 05:05:58 +03:00
|
|
|
},
|
|
|
|
{
|
2023-08-01 15:23:15 +03:00
|
|
|
r.NewStyle().Blink(true),
|
2024-03-14 17:56:02 +03:00
|
|
|
"\x1b[5mhello\x1b[m",
|
2022-04-07 05:05:58 +03:00
|
|
|
},
|
|
|
|
{
|
2023-08-01 15:23:15 +03:00
|
|
|
r.NewStyle().Faint(true),
|
2024-03-14 17:56:02 +03:00
|
|
|
"\x1b[2mhello\x1b[m",
|
2022-04-07 05:05:58 +03:00
|
|
|
},
|
|
|
|
}
|
|
|
|
|
|
|
|
for i, tc := range tt {
|
2022-10-03 20:11:44 +03:00
|
|
|
s := tc.style.Copy().SetString("hello")
|
|
|
|
res := s.Render()
|
2022-04-07 05:05:58 +03:00
|
|
|
if res != tc.expected {
|
|
|
|
t.Errorf("Test %d, expected:\n\n`%s`\n`%s`\n\nActual output:\n\n`%s`\n`%s`\n\n",
|
|
|
|
i, tc.expected, formatEscapes(tc.expected),
|
|
|
|
res, formatEscapes(res))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-11-18 23:57:57 +03:00
|
|
|
func TestStyleCustomRender(t *testing.T) {
|
2024-03-29 20:23:39 +03:00
|
|
|
r := NewRenderer(TrueColor, false)
|
2022-11-18 23:57:57 +03:00
|
|
|
tt := []struct {
|
|
|
|
style Style
|
|
|
|
expected string
|
|
|
|
}{
|
|
|
|
{
|
|
|
|
r.NewStyle().Foreground(Color("#5A56E0")),
|
2024-03-14 17:56:02 +03:00
|
|
|
"\x1b[38;2;89;86;224mhello\x1b[m",
|
2022-11-18 23:57:57 +03:00
|
|
|
},
|
|
|
|
{
|
|
|
|
r.NewStyle().Foreground(AdaptiveColor{Light: "#fffe12", Dark: "#5A56E0"}),
|
2024-03-14 17:56:02 +03:00
|
|
|
"\x1b[38;2;255;254;18mhello\x1b[m",
|
2022-11-18 23:57:57 +03:00
|
|
|
},
|
|
|
|
{
|
|
|
|
r.NewStyle().Bold(true),
|
2024-03-14 17:56:02 +03:00
|
|
|
"\x1b[1mhello\x1b[m",
|
2022-11-18 23:57:57 +03:00
|
|
|
},
|
|
|
|
{
|
|
|
|
r.NewStyle().Italic(true),
|
2024-03-14 17:56:02 +03:00
|
|
|
"\x1b[3mhello\x1b[m",
|
2022-11-18 23:57:57 +03:00
|
|
|
},
|
|
|
|
{
|
|
|
|
r.NewStyle().Underline(true),
|
2024-03-14 17:56:02 +03:00
|
|
|
"\x1b[4;4mh\x1b[m\x1b[4;4me\x1b[m\x1b[4;4ml\x1b[m\x1b[4;4ml\x1b[m\x1b[4;4mo\x1b[m",
|
2022-11-18 23:57:57 +03:00
|
|
|
},
|
|
|
|
{
|
|
|
|
r.NewStyle().Blink(true),
|
2024-03-14 17:56:02 +03:00
|
|
|
"\x1b[5mhello\x1b[m",
|
2022-11-18 23:57:57 +03:00
|
|
|
},
|
|
|
|
{
|
|
|
|
r.NewStyle().Faint(true),
|
2024-03-14 17:56:02 +03:00
|
|
|
"\x1b[2mhello\x1b[m",
|
2022-11-18 23:57:57 +03:00
|
|
|
},
|
2023-03-03 00:53:19 +03:00
|
|
|
{
|
|
|
|
NewStyle().Faint(true).Renderer(r),
|
2024-03-14 17:56:02 +03:00
|
|
|
"\x1b[2mhello\x1b[m",
|
2023-03-03 00:53:19 +03:00
|
|
|
},
|
2022-11-18 23:57:57 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
for i, tc := range tt {
|
|
|
|
s := tc.style.Copy().SetString("hello")
|
|
|
|
res := s.Render()
|
|
|
|
if res != tc.expected {
|
|
|
|
t.Errorf("Test %d, expected:\n\n`%s`\n`%s`\n\nActual output:\n\n`%s`\n`%s`\n\n",
|
|
|
|
i, tc.expected, formatEscapes(tc.expected),
|
|
|
|
res, formatEscapes(res))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2023-03-03 00:53:19 +03:00
|
|
|
func TestStyleRenderer(t *testing.T) {
|
2024-04-29 21:18:55 +03:00
|
|
|
r := NewRenderer(DetectColorProfile(os.Stdout, nil), true)
|
2023-03-03 00:53:19 +03:00
|
|
|
s1 := NewStyle().Bold(true)
|
|
|
|
s2 := s1.Renderer(r)
|
|
|
|
if s1.r == s2.r {
|
|
|
|
t.Fatalf("expected different renderers")
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-04-07 05:05:58 +03:00
|
|
|
func TestValueCopy(t *testing.T) {
|
|
|
|
t.Parallel()
|
|
|
|
|
|
|
|
s := NewStyle().
|
|
|
|
Bold(true)
|
|
|
|
|
|
|
|
i := s
|
|
|
|
i.Bold(false)
|
|
|
|
|
2022-10-14 20:59:10 +03:00
|
|
|
requireEqual(t, s.GetBold(), i.GetBold())
|
2022-04-07 05:05:58 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
func TestStyleInherit(t *testing.T) {
|
|
|
|
t.Parallel()
|
|
|
|
|
|
|
|
s := NewStyle().
|
|
|
|
Bold(true).
|
|
|
|
Italic(true).
|
|
|
|
Underline(true).
|
|
|
|
Strikethrough(true).
|
|
|
|
Blink(true).
|
|
|
|
Faint(true).
|
|
|
|
Foreground(Color("#ffffff")).
|
|
|
|
Background(Color("#111111")).
|
|
|
|
Margin(1, 1, 1, 1).
|
|
|
|
Padding(1, 1, 1, 1)
|
|
|
|
|
|
|
|
i := NewStyle().Inherit(s)
|
|
|
|
|
2022-10-14 20:59:10 +03:00
|
|
|
requireEqual(t, s.GetBold(), i.GetBold())
|
|
|
|
requireEqual(t, s.GetItalic(), i.GetItalic())
|
|
|
|
requireEqual(t, s.GetUnderline(), i.GetUnderline())
|
|
|
|
requireEqual(t, s.GetStrikethrough(), i.GetStrikethrough())
|
|
|
|
requireEqual(t, s.GetBlink(), i.GetBlink())
|
|
|
|
requireEqual(t, s.GetFaint(), i.GetFaint())
|
|
|
|
requireEqual(t, s.GetForeground(), i.GetForeground())
|
|
|
|
requireEqual(t, s.GetBackground(), i.GetBackground())
|
|
|
|
|
|
|
|
requireNotEqual(t, s.GetMarginLeft(), i.GetMarginLeft())
|
|
|
|
requireNotEqual(t, s.GetMarginRight(), i.GetMarginRight())
|
|
|
|
requireNotEqual(t, s.GetMarginTop(), i.GetMarginTop())
|
|
|
|
requireNotEqual(t, s.GetMarginBottom(), i.GetMarginBottom())
|
|
|
|
requireNotEqual(t, s.GetPaddingLeft(), i.GetPaddingLeft())
|
|
|
|
requireNotEqual(t, s.GetPaddingRight(), i.GetPaddingRight())
|
|
|
|
requireNotEqual(t, s.GetPaddingTop(), i.GetPaddingTop())
|
|
|
|
requireNotEqual(t, s.GetPaddingBottom(), i.GetPaddingBottom())
|
2022-04-07 05:05:58 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
func TestStyleCopy(t *testing.T) {
|
|
|
|
t.Parallel()
|
|
|
|
|
|
|
|
s := NewStyle().
|
|
|
|
Bold(true).
|
|
|
|
Italic(true).
|
|
|
|
Underline(true).
|
|
|
|
Strikethrough(true).
|
|
|
|
Blink(true).
|
|
|
|
Faint(true).
|
|
|
|
Foreground(Color("#ffffff")).
|
|
|
|
Background(Color("#111111")).
|
|
|
|
Margin(1, 1, 1, 1).
|
2023-07-24 18:22:48 +03:00
|
|
|
Padding(1, 1, 1, 1).
|
|
|
|
TabWidth(2)
|
2022-04-07 05:05:58 +03:00
|
|
|
|
|
|
|
i := s.Copy()
|
|
|
|
|
2022-10-14 20:59:10 +03:00
|
|
|
requireEqual(t, s.GetBold(), i.GetBold())
|
|
|
|
requireEqual(t, s.GetItalic(), i.GetItalic())
|
|
|
|
requireEqual(t, s.GetUnderline(), i.GetUnderline())
|
|
|
|
requireEqual(t, s.GetStrikethrough(), i.GetStrikethrough())
|
|
|
|
requireEqual(t, s.GetBlink(), i.GetBlink())
|
|
|
|
requireEqual(t, s.GetFaint(), i.GetFaint())
|
|
|
|
requireEqual(t, s.GetForeground(), i.GetForeground())
|
|
|
|
requireEqual(t, s.GetBackground(), i.GetBackground())
|
|
|
|
|
|
|
|
requireEqual(t, s.GetMarginLeft(), i.GetMarginLeft())
|
|
|
|
requireEqual(t, s.GetMarginRight(), i.GetMarginRight())
|
|
|
|
requireEqual(t, s.GetMarginTop(), i.GetMarginTop())
|
|
|
|
requireEqual(t, s.GetMarginBottom(), i.GetMarginBottom())
|
|
|
|
requireEqual(t, s.GetPaddingLeft(), i.GetPaddingLeft())
|
|
|
|
requireEqual(t, s.GetPaddingRight(), i.GetPaddingRight())
|
|
|
|
requireEqual(t, s.GetPaddingTop(), i.GetPaddingTop())
|
|
|
|
requireEqual(t, s.GetPaddingBottom(), i.GetPaddingBottom())
|
2023-07-24 18:22:48 +03:00
|
|
|
requireEqual(t, s.GetTabWidth(), i.GetTabWidth())
|
2022-04-07 05:05:58 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
func TestStyleUnset(t *testing.T) {
|
|
|
|
t.Parallel()
|
|
|
|
|
|
|
|
s := NewStyle().Bold(true)
|
2022-10-14 20:59:10 +03:00
|
|
|
requireTrue(t, s.GetBold())
|
2024-03-28 23:41:30 +03:00
|
|
|
s = s.UnsetBold()
|
2022-10-14 20:59:10 +03:00
|
|
|
requireFalse(t, s.GetBold())
|
2022-04-07 05:05:58 +03:00
|
|
|
|
|
|
|
s = NewStyle().Italic(true)
|
2022-10-14 20:59:10 +03:00
|
|
|
requireTrue(t, s.GetItalic())
|
2024-03-28 23:41:30 +03:00
|
|
|
s = s.UnsetItalic()
|
2022-10-14 20:59:10 +03:00
|
|
|
requireFalse(t, s.GetItalic())
|
2022-04-07 05:05:58 +03:00
|
|
|
|
|
|
|
s = NewStyle().Underline(true)
|
2022-10-14 20:59:10 +03:00
|
|
|
requireTrue(t, s.GetUnderline())
|
2024-03-28 23:41:30 +03:00
|
|
|
s = s.UnsetUnderline()
|
2022-10-14 20:59:10 +03:00
|
|
|
requireFalse(t, s.GetUnderline())
|
2022-04-07 05:05:58 +03:00
|
|
|
|
|
|
|
s = NewStyle().Strikethrough(true)
|
2022-10-14 20:59:10 +03:00
|
|
|
requireTrue(t, s.GetStrikethrough())
|
2024-03-28 23:41:30 +03:00
|
|
|
s = s.UnsetStrikethrough()
|
2022-10-14 20:59:10 +03:00
|
|
|
requireFalse(t, s.GetStrikethrough())
|
2022-04-07 05:05:58 +03:00
|
|
|
|
|
|
|
s = NewStyle().Reverse(true)
|
2022-10-14 20:59:10 +03:00
|
|
|
requireTrue(t, s.GetReverse())
|
2024-03-28 23:41:30 +03:00
|
|
|
s = s.UnsetReverse()
|
2022-10-14 20:59:10 +03:00
|
|
|
requireFalse(t, s.GetReverse())
|
2022-04-07 05:05:58 +03:00
|
|
|
|
|
|
|
s = NewStyle().Blink(true)
|
2022-10-14 20:59:10 +03:00
|
|
|
requireTrue(t, s.GetBlink())
|
2024-03-28 23:41:30 +03:00
|
|
|
s = s.UnsetBlink()
|
2022-10-14 20:59:10 +03:00
|
|
|
requireFalse(t, s.GetBlink())
|
2022-04-07 05:05:58 +03:00
|
|
|
|
|
|
|
s = NewStyle().Faint(true)
|
2022-10-14 20:59:10 +03:00
|
|
|
requireTrue(t, s.GetFaint())
|
2024-03-28 23:41:30 +03:00
|
|
|
s = s.UnsetFaint()
|
2022-10-14 20:59:10 +03:00
|
|
|
requireFalse(t, s.GetFaint())
|
2022-04-07 05:05:58 +03:00
|
|
|
|
|
|
|
s = NewStyle().Inline(true)
|
2022-10-14 20:59:10 +03:00
|
|
|
requireTrue(t, s.GetInline())
|
2024-03-28 23:41:30 +03:00
|
|
|
s = s.UnsetInline()
|
2022-10-14 20:59:10 +03:00
|
|
|
requireFalse(t, s.GetInline())
|
2022-04-07 05:05:58 +03:00
|
|
|
|
|
|
|
// colors
|
|
|
|
col := Color("#ffffff")
|
|
|
|
s = NewStyle().Foreground(col)
|
2022-10-14 20:59:10 +03:00
|
|
|
requireEqual(t, col, s.GetForeground())
|
2024-03-28 23:41:30 +03:00
|
|
|
s = s.UnsetForeground()
|
2022-10-14 20:59:10 +03:00
|
|
|
requireNotEqual(t, col, s.GetForeground())
|
2022-04-07 05:05:58 +03:00
|
|
|
|
|
|
|
s = NewStyle().Background(col)
|
2022-10-14 20:59:10 +03:00
|
|
|
requireEqual(t, col, s.GetBackground())
|
2024-03-28 23:41:30 +03:00
|
|
|
s = s.UnsetBackground()
|
2022-10-14 20:59:10 +03:00
|
|
|
requireNotEqual(t, col, s.GetBackground())
|
2022-04-07 05:05:58 +03:00
|
|
|
|
|
|
|
// margins
|
|
|
|
s = NewStyle().Margin(1, 2, 3, 4)
|
2022-10-14 20:59:10 +03:00
|
|
|
requireEqual(t, 1, s.GetMarginTop())
|
2024-03-28 23:41:30 +03:00
|
|
|
s = s.UnsetMarginTop()
|
2022-10-14 20:59:10 +03:00
|
|
|
requireEqual(t, 0, s.GetMarginTop())
|
2022-04-07 05:05:58 +03:00
|
|
|
|
2022-10-14 20:59:10 +03:00
|
|
|
requireEqual(t, 2, s.GetMarginRight())
|
2024-03-28 23:41:30 +03:00
|
|
|
s = s.UnsetMarginRight()
|
2022-10-14 20:59:10 +03:00
|
|
|
requireEqual(t, 0, s.GetMarginRight())
|
2022-04-07 05:05:58 +03:00
|
|
|
|
2022-10-14 20:59:10 +03:00
|
|
|
requireEqual(t, 3, s.GetMarginBottom())
|
2024-03-28 23:41:30 +03:00
|
|
|
s = s.UnsetMarginBottom()
|
2022-10-14 20:59:10 +03:00
|
|
|
requireEqual(t, 0, s.GetMarginBottom())
|
2022-04-07 05:05:58 +03:00
|
|
|
|
2022-10-14 20:59:10 +03:00
|
|
|
requireEqual(t, 4, s.GetMarginLeft())
|
2024-03-28 23:41:30 +03:00
|
|
|
s = s.UnsetMarginLeft()
|
2022-10-14 20:59:10 +03:00
|
|
|
requireEqual(t, 0, s.GetMarginLeft())
|
2022-04-07 05:05:58 +03:00
|
|
|
|
|
|
|
// padding
|
|
|
|
s = NewStyle().Padding(1, 2, 3, 4)
|
2022-10-14 20:59:10 +03:00
|
|
|
requireEqual(t, 1, s.GetPaddingTop())
|
2024-03-28 23:41:30 +03:00
|
|
|
s = s.UnsetPaddingTop()
|
2022-10-14 20:59:10 +03:00
|
|
|
requireEqual(t, 0, s.GetPaddingTop())
|
2022-04-07 05:05:58 +03:00
|
|
|
|
2022-10-14 20:59:10 +03:00
|
|
|
requireEqual(t, 2, s.GetPaddingRight())
|
2024-03-28 23:41:30 +03:00
|
|
|
s = s.UnsetPaddingRight()
|
2022-10-14 20:59:10 +03:00
|
|
|
requireEqual(t, 0, s.GetPaddingRight())
|
2022-04-07 05:05:58 +03:00
|
|
|
|
2022-10-14 20:59:10 +03:00
|
|
|
requireEqual(t, 3, s.GetPaddingBottom())
|
2024-03-28 23:41:30 +03:00
|
|
|
s = s.UnsetPaddingBottom()
|
2022-10-14 20:59:10 +03:00
|
|
|
requireEqual(t, 0, s.GetPaddingBottom())
|
2022-04-07 05:05:58 +03:00
|
|
|
|
2022-10-14 20:59:10 +03:00
|
|
|
requireEqual(t, 4, s.GetPaddingLeft())
|
2024-03-28 23:41:30 +03:00
|
|
|
s = s.UnsetPaddingLeft()
|
2022-10-14 20:59:10 +03:00
|
|
|
requireEqual(t, 0, s.GetPaddingLeft())
|
2022-04-07 05:05:58 +03:00
|
|
|
|
|
|
|
// border
|
|
|
|
s = NewStyle().Border(normalBorder, true, true, true, true)
|
2022-10-14 20:59:10 +03:00
|
|
|
requireTrue(t, s.GetBorderTop())
|
2024-03-28 23:41:30 +03:00
|
|
|
s = s.UnsetBorderTop()
|
2022-10-14 20:59:10 +03:00
|
|
|
requireFalse(t, s.GetBorderTop())
|
2022-04-07 05:05:58 +03:00
|
|
|
|
2022-10-14 20:59:10 +03:00
|
|
|
requireTrue(t, s.GetBorderRight())
|
2024-03-28 23:41:30 +03:00
|
|
|
s = s.UnsetBorderRight()
|
2022-10-14 20:59:10 +03:00
|
|
|
requireFalse(t, s.GetBorderRight())
|
2022-04-07 05:05:58 +03:00
|
|
|
|
2022-10-14 20:59:10 +03:00
|
|
|
requireTrue(t, s.GetBorderBottom())
|
2024-03-28 23:41:30 +03:00
|
|
|
s = s.UnsetBorderBottom()
|
2022-10-14 20:59:10 +03:00
|
|
|
requireFalse(t, s.GetBorderBottom())
|
2022-04-07 05:05:58 +03:00
|
|
|
|
2022-10-14 20:59:10 +03:00
|
|
|
requireTrue(t, s.GetBorderLeft())
|
2024-03-28 23:41:30 +03:00
|
|
|
s = s.UnsetBorderLeft()
|
2022-10-14 20:59:10 +03:00
|
|
|
requireFalse(t, s.GetBorderLeft())
|
2023-07-24 18:22:48 +03:00
|
|
|
|
|
|
|
// tab width
|
|
|
|
s = NewStyle().TabWidth(2)
|
|
|
|
requireEqual(t, s.GetTabWidth(), 2)
|
2024-03-28 23:41:30 +03:00
|
|
|
s = s.UnsetTabWidth()
|
2023-07-24 18:22:48 +03:00
|
|
|
requireNotEqual(t, s.GetTabWidth(), 4)
|
2022-04-07 05:05:58 +03:00
|
|
|
}
|
|
|
|
|
2022-10-03 20:11:44 +03:00
|
|
|
func TestStyleValue(t *testing.T) {
|
|
|
|
t.Parallel()
|
|
|
|
|
|
|
|
tt := []struct {
|
|
|
|
name string
|
2024-01-31 01:38:39 +03:00
|
|
|
text string
|
2022-10-03 20:11:44 +03:00
|
|
|
style Style
|
|
|
|
expected string
|
|
|
|
}{
|
|
|
|
{
|
|
|
|
name: "empty",
|
2024-01-31 01:38:39 +03:00
|
|
|
text: "foo",
|
2022-10-03 20:11:44 +03:00
|
|
|
style: NewStyle(),
|
|
|
|
expected: "foo",
|
|
|
|
},
|
|
|
|
{
|
|
|
|
name: "set string",
|
2024-01-31 01:38:39 +03:00
|
|
|
text: "foo",
|
2022-10-03 20:11:44 +03:00
|
|
|
style: NewStyle().SetString("bar"),
|
|
|
|
expected: "bar foo",
|
|
|
|
},
|
|
|
|
{
|
|
|
|
name: "set string with bold",
|
2024-01-31 01:38:39 +03:00
|
|
|
text: "foo",
|
2022-10-03 20:11:44 +03:00
|
|
|
style: NewStyle().SetString("bar").Bold(true),
|
2024-03-14 17:56:02 +03:00
|
|
|
expected: "\x1b[1mbar foo\x1b[m",
|
2022-10-03 20:11:44 +03:00
|
|
|
},
|
|
|
|
{
|
|
|
|
name: "new style with string",
|
2024-01-31 01:38:39 +03:00
|
|
|
text: "foo",
|
2023-03-03 00:53:19 +03:00
|
|
|
style: NewStyle().SetString("bar", "foobar"),
|
2022-10-03 20:11:44 +03:00
|
|
|
expected: "bar foobar foo",
|
|
|
|
},
|
2024-01-31 01:38:39 +03:00
|
|
|
{
|
|
|
|
name: "margin right",
|
|
|
|
text: "foo",
|
|
|
|
style: NewStyle().MarginRight(1),
|
|
|
|
expected: "foo ",
|
|
|
|
},
|
|
|
|
{
|
|
|
|
name: "margin left",
|
|
|
|
text: "foo",
|
|
|
|
style: NewStyle().MarginLeft(1),
|
|
|
|
expected: " foo",
|
|
|
|
},
|
|
|
|
{
|
|
|
|
name: "empty text margin right",
|
|
|
|
text: "",
|
|
|
|
style: NewStyle().MarginRight(1),
|
|
|
|
expected: " ",
|
|
|
|
},
|
|
|
|
{
|
|
|
|
name: "empty text margin left",
|
|
|
|
text: "",
|
|
|
|
style: NewStyle().MarginLeft(1),
|
|
|
|
expected: " ",
|
|
|
|
},
|
2022-10-03 20:11:44 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
for i, tc := range tt {
|
2024-01-31 01:38:39 +03:00
|
|
|
res := tc.style.Render(tc.text)
|
2022-10-03 20:11:44 +03:00
|
|
|
if res != tc.expected {
|
|
|
|
t.Errorf("Test %d, expected:\n\n`%s`\n`%s`\n\nActual output:\n\n`%s`\n`%s`\n\n",
|
|
|
|
i, tc.expected, formatEscapes(tc.expected),
|
|
|
|
res, formatEscapes(res))
|
|
|
|
}
|
|
|
|
}
|
2023-07-24 18:22:48 +03:00
|
|
|
}
|
2022-10-03 20:11:44 +03:00
|
|
|
|
2023-07-24 18:22:48 +03:00
|
|
|
func TestTabConversion(t *testing.T) {
|
|
|
|
s := NewStyle()
|
|
|
|
requireEqual(t, "[ ]", s.Render("[\t]"))
|
|
|
|
s = NewStyle().TabWidth(2)
|
|
|
|
requireEqual(t, "[ ]", s.Render("[\t]"))
|
|
|
|
s = NewStyle().TabWidth(0)
|
|
|
|
requireEqual(t, "[]", s.Render("[\t]"))
|
|
|
|
s = NewStyle().TabWidth(-1)
|
|
|
|
requireEqual(t, "[\t]", s.Render("[\t]"))
|
2022-10-03 20:11:44 +03:00
|
|
|
}
|
|
|
|
|
2023-11-27 22:33:38 +03:00
|
|
|
func TestStringTransform(t *testing.T) {
|
|
|
|
for i, tc := range []struct {
|
|
|
|
input string
|
|
|
|
fn func(string) string
|
|
|
|
expected string
|
|
|
|
}{
|
2024-03-22 23:12:37 +03:00
|
|
|
// No-op.
|
|
|
|
{
|
|
|
|
"hello",
|
|
|
|
func(s string) string { return s },
|
|
|
|
"hello",
|
|
|
|
},
|
|
|
|
// Uppercase.
|
2023-11-27 22:33:38 +03:00
|
|
|
{
|
|
|
|
"raow",
|
|
|
|
strings.ToUpper,
|
|
|
|
"RAOW",
|
|
|
|
},
|
2024-03-22 23:12:37 +03:00
|
|
|
// English and Chinese.
|
2023-11-27 22:33:38 +03:00
|
|
|
{
|
|
|
|
"The quick brown 狐 jumped over the lazy 犬",
|
|
|
|
func(s string) string {
|
|
|
|
n := 0
|
|
|
|
rune := make([]rune, len(s))
|
|
|
|
for _, r := range s {
|
|
|
|
rune[n] = r
|
|
|
|
n++
|
|
|
|
}
|
|
|
|
rune = rune[0:n]
|
|
|
|
for i := 0; i < n/2; i++ {
|
|
|
|
rune[i], rune[n-1-i] = rune[n-1-i], rune[i]
|
|
|
|
}
|
|
|
|
return string(rune)
|
|
|
|
},
|
|
|
|
"犬 yzal eht revo depmuj 狐 nworb kciuq ehT",
|
|
|
|
},
|
|
|
|
} {
|
2024-03-22 23:12:37 +03:00
|
|
|
res := NewStyle().Bold(true).Transform(tc.fn).Render(tc.input)
|
2024-03-14 17:56:02 +03:00
|
|
|
expected := "\x1b[1m" + tc.expected + "\x1b[m"
|
2024-03-22 23:12:37 +03:00
|
|
|
if res != expected {
|
|
|
|
t.Errorf("Test #%d:\nExpected: %q\nGot: %q", i+1, expected, res)
|
2023-11-27 22:33:38 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-04-07 03:15:01 +03:00
|
|
|
func BenchmarkStyleRender(b *testing.B) {
|
|
|
|
s := NewStyle().
|
|
|
|
Bold(true).
|
|
|
|
Foreground(Color("#ffffff"))
|
|
|
|
|
|
|
|
for i := 0; i < b.N; i++ {
|
|
|
|
s.Render("Hello world")
|
|
|
|
}
|
|
|
|
}
|
2022-10-14 20:59:10 +03:00
|
|
|
|
|
|
|
func requireTrue(tb testing.TB, b bool) {
|
2024-03-28 23:41:30 +03:00
|
|
|
tb.Helper()
|
2022-10-14 20:59:10 +03:00
|
|
|
requireEqual(tb, true, b)
|
|
|
|
}
|
|
|
|
|
|
|
|
func requireFalse(tb testing.TB, b bool) {
|
2024-03-28 23:41:30 +03:00
|
|
|
tb.Helper()
|
2022-10-14 20:59:10 +03:00
|
|
|
requireEqual(tb, false, b)
|
|
|
|
}
|
|
|
|
|
|
|
|
func requireEqual(tb testing.TB, a, b interface{}) {
|
|
|
|
tb.Helper()
|
|
|
|
if !reflect.DeepEqual(a, b) {
|
|
|
|
tb.Errorf("%v != %v", a, b)
|
|
|
|
tb.FailNow()
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func requireNotEqual(tb testing.TB, a, b interface{}) {
|
|
|
|
tb.Helper()
|
|
|
|
if reflect.DeepEqual(a, b) {
|
|
|
|
tb.Errorf("%v == %v", a, b)
|
|
|
|
tb.FailNow()
|
|
|
|
}
|
|
|
|
}
|