1 package term
2
3 import (
4 "bytes"
5 "testing"
6 )
7
8 func TestEscapeProxyRead(t *testing.T) {
9 t.Run("no escape keys, keys [a]", func(t *testing.T) {
10 escapeKeys, _ := ToBytes("")
11 keys, _ := ToBytes("a")
12 reader := NewEscapeProxy(bytes.NewReader(keys), escapeKeys)
13
14 buf := make([]byte, len(keys))
15 nr, err := reader.Read(buf)
16 if err != nil {
17 t.Error(err)
18 }
19 if expected := len(keys); nr != expected {
20 t.Errorf("expected: %d, got: %d", expected, nr)
21 }
22 if !bytes.Equal(buf, keys) {
23 t.Errorf("expected: %+v, got: %+v", keys, buf)
24 }
25 })
26
27 t.Run("no escape keys, keys [a,b,c]", func(t *testing.T) {
28 escapeKeys, _ := ToBytes("")
29 keys, _ := ToBytes("a,b,c")
30 reader := NewEscapeProxy(bytes.NewReader(keys), escapeKeys)
31
32 buf := make([]byte, len(keys))
33 nr, err := reader.Read(buf)
34 if err != nil {
35 t.Error(err)
36 }
37 if expected := len(keys); nr != expected {
38 t.Errorf("expected: %d, got: %d", expected, nr)
39 }
40 if !bytes.Equal(buf, keys) {
41 t.Errorf("expected: %+v, got: %+v", keys, buf)
42 }
43 })
44
45 t.Run("no escape keys, no keys", func(t *testing.T) {
46 escapeKeys, _ := ToBytes("")
47 keys, _ := ToBytes("")
48 reader := NewEscapeProxy(bytes.NewReader(keys), escapeKeys)
49
50 buf := make([]byte, len(keys))
51 nr, err := reader.Read(buf)
52 if err == nil {
53 t.Error("expected an error when there are no keys are to read")
54 }
55 if expected := 0; len(keys) != expected {
56 t.Errorf("expected: %d, got: %d", expected, len(keys))
57 }
58 if expected := len(keys); nr != expected {
59 t.Errorf("expected: %d, got: %d", expected, nr)
60 }
61 if expected := len(keys); len(buf) != expected {
62 t.Errorf("expected: %d, got: %d", expected, len(buf))
63 }
64 })
65
66 t.Run("DEL escape key, keys [a,b,c,+]", func(t *testing.T) {
67 escapeKeys, _ := ToBytes("DEL")
68 keys, _ := ToBytes("a,b,c,+")
69 reader := NewEscapeProxy(bytes.NewReader(keys), escapeKeys)
70
71 buf := make([]byte, len(keys))
72 nr, err := reader.Read(buf)
73 if err != nil {
74 t.Error(err)
75 }
76 if expected := len(keys); nr != expected {
77 t.Errorf("expected: %d, got: %d", expected, nr)
78 }
79 if !bytes.Equal(buf, keys) {
80 t.Errorf("expected: %+v, got: %+v", keys, buf)
81 }
82 })
83
84 t.Run("DEL escape key, no keys", func(t *testing.T) {
85 escapeKeys, _ := ToBytes("DEL")
86 keys, _ := ToBytes("")
87 reader := NewEscapeProxy(bytes.NewReader(keys), escapeKeys)
88
89 buf := make([]byte, len(keys))
90 nr, err := reader.Read(buf)
91 if err == nil {
92 t.Error("expected an error when there are no keys are to read")
93 }
94 if expected := 0; len(keys) != expected {
95 t.Errorf("expected: %d, got: %d", expected, len(keys))
96 }
97 if expected := len(keys); nr != expected {
98 t.Errorf("expected: %d, got: %d", expected, nr)
99 }
100 if expected := len(keys); len(buf) != expected {
101 t.Errorf("expected: %d, got: %d", expected, len(buf))
102 }
103 })
104
105 t.Run("ctrl-x,ctrl-@ escape key, keys [DEL]", func(t *testing.T) {
106 escapeKeys, _ := ToBytes("ctrl-x,ctrl-@")
107 keys, _ := ToBytes("DEL")
108 reader := NewEscapeProxy(bytes.NewReader(keys), escapeKeys)
109
110 buf := make([]byte, len(keys))
111 nr, err := reader.Read(buf)
112 if err != nil {
113 t.Error(err)
114 }
115 if expected := 1; nr != expected {
116 t.Errorf("expected: %d, got: %d", expected, nr)
117 }
118 if !bytes.Equal(buf, keys) {
119 t.Errorf("expected: %+v, got: %+v", keys, buf)
120 }
121 })
122
123 t.Run("ctrl-c escape key, keys [ctrl-c]", func(t *testing.T) {
124 escapeKeys, _ := ToBytes("ctrl-c")
125 keys, _ := ToBytes("ctrl-c")
126 reader := NewEscapeProxy(bytes.NewReader(keys), escapeKeys)
127
128 buf := make([]byte, len(keys))
129 nr, err := reader.Read(buf)
130 if expected := "read escape sequence"; err == nil || err.Error() != expected {
131 t.Errorf("expected: %v, got: %v", expected, err)
132 }
133 if expected := 0; nr != expected {
134 t.Errorf("expected: %d, got: %d", expected, nr)
135 }
136 if !bytes.Equal(buf, keys) {
137 t.Errorf("expected: %+v, got: %+v", keys, buf)
138 }
139 })
140
141 t.Run("ctrl-c,ctrl-z escape key, keys [ctrl-c],[ctrl-z]", func(t *testing.T) {
142 escapeKeys, _ := ToBytes("ctrl-c,ctrl-z")
143 keys, _ := ToBytes("ctrl-c,ctrl-z")
144 reader := NewEscapeProxy(bytes.NewReader(keys), escapeKeys)
145
146 buf := make([]byte, 1)
147 nr, err := reader.Read(buf)
148 if err != nil {
149 t.Error(err)
150 }
151 if expected := 0; nr != expected {
152 t.Errorf("expected: %d, got: %d", expected, nr)
153 }
154 if !bytes.Equal(buf, keys[0:1]) {
155 t.Errorf("expected: %+v, got: %+v", keys, buf)
156 }
157
158 nr, err = reader.Read(buf)
159 if expected := "read escape sequence"; err == nil || err.Error() != expected {
160 t.Errorf("expected: %v, got: %v", expected, err)
161 }
162 if expected := 0; nr != expected {
163 t.Errorf("expected: %d, got: %d", expected, nr)
164 }
165 if !bytes.Equal(buf, keys[1:]) {
166 t.Errorf("expected: %+v, got: %+v", keys, buf)
167 }
168 })
169
170 t.Run("ctrl-c,ctrl-z escape key, keys [ctrl-c,ctrl-z]", func(t *testing.T) {
171 escapeKeys, _ := ToBytes("ctrl-c,ctrl-z")
172 keys, _ := ToBytes("ctrl-c,ctrl-z")
173 reader := NewEscapeProxy(bytes.NewReader(keys), escapeKeys)
174
175 buf := make([]byte, 2)
176 nr, err := reader.Read(buf)
177 if expected := "read escape sequence"; err == nil || err.Error() != expected {
178 t.Errorf("expected: %v, got: %v", expected, err)
179 }
180 if expected := 0; nr != expected {
181 t.Errorf("expected: %d, got: %d", expected, nr)
182 }
183 if !bytes.Equal(buf, keys) {
184 t.Errorf("expected: %+v, got: %+v", keys, buf)
185 }
186 })
187
188 t.Run("ctrl-c,ctrl-z escape key, keys [ctrl-c],[DEL,+]", func(t *testing.T) {
189 escapeKeys, _ := ToBytes("ctrl-c,ctrl-z")
190 keys, _ := ToBytes("ctrl-c,DEL,+")
191 reader := NewEscapeProxy(bytes.NewReader(keys), escapeKeys)
192
193 buf := make([]byte, 1)
194 nr, err := reader.Read(buf)
195 if err != nil {
196 t.Error(err)
197 }
198 if expected := 0; nr != expected {
199 t.Errorf("expected: %d, got: %d", expected, nr)
200 }
201 if !bytes.Equal(buf, keys[0:1]) {
202 t.Errorf("expected: %+v, got: %+v", keys, buf)
203 }
204
205 buf = make([]byte, len(keys))
206 nr, err = reader.Read(buf)
207 if err != nil {
208 t.Error(err)
209 }
210 if expected := len(keys); nr != expected {
211 t.Errorf("expected: %d, got: %d", expected, nr)
212 }
213 if !bytes.Equal(buf, keys) {
214 t.Errorf("expected: %+v, got: %+v", keys, buf)
215 }
216 })
217
218 t.Run("ctrl-c,ctrl-z escape key, keys [ctrl-c],[DEL]", func(t *testing.T) {
219 escapeKeys, _ := ToBytes("ctrl-c,ctrl-z")
220 keys, _ := ToBytes("ctrl-c,DEL")
221 reader := NewEscapeProxy(bytes.NewReader(keys), escapeKeys)
222
223 buf := make([]byte, 1)
224 nr, err := reader.Read(buf)
225 if err != nil {
226 t.Error(err)
227 }
228 if expected := 0; nr != expected {
229 t.Errorf("expected: %d, got: %d", expected, nr)
230 }
231 if !bytes.Equal(buf, keys[0:1]) {
232 t.Errorf("expected: %+v, got: %+v", keys, buf)
233 }
234
235 buf = make([]byte, len(keys))
236 nr, err = reader.Read(buf)
237 if err != nil {
238 t.Error(err)
239 }
240 if expected := len(keys); nr != expected {
241 t.Errorf("expected: %d, got: %d", expected, nr)
242 }
243 if !bytes.Equal(buf, keys) {
244 t.Errorf("expected: %+v, got: %+v", keys, buf)
245 }
246 })
247
248 t.Run("a,b,c,d escape key, keys [a,b],[c,d]", func(t *testing.T) {
249 escapeKeys, _ := ToBytes("a,b,c,d")
250 keys, _ := ToBytes("a,b,c,d")
251 reader := NewEscapeProxy(bytes.NewReader(keys), escapeKeys)
252
253 buf := make([]byte, 2)
254 nr, err := reader.Read(buf)
255 if err != nil {
256 t.Error(err)
257 }
258 if expected := 0; nr != expected {
259 t.Errorf("expected: %d, got: %d", expected, nr)
260 }
261 if !bytes.Equal(buf, keys[0:2]) {
262 t.Errorf("expected: %+v, got: %+v", keys, buf)
263 }
264
265 buf = make([]byte, 2)
266 nr, err = reader.Read(buf)
267 if expected := "read escape sequence"; err == nil || err.Error() != expected {
268 t.Errorf("expected: %v, got: %v", expected, err)
269 }
270 if expected := 0; nr != expected {
271 t.Errorf("expected: %d, got: %d", expected, nr)
272 }
273 if !bytes.Equal(buf, keys[2:4]) {
274 t.Errorf("expected: %+v, got: %+v", keys, buf)
275 }
276 })
277
278 t.Run("ctrl-p,ctrl-q escape key, keys [ctrl-p],[a],[ctrl-p,ctrl-q]", func(t *testing.T) {
279 escapeKeys, _ := ToBytes("ctrl-p,ctrl-q")
280 keys, _ := ToBytes("ctrl-p,a,ctrl-p,ctrl-q")
281 reader := NewEscapeProxy(bytes.NewReader(keys), escapeKeys)
282
283 buf := make([]byte, 1)
284 nr, err := reader.Read(buf)
285 if err != nil {
286 t.Error(err)
287 }
288 if expected := 0; nr != expected {
289 t.Errorf("expected: %d, got: %d", expected, nr)
290 }
291
292 buf = make([]byte, 1)
293 nr, err = reader.Read(buf)
294 if err != nil {
295 t.Error(err)
296 }
297 if expected := 1; nr != expected {
298 t.Errorf("expected: %d, got: %d", expected, nr)
299 }
300 if !bytes.Equal(buf, keys[:1]) {
301 t.Errorf("expected: %+v, got: %+v", keys, buf)
302 }
303
304 buf = make([]byte, 2)
305 nr, err = reader.Read(buf)
306 if err != nil {
307 t.Error(err)
308 }
309 if expected := 1; nr != expected {
310 t.Errorf("expected: %d, got: %d", expected, nr)
311 }
312 if !bytes.Equal(buf, keys[1:3]) {
313 t.Errorf("expected: %+v, got: %+v", keys, buf)
314 }
315
316 buf = make([]byte, 2)
317 nr, err = reader.Read(buf)
318 if expected := "read escape sequence"; err == nil || err.Error() != expected {
319 t.Errorf("expected: %v, got: %v", expected, err)
320 }
321 if expected := 0; nr != expected {
322 t.Errorf("expected: %d, got: %d", expected, nr)
323 }
324 })
325 }
326
View as plain text