stream_buffer/
lib.rs

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        // let result = stream_buffer.read(4, 4).unwrap();
85        stream_buffer.file.seek(SeekFrom::Start(0u64)).unwrap();
86        // assert_eq!(stream_buffer.index, 8);
87
88        let result = stream_buffer.read(4, 4).unwrap();
89        // test type casting as well
90        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    // moved main() to a test
199    #[test]
200    fn old_main_fn() {
201        let file = File::open(TEST_FILE).unwrap();
202        let bytes = Box::new(file.bytes());
203
204        // for Ok(byte) in bytes {
205        //     println!("{}", byte);
206        // }
207    
208        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        // println!("{}", _sb.read(0, 5));
228    }
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    }