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
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
|
package text
import (
"strings"
"testing"
)
func TestWrap(t *testing.T) {
cases := []struct {
Input, Output string
Lim int
}{
// A simple word passes through.
{
"foo",
"foo",
4,
},
// Word breaking
{
"foobarbaz",
"foob\narba\nz",
4,
},
// Lines are broken at whitespace.
{
"foo bar baz",
"foo\nbar\nbaz",
4,
},
// Word breaking
{
"foo bars bazzes",
"foo\nbars\nbazz\nes",
4,
},
// A word that would run beyond the width is wrapped.
{
"fo sop",
"fo\nsop",
4,
},
// A tab counts as 4 characters.
{
"foo\nb\t r\n baz",
"foo\nb\n r\n baz",
4,
},
// Trailing whitespace is removed after used for wrapping.
// Runs of whitespace on which a line is broken are removed.
{
"foo \nb ar ",
"foo\n\nb\nar\n",
4,
},
// An explicit line break at the end of the input is preserved.
{
"foo bar baz\n",
"foo\nbar\nbaz\n",
4,
},
// Explicit break are always preserved.
{
"\nfoo bar\n\n\nbaz\n",
"\nfoo\nbar\n\n\nbaz\n",
4,
},
// Ignore complete words with terminal color sequence
{
"foo \x1b[31mbar\x1b[0m baz",
"foo\n\x1b[31mbar\x1b[0m\nbaz",
4,
},
// Handle words with colors sequence inside the word
{
"foo b\x1b[31mbar\x1b[0mr baz",
"foo\nb\x1b[31mbar\n\x1b[0mr\nbaz",
4,
},
// Break words with colors sequence inside the word
{
"foo bb\x1b[31mbar\x1b[0mr baz",
"foo\nbb\x1b[31mba\nr\x1b[0mr\nbaz",
4,
},
// Complete example:
{
" This is a list: \n\n\t* foo\n\t* bar\n\n\n\t* baz \nBAM ",
" This\nis a\nlist:\n\n\n *\nfoo\n *\nbar\n\n\n *\nbaz\nBAM\n",
6,
},
// Handle chinese
{
"婞一枳郲逴靲屮蜧曀殳，掫乇峔掮傎溒兀緉冘仜。",
"婞一枳郲逴靲屮蜧曀殳，掫\n乇峔掮傎溒兀緉冘仜。",
12,
},
// Handle chinese with colors
{
"婞一枳郲逴\x1b[31m靲屮蜧曀殳，掫乇峔掮傎溒\x1b[0m兀緉冘仜。",
"婞一枳郲逴\x1b[31m靲屮蜧曀殳，掫\n乇峔掮傎溒\x1b[0m兀緉冘仜。",
12,
},
}
for i, tc := range cases {
actual, lines := Wrap(tc.Input, tc.Lim)
if actual != tc.Output {
t.Fatalf("Case %d Input:\n\n`%s`\n\nExpected Output:\n\n`%s`\n\nActual Output:\n`\n%s`",
i, tc.Input, tc.Output, actual)
}
expected := len(strings.Split(tc.Output, "\n"))
if expected != lines {
t.Fatalf("Case %d Nb lines mismatch\nExpected:%d\nActual:%d",
i, expected, lines)
}
}
}
func TestWrapLeftPadded(t *testing.T) {
cases := []struct {
input, output string
lim, pad int
}{
{
"The Lorem ipsum text is typically composed of pseudo-Latin words. It is commonly used as placeholder text to examine or demonstrate the visual effects of various graphic design.",
` The Lorem ipsum text is typically composed of
pseudo-Latin words. It is commonly used as placeholder
text to examine or demonstrate the visual effects of
various graphic design.`,
59, 4,
},
// Handle Chinese
{
"婞一枳郲逴靲屮蜧曀殳，掫乇峔掮傎溒兀緉冘仜。郼牪艽螗媷錵朸一詅掜豗怙刉笀丌，楀棶乇矹迡搦囷圣亍昄漚粁仈祂。覂一洳袶揙楱亍滻瘯毌，掗屮柅軡菵腩乜榵毌夯。勼哻怌婇怤灟葠雺奷朾恦扰衪岨坋誁乇芚誙腞。冇笉妺悆浂鱦賌廌灱灱觓坋佫呬耴跣兀枔蓔輈。嵅咍犴膰痭瘰机一靬涽捊矷尒玶乇，煚塈丌岰陊鉖怞戉兀甿跾觓夬侄。棩岧汌橩僁螗玎一逭舴圂衪扐衲兀，嵲媕亍衩衿溽昃夯丌侄蒰扂丱呤。毰侘妅錣廇螉仴一暀淖蚗佶庂咺丌，輀鈁乇彽洢溦洰氶乇构碨洐巿阹。",
` 婞一枳郲逴靲屮蜧曀殳，掫乇峔掮傎溒兀緉冘仜。郼牪艽螗媷錵朸一詅掜豗怙刉笀丌，楀棶乇矹迡搦囷圣亍昄漚粁仈祂。覂一
洳袶揙楱亍滻瘯毌，掗屮柅軡菵腩乜榵毌夯。勼哻怌婇怤灟葠雺奷朾恦扰衪岨坋誁乇芚誙腞。冇笉妺悆浂鱦賌廌灱灱觓坋佫呬
耴跣兀枔蓔輈。嵅咍犴膰痭瘰机一靬涽捊矷尒玶乇，煚塈丌岰陊鉖怞戉兀甿跾觓夬侄。棩岧汌橩僁螗玎一逭舴圂衪扐衲兀，嵲
媕亍衩衿溽昃夯丌侄蒰扂丱呤。毰侘妅錣廇螉仴一暀淖蚗佶庂咺丌，輀鈁乇彽洢溦洰氶乇构碨洐巿阹。`,
59, 4,
},
}
for i, tc := range cases {
actual, lines := WrapLeftPadded(tc.input, tc.lim, tc.pad)
if actual != tc.output {
t.Fatalf("Case %d Input:\n\n`%s`\n\nExpected Output:\n`\n%s`\n\nActual Output:\n`\n%s\n%s`",
i, tc.input, tc.output,
"|"+strings.Repeat("-", tc.lim-2)+"|",
actual)
}
expected := len(strings.Split(tc.output, "\n"))
if expected != lines {
t.Fatalf("Case %d Nb lines mismatch\nExpected:%d\nActual:%d",
i, expected, lines)
}
}
}
func TestWordLen(t *testing.T) {
cases := []struct {
Input string
Length int
}{
// A simple word
{
"foo",
3,
},
// A simple word with colors
{
"\x1b[31mbar\x1b[0m",
3,
},
// Handle prefix and suffix properly
{
"foo\x1b[31mfoobarHoy\x1b[0mbaaar",
17,
},
// Handle chinese
{
"快檢什麼望對",
6,
},
// Handle chinese with colors
{
"快\x1b[31m檢什麼\x1b[0m望對",
6,
},
}
for i, tc := range cases {
l := wordLen(tc.Input)
if l != tc.Length {
t.Fatalf("Case %d Input:\n\n`%s`\n\nExpected Output:\n\n`%d`\n\nActual Output:\n\n`%d`",
i, tc.Input, tc.Length, l)
}
}
}
|
