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
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
|
package sixel
import (
"bytes"
"testing"
)
func TestWriteRepeat(t *testing.T) {
tests := []struct {
name string
count int
char byte
expected string
wantErr bool
}{
{
name: "basic repeat",
count: 3,
char: 'A',
expected: "!3A",
},
{
name: "single digit",
count: 5,
char: '#',
expected: "!5#",
},
{
name: "multiple digits",
count: 123,
char: 'x',
expected: "!123x",
},
{
name: "zero count",
count: 0,
char: 'B',
expected: "!0B",
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
buf := &bytes.Buffer{}
n, err := WriteRepeat(buf, tt.count, tt.char)
if (err != nil) != tt.wantErr {
t.Errorf("WriteRepeat() error = %v, wantErr %v", err, tt.wantErr)
return
}
if got := buf.String(); got != tt.expected {
t.Errorf("WriteRepeat() = %v, want %v", got, tt.expected)
}
if n != len(tt.expected) {
t.Errorf("WriteRepeat() returned length = %v, want %v", n, len(tt.expected))
}
})
}
}
func TestDecodeRepeat(t *testing.T) {
tests := []struct {
name string
input []byte
wantRepeat Repeat
wantN int
description string
}{
{
name: "basic repeat",
input: []byte("!3A"),
wantRepeat: Repeat{Count: 3, Char: 'A'},
wantN: 3,
description: "simple single digit repeat",
},
{
name: "multiple digits",
input: []byte("!123x"),
wantRepeat: Repeat{Count: 123, Char: 'x'},
wantN: 5,
description: "repeat with multiple digits",
},
{
name: "empty input",
input: []byte{},
wantRepeat: Repeat{},
wantN: 0,
description: "empty input should return zero values",
},
{
name: "invalid introducer",
input: []byte("X3A"),
wantRepeat: Repeat{},
wantN: 0,
description: "input without proper introducer",
},
{
name: "incomplete sequence",
input: []byte("!3"),
wantRepeat: Repeat{},
wantN: 0,
description: "incomplete sequence without character",
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
gotRepeat, gotN := DecodeRepeat(tt.input)
if gotRepeat != tt.wantRepeat {
t.Errorf("DecodeRepeat() gotRepeat = %v, want %v", gotRepeat, tt.wantRepeat)
}
if gotN != tt.wantN {
t.Errorf("DecodeRepeat() gotN = %v, want %v", gotN, tt.wantN)
}
})
}
}
func TestRepeat_String(t *testing.T) {
tests := []struct {
name string
repeat Repeat
expected string
}{
{
name: "basic repeat",
repeat: Repeat{Count: 3, Char: 'A'},
expected: "!3A",
},
{
name: "multiple digits",
repeat: Repeat{Count: 123, Char: 'x'},
expected: "!123x",
},
{
name: "zero count",
repeat: Repeat{Count: 0, Char: 'B'},
expected: "!0B",
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
if got := tt.repeat.String(); got != tt.expected {
t.Errorf("Repeat.String() = %v, want %v", got, tt.expected)
}
})
}
}
|
