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
use crate::reg;
use crate::reg::ErrorList::EmptyVec;
use crate::reg::ErrorList::UncappedEscape;
use crate::term::TermStrings;
use std::fmt::Debug;
use std::io::Write;
#[derive(Debug, Clone)]
pub struct TermWriter {
writer: Vec<u8>,
}
impl Write for TermWriter {
fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
self.writer.write(buf)
}
fn flush(&mut self) -> std::io::Result<()> {
self.writer.flush()
}
}
impl TermWriter {
pub fn new() -> TermWriter {
TermWriter { writer: Vec::new() }
}
pub fn compare(self, _t: TermStrings) -> Result<bool, &'static str> {
let compare_result = reg::compare(self.writer, _t.get_term_list());
match compare_result {
Ok(true) => return Ok(true),
Err(EmptyVec) => return Err(&"Provided terminal escape sequences were empty."),
Err(UncappedEscape(_)) => {
return Err(&"Potential unrecognized escape sequences were found")
}
_ => return Err(&"Unknown error occurred"),
};
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
#[ignore]
fn vec_string_bytes() {
let vec1 = vec!["Some".to_string(), "junk".to_string(), "text".to_string()];
let joined_vec1 = vec1.join(" ");
let vec1_bytes = joined_vec1.as_bytes();
let bytes_literal = b"Some junk text";
assert_eq!(vec1_bytes, bytes_literal);
}
#[test]
#[ignore]
fn termwriter_write() {
let bytes_literal = b"Some junk text";
let mut buffer = TermWriter::new();
let bytes_written = buffer.write(bytes_literal);
assert_eq!(bytes_written.unwrap(), 14);
}
#[test]
#[ignore]
fn termwriter_write_all() {
let bytes_literal = b"Some junk text";
let mut buffer = TermWriter::new();
assert_eq!((), buffer.write_all(bytes_literal).unwrap());
}
#[test]
#[ignore]
fn termwriter_flush() {
let bytes_literal = b"Some junk text";
let mut buffer = TermWriter::new();
let _ = buffer.write(bytes_literal);
assert_eq!((), buffer.flush().unwrap())
}
#[test]
#[ignore]
fn termwriter_compare() {
let mut buffer = TermWriter::new();
let _ = buffer.write(b"Text with\nTwo lines");
let result = buffer.compare(TermStrings::new_from_env());
if result.is_err() {
assert_eq!(
Err("Provided terminal escape sequences were empty."),
result
);
} else {
assert_eq!(Ok(true), result);
}
}
}