1#![feature(type_alias_impl_trait)]
2#![feature(trait_alias)]
3#![feature(extend_one)]
4
5mod buf;
6mod chunk;
7mod constants;
8mod types;
9mod utils;
10
11pub use buf::StreamBuffer;
12
13#[cfg(test)]
14mod tests {
15 use std::io::{Read, SeekFrom};
16 use std::fs::File;
17 use std::iter::repeat;
18
19 use std::io::{self, BufRead};
20 use itertools::Itertools;
21 use tempfile::{SpooledTempFile};
22
23 use super::constants::{ZERO_BYTE, MAX_SIZE};
24 use super::buf::{StreamBuffer, StreamBuffer2, ByteStreamBuf, BufferRead, BufferCreate};
25 use super::types::*;
26
27 const START: usize = 0;
28 const LEN: usize = 25;
29 const TEST_FILE: &str = "test.txt";
30 const BUF_SIZE: usize = 5;
31
32 #[test]
33 fn create() {
34 let file = File::open(TEST_FILE).unwrap();
35 let bytes = Box::new(file.bytes());
36
37 let _stream_buffer =
38 ByteStreamBuf::new(bytes, LEN);
39 }
40
41 #[test]
42 fn chunk_from_0() {
43 let file = File::open(TEST_FILE).unwrap();
44 let bytes = Box::new(file.bytes());
45
46 let mut stream_buffer =
47 StreamBuffer::new(bytes, LEN);
48
49 let result = stream_buffer.read(START, BUF_SIZE).unwrap();
50 assert_eq!(result, b"0\n1\n2");
51 }
52
53 #[test]
54 fn forward() {
55 let file = File::open(TEST_FILE).unwrap();
56 let bytes = Box::new(file.bytes());
57
58 let mut stream_buffer =
59 StreamBuffer::new(bytes, LEN);
60
61 let result = stream_buffer.read(START, BUF_SIZE).unwrap();
62 assert_eq!(result, b"0\n1\n2");
63
64 let result = stream_buffer.read(5, BUF_SIZE).unwrap();
65 assert_eq!(result, b"\n3\n4\n");
66 }
67
68 #[test]
69 fn stutter() {
70 let file = File::open(TEST_FILE).unwrap();
71 let bytes = Box::new(file.bytes());
72
73 let mut stream_buffer =
74 StreamBuffer::new(bytes, LEN);
75
76 let result = stream_buffer.read(START, BUF_SIZE).unwrap();
77 assert_eq!(result, b"0\n1\n2");
78 assert_eq!(stream_buffer.index, BUF_SIZE);
79
80 let slice = b"2\n3\n";
81 let result = stream_buffer.read(4, 4).unwrap();
82 assert_eq!(result, slice);
83
84 stream_buffer.file.seek(SeekFrom::Start(0u64)).unwrap();
86 let result = stream_buffer.read(4, 4).unwrap();
89 stream_buffer.file.seek(SeekFrom::Start(0usize as u64)).unwrap();
91 assert_eq!(stream_buffer.index, 8);
92
93 let mut buf = String::new();
94 stream_buffer.file.read_to_string(&mut buf).unwrap();
95 let s = "0\n1\n2\n3\n".to_string();
96 assert_eq!(buf, s);
97
98 assert_eq!(result, slice);
99 }
100
101 #[test]
102 fn inject_file_dependency() {
103 let temp = SpooledTempFile::new(MAX_SIZE);
104
105 let file = File::open(TEST_FILE).unwrap();
106 let bytes = Box::new(file.bytes());
107
108 let _buf = StreamBuffer::from_file(bytes, LEN, temp);
109 }
110
111 #[test]
112 fn backwards() {
113 let file = File::open(TEST_FILE).unwrap();
114 let bytes = Box::new(file.bytes());
115
116 let mut stream_buffer =
117 StreamBuffer::new(bytes, LEN);
118
119 let result =
120 stream_buffer.read(START, BUF_SIZE).unwrap();
121 assert_eq!(result, b"0\n1\n2");
122
123 let result = stream_buffer.read(5, BUF_SIZE).unwrap();
124 assert_eq!(result, b"\n3\n4\n");
125
126 let result = stream_buffer.read(START, BUF_SIZE).unwrap();
127 assert_eq!(result, b"0\n1\n2");
128 }
129
130 #[test]
131 fn same_chunk_from_0() {
132 let file = File::open(TEST_FILE).unwrap();
133 let bytes = Box::new(file.bytes());
134
135 let mut stream_buffer =
136 StreamBuffer::new(bytes, LEN);
137
138 let result = stream_buffer.read(START, BUF_SIZE).unwrap();
139 assert_eq!(result, b"0\n1\n2");
140
141 let result = stream_buffer.read(START, BUF_SIZE).unwrap();
142 assert_eq!(result, b"0\n1\n2");
143 }
144
145 #[test]
146 fn forward_then_extend_from_0() {
147 let file = File::open(TEST_FILE).unwrap();
148 let bytes = Box::new(file.bytes());
149
150 let mut buffer =
151 StreamBuffer::new(bytes, LEN);
152
153 let result = buffer.read(START, BUF_SIZE).unwrap();
154 assert_eq!(result, b"0\n1\n2");
155
156 let result = buffer.read(START, BUF_SIZE).unwrap();
157 assert_eq!(result, b"0\n1\n2");
158
159 let result = buffer.read(START, 10).unwrap();
160 assert_eq!(result, b"0\n1\n2\n3\n4\n");
161 }
162
163 #[test]
164 fn forward_skip_ahead() {
165 let file = File::open(TEST_FILE).unwrap();
166 let bytes = Box::new(file.bytes());
167
168 let mut buffer =
169 StreamBuffer::new(bytes, LEN);
170
171 let result = buffer.read(START, BUF_SIZE).unwrap();
172 assert_eq!(result, b"0\n1\n2");
173
174 let result = buffer.read(8, 3).unwrap();
175 assert_eq!(result, b"\n4\n");
176 }
177
178 #[test]
179 fn tempfile() {
180 let mut temp = SpooledTempFile::new(MAX_SIZE);
181 let data: [u8; 10] =
182 [0, 1, 2, 3, 4,
183 5, 6, 7, 8, 9];
184 temp.write(&data).unwrap();
185 temp.seek(SeekFrom::Start(0u64)).unwrap();
186 let mut buf = [0u8; 10];
187 temp.read(&mut buf).unwrap();
188 assert_eq!(buf, data);
189 }
190
191 #[test]
192 fn vec_iter() {
193 let file = File::open(TEST_FILE).unwrap();
194 let bytes = Box::new(file.bytes());
195 let _vec: Vec<ByteResult> = bytes.collect();
196 }
197
198 #[test]
200 fn old_main_fn() {
201 let file = File::open(TEST_FILE).unwrap();
202 let bytes = Box::new(file.bytes());
203
204 let mut buffer: StreamBuffer<_, SpooledTempFile> =
209 StreamBuffer::new(bytes, LEN);
210
211 let _result = buffer.read(4, 4).unwrap();
212
213 let result = buffer.read(START, BUF_SIZE).unwrap();
214 assert_eq!(result, b"0\n1\n2");
215
216 let result = buffer.read(START, BUF_SIZE).unwrap();
217 assert_eq!(result, b"0\n1\n2");
218
219 buffer.file.seek(SeekFrom::Start(START as u64)).unwrap();
220 let mut buf: Vec<u8> = repeat(ZERO_BYTE).take(10).collect();
221 buffer.file.read(&mut buf).unwrap();
222
223 let buf: Vec<u32> = repeat(ZERO_BYTE as u32).take(10).collect();
224 let bx = Box::new(buf.into_iter());
225
226 let _sb = StreamBuffer::new(bx, 10);
227 }
229
230 #[test]
231 fn old_main_fn2() {
232 let file = File::open(TEST_FILE).unwrap();
233 let bytes = Box::new(file.bytes());
234
235 for byte in bytes {
236 let byte = match byte {
237 Ok(result) => result,
238 _ => panic!()
239 };
240 println!("{}", byte);
241 }
242 }
243 }