Debian Codegraph @

.cargo/vendor/core2/tests/tests.rs

raw
1 use core::cmp;
2 use core2::io::{self as io, BufRead, Cursor, Read, Write};
3
4 // #[test]
5 // #[cfg_attr(target_os = "emscripten", ignore)]
6 // fn read_until() {
7 // let mut buf = Cursor::new(&b"12"[..]);
8 // let mut v = Vec::new();
9 // assert_eq!(buf.read_until(b'3', &mut v).unwrap(), 2);
10 // assert_eq!(v, b"12");
11
12 // let mut buf = Cursor::new(&b"1233"[..]);
13 // let mut v = Vec::new();
14 // assert_eq!(buf.read_until(b'3', &mut v).unwrap(), 3);
15 // assert_eq!(v, b"123");
16 // v.truncate(0);
17 // assert_eq!(buf.read_until(b'3', &mut v).unwrap(), 1);
18 // assert_eq!(v, b"3");
19 // v.truncate(0);
20 // assert_eq!(buf.read_until(b'3', &mut v).unwrap(), 0);
21 // assert_eq!(v, []);
22 // }
23
24 // #[test]
25 // fn split() {
26 // let buf = Cursor::new(&b"12"[..]);
27 // let mut s = buf.split(b'3');
28 // assert_eq!(s.next().unwrap().unwrap(), vec![b'1', b'2']);
29 // assert!(s.next().is_none());
30
31 // let buf = Cursor::new(&b"1233"[..]);
32 // let mut s = buf.split(b'3');
33 // assert_eq!(s.next().unwrap().unwrap(), vec![b'1', b'2']);
34 // assert_eq!(s.next().unwrap().unwrap(), vec![]);
35 // assert!(s.next().is_none());
36 // }
37
38 // #[test]
39 // fn read_line() {
40 // let mut buf = Cursor::new(&b"12"[..]);
41 // let mut v = String::new();
42 // assert_eq!(buf.read_line(&mut v).unwrap(), 2);
43 // assert_eq!(v, "12");
44
45 // let mut buf = Cursor::new(&b"12\n\n"[..]);
46 // let mut v = String::new();
47 // assert_eq!(buf.read_line(&mut v).unwrap(), 3);
48 // assert_eq!(v, "12\n");
49 // v.truncate(0);
50 // assert_eq!(buf.read_line(&mut v).unwrap(), 1);
51 // assert_eq!(v, "\n");
52 // v.truncate(0);
53 // assert_eq!(buf.read_line(&mut v).unwrap(), 0);
54 // assert_eq!(v, "");
55 // }
56
57 // #[test]
58 // fn lines() {
59 // let buf = Cursor::new(&b"12\r"[..]);
60 // let mut s = buf.lines();
61 // assert_eq!(s.next().unwrap().unwrap(), "12\r".to_string());
62 // assert!(s.next().is_none());
63
64 // let buf = Cursor::new(&b"12\r\n\n"[..]);
65 // let mut s = buf.lines();
66 // assert_eq!(s.next().unwrap().unwrap(), "12".to_string());
67 // assert_eq!(s.next().unwrap().unwrap(), "".to_string());
68 // assert!(s.next().is_none());
69 // }
70
71 // #[test]
72 // fn read_to_end() {
73 // let mut c = Cursor::new(&b""[..]);
74 // let mut v = Vec::new();
75 // assert_eq!(c.read_to_end(&mut v).unwrap(), 0);
76 // assert_eq!(v, []);
77
78 // let mut c = Cursor::new(&b"1"[..]);
79 // let mut v = Vec::new();
80 // assert_eq!(c.read_to_end(&mut v).unwrap(), 1);
81 // assert_eq!(v, b"1");
82
83 // let cap = 1024 * 1024;
84 // let data = (0..cap).map(|i| (i / 3) as u8).collect::<Vec<_>>();
85 // let mut v = Vec::new();
86 // let (a, b) = data.split_at(data.len() / 2);
87 // assert_eq!(Cursor::new(a).read_to_end(&mut v).unwrap(), a.len());
88 // assert_eq!(Cursor::new(b).read_to_end(&mut v).unwrap(), b.len());
89 // assert_eq!(v, data);
90 // }
91
92 // #[test]
93 // fn read_to_string() {
94 // let mut c = Cursor::new(&b""[..]);
95 // let mut v = String::new();
96 // assert_eq!(c.read_to_string(&mut v).unwrap(), 0);
97 // assert_eq!(v, "");
98
99 // let mut c = Cursor::new(&b"1"[..]);
100 // let mut v = String::new();
101 // assert_eq!(c.read_to_string(&mut v).unwrap(), 1);
102 // assert_eq!(v, "1");
103
104 // let mut c = Cursor::new(&b"\xff"[..]);
105 // let mut v = String::new();
106 // assert!(c.read_to_string(&mut v).is_err());
107 // }
108
109 #[test]
110 fn read_exact() {
111 let mut buf = [0; 4];
112
113 let mut c = Cursor::new(&b""[..]);
114 assert_eq!(
115 c.read_exact(&mut buf).unwrap_err().kind(),
116 io::ErrorKind::UnexpectedEof
117 );
118
119 let mut c = Cursor::new(&b"123"[..]).chain(Cursor::new(&b"456789"[..]));
120 c.read_exact(&mut buf).unwrap();
121 assert_eq!(&buf, b"1234");
122 c.read_exact(&mut buf).unwrap();
123 assert_eq!(&buf, b"5678");
124 assert_eq!(
125 c.read_exact(&mut buf).unwrap_err().kind(),
126 io::ErrorKind::UnexpectedEof
127 );
128 }
129
130 #[test]
131 fn read_exact_slice() {
132 let mut buf = [0; 4];
133
134 let mut c = &b""[..];
135 assert_eq!(
136 c.read_exact(&mut buf).unwrap_err().kind(),
137 io::ErrorKind::UnexpectedEof
138 );
139
140 let mut c = &b"123"[..];
141 assert_eq!(
142 c.read_exact(&mut buf).unwrap_err().kind(),
143 io::ErrorKind::UnexpectedEof
144 );
145 // make sure the optimized (early returning) method is being used
146 assert_eq!(&buf, &[0; 4]);
147
148 let mut c = &b"1234"[..];
149 c.read_exact(&mut buf).unwrap();
150 assert_eq!(&buf, b"1234");
151
152 let mut c = &b"56789"[..];
153 c.read_exact(&mut buf).unwrap();
154 assert_eq!(&buf, b"5678");
155 assert_eq!(c, b"9");
156 }
157
158 #[test]
159 fn take_eof() {
160 struct R;
161
162 impl Read for R {
163 fn read(&mut self, _: &mut [u8]) -> io::Result<usize> {
164 Err(io::Error::new(io::ErrorKind::Other, ""))
165 }
166 }
167 impl BufRead for R {
168 fn fill_buf(&mut self) -> io::Result<&[u8]> {
169 Err(io::Error::new(io::ErrorKind::Other, ""))
170 }
171 fn consume(&mut self, _amt: usize) {}
172 }
173
174 let mut buf = [0; 1];
175 assert_eq!(0, R.take(0).read(&mut buf).unwrap());
176 assert_eq!(b"", R.take(0).fill_buf().unwrap());
177 }
178
179 fn cmp_bufread<Br1: BufRead, Br2: BufRead>(mut br1: Br1, mut br2: Br2, exp: &[u8]) {
180 let mut cat = Vec::new();
181 loop {
182 let consume = {
183 let buf1 = br1.fill_buf().unwrap();
184 let buf2 = br2.fill_buf().unwrap();
185 let minlen = if buf1.len() < buf2.len() {
186 buf1.len()
187 } else {
188 buf2.len()
189 };
190 assert_eq!(buf1[..minlen], buf2[..minlen]);
191 cat.extend_from_slice(&buf1[..minlen]);
192 minlen
193 };
194 if consume == 0 {
195 break;
196 }
197 br1.consume(consume);
198 br2.consume(consume);
199 }
200 assert_eq!(br1.fill_buf().unwrap().len(), 0);
201 assert_eq!(br2.fill_buf().unwrap().len(), 0);
202 assert_eq!(&cat[..], &exp[..])
203 }
204
205 #[test]
206 fn chain_bufread() {
207 let testdata = b"ABCDEFGHIJKL";
208 let chain1 = (&testdata[..3])
209 .chain(&testdata[3..6])
210 .chain(&testdata[6..9])
211 .chain(&testdata[9..]);
212 let chain2 = (&testdata[..4])
213 .chain(&testdata[4..8])
214 .chain(&testdata[8..]);
215 cmp_bufread(chain1, chain2, &testdata[..]);
216 }
217
218 // #[test]
219 // fn chain_zero_length_read_is_not_eof() {
220 // let a = b"A";
221 // let b = b"B";
222 // let mut s = String::new();
223 // let mut chain = (&a[..]).chain(&b[..]);
224 // chain.read(&mut []).unwrap();
225 // chain.read_to_string(&mut s).unwrap();
226 // assert_eq!("AB", s);
227 // }
228
229 // #[bench]
230 // #[cfg_attr(target_os = "emscripten", ignore)]
231 // fn bench_read_to_end(b: &mut test::Bencher) {
232 // b.iter(|| {
233 // let mut lr = repeat(1).take(10000000);
234 // let mut vec = Vec::with_capacity(1024);
235 // super::read_to_end(&mut lr, &mut vec)
236 // });
237 // }
238
239 // #[test]
240 // fn seek_len() -> io::Result<()> {
241 // let mut c = Cursor::new(vec![0; 15]);
242 // assert_eq!(c.stream_len()?, 15);
243
244 // c.seek(SeekFrom::End(0))?;
245 // let old_pos = c.stream_position()?;
246 // assert_eq!(c.stream_len()?, 15);
247 // assert_eq!(c.stream_position()?, old_pos);
248
249 // c.seek(SeekFrom::Start(7))?;
250 // c.seek(SeekFrom::Current(2))?;
251 // let old_pos = c.stream_position()?;
252 // assert_eq!(c.stream_len()?, 15);
253 // assert_eq!(c.stream_position()?, old_pos);
254
255 // Ok(())
256 // }
257
258 // #[test]
259 // fn seek_position() -> io::Result<()> {
260 // // All `asserts` are duplicated here to make sure the method does not
261 // // change anything about the seek state.
262 // let mut c = Cursor::new(vec![0; 15]);
263 // assert_eq!(c.stream_position()?, 0);
264 // assert_eq!(c.stream_position()?, 0);
265
266 // c.seek(SeekFrom::End(0))?;
267 // assert_eq!(c.stream_position()?, 15);
268 // assert_eq!(c.stream_position()?, 15);
269
270 // c.seek(SeekFrom::Start(7))?;
271 // c.seek(SeekFrom::Current(2))?;
272 // assert_eq!(c.stream_position()?, 9);
273 // assert_eq!(c.stream_position()?, 9);
274
275 // c.seek(SeekFrom::End(-3))?;
276 // c.seek(SeekFrom::Current(1))?;
277 // c.seek(SeekFrom::Current(-5))?;
278 // assert_eq!(c.stream_position()?, 8);
279 // assert_eq!(c.stream_position()?, 8);
280
281 // Ok(())
282 // }
283
284 // A simple example reader which uses the default implementation of
285 // read_to_end.
286 struct ExampleSliceReader<'a> {
287 slice: &'a [u8],
288 }
289
290 impl<'a> Read for ExampleSliceReader<'a> {
291 fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
292 let len = cmp::min(self.slice.len(), buf.len());
293 buf[..len].copy_from_slice(&self.slice[..len]);
294 self.slice = &self.slice[len..];
295 Ok(len)
296 }
297 }
298
299 // #[test]
300 // fn test_read_to_end_capacity() -> io::Result<()> {
301 // let input = &b"foo"[..];
302
303 // // read_to_end() generally needs to over-allocate, both for efficiency
304 // // and so that it can distinguish EOF. Assert that this is the case
305 // // with this simple ExampleSliceReader struct, which uses the default
306 // // implementation of read_to_end. Even though vec1 is allocated with
307 // // exactly enough capacity for the read, read_to_end will allocate more
308 // // space here.
309 // let mut vec1 = Vec::with_capacity(input.len());
310 // ExampleSliceReader { slice: input }.read_to_end(&mut vec1)?;
311 // assert_eq!(vec1.len(), input.len());
312 // assert!(vec1.capacity() > input.len(), "allocated more");
313
314 // // However, std::io::Take includes an implementation of read_to_end
315 // // that will not allocate when the limit has already been reached. In
316 // // this case, vec2 never grows.
317 // let mut vec2 = Vec::with_capacity(input.len());
318 // ExampleSliceReader { slice: input }.take(input.len() as u64).read_to_end(&mut vec2)?;
319 // assert_eq!(vec2.len(), input.len());
320 // assert_eq!(vec2.capacity(), input.len(), "did not allocate more");
321
322 // Ok(())
323 // }
324
325 // #[test]
326 // fn io_slice_mut_advance() {
327 // let mut buf1 = [1; 8];
328 // let mut buf2 = [2; 16];
329 // let mut buf3 = [3; 8];
330 // let mut bufs = &mut [
331 // IoSliceMut::new(&mut buf1),
332 // IoSliceMut::new(&mut buf2),
333 // IoSliceMut::new(&mut buf3),
334 // ][..];
335
336 // // Only in a single buffer..
337 // bufs = IoSliceMut::advance(bufs, 1);
338 // assert_eq!(bufs[0].deref(), [1; 7].as_ref());
339 // assert_eq!(bufs[1].deref(), [2; 16].as_ref());
340 // assert_eq!(bufs[2].deref(), [3; 8].as_ref());
341
342 // // Removing a buffer, leaving others as is.
343 // bufs = IoSliceMut::advance(bufs, 7);
344 // assert_eq!(bufs[0].deref(), [2; 16].as_ref());
345 // assert_eq!(bufs[1].deref(), [3; 8].as_ref());
346
347 // // Removing a buffer and removing from the next buffer.
348 // bufs = IoSliceMut::advance(bufs, 18);
349 // assert_eq!(bufs[0].deref(), [3; 6].as_ref());
350 // }
351
352 // #[test]
353 // fn io_slice_mut_advance_empty_slice() {
354 // let empty_bufs = &mut [][..];
355 // // Shouldn't panic.
356 // IoSliceMut::advance(empty_bufs, 1);
357 // }
358
359 // #[test]
360 // fn io_slice_mut_advance_beyond_total_length() {
361 // let mut buf1 = [1; 8];
362 // let mut bufs = &mut [IoSliceMut::new(&mut buf1)][..];
363
364 // // Going beyond the total length should be ok.
365 // bufs = IoSliceMut::advance(bufs, 9);
366 // assert!(bufs.is_empty());
367 // }
368
369 // #[test]
370 // fn io_slice_advance() {
371 // let buf1 = [1; 8];
372 // let buf2 = [2; 16];
373 // let buf3 = [3; 8];
374 // let mut bufs = &mut [IoSlice::new(&buf1), IoSlice::new(&buf2), IoSlice::new(&buf3)][..];
375
376 // // Only in a single buffer..
377 // bufs = IoSlice::advance(bufs, 1);
378 // assert_eq!(bufs[0].deref(), [1; 7].as_ref());
379 // assert_eq!(bufs[1].deref(), [2; 16].as_ref());
380 // assert_eq!(bufs[2].deref(), [3; 8].as_ref());
381
382 // // Removing a buffer, leaving others as is.
383 // bufs = IoSlice::advance(bufs, 7);
384 // assert_eq!(bufs[0].deref(), [2; 16].as_ref());
385 // assert_eq!(bufs[1].deref(), [3; 8].as_ref());
386
387 // // Removing a buffer and removing from the next buffer.
388 // bufs = IoSlice::advance(bufs, 18);
389 // assert_eq!(bufs[0].deref(), [3; 6].as_ref());
390 // }
391
392 // #[test]
393 // fn io_slice_advance_empty_slice() {
394 // let empty_bufs = &mut [][..];
395 // // Shouldn't panic.
396 // IoSlice::advance(empty_bufs, 1);
397 // }
398
399 // #[test]
400 // fn io_slice_advance_beyond_total_length() {
401 // let buf1 = [1; 8];
402 // let mut bufs = &mut [IoSlice::new(&buf1)][..];
403
404 // // Going beyond the total length should be ok.
405 // bufs = IoSlice::advance(bufs, 9);
406 // assert!(bufs.is_empty());
407 // }
408
409 /// Create a new writer that reads from at most `n_bufs` and reads
410 /// `per_call` bytes (in total) per call to write.
411 fn test_writer() -> TestWriter {
412 TestWriter {
413 written: Vec::new(),
414 per_call: 2,
415 }
416 }
417
418 struct TestWriter {
419 written: Vec<u8>,
420 per_call: usize,
421 }
422
423 impl Write for TestWriter {
424 fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
425 let n = self.per_call.min(buf.len());
426 self.written.extend_from_slice(&buf[..n]);
427 Ok(n)
428 }
429
430 fn flush(&mut self) -> io::Result<()> {
431 Ok(())
432 }
433 }
434
435 #[test]
436 fn test_writer_read_from_one_buf() {
437 let mut writer = test_writer();
438
439 assert_eq!(writer.write(&[]).unwrap(), 0);
440 // assert_eq!(writer.write_vectored(&[]).unwrap(), 0);
441
442 // Read at most 2 bytes.
443 assert_eq!(writer.write(&[1, 1, 1]).unwrap(), 2);
444 assert_eq!(writer.write(&[2, 2, 2]).unwrap(), 2);
445
446 // Only read from first buf.
447 assert_eq!(writer.write(&[3]).unwrap(), 1);
448
449 assert_eq!(writer.written, &[1, 1, 2, 2, 3]);
450 }
451
452 // #[test]
453 // fn test_writer_read_from_multiple_bufs() {
454 // let mut writer = test_writer(3, 3);
455
456 // // Read at most 3 bytes from two buffers.
457 // let bufs = &[IoSlice::new(&[1]), IoSlice::new(&[2, 2, 2])];
458 // assert_eq!(writer.write_vectored(bufs).unwrap(), 3);
459
460 // // Read at most 3 bytes from three buffers.
461 // let bufs = &[IoSlice::new(&[3]), IoSlice::new(&[4]), IoSlice::new(&[5, 5])];
462 // assert_eq!(writer.write_vectored(bufs).unwrap(), 3);
463
464 // assert_eq!(writer.written, &[1, 2, 2, 3, 4, 5]);
465 // }
466
467 // #[test]
468 // fn test_write_all_vectored() {
469 // #[rustfmt::skip] // Becomes unreadable otherwise.
470 // let tests: Vec<(_, &'static [u8])> = vec![
471 // (vec![], &[]),
472 // (vec![IoSlice::new(&[]), IoSlice::new(&[])], &[]),
473 // (vec![IoSlice::new(&[1])], &[1]),
474 // (vec![IoSlice::new(&[1, 2])], &[1, 2]),
475 // (vec![IoSlice::new(&[1, 2, 3])], &[1, 2, 3]),
476 // (vec![IoSlice::new(&[1, 2, 3, 4])], &[1, 2, 3, 4]),
477 // (vec![IoSlice::new(&[1, 2, 3, 4, 5])], &[1, 2, 3, 4, 5]),
478 // (vec![IoSlice::new(&[1]), IoSlice::new(&[2])], &[1, 2]),
479 // (vec![IoSlice::new(&[1]), IoSlice::new(&[2, 2])], &[1, 2, 2]),
480 // (vec![IoSlice::new(&[1, 1]), IoSlice::new(&[2, 2])], &[1, 1, 2, 2]),
481 // (vec![IoSlice::new(&[1, 1]), IoSlice::new(&[2, 2, 2])], &[1, 1, 2, 2, 2]),
482 // (vec![IoSlice::new(&[1, 1]), IoSlice::new(&[2, 2, 2])], &[1, 1, 2, 2, 2]),
483 // (vec![IoSlice::new(&[1, 1, 1]), IoSlice::new(&[2, 2, 2])], &[1, 1, 1, 2, 2, 2]),
484 // (vec![IoSlice::new(&[1, 1, 1]), IoSlice::new(&[2, 2, 2, 2])], &[1, 1, 1, 2, 2, 2, 2]),
485 // (vec![IoSlice::new(&[1, 1, 1, 1]), IoSlice::new(&[2, 2, 2, 2])], &[1, 1, 1, 1, 2, 2, 2, 2]),
486 // (vec![IoSlice::new(&[1]), IoSlice::new(&[2]), IoSlice::new(&[3])], &[1, 2, 3]),
487 // (vec![IoSlice::new(&[1, 1]), IoSlice::new(&[2, 2]), IoSlice::new(&[3, 3])], &[1, 1, 2, 2, 3, 3]),
488 // (vec![IoSlice::new(&[1]), IoSlice::new(&[2, 2]), IoSlice::new(&[3, 3, 3])], &[1, 2, 2, 3, 3, 3]),
489 // (vec![IoSlice::new(&[1, 1, 1]), IoSlice::new(&[2, 2, 2]), IoSlice::new(&[3, 3, 3])], &[1, 1, 1, 2, 2, 2, 3, 3, 3]),
490 // ];
491
492 // let writer_configs = &[(1, 1), (1, 2), (1, 3), (2, 2), (2, 3), (3, 3)];
493
494 // for (n_bufs, per_call) in writer_configs.iter().copied() {
495 // for (mut input, wanted) in tests.clone().into_iter() {
496 // let mut writer = test_writer(n_bufs, per_call);
497 // assert!(writer.write_all_vectored(&mut *input).is_ok());
498 // assert_eq!(&*writer.written, &*wanted);
499 // }
500 // }
501 // }