mirror of
https://github.com/fatih/color.git
synced 2024-11-24 08:02:14 +02:00
a2983f4b63
The newline should be added after wrapping the input with escape sequences. That way `less` or other commands can parse the output correctly. fixes https://github.com/fatih/color/issues/157
472 lines
11 KiB
Go
472 lines
11 KiB
Go
package color
|
|
|
|
import (
|
|
"bytes"
|
|
"fmt"
|
|
"io"
|
|
"os"
|
|
"testing"
|
|
|
|
"github.com/mattn/go-colorable"
|
|
)
|
|
|
|
// Testing colors is kinda different. First we test for given colors and their
|
|
// escaped formatted results. Next we create some visual tests to be tested.
|
|
// Each visual test includes the color name to be compared.
|
|
func TestColor(t *testing.T) {
|
|
rb := new(bytes.Buffer)
|
|
Output = rb
|
|
|
|
NoColor = false
|
|
|
|
testColors := []struct {
|
|
text string
|
|
code Attribute
|
|
}{
|
|
{text: "black", code: FgBlack},
|
|
{text: "red", code: FgRed},
|
|
{text: "green", code: FgGreen},
|
|
{text: "yellow", code: FgYellow},
|
|
{text: "blue", code: FgBlue},
|
|
{text: "magent", code: FgMagenta},
|
|
{text: "cyan", code: FgCyan},
|
|
{text: "white", code: FgWhite},
|
|
{text: "hblack", code: FgHiBlack},
|
|
{text: "hred", code: FgHiRed},
|
|
{text: "hgreen", code: FgHiGreen},
|
|
{text: "hyellow", code: FgHiYellow},
|
|
{text: "hblue", code: FgHiBlue},
|
|
{text: "hmagent", code: FgHiMagenta},
|
|
{text: "hcyan", code: FgHiCyan},
|
|
{text: "hwhite", code: FgHiWhite},
|
|
}
|
|
|
|
for _, c := range testColors {
|
|
New(c.code).Print(c.text)
|
|
|
|
line, _ := rb.ReadString('\n')
|
|
scannedLine := fmt.Sprintf("%q", line)
|
|
colored := fmt.Sprintf("\x1b[%dm%s\x1b[0m", c.code, c.text)
|
|
escapedForm := fmt.Sprintf("%q", colored)
|
|
|
|
fmt.Printf("%s\t: %s\n", c.text, line)
|
|
|
|
if scannedLine != escapedForm {
|
|
t.Errorf("Expecting %s, got '%s'\n", escapedForm, scannedLine)
|
|
}
|
|
}
|
|
|
|
for _, c := range testColors {
|
|
line := New(c.code).Sprintf("%s", c.text)
|
|
scannedLine := fmt.Sprintf("%q", line)
|
|
colored := fmt.Sprintf("\x1b[%dm%s\x1b[0m", c.code, c.text)
|
|
escapedForm := fmt.Sprintf("%q", colored)
|
|
|
|
fmt.Printf("%s\t: %s\n", c.text, line)
|
|
|
|
if scannedLine != escapedForm {
|
|
t.Errorf("Expecting %s, got '%s'\n", escapedForm, scannedLine)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestColorEquals(t *testing.T) {
|
|
fgblack1 := New(FgBlack)
|
|
fgblack2 := New(FgBlack)
|
|
bgblack := New(BgBlack)
|
|
fgbgblack := New(FgBlack, BgBlack)
|
|
fgblackbgred := New(FgBlack, BgRed)
|
|
fgred := New(FgRed)
|
|
bgred := New(BgRed)
|
|
|
|
if !fgblack1.Equals(fgblack2) {
|
|
t.Error("Two black colors are not equal")
|
|
}
|
|
|
|
if fgblack1.Equals(bgblack) {
|
|
t.Error("Fg and bg black colors are equal")
|
|
}
|
|
|
|
if fgblack1.Equals(fgbgblack) {
|
|
t.Error("Fg black equals fg/bg black color")
|
|
}
|
|
|
|
if fgblack1.Equals(fgred) {
|
|
t.Error("Fg black equals Fg red")
|
|
}
|
|
|
|
if fgblack1.Equals(bgred) {
|
|
t.Error("Fg black equals Bg red")
|
|
}
|
|
|
|
if fgblack1.Equals(fgblackbgred) {
|
|
t.Error("Fg black equals fg black bg red")
|
|
}
|
|
}
|
|
|
|
func TestNoColor(t *testing.T) {
|
|
rb := new(bytes.Buffer)
|
|
Output = rb
|
|
|
|
testColors := []struct {
|
|
text string
|
|
code Attribute
|
|
}{
|
|
{text: "black", code: FgBlack},
|
|
{text: "red", code: FgRed},
|
|
{text: "green", code: FgGreen},
|
|
{text: "yellow", code: FgYellow},
|
|
{text: "blue", code: FgBlue},
|
|
{text: "magent", code: FgMagenta},
|
|
{text: "cyan", code: FgCyan},
|
|
{text: "white", code: FgWhite},
|
|
{text: "hblack", code: FgHiBlack},
|
|
{text: "hred", code: FgHiRed},
|
|
{text: "hgreen", code: FgHiGreen},
|
|
{text: "hyellow", code: FgHiYellow},
|
|
{text: "hblue", code: FgHiBlue},
|
|
{text: "hmagent", code: FgHiMagenta},
|
|
{text: "hcyan", code: FgHiCyan},
|
|
{text: "hwhite", code: FgHiWhite},
|
|
}
|
|
|
|
for _, c := range testColors {
|
|
p := New(c.code)
|
|
p.DisableColor()
|
|
p.Print(c.text)
|
|
|
|
line, _ := rb.ReadString('\n')
|
|
if line != c.text {
|
|
t.Errorf("Expecting %s, got '%s'\n", c.text, line)
|
|
}
|
|
}
|
|
|
|
// global check
|
|
NoColor = true
|
|
t.Cleanup(func() {
|
|
NoColor = false
|
|
})
|
|
|
|
for _, c := range testColors {
|
|
p := New(c.code)
|
|
p.Print(c.text)
|
|
|
|
line, _ := rb.ReadString('\n')
|
|
if line != c.text {
|
|
t.Errorf("Expecting %s, got '%s'\n", c.text, line)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestNoColor_Env(t *testing.T) {
|
|
rb := new(bytes.Buffer)
|
|
Output = rb
|
|
|
|
testColors := []struct {
|
|
text string
|
|
code Attribute
|
|
}{
|
|
{text: "black", code: FgBlack},
|
|
{text: "red", code: FgRed},
|
|
{text: "green", code: FgGreen},
|
|
{text: "yellow", code: FgYellow},
|
|
{text: "blue", code: FgBlue},
|
|
{text: "magent", code: FgMagenta},
|
|
{text: "cyan", code: FgCyan},
|
|
{text: "white", code: FgWhite},
|
|
{text: "hblack", code: FgHiBlack},
|
|
{text: "hred", code: FgHiRed},
|
|
{text: "hgreen", code: FgHiGreen},
|
|
{text: "hyellow", code: FgHiYellow},
|
|
{text: "hblue", code: FgHiBlue},
|
|
{text: "hmagent", code: FgHiMagenta},
|
|
{text: "hcyan", code: FgHiCyan},
|
|
{text: "hwhite", code: FgHiWhite},
|
|
}
|
|
|
|
os.Setenv("NO_COLOR", "1")
|
|
t.Cleanup(func() {
|
|
os.Unsetenv("NO_COLOR")
|
|
})
|
|
|
|
for _, c := range testColors {
|
|
p := New(c.code)
|
|
p.Print(c.text)
|
|
|
|
line, _ := rb.ReadString('\n')
|
|
if line != c.text {
|
|
t.Errorf("Expecting %s, got '%s'\n", c.text, line)
|
|
}
|
|
}
|
|
}
|
|
|
|
func Test_noColorIsSet(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
act func()
|
|
want bool
|
|
}{
|
|
{
|
|
name: "default",
|
|
act: func() {},
|
|
want: false,
|
|
},
|
|
{
|
|
name: "NO_COLOR=1",
|
|
act: func() { os.Setenv("NO_COLOR", "1") },
|
|
want: true,
|
|
},
|
|
{
|
|
name: "NO_COLOR=",
|
|
act: func() { os.Setenv("NO_COLOR", "") },
|
|
want: false,
|
|
},
|
|
}
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
t.Cleanup(func() {
|
|
os.Unsetenv("NO_COLOR")
|
|
})
|
|
tt.act()
|
|
if got := noColorIsSet(); got != tt.want {
|
|
t.Errorf("noColorIsSet() = %v, want %v", got, tt.want)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestColorVisual(t *testing.T) {
|
|
// First Visual Test
|
|
Output = colorable.NewColorableStdout()
|
|
|
|
New(FgRed).Printf("red\t")
|
|
New(BgRed).Print(" ")
|
|
New(FgRed, Bold).Println(" red")
|
|
|
|
New(FgGreen).Printf("green\t")
|
|
New(BgGreen).Print(" ")
|
|
New(FgGreen, Bold).Println(" green")
|
|
|
|
New(FgYellow).Printf("yellow\t")
|
|
New(BgYellow).Print(" ")
|
|
New(FgYellow, Bold).Println(" yellow")
|
|
|
|
New(FgBlue).Printf("blue\t")
|
|
New(BgBlue).Print(" ")
|
|
New(FgBlue, Bold).Println(" blue")
|
|
|
|
New(FgMagenta).Printf("magenta\t")
|
|
New(BgMagenta).Print(" ")
|
|
New(FgMagenta, Bold).Println(" magenta")
|
|
|
|
New(FgCyan).Printf("cyan\t")
|
|
New(BgCyan).Print(" ")
|
|
New(FgCyan, Bold).Println(" cyan")
|
|
|
|
New(FgWhite).Printf("white\t")
|
|
New(BgWhite).Print(" ")
|
|
New(FgWhite, Bold).Println(" white")
|
|
fmt.Println("")
|
|
|
|
// Second Visual test
|
|
Black("black")
|
|
Red("red")
|
|
Green("green")
|
|
Yellow("yellow")
|
|
Blue("blue")
|
|
Magenta("magenta")
|
|
Cyan("cyan")
|
|
White("white")
|
|
HiBlack("hblack")
|
|
HiRed("hred")
|
|
HiGreen("hgreen")
|
|
HiYellow("hyellow")
|
|
HiBlue("hblue")
|
|
HiMagenta("hmagenta")
|
|
HiCyan("hcyan")
|
|
HiWhite("hwhite")
|
|
|
|
// Third visual test
|
|
fmt.Println()
|
|
Set(FgBlue)
|
|
fmt.Println("is this blue?")
|
|
Unset()
|
|
|
|
Set(FgMagenta)
|
|
fmt.Println("and this magenta?")
|
|
Unset()
|
|
|
|
// Fourth Visual test
|
|
fmt.Println()
|
|
blue := New(FgBlue).PrintlnFunc()
|
|
blue("blue text with custom print func")
|
|
|
|
red := New(FgRed).PrintfFunc()
|
|
red("red text with a printf func: %d\n", 123)
|
|
|
|
put := New(FgYellow).SprintFunc()
|
|
warn := New(FgRed).SprintFunc()
|
|
|
|
fmt.Fprintf(Output, "this is a %s and this is %s.\n", put("warning"), warn("error"))
|
|
|
|
info := New(FgWhite, BgGreen).SprintFunc()
|
|
fmt.Fprintf(Output, "this %s rocks!\n", info("package"))
|
|
|
|
notice := New(FgBlue).FprintFunc()
|
|
notice(os.Stderr, "just a blue notice to stderr")
|
|
|
|
// Fifth Visual Test
|
|
fmt.Println()
|
|
|
|
fmt.Fprintln(Output, BlackString("black"))
|
|
fmt.Fprintln(Output, RedString("red"))
|
|
fmt.Fprintln(Output, GreenString("green"))
|
|
fmt.Fprintln(Output, YellowString("yellow"))
|
|
fmt.Fprintln(Output, BlueString("blue"))
|
|
fmt.Fprintln(Output, MagentaString("magenta"))
|
|
fmt.Fprintln(Output, CyanString("cyan"))
|
|
fmt.Fprintln(Output, WhiteString("white"))
|
|
fmt.Fprintln(Output, HiBlackString("hblack"))
|
|
fmt.Fprintln(Output, HiRedString("hred"))
|
|
fmt.Fprintln(Output, HiGreenString("hgreen"))
|
|
fmt.Fprintln(Output, HiYellowString("hyellow"))
|
|
fmt.Fprintln(Output, HiBlueString("hblue"))
|
|
fmt.Fprintln(Output, HiMagentaString("hmagenta"))
|
|
fmt.Fprintln(Output, HiCyanString("hcyan"))
|
|
fmt.Fprintln(Output, HiWhiteString("hwhite"))
|
|
}
|
|
|
|
func TestNoFormat(t *testing.T) {
|
|
fmt.Printf("%s %%s = ", BlackString("Black"))
|
|
Black("%s")
|
|
|
|
fmt.Printf("%s %%s = ", RedString("Red"))
|
|
Red("%s")
|
|
|
|
fmt.Printf("%s %%s = ", GreenString("Green"))
|
|
Green("%s")
|
|
|
|
fmt.Printf("%s %%s = ", YellowString("Yellow"))
|
|
Yellow("%s")
|
|
|
|
fmt.Printf("%s %%s = ", BlueString("Blue"))
|
|
Blue("%s")
|
|
|
|
fmt.Printf("%s %%s = ", MagentaString("Magenta"))
|
|
Magenta("%s")
|
|
|
|
fmt.Printf("%s %%s = ", CyanString("Cyan"))
|
|
Cyan("%s")
|
|
|
|
fmt.Printf("%s %%s = ", WhiteString("White"))
|
|
White("%s")
|
|
|
|
fmt.Printf("%s %%s = ", HiBlackString("HiBlack"))
|
|
HiBlack("%s")
|
|
|
|
fmt.Printf("%s %%s = ", HiRedString("HiRed"))
|
|
HiRed("%s")
|
|
|
|
fmt.Printf("%s %%s = ", HiGreenString("HiGreen"))
|
|
HiGreen("%s")
|
|
|
|
fmt.Printf("%s %%s = ", HiYellowString("HiYellow"))
|
|
HiYellow("%s")
|
|
|
|
fmt.Printf("%s %%s = ", HiBlueString("HiBlue"))
|
|
HiBlue("%s")
|
|
|
|
fmt.Printf("%s %%s = ", HiMagentaString("HiMagenta"))
|
|
HiMagenta("%s")
|
|
|
|
fmt.Printf("%s %%s = ", HiCyanString("HiCyan"))
|
|
HiCyan("%s")
|
|
|
|
fmt.Printf("%s %%s = ", HiWhiteString("HiWhite"))
|
|
HiWhite("%s")
|
|
}
|
|
|
|
func TestNoFormatString(t *testing.T) {
|
|
tests := []struct {
|
|
f func(string, ...interface{}) string
|
|
format string
|
|
args []interface{}
|
|
want string
|
|
}{
|
|
{BlackString, "%s", nil, "\x1b[30m%s\x1b[0m"},
|
|
{RedString, "%s", nil, "\x1b[31m%s\x1b[0m"},
|
|
{GreenString, "%s", nil, "\x1b[32m%s\x1b[0m"},
|
|
{YellowString, "%s", nil, "\x1b[33m%s\x1b[0m"},
|
|
{BlueString, "%s", nil, "\x1b[34m%s\x1b[0m"},
|
|
{MagentaString, "%s", nil, "\x1b[35m%s\x1b[0m"},
|
|
{CyanString, "%s", nil, "\x1b[36m%s\x1b[0m"},
|
|
{WhiteString, "%s", nil, "\x1b[37m%s\x1b[0m"},
|
|
{HiBlackString, "%s", nil, "\x1b[90m%s\x1b[0m"},
|
|
{HiRedString, "%s", nil, "\x1b[91m%s\x1b[0m"},
|
|
{HiGreenString, "%s", nil, "\x1b[92m%s\x1b[0m"},
|
|
{HiYellowString, "%s", nil, "\x1b[93m%s\x1b[0m"},
|
|
{HiBlueString, "%s", nil, "\x1b[94m%s\x1b[0m"},
|
|
{HiMagentaString, "%s", nil, "\x1b[95m%s\x1b[0m"},
|
|
{HiCyanString, "%s", nil, "\x1b[96m%s\x1b[0m"},
|
|
{HiWhiteString, "%s", nil, "\x1b[97m%s\x1b[0m"},
|
|
}
|
|
|
|
for i, test := range tests {
|
|
s := test.f(test.format, test.args...)
|
|
|
|
if s != test.want {
|
|
t.Errorf("[%d] want: %q, got: %q", i, test.want, s)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestColor_Println_Newline(t *testing.T) {
|
|
rb := new(bytes.Buffer)
|
|
Output = rb
|
|
|
|
c := New(FgRed)
|
|
c.Println("foo")
|
|
|
|
got := readRaw(t, rb)
|
|
want := "\x1b[31mfoo\x1b[0m\n"
|
|
|
|
if want != got {
|
|
t.Errorf("Println newline error\n\nwant: %q\n got: %q", want, got)
|
|
}
|
|
}
|
|
|
|
func TestColor_Sprintln_Newline(t *testing.T) {
|
|
c := New(FgRed)
|
|
|
|
got := c.Sprintln("foo")
|
|
want := "\x1b[31mfoo\x1b[0m\n"
|
|
|
|
if want != got {
|
|
t.Errorf("Println newline error\n\nwant: %q\n got: %q", want, got)
|
|
}
|
|
}
|
|
|
|
func TestColor_Fprintln_Newline(t *testing.T) {
|
|
rb := new(bytes.Buffer)
|
|
c := New(FgRed)
|
|
c.Fprintln(rb, "foo")
|
|
|
|
got := readRaw(t, rb)
|
|
want := "\x1b[31mfoo\x1b[0m\n"
|
|
|
|
if want != got {
|
|
t.Errorf("Println newline error\n\nwant: %q\n got: %q", want, got)
|
|
}
|
|
}
|
|
|
|
func readRaw(t *testing.T, r io.Reader) string {
|
|
t.Helper()
|
|
|
|
out, err := io.ReadAll(r)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
return string(out)
|
|
}
|