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     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);
  26     assert_eq!(
  27         writer
  28             .write_vectored(&[IoSlice::new(&[]), IoSlice::new(&[8, 9]), IoSlice::new(&[10])],)
  29             .unwrap(),
  30         3
  31     );
  32     let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
  33     assert_eq!(&writer.get_ref()[..], b);
  34 }
  35
  36 #[test]
  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);
  43     assert_eq!(
  44         writer
  45             .write_vectored(&[IoSlice::new(&[]), IoSlice::new(&[8, 9]), IoSlice::new(&[10])],)
  46             .unwrap(),
  47         3
  48     );
  49     let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
  50     assert_eq!(&writer.get_ref()[..], b);
  51 }
  52
  53 #[test]
  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);
  64
  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);
  69 }
  70
  71 #[test]
  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);
  77     assert_eq!(
  78         writer.write_vectored(&[IoSlice::new(&[1, 2, 3]), IoSlice::new(&[4, 5, 6, 7]),]).unwrap(),
  79         7,
  80     );
  81     assert_eq!(writer.position(), 8);
  82     assert_eq!(writer.write_vectored(&[]).unwrap(), 0);
  83     assert_eq!(writer.position(), 8);
  84
  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);
  89 }
  90
  91 #[test]
  92 fn test_buf_writer() {
  93     let mut buf = [0 as u8; 9];
  94     {
  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);
 104
 105         assert_eq!(writer.write(&[8, 9]).unwrap(), 1);
 106         assert_eq!(writer.write(&[10]).unwrap(), 0);
 107     }
 108     let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8];
 109     assert_eq!(buf, b);
 110 }
 111
 112 #[test]
 113 fn test_buf_writer_vectored() {
 114     let mut buf = [0 as u8; 9];
 115     {
 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);
 120         assert_eq!(
 121             writer
 122                 .write_vectored(&[IoSlice::new(&[1, 2, 3]), IoSlice::new(&[4, 5, 6, 7])],)
 123                 .unwrap(),
 124             7,
 125         );
 126         assert_eq!(writer.position(), 8);
 127         assert_eq!(writer.write_vectored(&[]).unwrap(), 0);
 128         assert_eq!(writer.position(), 8);
 129
 130         assert_eq!(writer.write_vectored(&[IoSlice::new(&[8, 9])]).unwrap(), 1);
 131         assert_eq!(writer.write_vectored(&[IoSlice::new(&[10])]).unwrap(), 0);
 132     }
 133     let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8];
 134     assert_eq!(buf, b);
 135 }
 136
 137 #[test]
 138 fn test_buf_writer_seek() {
 139     let mut buf = [0 as u8; 8];
 140     {
 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);
 145
 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);
 150
 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);
 155
 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);
 160     }
 161     let b: &[_] = &[1, 3, 2, 0, 0, 0, 0, 4];
 162     assert_eq!(buf, b);
 163 }
 164
 165 #[test]
 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);
 172 }
 173
 174 #[test]
 175 fn test_mem_reader() {
 176     let mut reader = Cursor::new(vec![0, 1, 2, 3, 4, 5, 6, 7]);
 177     let mut buf = [];
 178     assert_eq!(reader.read(&mut buf).unwrap(), 0);
 179     assert_eq!(reader.position(), 0);
 180     let mut buf = [0];
 181     assert_eq!(reader.read(&mut buf).unwrap(), 1);
 182     assert_eq!(reader.position(), 1);
 183     let b: &[_] = &[0];
 184     assert_eq!(buf, b);
 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];
 189     assert_eq!(buf, b);
 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);
 194 }
 195
 196 #[test]
 197 fn test_mem_reader_vectored() {
 198     let mut reader = Cursor::new(vec![0, 1, 2, 3, 4, 5, 6, 7]);
 199     let mut buf = [];
 200     assert_eq!(reader.read_vectored(&mut [IoSliceMut::new(&mut buf)]).unwrap(), 0);
 201     assert_eq!(reader.position(), 0);
 202     let mut buf = [0];
 203     assert_eq!(
 204         reader.read_vectored(&mut [IoSliceMut::new(&mut []), IoSliceMut::new(&mut buf),]).unwrap(),
 205         1,
 206     );
 207     assert_eq!(reader.position(), 1);
 208     let b: &[_] = &[0];
 209     assert_eq!(buf, b);
 210     let mut buf1 = [0; 4];
 211     let mut buf2 = [0; 4];
 212     assert_eq!(
 213         reader
 214             .read_vectored(&mut [IoSliceMut::new(&mut buf1), IoSliceMut::new(&mut buf2),])
 215             .unwrap(),
 216         7,
 217     );
 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);
 223 }
 224
 225 #[test]
 226 fn test_boxed_slice_reader() {
 227     let mut reader = Cursor::new(vec![0, 1, 2, 3, 4, 5, 6, 7].into_boxed_slice());
 228     let mut buf = [];
 229     assert_eq!(reader.read(&mut buf).unwrap(), 0);
 230     assert_eq!(reader.position(), 0);
 231     let mut buf = [0];
 232     assert_eq!(reader.read(&mut buf).unwrap(), 1);
 233     assert_eq!(reader.position(), 1);
 234     let b: &[_] = &[0];
 235     assert_eq!(buf, b);
 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];
 240     assert_eq!(buf, b);
 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);
 245 }
 246
 247 #[test]
 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());
 250     let mut buf = [];
 251     assert_eq!(reader.read_vectored(&mut [IoSliceMut::new(&mut buf)]).unwrap(), 0);
 252     assert_eq!(reader.position(), 0);
 253     let mut buf = [0];
 254     assert_eq!(
 255         reader.read_vectored(&mut [IoSliceMut::new(&mut []), IoSliceMut::new(&mut buf),]).unwrap(),
 256         1,
 257     );
 258     assert_eq!(reader.position(), 1);
 259     let b: &[_] = &[0];
 260     assert_eq!(buf, b);
 261     let mut buf1 = [0; 4];
 262     let mut buf2 = [0; 4];
 263     assert_eq!(
 264         reader
 265             .read_vectored(&mut [IoSliceMut::new(&mut buf1), IoSliceMut::new(&mut buf2)],)
 266             .unwrap(),
 267         7,
 268     );
 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);
 274 }
 275
 276 #[test]
 277 fn read_to_end() {
 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]);
 282 }
 283
 284 #[test]
 285 fn test_slice_reader() {
 286     let in_buf = vec![0, 1, 2, 3, 4, 5, 6, 7];
 287     let reader = &mut &in_buf[..];
 288     let mut buf = [];
 289     assert_eq!(reader.read(&mut buf).unwrap(), 0);
 290     let mut buf = [0];
 291     assert_eq!(reader.read(&mut buf).unwrap(), 1);
 292     assert_eq!(reader.len(), 7);
 293     let b: &[_] = &[0];
 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);
 304 }
 305
 306 #[test]
 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[..];
 310     let mut buf = [];
 311     assert_eq!(reader.read_vectored(&mut [IoSliceMut::new(&mut buf)]).unwrap(), 0);
 312     let mut buf = [0];
 313     assert_eq!(
 314         reader.read_vectored(&mut [IoSliceMut::new(&mut []), IoSliceMut::new(&mut buf),]).unwrap(),
 315         1,
 316     );
 317     assert_eq!(reader.len(), 7);
 318     let b: &[_] = &[0];
 319     assert_eq!(buf, b);
 320     let mut buf1 = [0; 4];
 321     let mut buf2 = [0; 4];
 322     assert_eq!(
 323         reader
 324             .read_vectored(&mut [IoSliceMut::new(&mut buf1), IoSliceMut::new(&mut buf2)],)
 325             .unwrap(),
 326         7,
 327     );
 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);
 333 }
 334
 335 #[test]
 336 fn test_read_exact() {
 337     let in_buf = vec![0, 1, 2, 3, 4, 5, 6, 7];
 338     let reader = &mut &in_buf[..];
 339     let mut buf = [];
 340     assert!(reader.read_exact(&mut buf).is_ok());
 341     let mut buf = [8];
 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);
 349     let mut buf = [0];
 350     assert!(reader.read_exact(&mut buf).is_err());
 351 }
 352
 353 #[test]
 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[..]);
 357     let mut buf = [];
 358     assert_eq!(reader.read(&mut buf).unwrap(), 0);
 359     assert_eq!(reader.position(), 0);
 360     let mut buf = [0];
 361     assert_eq!(reader.read(&mut buf).unwrap(), 1);
 362     assert_eq!(reader.position(), 1);
 363     let b: &[_] = &[0];
 364     assert_eq!(buf, b);
 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];
 369     assert_eq!(buf, b);
 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);
 374 }
 375
 376 #[test]
 377 fn seek_past_end() {
 378     let buf = [0xff];
 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);
 382
 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);
 386
 387     let mut buf = [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);
 391
 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);
 395 }
 396
 397 #[test]
 398 fn seek_past_i64() {
 399     let buf = [0xff];
 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);
 407
 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);
 415
 416     let mut buf = [0];
 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);
 424
 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);
 432 }
 433
 434 #[test]
 435 fn seek_before_0() {
 436     let buf = [0xff];
 437     let mut r = Cursor::new(&buf[..]);
 438     assert!(r.seek(SeekFrom::End(-2)).is_err());
 439
 440     let mut r = Cursor::new(vec![10]);
 441     assert!(r.seek(SeekFrom::End(-2)).is_err());
 442
 443     let mut buf = [0];
 444     let mut r = Cursor::new(&mut buf[..]);
 445     assert!(r.seek(SeekFrom::End(-2)).is_err());
 446
 447     let mut r = Cursor::new(vec![10].into_boxed_slice());
 448     assert!(r.seek(SeekFrom::End(-2)).is_err());
 449 }
 450
 451 #[test]
 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);
 462
 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);
 468
 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);
 473
 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);
 478
 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);
 483 }
 484
 485 #[test]
 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);
 490 }
 491
 492 #[test]
 493 fn vec_seek_before_0() {
 494     let mut r = Cursor::new(Vec::new());
 495     assert!(r.seek(SeekFrom::End(-2)).is_err());
 496 }
 497
 498 #[test]
 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());
 504 }
 505
 506 #[test]
 507 fn test_partial_eq() {
 508     assert_eq!(Cursor::new(Vec::<u8>::new()), Cursor::new(Vec::<u8>::new()));
 509 }
 510
 511 #[test]
 512 fn test_eq() {
 513     struct AssertEq<T: Eq>(pub T);
 514
 515     let _: AssertEq<Cursor<Vec<u8>>> = AssertEq(Cursor::new(Vec::new()));
 516 }
 517
 518 #[allow(dead_code)]
 519 fn const_cursor() {
 520     const CURSOR: Cursor<&[u8]> = Cursor::new(&[0]);
 521     const _: &&[u8] = CURSOR.get_ref();
 522     const _: u64 = CURSOR.position();
 523 }