File: writer_test.go

package info (click to toggle)
golang-github-muesli-ansi 0.0~git20211031.c9f0611-2
  • links: PTS, VCS
  • area: main
  • in suites: bookworm, forky, sid, trixie
  • size: 120 kB
  • sloc: makefile: 2
file content (116 lines) | stat: -rw-r--r-- 2,173 bytes parent folder | download | duplicates (2)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
package ansi

import (
	"bytes"
	"errors"
	"io/ioutil"
	"testing"
)

func TestWriter_Write(t *testing.T) {
	t.Parallel()

	buf := []byte("\x1B[38;2;249;38;114m你好reflow\x1B[0m")
	forward := &bytes.Buffer{}
	w := &Writer{Forward: forward}

	n, err := w.Write(buf)

	w.ResetAnsi()

	w.RestoreAnsi()

	if err != nil {
		t.Fatalf("err should be nil, but got %v", err)
	}

	if l := len(buf); n != l {
		t.Fatalf("n should be %d, got %d", l, n)
	}

	if ls := w.LastSequence(); ls != "" {
		t.Fatalf("LastSequence should be empty, got %s", ls)
	}

	if b := forward.Bytes(); !bytes.Equal(b, buf) {
		t.Fatalf("forward should be wrote by %v, but got %v", buf, b)
	}
}

var fakeErr = errors.New("fake error")

type fakeWriter struct{}

func (fakeWriter) Write(_ []byte) (int, error) {
	return 0, fakeErr
}

func TestWriter_Write_Error(t *testing.T) {
	t.Parallel()

	w := &Writer{Forward: fakeWriter{}}

	_, err := w.Write([]byte("foo"))

	if err != fakeErr {
		t.Fatalf("err should be fakeErr, but got %v", err)
	}
}

// go test -bench=BenchmarkWriter_Write -benchmem -count=4
func BenchmarkWriter_Write(b *testing.B) {
	buf := []byte("\x1B[38;2;249;38;114m你好reflow\x1B[0m")
	w := &Writer{Forward: ioutil.Discard}

	b.ReportAllocs()
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		_, _ = w.Write(buf)
	}
}

func TestWriter_LastSequence(t *testing.T) {
	t.Parallel()

	w := &Writer{}
	if s := w.LastSequence(); s != "" {
		t.Fatalf("LastSequence should be empty, but got %s", s)
	}
}

func TestWriter_ResetAnsi(t *testing.T) {
	t.Parallel()

	b := &bytes.Buffer{}
	w := &Writer{Forward: b}

	w.ResetAnsi()

	if s := b.String(); s != "" {
		t.Fatalf("b should be empty, but got %s", s)
	}

	w.seqchanged = true

	w.ResetAnsi()

	if s := b.String(); s != "\x1b[0m" {
		t.Fatalf("b.String() should be \"\\x1b[0m\", got %s", s)
	}
}

func TestWriter_RestoreAnsi(t *testing.T) {
	t.Parallel()

	b := &bytes.Buffer{}

	lastseq := bytes.Buffer{}
	lastseq.WriteString("\x1B[38;2;249;38;114m")
	w := &Writer{Forward: b, lastseq: lastseq}

	w.RestoreAnsi()

	if s := b.String(); s != "\x1B[38;2;249;38;114m" {
		t.Fatalf("b.String() should be \"\\x1B[38;2;249;38;114m\", got %s", s)
	}
}