library/std/src/io/cursor/tests.rs

   1 use crate::io::prelude::*;
   2 use crate::io::{Cursor, IoSlice, IoSliceMut, SeekFrom};
   3
   4 #[test]
   5 fn test_vec_writer() {
   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);
  10     assert_eq!(
  11         writer
  12             .write_vectored(&[IoSlice::new(&[]), IoSlice::new(&[8, 9]), IoSlice::new(&[10])],)
  13             .unwrap(),
  14         3
  15     );
  16     let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
  17     assert_eq!(writer, b);
  18 }
  19
  20 #[test]
  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);
  27     assert_eq!(
  28         writer
  29             .write_vectored(&[IoSlice::new(&[]), IoSlice::new(&[8, 9]), IoSlice::new(&[10])],)
  30             .unwrap(),
  31         3
  32     );
  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);
  36 }
  37
  38 #[test]
  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);
  46 }
  47
  48 #[test]
  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);
  55     assert_eq!(
  56         writer
  57             .write_vectored(&[IoSlice::new(&[]), IoSlice::new(&[8, 9]), IoSlice::new(&[10])],)
  58             .unwrap(),
  59         3
  60     );
  61     let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
  62     assert_eq!(&writer.get_ref()[..], b);
  63 }
  64
  65 fn test_slice_writer<T>(writer: &mut Cursor<T>)
  66 where
  67     T: AsRef<[u8]>,
  68     Cursor<T>: Write,
  69 {
  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);
  78
  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);
  83 }
  84
  85 fn test_slice_writer_vectored<T>(writer: &mut Cursor<T>)
  86 where
  87     T: AsRef<[u8]>,
  88     Cursor<T>: Write,
  89 {
  90     assert_eq!(writer.position(), 0);
  91     assert_eq!(writer.write_vectored(&[IoSlice::new(&[0])]).unwrap(), 1);
  92     assert_eq!(writer.position(), 1);
  93     assert_eq!(
  94         writer.write_vectored(&[IoSlice::new(&[1, 2, 3]), IoSlice::new(&[4, 5, 6, 7]),]).unwrap(),
  95         7,
  96     );
  97     assert_eq!(writer.position(), 8);
  98     assert_eq!(writer.write_vectored(&[]).unwrap(), 0);
  99     assert_eq!(writer.position(), 8);
 100
 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);
 105 }
 106
 107 #[test]
 108 fn test_box_slice_writer() {
 109     let mut writer = Cursor::new(vec![0u8; 9].into_boxed_slice());
 110     test_slice_writer(&mut writer);
 111 }
 112
 113 #[test]
 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);
 117 }
 118
 119 #[test]
 120 fn test_array_writer() {
 121     let mut writer = Cursor::new([0u8; 9]);
 122     test_slice_writer(&mut writer);
 123 }
 124
 125 #[test]
 126 fn test_array_writer_vectored() {
 127     let mut writer = Cursor::new([0u8; 9]);
 128     test_slice_writer_vectored(&mut writer);
 129 }
 130
 131 #[test]
 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);
 136 }
 137
 138 #[test]
 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);
 143 }
 144
 145 #[test]
 146 fn test_buf_writer_seek() {
 147     let mut buf = [0 as u8; 8];
 148     {
 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);
 153
 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);
 158
 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);
 163
 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);
 168     }
 169     let b: &[_] = &[1, 3, 2, 0, 0, 0, 0, 4];
 170     assert_eq!(buf, b);
 171 }
 172
 173 #[test]
 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);
 180 }
 181
 182 #[test]
 183 fn test_mem_reader() {
 184     let mut reader = Cursor::new(vec![0, 1, 2, 3, 4, 5, 6, 7]);
 185     let mut buf = [];
 186     assert_eq!(reader.read(&mut buf).unwrap(), 0);
 187     assert_eq!(reader.position(), 0);
 188     let mut buf = [0];
 189     assert_eq!(reader.read(&mut buf).unwrap(), 1);
 190     assert_eq!(reader.position(), 1);
 191     let b: &[_] = &[0];
 192     assert_eq!(buf, b);
 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];
 197     assert_eq!(buf, b);
 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);
 202 }
 203
 204 #[test]
 205 fn test_mem_reader_vectored() {
 206     let mut reader = Cursor::new(vec![0, 1, 2, 3, 4, 5, 6, 7]);
 207     let mut buf = [];
 208     assert_eq!(reader.read_vectored(&mut [IoSliceMut::new(&mut buf)]).unwrap(), 0);
 209     assert_eq!(reader.position(), 0);
 210     let mut buf = [0];
 211     assert_eq!(
 212         reader.read_vectored(&mut [IoSliceMut::new(&mut []), IoSliceMut::new(&mut buf),]).unwrap(),
 213         1,
 214     );
 215     assert_eq!(reader.position(), 1);
 216     let b: &[_] = &[0];
 217     assert_eq!(buf, b);
 218     let mut buf1 = [0; 4];
 219     let mut buf2 = [0; 4];
 220     assert_eq!(
 221         reader
 222             .read_vectored(&mut [IoSliceMut::new(&mut buf1), IoSliceMut::new(&mut buf2),])
 223             .unwrap(),
 224         7,
 225     );
 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);
 231 }
 232
 233 #[test]
 234 fn test_boxed_slice_reader() {
 235     let mut reader = Cursor::new(vec![0, 1, 2, 3, 4, 5, 6, 7].into_boxed_slice());
 236     let mut buf = [];
 237     assert_eq!(reader.read(&mut buf).unwrap(), 0);
 238     assert_eq!(reader.position(), 0);
 239     let mut buf = [0];
 240     assert_eq!(reader.read(&mut buf).unwrap(), 1);
 241     assert_eq!(reader.position(), 1);
 242     let b: &[_] = &[0];
 243     assert_eq!(buf, b);
 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];
 248     assert_eq!(buf, b);
 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);
 253 }
 254
 255 #[test]
 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());
 258     let mut buf = [];
 259     assert_eq!(reader.read_vectored(&mut [IoSliceMut::new(&mut buf)]).unwrap(), 0);
 260     assert_eq!(reader.position(), 0);
 261     let mut buf = [0];
 262     assert_eq!(
 263         reader.read_vectored(&mut [IoSliceMut::new(&mut []), IoSliceMut::new(&mut buf),]).unwrap(),
 264         1,
 265     );
 266     assert_eq!(reader.position(), 1);
 267     let b: &[_] = &[0];
 268     assert_eq!(buf, b);
 269     let mut buf1 = [0; 4];
 270     let mut buf2 = [0; 4];
 271     assert_eq!(
 272         reader
 273             .read_vectored(&mut [IoSliceMut::new(&mut buf1), IoSliceMut::new(&mut buf2)],)
 274             .unwrap(),
 275         7,
 276     );
 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);
 282 }
 283
 284 #[test]
 285 fn read_to_end() {
 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]);
 290 }
 291
 292 #[test]
 293 fn test_slice_reader() {
 294     let in_buf = vec![0, 1, 2, 3, 4, 5, 6, 7];
 295     let reader = &mut &in_buf[..];
 296     let mut buf = [];
 297     assert_eq!(reader.read(&mut buf).unwrap(), 0);
 298     let mut buf = [0];
 299     assert_eq!(reader.read(&mut buf).unwrap(), 1);
 300     assert_eq!(reader.len(), 7);
 301     let b: &[_] = &[0];
 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);
 312 }
 313
 314 #[test]
 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[..];
 318     let mut buf = [];
 319     assert_eq!(reader.read_vectored(&mut [IoSliceMut::new(&mut buf)]).unwrap(), 0);
 320     let mut buf = [0];
 321     assert_eq!(
 322         reader.read_vectored(&mut [IoSliceMut::new(&mut []), IoSliceMut::new(&mut buf),]).unwrap(),
 323         1,
 324     );
 325     assert_eq!(reader.len(), 7);
 326     let b: &[_] = &[0];
 327     assert_eq!(buf, b);
 328     let mut buf1 = [0; 4];
 329     let mut buf2 = [0; 4];
 330     assert_eq!(
 331         reader
 332             .read_vectored(&mut [IoSliceMut::new(&mut buf1), IoSliceMut::new(&mut buf2)],)
 333             .unwrap(),
 334         7,
 335     );
 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);
 341 }
 342
 343 #[test]
 344 fn test_read_exact() {
 345     let in_buf = vec![0, 1, 2, 3, 4, 5, 6, 7];
 346     let reader = &mut &in_buf[..];
 347     let mut buf = [];
 348     assert!(reader.read_exact(&mut buf).is_ok());
 349     let mut buf = [8];
 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);
 357     let mut buf = [0];
 358     assert!(reader.read_exact(&mut buf).is_err());
 359 }
 360
 361 #[test]
 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[..]);
 365     let mut buf = [];
 366     assert_eq!(reader.read(&mut buf).unwrap(), 0);
 367     assert_eq!(reader.position(), 0);
 368     let mut buf = [0];
 369     assert_eq!(reader.read(&mut buf).unwrap(), 1);
 370     assert_eq!(reader.position(), 1);
 371     let b: &[_] = &[0];
 372     assert_eq!(buf, b);
 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];
 377     assert_eq!(buf, b);
 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);
 382 }
 383
 384 #[test]
 385 fn seek_past_end() {
 386     let buf = [0xff];
 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);
 390
 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);
 394
 395     let mut buf = [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);
 399
 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);
 403 }
 404
 405 #[test]
 406 fn seek_past_i64() {
 407     let buf = [0xff];
 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);
 415
 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);
 423
 424     let mut buf = [0];
 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);
 432
 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);
 440 }
 441
 442 #[test]
 443 fn seek_before_0() {
 444     let buf = [0xff];
 445     let mut r = Cursor::new(&buf[..]);
 446     assert!(r.seek(SeekFrom::End(-2)).is_err());
 447
 448     let mut r = Cursor::new(vec![10]);
 449     assert!(r.seek(SeekFrom::End(-2)).is_err());
 450
 451     let mut buf = [0];
 452     let mut r = Cursor::new(&mut buf[..]);
 453     assert!(r.seek(SeekFrom::End(-2)).is_err());
 454
 455     let mut r = Cursor::new(vec![10].into_boxed_slice());
 456     assert!(r.seek(SeekFrom::End(-2)).is_err());
 457 }
 458
 459 #[test]
 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);
 470
 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);
 476
 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);
 481
 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);
 486
 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);
 491 }
 492
 493 #[test]
 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);
 498 }
 499
 500 #[test]
 501 fn vec_seek_before_0() {
 502     let mut r = Cursor::new(Vec::new());
 503     assert!(r.seek(SeekFrom::End(-2)).is_err());
 504 }
 505
 506 #[test]
 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());
 512 }
 513
 514 #[test]
 515 fn test_partial_eq() {
 516     assert_eq!(Cursor::new(Vec::<u8>::new()), Cursor::new(Vec::<u8>::new()));
 517 }
 518
 519 #[test]
 520 fn test_eq() {
 521     struct AssertEq<T: Eq>(pub T);
 522
 523     let _: AssertEq<Cursor<Vec<u8>>> = AssertEq(Cursor::new(Vec::new()));
 524 }
 525
 526 #[allow(dead_code)]
 527 fn const_cursor() {
 528     const CURSOR: Cursor<&[u8]> = Cursor::new(&[0]);
 529     const _: &&[u8] = CURSOR.get_ref();
 530     const _: u64 = CURSOR.position();
 531 }
 532
 533 #[bench]
 534 fn bench_write_vec(b: &mut test::Bencher) {
 535     let slice = &[1; 128];
 536
 537     b.iter(|| {
 538         let mut buf = b"some random data to overwrite".to_vec();
 539         let mut cursor = Cursor::new(&mut buf);
 540
 541         let _ = cursor.write_all(slice);
 542         test::black_box(&cursor);
 543     })
 544 }
 545
 546 #[bench]
 547 fn bench_write_vec_vectored(b: &mut test::Bencher) {
 548     let slices = [
 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]),
 557     ];
 558
 559     b.iter(|| {
 560         let mut buf = b"some random data to overwrite".to_vec();
 561         let mut cursor = Cursor::new(&mut buf);
 562
 563         let mut slices = slices;
 564         let _ = cursor.write_all_vectored(&mut slices);
 565         test::black_box(&cursor);
 566     })
 567 }