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 assert_eq!(writer.write(&[0]).unwrap(), 1);
24 assert_eq!(writer.write(&[1, 2, 3]).unwrap(), 3);
25 assert_eq!(writer.write(&[4, 5, 6, 7]).unwrap(), 4);
28 .write_vectored(&[IoSlice::new(&[]), IoSlice::new(&[8, 9]), IoSlice::new(&[10])],)
32 let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
33 assert_eq!(&writer.get_ref()[..], b);
37 fn test_mem_mut_writer() {
38 let mut vec = Vec::new();
39 let mut writer = Cursor::new(&mut vec);
40 assert_eq!(writer.write(&[0]).unwrap(), 1);
41 assert_eq!(writer.write(&[1, 2, 3]).unwrap(), 3);
42 assert_eq!(writer.write(&[4, 5, 6, 7]).unwrap(), 4);
45 .write_vectored(&[IoSlice::new(&[]), IoSlice::new(&[8, 9]), IoSlice::new(&[10])],)
49 let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
50 assert_eq!(&writer.get_ref()[..], b);
54 fn test_box_slice_writer() {
55 let mut writer = Cursor::new(vec![0u8; 9].into_boxed_slice());
56 assert_eq!(writer.position(), 0);
57 assert_eq!(writer.write(&[0]).unwrap(), 1);
58 assert_eq!(writer.position(), 1);
59 assert_eq!(writer.write(&[1, 2, 3]).unwrap(), 3);
60 assert_eq!(writer.write(&[4, 5, 6, 7]).unwrap(), 4);
61 assert_eq!(writer.position(), 8);
62 assert_eq!(writer.write(&[]).unwrap(), 0);
63 assert_eq!(writer.position(), 8);
65 assert_eq!(writer.write(&[8, 9]).unwrap(), 1);
66 assert_eq!(writer.write(&[10]).unwrap(), 0);
67 let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8];
68 assert_eq!(&**writer.get_ref(), b);
72 fn test_box_slice_writer_vectored() {
73 let mut writer = Cursor::new(vec![0u8; 9].into_boxed_slice());
74 assert_eq!(writer.position(), 0);
75 assert_eq!(writer.write_vectored(&[IoSlice::new(&[0])]).unwrap(), 1);
76 assert_eq!(writer.position(), 1);
78 writer.write_vectored(&[IoSlice::new(&[1, 2, 3]), IoSlice::new(&[4, 5, 6, 7]),]).unwrap(),
81 assert_eq!(writer.position(), 8);
82 assert_eq!(writer.write_vectored(&[]).unwrap(), 0);
83 assert_eq!(writer.position(), 8);
85 assert_eq!(writer.write_vectored(&[IoSlice::new(&[8, 9])]).unwrap(), 1);
86 assert_eq!(writer.write_vectored(&[IoSlice::new(&[10])]).unwrap(), 0);
87 let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8];
88 assert_eq!(&**writer.get_ref(), b);
92 fn test_buf_writer() {
93 let mut buf = [0 as u8; 9];
95 let mut writer = Cursor::new(&mut buf[..]);
96 assert_eq!(writer.position(), 0);
97 assert_eq!(writer.write(&[0]).unwrap(), 1);
98 assert_eq!(writer.position(), 1);
99 assert_eq!(writer.write(&[1, 2, 3]).unwrap(), 3);
100 assert_eq!(writer.write(&[4, 5, 6, 7]).unwrap(), 4);
101 assert_eq!(writer.position(), 8);
102 assert_eq!(writer.write(&[]).unwrap(), 0);
103 assert_eq!(writer.position(), 8);
105 assert_eq!(writer.write(&[8, 9]).unwrap(), 1);
106 assert_eq!(writer.write(&[10]).unwrap(), 0);
108 let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8];
113 fn test_buf_writer_vectored() {
114 let mut buf = [0 as u8; 9];
116 let mut writer = Cursor::new(&mut buf[..]);
117 assert_eq!(writer.position(), 0);
118 assert_eq!(writer.write_vectored(&[IoSlice::new(&[0])]).unwrap(), 1);
119 assert_eq!(writer.position(), 1);
122 .write_vectored(&[IoSlice::new(&[1, 2, 3]), IoSlice::new(&[4, 5, 6, 7])],)
126 assert_eq!(writer.position(), 8);
127 assert_eq!(writer.write_vectored(&[]).unwrap(), 0);
128 assert_eq!(writer.position(), 8);
130 assert_eq!(writer.write_vectored(&[IoSlice::new(&[8, 9])]).unwrap(), 1);
131 assert_eq!(writer.write_vectored(&[IoSlice::new(&[10])]).unwrap(), 0);
133 let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8];
138 fn test_buf_writer_seek() {
139 let mut buf = [0 as u8; 8];
141 let mut writer = Cursor::new(&mut buf[..]);
142 assert_eq!(writer.position(), 0);
143 assert_eq!(writer.write(&[1]).unwrap(), 1);
144 assert_eq!(writer.position(), 1);
146 assert_eq!(writer.seek(SeekFrom::Start(2)).unwrap(), 2);
147 assert_eq!(writer.position(), 2);
148 assert_eq!(writer.write(&[2]).unwrap(), 1);
149 assert_eq!(writer.position(), 3);
151 assert_eq!(writer.seek(SeekFrom::Current(-2)).unwrap(), 1);
152 assert_eq!(writer.position(), 1);
153 assert_eq!(writer.write(&[3]).unwrap(), 1);
154 assert_eq!(writer.position(), 2);
156 assert_eq!(writer.seek(SeekFrom::End(-1)).unwrap(), 7);
157 assert_eq!(writer.position(), 7);
158 assert_eq!(writer.write(&[4]).unwrap(), 1);
159 assert_eq!(writer.position(), 8);
161 let b: &[_] = &[1, 3, 2, 0, 0, 0, 0, 4];
166 fn test_buf_writer_error() {
167 let mut buf = [0 as u8; 2];
168 let mut writer = Cursor::new(&mut buf[..]);
169 assert_eq!(writer.write(&[0]).unwrap(), 1);
170 assert_eq!(writer.write(&[0, 0]).unwrap(), 1);
171 assert_eq!(writer.write(&[0, 0]).unwrap(), 0);
175 fn test_mem_reader() {
176 let mut reader = Cursor::new(vec![0, 1, 2, 3, 4, 5, 6, 7]);
178 assert_eq!(reader.read(&mut buf).unwrap(), 0);
179 assert_eq!(reader.position(), 0);
181 assert_eq!(reader.read(&mut buf).unwrap(), 1);
182 assert_eq!(reader.position(), 1);
185 let mut buf = [0; 4];
186 assert_eq!(reader.read(&mut buf).unwrap(), 4);
187 assert_eq!(reader.position(), 5);
188 let b: &[_] = &[1, 2, 3, 4];
190 assert_eq!(reader.read(&mut buf).unwrap(), 3);
191 let b: &[_] = &[5, 6, 7];
192 assert_eq!(&buf[..3], b);
193 assert_eq!(reader.read(&mut buf).unwrap(), 0);
197 fn test_mem_reader_vectored() {
198 let mut reader = Cursor::new(vec![0, 1, 2, 3, 4, 5, 6, 7]);
200 assert_eq!(reader.read_vectored(&mut [IoSliceMut::new(&mut buf)]).unwrap(), 0);
201 assert_eq!(reader.position(), 0);
204 reader.read_vectored(&mut [IoSliceMut::new(&mut []), IoSliceMut::new(&mut buf),]).unwrap(),
207 assert_eq!(reader.position(), 1);
210 let mut buf1 = [0; 4];
211 let mut buf2 = [0; 4];
214 .read_vectored(&mut [IoSliceMut::new(&mut buf1), IoSliceMut::new(&mut buf2),])
218 let b1: &[_] = &[1, 2, 3, 4];
219 let b2: &[_] = &[5, 6, 7];
220 assert_eq!(buf1, b1);
221 assert_eq!(&buf2[..3], b2);
222 assert_eq!(reader.read(&mut buf).unwrap(), 0);
226 fn test_boxed_slice_reader() {
227 let mut reader = Cursor::new(vec![0, 1, 2, 3, 4, 5, 6, 7].into_boxed_slice());
229 assert_eq!(reader.read(&mut buf).unwrap(), 0);
230 assert_eq!(reader.position(), 0);
232 assert_eq!(reader.read(&mut buf).unwrap(), 1);
233 assert_eq!(reader.position(), 1);
236 let mut buf = [0; 4];
237 assert_eq!(reader.read(&mut buf).unwrap(), 4);
238 assert_eq!(reader.position(), 5);
239 let b: &[_] = &[1, 2, 3, 4];
241 assert_eq!(reader.read(&mut buf).unwrap(), 3);
242 let b: &[_] = &[5, 6, 7];
243 assert_eq!(&buf[..3], b);
244 assert_eq!(reader.read(&mut buf).unwrap(), 0);
248 fn test_boxed_slice_reader_vectored() {
249 let mut reader = Cursor::new(vec![0, 1, 2, 3, 4, 5, 6, 7].into_boxed_slice());
251 assert_eq!(reader.read_vectored(&mut [IoSliceMut::new(&mut buf)]).unwrap(), 0);
252 assert_eq!(reader.position(), 0);
255 reader.read_vectored(&mut [IoSliceMut::new(&mut []), IoSliceMut::new(&mut buf),]).unwrap(),
258 assert_eq!(reader.position(), 1);
261 let mut buf1 = [0; 4];
262 let mut buf2 = [0; 4];
265 .read_vectored(&mut [IoSliceMut::new(&mut buf1), IoSliceMut::new(&mut buf2)],)
269 let b1: &[_] = &[1, 2, 3, 4];
270 let b2: &[_] = &[5, 6, 7];
271 assert_eq!(buf1, b1);
272 assert_eq!(&buf2[..3], b2);
273 assert_eq!(reader.read(&mut buf).unwrap(), 0);
278 let mut reader = Cursor::new(vec![0, 1, 2, 3, 4, 5, 6, 7]);
279 let mut v = Vec::new();
280 reader.read_to_end(&mut v).unwrap();
281 assert_eq!(v, [0, 1, 2, 3, 4, 5, 6, 7]);
285 fn test_slice_reader() {
286 let in_buf = vec![0, 1, 2, 3, 4, 5, 6, 7];
287 let reader = &mut &in_buf[..];
289 assert_eq!(reader.read(&mut buf).unwrap(), 0);
291 assert_eq!(reader.read(&mut buf).unwrap(), 1);
292 assert_eq!(reader.len(), 7);
294 assert_eq!(&buf[..], b);
295 let mut buf = [0; 4];
296 assert_eq!(reader.read(&mut buf).unwrap(), 4);
297 assert_eq!(reader.len(), 3);
298 let b: &[_] = &[1, 2, 3, 4];
299 assert_eq!(&buf[..], b);
300 assert_eq!(reader.read(&mut buf).unwrap(), 3);
301 let b: &[_] = &[5, 6, 7];
302 assert_eq!(&buf[..3], b);
303 assert_eq!(reader.read(&mut buf).unwrap(), 0);
307 fn test_slice_reader_vectored() {
308 let in_buf = vec![0, 1, 2, 3, 4, 5, 6, 7];
309 let reader = &mut &in_buf[..];
311 assert_eq!(reader.read_vectored(&mut [IoSliceMut::new(&mut buf)]).unwrap(), 0);
314 reader.read_vectored(&mut [IoSliceMut::new(&mut []), IoSliceMut::new(&mut buf),]).unwrap(),
317 assert_eq!(reader.len(), 7);
320 let mut buf1 = [0; 4];
321 let mut buf2 = [0; 4];
324 .read_vectored(&mut [IoSliceMut::new(&mut buf1), IoSliceMut::new(&mut buf2)],)
328 let b1: &[_] = &[1, 2, 3, 4];
329 let b2: &[_] = &[5, 6, 7];
330 assert_eq!(buf1, b1);
331 assert_eq!(&buf2[..3], b2);
332 assert_eq!(reader.read(&mut buf).unwrap(), 0);
336 fn test_read_exact() {
337 let in_buf = vec![0, 1, 2, 3, 4, 5, 6, 7];
338 let reader = &mut &in_buf[..];
340 assert!(reader.read_exact(&mut buf).is_ok());
342 assert!(reader.read_exact(&mut buf).is_ok());
343 assert_eq!(buf[0], 0);
344 assert_eq!(reader.len(), 7);
345 let mut buf = [0, 0, 0, 0, 0, 0, 0];
346 assert!(reader.read_exact(&mut buf).is_ok());
347 assert_eq!(buf, [1, 2, 3, 4, 5, 6, 7]);
348 assert_eq!(reader.len(), 0);
350 assert!(reader.read_exact(&mut buf).is_err());
354 fn test_buf_reader() {
355 let in_buf = vec![0, 1, 2, 3, 4, 5, 6, 7];
356 let mut reader = Cursor::new(&in_buf[..]);
358 assert_eq!(reader.read(&mut buf).unwrap(), 0);
359 assert_eq!(reader.position(), 0);
361 assert_eq!(reader.read(&mut buf).unwrap(), 1);
362 assert_eq!(reader.position(), 1);
365 let mut buf = [0; 4];
366 assert_eq!(reader.read(&mut buf).unwrap(), 4);
367 assert_eq!(reader.position(), 5);
368 let b: &[_] = &[1, 2, 3, 4];
370 assert_eq!(reader.read(&mut buf).unwrap(), 3);
371 let b: &[_] = &[5, 6, 7];
372 assert_eq!(&buf[..3], b);
373 assert_eq!(reader.read(&mut buf).unwrap(), 0);
379 let mut r = Cursor::new(&buf[..]);
380 assert_eq!(r.seek(SeekFrom::Start(10)).unwrap(), 10);
381 assert_eq!(r.read(&mut [0]).unwrap(), 0);
383 let mut r = Cursor::new(vec![10]);
384 assert_eq!(r.seek(SeekFrom::Start(10)).unwrap(), 10);
385 assert_eq!(r.read(&mut [0]).unwrap(), 0);
388 let mut r = Cursor::new(&mut buf[..]);
389 assert_eq!(r.seek(SeekFrom::Start(10)).unwrap(), 10);
390 assert_eq!(r.write(&[3]).unwrap(), 0);
392 let mut r = Cursor::new(vec![10].into_boxed_slice());
393 assert_eq!(r.seek(SeekFrom::Start(10)).unwrap(), 10);
394 assert_eq!(r.write(&[3]).unwrap(), 0);
400 let mut r = Cursor::new(&buf[..]);
401 assert_eq!(r.seek(SeekFrom::Start(6)).unwrap(), 6);
402 assert_eq!(r.seek(SeekFrom::Current(0x7ffffffffffffff0)).unwrap(), 0x7ffffffffffffff6);
403 assert_eq!(r.seek(SeekFrom::Current(0x10)).unwrap(), 0x8000000000000006);
404 assert_eq!(r.seek(SeekFrom::Current(0)).unwrap(), 0x8000000000000006);
405 assert!(r.seek(SeekFrom::Current(0x7ffffffffffffffd)).is_err());
406 assert_eq!(r.seek(SeekFrom::Current(-0x8000000000000000)).unwrap(), 6);
408 let mut r = Cursor::new(vec![10]);
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);
417 let mut r = Cursor::new(&mut buf[..]);
418 assert_eq!(r.seek(SeekFrom::Start(6)).unwrap(), 6);
419 assert_eq!(r.seek(SeekFrom::Current(0x7ffffffffffffff0)).unwrap(), 0x7ffffffffffffff6);
420 assert_eq!(r.seek(SeekFrom::Current(0x10)).unwrap(), 0x8000000000000006);
421 assert_eq!(r.seek(SeekFrom::Current(0)).unwrap(), 0x8000000000000006);
422 assert!(r.seek(SeekFrom::Current(0x7ffffffffffffffd)).is_err());
423 assert_eq!(r.seek(SeekFrom::Current(-0x8000000000000000)).unwrap(), 6);
425 let mut r = Cursor::new(vec![10].into_boxed_slice());
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);
437 let mut r = Cursor::new(&buf[..]);
438 assert!(r.seek(SeekFrom::End(-2)).is_err());
440 let mut r = Cursor::new(vec![10]);
441 assert!(r.seek(SeekFrom::End(-2)).is_err());
444 let mut r = Cursor::new(&mut buf[..]);
445 assert!(r.seek(SeekFrom::End(-2)).is_err());
447 let mut r = Cursor::new(vec![10].into_boxed_slice());
448 assert!(r.seek(SeekFrom::End(-2)).is_err());
452 fn test_seekable_mem_writer() {
453 let mut writer = Cursor::new(Vec::<u8>::new());
454 assert_eq!(writer.position(), 0);
455 assert_eq!(writer.write(&[0]).unwrap(), 1);
456 assert_eq!(writer.position(), 1);
457 assert_eq!(writer.write(&[1, 2, 3]).unwrap(), 3);
458 assert_eq!(writer.write(&[4, 5, 6, 7]).unwrap(), 4);
459 assert_eq!(writer.position(), 8);
460 let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7];
461 assert_eq!(&writer.get_ref()[..], b);
463 assert_eq!(writer.seek(SeekFrom::Start(0)).unwrap(), 0);
464 assert_eq!(writer.position(), 0);
465 assert_eq!(writer.write(&[3, 4]).unwrap(), 2);
466 let b: &[_] = &[3, 4, 2, 3, 4, 5, 6, 7];
467 assert_eq!(&writer.get_ref()[..], b);
469 assert_eq!(writer.seek(SeekFrom::Current(1)).unwrap(), 3);
470 assert_eq!(writer.write(&[0, 1]).unwrap(), 2);
471 let b: &[_] = &[3, 4, 2, 0, 1, 5, 6, 7];
472 assert_eq!(&writer.get_ref()[..], b);
474 assert_eq!(writer.seek(SeekFrom::End(-1)).unwrap(), 7);
475 assert_eq!(writer.write(&[1, 2]).unwrap(), 2);
476 let b: &[_] = &[3, 4, 2, 0, 1, 5, 6, 1, 2];
477 assert_eq!(&writer.get_ref()[..], b);
479 assert_eq!(writer.seek(SeekFrom::End(1)).unwrap(), 10);
480 assert_eq!(writer.write(&[1]).unwrap(), 1);
481 let b: &[_] = &[3, 4, 2, 0, 1, 5, 6, 1, 2, 0, 1];
482 assert_eq!(&writer.get_ref()[..], b);
486 fn vec_seek_past_end() {
487 let mut r = Cursor::new(Vec::new());
488 assert_eq!(r.seek(SeekFrom::Start(10)).unwrap(), 10);
489 assert_eq!(r.write(&[3]).unwrap(), 1);
493 fn vec_seek_before_0() {
494 let mut r = Cursor::new(Vec::new());
495 assert!(r.seek(SeekFrom::End(-2)).is_err());
499 #[cfg(target_pointer_width = "32")]
500 fn vec_seek_and_write_past_usize_max() {
501 let mut c = Cursor::new(Vec::new());
502 c.set_position(usize::MAX as u64 + 1);
503 assert!(c.write_all(&[1, 2, 3]).is_err());
507 fn test_partial_eq() {
508 assert_eq!(Cursor::new(Vec::<u8>::new()), Cursor::new(Vec::<u8>::new()));
513 struct AssertEq<T: Eq>(pub T);
515 let _: AssertEq<Cursor<Vec<u8>>> = AssertEq(Cursor::new(Vec::new()));
520 const CURSOR: Cursor<&[u8]> = Cursor::new(&[0]);
521 const _: &&[u8] = CURSOR.get_ref();
522 const _: u64 = CURSOR.position();