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
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
|
#![allow(clippy::cognitive_complexity)]
#[test]
fn ascii() {
let mut parser = vt100::Parser::default();
parser.process(b"foo");
assert_eq!(parser.screen().cell(0, 0).unwrap().contents(), "f");
assert_eq!(parser.screen().cell(0, 1).unwrap().contents(), "o");
assert_eq!(parser.screen().cell(0, 2).unwrap().contents(), "o");
assert_eq!(parser.screen().cell(0, 3).unwrap().contents(), "");
assert_eq!(parser.screen().cell(1, 0).unwrap().contents(), "");
assert_eq!(parser.screen().contents(), "foo");
}
#[test]
fn utf8() {
let mut parser = vt100::Parser::default();
parser.process("café".as_bytes());
assert_eq!(parser.screen().cell(0, 0).unwrap().contents(), "c");
assert_eq!(parser.screen().cell(0, 1).unwrap().contents(), "a");
assert_eq!(parser.screen().cell(0, 2).unwrap().contents(), "f");
assert_eq!(parser.screen().cell(0, 3).unwrap().contents(), "é");
assert_eq!(parser.screen().cell(0, 4).unwrap().contents(), "");
assert_eq!(parser.screen().cell(1, 0).unwrap().contents(), "");
assert_eq!(parser.screen().contents(), "café");
}
#[test]
fn newlines() {
let mut parser = vt100::Parser::default();
parser.process(b"f\r\noo\r\nood");
assert_eq!(parser.screen().cell(0, 0).unwrap().contents(), "f");
assert_eq!(parser.screen().cell(0, 1).unwrap().contents(), "");
assert_eq!(parser.screen().cell(0, 2).unwrap().contents(), "");
assert_eq!(parser.screen().cell(1, 0).unwrap().contents(), "o");
assert_eq!(parser.screen().cell(1, 1).unwrap().contents(), "o");
assert_eq!(parser.screen().cell(1, 2).unwrap().contents(), "");
assert_eq!(parser.screen().cell(2, 0).unwrap().contents(), "o");
assert_eq!(parser.screen().cell(2, 1).unwrap().contents(), "o");
assert_eq!(parser.screen().cell(2, 2).unwrap().contents(), "d");
assert_eq!(parser.screen().cell(0, 3).unwrap().contents(), "");
assert_eq!(parser.screen().cell(3, 0).unwrap().contents(), "");
assert_eq!(parser.screen().contents(), "f\noo\nood");
}
#[test]
fn wide() {
let mut parser = vt100::Parser::default();
let screen = parser.screen().clone();
parser.process("aデbネ".as_bytes());
assert_eq!(parser.screen().cell(0, 0).unwrap().contents(), "a");
assert_eq!(parser.screen().cell(0, 1).unwrap().contents(), "デ");
assert_eq!(parser.screen().cell(0, 2).unwrap().contents(), "");
assert_eq!(parser.screen().cell(0, 3).unwrap().contents(), "b");
assert_eq!(parser.screen().cell(0, 4).unwrap().contents(), "ネ");
assert_eq!(parser.screen().cell(0, 5).unwrap().contents(), "");
assert_eq!(parser.screen().cell(0, 6).unwrap().contents(), "");
assert_eq!(parser.screen().cell(1, 0).unwrap().contents(), "");
assert_eq!(parser.screen().contents(), "aデbネ");
assert_eq!(parser.screen().cursor_position(), (0, 6));
assert_eq!(
parser.screen().contents_formatted(),
"\x1b[?25h\x1b[m\x1b[H\x1b[Jaデbネ".as_bytes()
);
assert_eq!(parser.screen().contents_diff(&screen), "aデbネ".as_bytes());
let screen = parser.screen().clone();
parser.process(b"\x1b[1;1H\x1b[3Cc");
assert_eq!(parser.screen().contents(), "aデcネ");
assert_eq!(parser.screen().cursor_position(), (0, 4));
assert_eq!(
parser.screen().contents_formatted(),
"\x1b[?25h\x1b[m\x1b[H\x1b[Jaデcネ\x1b[1;5H".as_bytes()
);
assert_eq!(
parser.screen().contents_diff(&screen),
"\x1b[1;4Hc".as_bytes()
);
let screen = parser.screen().clone();
parser.process("\x1b[1;7Hfoobar".as_bytes());
assert_eq!(parser.screen().contents(), "aデcネfoobar");
assert_eq!(parser.screen().cursor_position(), (0, 12));
assert_eq!(
parser.screen().contents_formatted(),
"\x1b[?25h\x1b[m\x1b[H\x1b[Jaデcネfoobar".as_bytes()
);
assert_eq!(
parser.screen().contents_diff(&screen),
"\x1b[2Cfoobar".as_bytes()
);
let screen = parser.screen().clone();
parser.process("\x1b[1;1Hデcネfoobar\x1b[K".as_bytes());
assert_eq!(parser.screen().contents(), "デcネfoobar");
assert_eq!(parser.screen().cursor_position(), (0, 11));
assert_eq!(
parser.screen().contents_formatted(),
"\x1b[?25h\x1b[m\x1b[H\x1b[Jデcネfoobar".as_bytes()
);
assert_eq!(
parser.screen().contents_diff(&screen),
"\x1b[Hデcネfo\x1b[Cbar\x1b[K".as_bytes()
);
let screen = parser.screen().clone();
parser.process("\x1b[1;1Haデcネfoobar\x1b[K".as_bytes());
assert_eq!(parser.screen().contents(), "aデcネfoobar");
assert_eq!(parser.screen().cursor_position(), (0, 12));
assert_eq!(
parser.screen().contents_formatted(),
"\x1b[?25h\x1b[m\x1b[H\x1b[Jaデcネfoobar".as_bytes()
);
assert_eq!(
parser.screen().contents_diff(&screen),
"\x1b[Haデcネf\x1b[Cobar".as_bytes()
);
let screen = parser.screen().clone();
parser.process("\x1b[1;1Hデcネfoobar\x1b[K".as_bytes());
assert_eq!(parser.screen().contents(), "デcネfoobar");
assert_eq!(parser.screen().cursor_position(), (0, 11));
assert_eq!(
parser.screen().contents_formatted(),
"\x1b[?25h\x1b[m\x1b[H\x1b[Jデcネfoobar".as_bytes()
);
assert_eq!(
parser.screen().contents_diff(&screen),
"\x1b[Hデcネfo\x1b[Cbar\x1b[K".as_bytes()
);
}
#[cfg(feature = "unicode-normalization")]
#[test]
fn combining() {
let mut parser = vt100::Parser::default();
parser.process(b"a");
assert_eq!(parser.screen().cell(0, 0).unwrap().contents(), "a");
parser.process("\u{0301}".as_bytes());
assert_eq!(parser.screen().cell(0, 0).unwrap().contents(), "á");
parser.process(b"\x1bcabcdefg");
assert_eq!(parser.screen().contents(), "abcdefg");
parser.process("\x1b[1;6H\u{0301}".as_bytes());
assert_eq!(parser.screen().contents(), "abcdéfg");
parser.process(b"\x1b[10;78Haaa");
assert_eq!(parser.screen().cell(9, 79).unwrap().contents(), "a");
parser.process("\r\n\u{0301}".as_bytes());
assert_eq!(parser.screen().cell(9, 79).unwrap().contents(), "a");
assert_eq!(parser.screen().cell(10, 0).unwrap().contents(), "");
parser.process("\x1bcabcdefg\x1b[1;3H\u{0301}".as_bytes());
assert_eq!(parser.screen().contents(), "ab́cdefg");
parser.process("\x1b[1;2Hb\x1b[1;8H".as_bytes());
assert_eq!(parser.screen().contents(), "abcdefg");
let screen = parser.screen().clone();
parser.process(b"\x1bcabcdefg");
assert_eq!(parser.screen().contents_diff(&screen), b"");
parser.process(b"\x1bcaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa");
assert_eq!(parser.screen().cursor_position(), (0, 80));
assert_eq!(parser.screen().contents(), "a".repeat(80));
parser.process("\u{0301}".as_bytes());
assert_eq!(parser.screen().cursor_position(), (1, 0));
assert_eq!(parser.screen().contents(), format!("{}á", "a".repeat(79)));
parser.process("\x1b[H\x1b[Jａ\u{0301}".as_bytes());
assert_eq!(parser.screen().cell(0, 0).unwrap().contents(), "ａ\u{0301}");
assert_eq!(parser.screen().cell(0, 1).unwrap().contents(), "");
parser.process("\x1b[H\x1b[J\x1b[2C\u{0301}".as_bytes());
assert_eq!(parser.screen().cell(0, 0).unwrap().contents(), "");
assert_eq!(parser.screen().cell(0, 1).unwrap().contents(), " \u{0301}");
assert_eq!(parser.screen().cell(0, 2).unwrap().contents(), "");
assert_eq!(parser.screen().cell(0, 3).unwrap().contents(), "");
}
#[test]
fn wrap() {
let mut parser = vt100::Parser::default();
parser.process(b"0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789");
assert_eq!(parser.screen().contents(), "0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789");
parser.process(b"\x1b[5H01234567890123456789012345678901234567890123456789012345678901234567890123456789");
parser.process(b"\x1b[6H01234567890123456789012345678901234567890123456789012345678901234567890123456789");
assert_eq!(parser.screen().contents(), "0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789\n\n\n01234567890123456789012345678901234567890123456789012345678901234567890123456789\n01234567890123456789012345678901234567890123456789012345678901234567890123456789");
parser.process(b"\x1b[H\x1b[J");
parser.process(b"0123456789012345678901234567890123456789012345678901234567890123456789012345678");
assert_eq!(parser.screen().contents(), "0123456789012345678901234567890123456789012345678901234567890123456789012345678");
assert_eq!(parser.screen().cursor_position(), (0, 79));
parser.process(b"9");
assert_eq!(parser.screen().contents(), "01234567890123456789012345678901234567890123456789012345678901234567890123456789");
assert_eq!(parser.screen().cursor_position(), (0, 80));
parser.process(b"a");
assert_eq!(parser.screen().contents(), "01234567890123456789012345678901234567890123456789012345678901234567890123456789a");
assert_eq!(parser.screen().cursor_position(), (1, 1));
parser.process(b"b");
assert_eq!(parser.screen().contents(), "01234567890123456789012345678901234567890123456789012345678901234567890123456789ab");
assert_eq!(parser.screen().cursor_position(), (1, 2));
parser.process(b"\x1b[H\x1b[J");
parser.process(b"012345678901234567890123456789012345678901234567890123456789012345678901234567");
assert_eq!(parser.screen().contents(), "012345678901234567890123456789012345678901234567890123456789012345678901234567");
assert_eq!(parser.screen().cursor_position(), (0, 78));
parser.process("ネ".as_bytes());
assert_eq!(parser.screen().contents(), "012345678901234567890123456789012345678901234567890123456789012345678901234567ネ");
assert_eq!(parser.screen().cursor_position(), (0, 80));
parser.process(b"a");
assert_eq!(parser.screen().contents(), "012345678901234567890123456789012345678901234567890123456789012345678901234567ネa");
assert_eq!(parser.screen().cursor_position(), (1, 1));
assert_eq!(parser.screen().cell(0, 77).unwrap().contents(), "7");
assert_eq!(parser.screen().cell(0, 78).unwrap().contents(), "ネ");
assert_eq!(parser.screen().cell(0, 79).unwrap().contents(), "");
assert_eq!(parser.screen().cell(1, 0).unwrap().contents(), "a");
assert_eq!(parser.screen().cell(1, 1).unwrap().contents(), "");
parser.process(b"\x1b[H\x1b[J");
parser.process(b"0123456789012345678901234567890123456789012345678901234567890123456789012345678");
assert_eq!(parser.screen().contents(), "0123456789012345678901234567890123456789012345678901234567890123456789012345678");
assert_eq!(parser.screen().cursor_position(), (0, 79));
parser.process("ネ".as_bytes());
assert_eq!(parser.screen().contents(), "0123456789012345678901234567890123456789012345678901234567890123456789012345678\nネ");
assert_eq!(parser.screen().cursor_position(), (1, 2));
parser.process(b"a");
assert_eq!(parser.screen().contents(), "0123456789012345678901234567890123456789012345678901234567890123456789012345678\nネa");
assert_eq!(parser.screen().cursor_position(), (1, 3));
assert_eq!(parser.screen().cell(0, 77).unwrap().contents(), "7");
assert_eq!(parser.screen().cell(0, 78).unwrap().contents(), "8");
assert_eq!(parser.screen().cell(0, 79).unwrap().contents(), "");
assert_eq!(parser.screen().cell(1, 0).unwrap().contents(), "ネ");
assert_eq!(parser.screen().cell(1, 1).unwrap().contents(), "");
assert_eq!(parser.screen().cell(1, 2).unwrap().contents(), "a");
assert_eq!(parser.screen().cell(1, 3).unwrap().contents(), "");
let mut new_parser = vt100::Parser::default();
new_parser.process(&parser.screen().contents_formatted());
assert_eq!(new_parser.screen().contents(), parser.screen().contents());
parser.process(b"\x1b[H\x1b[J");
assert_eq!(parser.screen().contents(), "");
parser.process(b" ");
assert_eq!(parser.screen().contents(), " ");
parser.process(b"\n");
assert_eq!(parser.screen().contents(), " ");
parser.process(b"\n");
assert_eq!(parser.screen().contents(), " ");
parser.process(b" ");
assert_eq!(parser.screen().contents(), " \n\n\n ");
parser.process(b"\x1b[H\x1b[J");
assert_eq!(parser.screen().contents(), "");
let screen = parser.screen().clone();
parser.process("ネa\x1b[L\x1b[1;79Hbcd".as_bytes());
assert_eq!(parser.screen().contents(), " bcd a");
assert_eq!(
parser.screen().contents_formatted(),
"\x1b[?25h\x1b[m\x1b[H\x1b[J\x1b[78Cbcd\x1b[Ca\x1b[2;2H".as_bytes()
);
assert_eq!(
parser.screen().contents_diff(&screen),
"\x1b[78Cbcd\x1b[Ca\x1b[2;2H".as_bytes()
);
}
#[test]
fn wrap_weird() {
let mut parser = vt100::Parser::default();
let screen = parser.screen().clone();
parser.process(b"foo\r\nfoo\r\nfoo\r\nfoo\r\nfoo\r\nfoo\r\nfoo\r\nfoo\r\nfoo\r\nfoo\r\nfoo\r\nfoo\r\nfoo\r\nfoo\r\nfoo\r\nfoo\r\nfoo\r\nfoo\r\nfoo\r\nfoo\r\nfoo\r\nfoo\r\nfoo\r\nfoo");
assert_eq!(parser.screen().contents_formatted(), &b"\x1b[?25h\x1b[m\x1b[H\x1b[Jfoo\r\nfoo\r\nfoo\r\nfoo\r\nfoo\r\nfoo\r\nfoo\r\nfoo\r\nfoo\r\nfoo\r\nfoo\r\nfoo\r\nfoo\r\nfoo\r\nfoo\r\nfoo\r\nfoo\r\nfoo\r\nfoo\r\nfoo\r\nfoo\r\nfoo\r\nfoo\r\nfoo"[..]);
assert_eq!(parser.screen().contents_diff(&screen), &b"foo\r\nfoo\r\nfoo\r\nfoo\r\nfoo\r\nfoo\r\nfoo\r\nfoo\r\nfoo\r\nfoo\r\nfoo\r\nfoo\r\nfoo\r\nfoo\r\nfoo\r\nfoo\r\nfoo\r\nfoo\r\nfoo\r\nfoo\r\nfoo\r\nfoo\r\nfoo\r\nfoo"[..]);
let screen = parser.screen().clone();
parser.process(b"\x1b[3;80H ");
assert_eq!(parser.screen().contents_formatted(), &b"\x1b[?25h\x1b[m\x1b[H\x1b[Jfoo\r\nfoo\r\nfoo\x1b[76C \r\nfoo\r\nfoo\r\nfoo\r\nfoo\r\nfoo\r\nfoo\r\nfoo\r\nfoo\r\nfoo\r\nfoo\r\nfoo\r\nfoo\r\nfoo\r\nfoo\r\nfoo\r\nfoo\r\nfoo\r\nfoo\r\nfoo\r\nfoo\r\nfoo\x1b[3;80H "[..]);
assert_eq!(parser.screen().contents_diff(&screen), &b"\x1b[3;80H "[..]);
}
|
