1 use crate::io::prelude::*;
2 use crate::io::{Cursor, IoSlice, IoSliceMut, SeekFrom};
6 let mut writer = Vec::new();
7 assert_eq!(writer.write(&[0]).unwrap(), 1);
8 assert_eq!(writer.write(&[1, 2, 3]).unwrap(), 3);
9 assert_eq!(writer.write(&[4, 5, 6, 7]).unwrap(), 4);
12 .write_vectored(&[IoSlice::new(&[]), IoSlice::new(&[8, 9]), IoSlice::new(&[10])],)
16 let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
17 assert_eq!(writer, b);
21 fn test_mem_writer() {
22 let mut writer = Cursor::new(Vec::new());
23 writer.set_position(10);
24 assert_eq!(writer.write(&[0]).unwrap(), 1);
25 assert_eq!(writer.write(&[1, 2, 3]).unwrap(), 3);
26 assert_eq!(writer.write(&[4, 5, 6, 7]).unwrap(), 4);
29 .write_vectored(&[IoSlice::new(&[]), IoSlice::new(&[8, 9]), IoSlice::new(&[10])],)
33 let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
34 assert_eq!(&writer.get_ref()[..10], &[0; 10]);
35 assert_eq!(&writer.get_ref()[10..], b);
39 fn test_mem_writer_preallocated() {
40 let mut writer = Cursor::new(vec![0, 0, 0, 0, 0, 0, 0, 0, 8, 9, 10]);
41 assert_eq!(writer.write(&[0]).unwrap(), 1);
42 assert_eq!(writer.write(&[1, 2, 3]).unwrap(), 3);
43 assert_eq!(writer.write(&[4, 5, 6, 7]).unwrap(), 4);
44 let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
45 assert_eq!(&writer.get_ref()[..], b);
49 fn test_mem_mut_writer() {
50 let mut vec = Vec::new();
51 let mut writer = Cursor::new(&mut vec);
52 assert_eq!(writer.write(&[0]).unwrap(), 1);
53 assert_eq!(writer.write(&[1, 2, 3]).unwrap(), 3);
54 assert_eq!(writer.write(&[4, 5, 6, 7]).unwrap(), 4);
57 .write_vectored(&[IoSlice::new(&[]), IoSlice::new(&[8, 9]), IoSlice::new(&[10])],)
61 let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
62 assert_eq!(&writer.get_ref()[..], b);
65 fn test_slice_writer<T>(writer: &mut Cursor<T>)
70 assert_eq!(writer.position(), 0);
71 assert_eq!(writer.write(&[0]).unwrap(), 1);
72 assert_eq!(writer.position(), 1);
73 assert_eq!(writer.write(&[1, 2, 3]).unwrap(), 3);
74 assert_eq!(writer.write(&[4, 5, 6, 7]).unwrap(), 4);
75 assert_eq!(writer.position(), 8);
76 assert_eq!(writer.write(&[]).unwrap(), 0);
77 assert_eq!(writer.position(), 8);
79 assert_eq!(writer.write(&[8, 9]).unwrap(), 1);
80 assert_eq!(writer.write(&[10]).unwrap(), 0);
81 let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8];
82 assert_eq!(writer.get_ref().as_ref(), b);
85 fn test_slice_writer_vectored<T>(writer: &mut Cursor<T>)
90 assert_eq!(writer.position(), 0);
91 assert_eq!(writer.write_vectored(&[IoSlice::new(&[0])]).unwrap(), 1);
92 assert_eq!(writer.position(), 1);
94 writer.write_vectored(&[IoSlice::new(&[1, 2, 3]), IoSlice::new(&[4, 5, 6, 7]),]).unwrap(),
97 assert_eq!(writer.position(), 8);
98 assert_eq!(writer.write_vectored(&[]).unwrap(), 0);
99 assert_eq!(writer.position(), 8);
101 assert_eq!(writer.write_vectored(&[IoSlice::new(&[8, 9])]).unwrap(), 1);
102 assert_eq!(writer.write_vectored(&[IoSlice::new(&[10])]).unwrap(), 0);
103 let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8];
104 assert_eq!(writer.get_ref().as_ref(), b);
108 fn test_box_slice_writer() {
109 let mut writer = Cursor::new(vec![0u8; 9].into_boxed_slice());
110 test_slice_writer(&mut writer);
114 fn test_box_slice_writer_vectored() {
115 let mut writer = Cursor::new(vec![0u8; 9].into_boxed_slice());
116 test_slice_writer_vectored(&mut writer);
120 fn test_array_writer() {
121 let mut writer = Cursor::new([0u8; 9]);
122 test_slice_writer(&mut writer);
126 fn test_array_writer_vectored() {
127 let mut writer = Cursor::new([0u8; 9]);
128 test_slice_writer_vectored(&mut writer);
132 fn test_buf_writer() {
133 let mut buf = [0 as u8; 9];
134 let mut writer = Cursor::new(&mut buf[..]);
135 test_slice_writer(&mut writer);
139 fn test_buf_writer_vectored() {
140 let mut buf = [0 as u8; 9];
141 let mut writer = Cursor::new(&mut buf[..]);
142 test_slice_writer_vectored(&mut writer);
146 fn test_buf_writer_seek() {
147 let mut buf = [0 as u8; 8];
149 let mut writer = Cursor::new(&mut buf[..]);
150 assert_eq!(writer.position(), 0);
151 assert_eq!(writer.write(&[1]).unwrap(), 1);
152 assert_eq!(writer.position(), 1);
154 assert_eq!(writer.seek(SeekFrom::Start(2)).unwrap(), 2);
155 assert_eq!(writer.position(), 2);
156 assert_eq!(writer.write(&[2]).unwrap(), 1);
157 assert_eq!(writer.position(), 3);
159 assert_eq!(writer.seek(SeekFrom::Current(-2)).unwrap(), 1);
160 assert_eq!(writer.position(), 1);
161 assert_eq!(writer.write(&[3]).unwrap(), 1);
162 assert_eq!(writer.position(), 2);
164 assert_eq!(writer.seek(SeekFrom::End(-1)).unwrap(), 7);
165 assert_eq!(writer.position(), 7);
166 assert_eq!(writer.write(&[4]).unwrap(), 1);
167 assert_eq!(writer.position(), 8);
169 let b: &[_] = &[1, 3, 2, 0, 0, 0, 0, 4];
174 fn test_buf_writer_error() {
175 let mut buf = [0 as u8; 2];
176 let mut writer = Cursor::new(&mut buf[..]);
177 assert_eq!(writer.write(&[0]).unwrap(), 1);
178 assert_eq!(writer.write(&[0, 0]).unwrap(), 1);
179 assert_eq!(writer.write(&[0, 0]).unwrap(), 0);
183 fn test_mem_reader() {
184 let mut reader = Cursor::new(vec![0, 1, 2, 3, 4, 5, 6, 7]);
186 assert_eq!(reader.read(&mut buf).unwrap(), 0);
187 assert_eq!(reader.position(), 0);
189 assert_eq!(reader.read(&mut buf).unwrap(), 1);
190 assert_eq!(reader.position(), 1);
193 let mut buf = [0; 4];
194 assert_eq!(reader.read(&mut buf).unwrap(), 4);
195 assert_eq!(reader.position(), 5);
196 let b: &[_] = &[1, 2, 3, 4];
198 assert_eq!(reader.read(&mut buf).unwrap(), 3);
199 let b: &[_] = &[5, 6, 7];
200 assert_eq!(&buf[..3], b);
201 assert_eq!(reader.read(&mut buf).unwrap(), 0);
205 fn test_mem_reader_vectored() {
206 let mut reader = Cursor::new(vec![0, 1, 2, 3, 4, 5, 6, 7]);
208 assert_eq!(reader.read_vectored(&mut [IoSliceMut::new(&mut buf)]).unwrap(), 0);
209 assert_eq!(reader.position(), 0);
212 reader.read_vectored(&mut [IoSliceMut::new(&mut []), IoSliceMut::new(&mut buf),]).unwrap(),
215 assert_eq!(reader.position(), 1);
218 let mut buf1 = [0; 4];
219 let mut buf2 = [0; 4];
222 .read_vectored(&mut [IoSliceMut::new(&mut buf1), IoSliceMut::new(&mut buf2),])
226 let b1: &[_] = &[1, 2, 3, 4];
227 let b2: &[_] = &[5, 6, 7];
228 assert_eq!(buf1, b1);
229 assert_eq!(&buf2[..3], b2);
230 assert_eq!(reader.read(&mut buf).unwrap(), 0);
234 fn test_boxed_slice_reader() {
235 let mut reader = Cursor::new(vec![0, 1, 2, 3, 4, 5, 6, 7].into_boxed_slice());
237 assert_eq!(reader.read(&mut buf).unwrap(), 0);
238 assert_eq!(reader.position(), 0);
240 assert_eq!(reader.read(&mut buf).unwrap(), 1);
241 assert_eq!(reader.position(), 1);
244 let mut buf = [0; 4];
245 assert_eq!(reader.read(&mut buf).unwrap(), 4);
246 assert_eq!(reader.position(), 5);
247 let b: &[_] = &[1, 2, 3, 4];
249 assert_eq!(reader.read(&mut buf).unwrap(), 3);
250 let b: &[_] = &[5, 6, 7];
251 assert_eq!(&buf[..3], b);
252 assert_eq!(reader.read(&mut buf).unwrap(), 0);
256 fn test_boxed_slice_reader_vectored() {
257 let mut reader = Cursor::new(vec![0, 1, 2, 3, 4, 5, 6, 7].into_boxed_slice());
259 assert_eq!(reader.read_vectored(&mut [IoSliceMut::new(&mut buf)]).unwrap(), 0);
260 assert_eq!(reader.position(), 0);
263 reader.read_vectored(&mut [IoSliceMut::new(&mut []), IoSliceMut::new(&mut buf),]).unwrap(),
266 assert_eq!(reader.position(), 1);
269 let mut buf1 = [0; 4];
270 let mut buf2 = [0; 4];
273 .read_vectored(&mut [IoSliceMut::new(&mut buf1), IoSliceMut::new(&mut buf2)],)
277 let b1: &[_] = &[1, 2, 3, 4];
278 let b2: &[_] = &[5, 6, 7];
279 assert_eq!(buf1, b1);
280 assert_eq!(&buf2[..3], b2);
281 assert_eq!(reader.read(&mut buf).unwrap(), 0);
286 let mut reader = Cursor::new(vec![0, 1, 2, 3, 4, 5, 6, 7]);
287 let mut v = Vec::new();
288 reader.read_to_end(&mut v).unwrap();
289 assert_eq!(v, [0, 1, 2, 3, 4, 5, 6, 7]);
293 fn test_slice_reader() {
294 let in_buf = vec![0, 1, 2, 3, 4, 5, 6, 7];
295 let reader = &mut &in_buf[..];
297 assert_eq!(reader.read(&mut buf).unwrap(), 0);
299 assert_eq!(reader.read(&mut buf).unwrap(), 1);
300 assert_eq!(reader.len(), 7);
302 assert_eq!(&buf[..], b);
303 let mut buf = [0; 4];
304 assert_eq!(reader.read(&mut buf).unwrap(), 4);
305 assert_eq!(reader.len(), 3);
306 let b: &[_] = &[1, 2, 3, 4];
307 assert_eq!(&buf[..], b);
308 assert_eq!(reader.read(&mut buf).unwrap(), 3);
309 let b: &[_] = &[5, 6, 7];
310 assert_eq!(&buf[..3], b);
311 assert_eq!(reader.read(&mut buf).unwrap(), 0);
315 fn test_slice_reader_vectored() {
316 let in_buf = vec![0, 1, 2, 3, 4, 5, 6, 7];
317 let reader = &mut &in_buf[..];
319 assert_eq!(reader.read_vectored(&mut [IoSliceMut::new(&mut buf)]).unwrap(), 0);
322 reader.read_vectored(&mut [IoSliceMut::new(&mut []), IoSliceMut::new(&mut buf),]).unwrap(),
325 assert_eq!(reader.len(), 7);
328 let mut buf1 = [0; 4];
329 let mut buf2 = [0; 4];
332 .read_vectored(&mut [IoSliceMut::new(&mut buf1), IoSliceMut::new(&mut buf2)],)
336 let b1: &[_] = &[1, 2, 3, 4];
337 let b2: &[_] = &[5, 6, 7];
338 assert_eq!(buf1, b1);
339 assert_eq!(&buf2[..3], b2);
340 assert_eq!(reader.read(&mut buf).unwrap(), 0);
344 fn test_read_exact() {
345 let in_buf = vec![0, 1, 2, 3, 4, 5, 6, 7];
346 let reader = &mut &in_buf[..];
348 assert!(reader.read_exact(&mut buf).is_ok());
350 assert!(reader.read_exact(&mut buf).is_ok());
351 assert_eq!(buf[0], 0);
352 assert_eq!(reader.len(), 7);
353 let mut buf = [0, 0, 0, 0, 0, 0, 0];
354 assert!(reader.read_exact(&mut buf).is_ok());
355 assert_eq!(buf, [1, 2, 3, 4, 5, 6, 7]);
356 assert_eq!(reader.len(), 0);
358 assert!(reader.read_exact(&mut buf).is_err());
362 fn test_buf_reader() {
363 let in_buf = vec![0, 1, 2, 3, 4, 5, 6, 7];
364 let mut reader = Cursor::new(&in_buf[..]);
366 assert_eq!(reader.read(&mut buf).unwrap(), 0);
367 assert_eq!(reader.position(), 0);
369 assert_eq!(reader.read(&mut buf).unwrap(), 1);
370 assert_eq!(reader.position(), 1);
373 let mut buf = [0; 4];
374 assert_eq!(reader.read(&mut buf).unwrap(), 4);
375 assert_eq!(reader.position(), 5);
376 let b: &[_] = &[1, 2, 3, 4];
378 assert_eq!(reader.read(&mut buf).unwrap(), 3);
379 let b: &[_] = &[5, 6, 7];
380 assert_eq!(&buf[..3], b);
381 assert_eq!(reader.read(&mut buf).unwrap(), 0);
387 let mut r = Cursor::new(&buf[..]);
388 assert_eq!(r.seek(SeekFrom::Start(10)).unwrap(), 10);
389 assert_eq!(r.read(&mut [0]).unwrap(), 0);
391 let mut r = Cursor::new(vec![10]);
392 assert_eq!(r.seek(SeekFrom::Start(10)).unwrap(), 10);
393 assert_eq!(r.read(&mut [0]).unwrap(), 0);
396 let mut r = Cursor::new(&mut buf[..]);
397 assert_eq!(r.seek(SeekFrom::Start(10)).unwrap(), 10);
398 assert_eq!(r.write(&[3]).unwrap(), 0);
400 let mut r = Cursor::new(vec![10].into_boxed_slice());
401 assert_eq!(r.seek(SeekFrom::Start(10)).unwrap(), 10);
402 assert_eq!(r.write(&[3]).unwrap(), 0);
408 let mut r = Cursor::new(&buf[..]);
409 assert_eq!(r.seek(SeekFrom::Start(6)).unwrap(), 6);
410 assert_eq!(r.seek(SeekFrom::Current(0x7ffffffffffffff0)).unwrap(), 0x7ffffffffffffff6);
411 assert_eq!(r.seek(SeekFrom::Current(0x10)).unwrap(), 0x8000000000000006);
412 assert_eq!(r.seek(SeekFrom::Current(0)).unwrap(), 0x8000000000000006);
413 assert!(r.seek(SeekFrom::Current(0x7ffffffffffffffd)).is_err());
414 assert_eq!(r.seek(SeekFrom::Current(-0x8000000000000000)).unwrap(), 6);
416 let mut r = Cursor::new(vec![10]);
417 assert_eq!(r.seek(SeekFrom::Start(6)).unwrap(), 6);
418 assert_eq!(r.seek(SeekFrom::Current(0x7ffffffffffffff0)).unwrap(), 0x7ffffffffffffff6);
419 assert_eq!(r.seek(SeekFrom::Current(0x10)).unwrap(), 0x8000000000000006);
420 assert_eq!(r.seek(SeekFrom::Current(0)).unwrap(), 0x8000000000000006);
421 assert!(r.seek(SeekFrom::Current(0x7ffffffffffffffd)).is_err());
422 assert_eq!(r.seek(SeekFrom::Current(-0x8000000000000000)).unwrap(), 6);
425 let mut r = Cursor::new(&mut buf[..]);
426 assert_eq!(r.seek(SeekFrom::Start(6)).unwrap(), 6);
427 assert_eq!(r.seek(SeekFrom::Current(0x7ffffffffffffff0)).unwrap(), 0x7ffffffffffffff6);
428 assert_eq!(r.seek(SeekFrom::Current(0x10)).unwrap(), 0x8000000000000006);
429 assert_eq!(r.seek(SeekFrom::Current(0)).unwrap(), 0x8000000000000006);
430 assert!(r.seek(SeekFrom::Current(0x7ffffffffffffffd)).is_err());
431 assert_eq!(r.seek(SeekFrom::Current(-0x8000000000000000)).unwrap(), 6);
433 let mut r = Cursor::new(vec![10].into_boxed_slice());
434 assert_eq!(r.seek(SeekFrom::Start(6)).unwrap(), 6);
435 assert_eq!(r.seek(SeekFrom::Current(0x7ffffffffffffff0)).unwrap(), 0x7ffffffffffffff6);
436 assert_eq!(r.seek(SeekFrom::Current(0x10)).unwrap(), 0x8000000000000006);
437 assert_eq!(r.seek(SeekFrom::Current(0)).unwrap(), 0x8000000000000006);
438 assert!(r.seek(SeekFrom::Current(0x7ffffffffffffffd)).is_err());
439 assert_eq!(r.seek(SeekFrom::Current(-0x8000000000000000)).unwrap(), 6);
445 let mut r = Cursor::new(&buf[..]);
446 assert!(r.seek(SeekFrom::End(-2)).is_err());
448 let mut r = Cursor::new(vec![10]);
449 assert!(r.seek(SeekFrom::End(-2)).is_err());
452 let mut r = Cursor::new(&mut buf[..]);
453 assert!(r.seek(SeekFrom::End(-2)).is_err());
455 let mut r = Cursor::new(vec![10].into_boxed_slice());
456 assert!(r.seek(SeekFrom::End(-2)).is_err());
460 fn test_seekable_mem_writer() {
461 let mut writer = Cursor::new(Vec::<u8>::new());
462 assert_eq!(writer.position(), 0);
463 assert_eq!(writer.write(&[0]).unwrap(), 1);
464 assert_eq!(writer.position(), 1);
465 assert_eq!(writer.write(&[1, 2, 3]).unwrap(), 3);
466 assert_eq!(writer.write(&[4, 5, 6, 7]).unwrap(), 4);
467 assert_eq!(writer.position(), 8);
468 let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7];
469 assert_eq!(&writer.get_ref()[..], b);
471 assert_eq!(writer.seek(SeekFrom::Start(0)).unwrap(), 0);
472 assert_eq!(writer.position(), 0);
473 assert_eq!(writer.write(&[3, 4]).unwrap(), 2);
474 let b: &[_] = &[3, 4, 2, 3, 4, 5, 6, 7];
475 assert_eq!(&writer.get_ref()[..], b);
477 assert_eq!(writer.seek(SeekFrom::Current(1)).unwrap(), 3);
478 assert_eq!(writer.write(&[0, 1]).unwrap(), 2);
479 let b: &[_] = &[3, 4, 2, 0, 1, 5, 6, 7];
480 assert_eq!(&writer.get_ref()[..], b);
482 assert_eq!(writer.seek(SeekFrom::End(-1)).unwrap(), 7);
483 assert_eq!(writer.write(&[1, 2]).unwrap(), 2);
484 let b: &[_] = &[3, 4, 2, 0, 1, 5, 6, 1, 2];
485 assert_eq!(&writer.get_ref()[..], b);
487 assert_eq!(writer.seek(SeekFrom::End(1)).unwrap(), 10);
488 assert_eq!(writer.write(&[1]).unwrap(), 1);
489 let b: &[_] = &[3, 4, 2, 0, 1, 5, 6, 1, 2, 0, 1];
490 assert_eq!(&writer.get_ref()[..], b);
494 fn vec_seek_past_end() {
495 let mut r = Cursor::new(Vec::new());
496 assert_eq!(r.seek(SeekFrom::Start(10)).unwrap(), 10);
497 assert_eq!(r.write(&[3]).unwrap(), 1);
501 fn vec_seek_before_0() {
502 let mut r = Cursor::new(Vec::new());
503 assert!(r.seek(SeekFrom::End(-2)).is_err());
507 #[cfg(target_pointer_width = "32")]
508 fn vec_seek_and_write_past_usize_max() {
509 let mut c = Cursor::new(Vec::new());
510 c.set_position(usize::MAX as u64 + 1);
511 assert!(c.write_all(&[1, 2, 3]).is_err());
515 fn test_partial_eq() {
516 assert_eq!(Cursor::new(Vec::<u8>::new()), Cursor::new(Vec::<u8>::new()));
521 struct AssertEq<T: Eq>(pub T);
523 let _: AssertEq<Cursor<Vec<u8>>> = AssertEq(Cursor::new(Vec::new()));
528 const CURSOR: Cursor<&[u8]> = Cursor::new(&[0]);
529 const _: &&[u8] = CURSOR.get_ref();
530 const _: u64 = CURSOR.position();
534 fn bench_write_vec(b: &mut test::Bencher) {
535 let slice = &[1; 128];
538 let mut buf = b"some random data to overwrite".to_vec();
539 let mut cursor = Cursor::new(&mut buf);
541 let _ = cursor.write_all(slice);
542 test::black_box(&cursor);
547 fn bench_write_vec_vectored(b: &mut test::Bencher) {
549 IoSlice::new(&[1; 128]),
550 IoSlice::new(&[2; 256]),
551 IoSlice::new(&[3; 512]),
552 IoSlice::new(&[4; 1024]),
553 IoSlice::new(&[5; 2048]),
554 IoSlice::new(&[6; 4096]),
555 IoSlice::new(&[7; 8192]),
556 IoSlice::new(&[8; 8192 * 2]),
560 let mut buf = b"some random data to overwrite".to_vec();
561 let mut cursor = Cursor::new(&mut buf);
563 let mut slices = slices;
564 let _ = cursor.write_all_vectored(&mut slices);
565 test::black_box(&cursor);