A better Rust ATProto crate
1use crate::io::prelude::*;
2use crate::io::{self, Error, ErrorKind, Initializer, SeekFrom};
3
4use core::cmp;
5
6#[cfg(feature = "alloc")]
7use core::convert::TryInto;
8
9#[cfg(feature = "alloc")]
10use crate::alloc::{boxed::Box, vec::Vec};
11
12/// A `Cursor` wraps an in-memory buffer and provides it with a
13/// [`Seek`] implementation.
14///
15/// `Cursor`s are used with in-memory buffers, anything implementing
16/// `AsRef<[u8]>`, to allow them to implement [`Read`] and/or [`Write`],
17/// allowing these buffers to be used anywhere you might use a reader or writer
18/// that does actual I/O.
19///
20/// The standard library implements some I/O traits on various types which
21/// are commonly used as a buffer, like `Cursor<`[`Vec`]`<u8>>` and
22/// `Cursor<`[`&[u8]`][bytes]`>`.
23///
24/// [`Seek`]: trait.Seek.html
25/// [`Read`]: trait.Read.html
26/// [`Write`]: trait.Write.html
27/// [`Vec`]: ../../alloc/vec/struct.Vec.html
28/// [bytes]: ../../core/primitive.slice.html
29#[derive(Clone, Debug, Default)]
30pub struct Cursor<T> {
31 inner: T,
32 pos: u64,
33}
34
35impl<T> Cursor<T> {
36 /// Creates a new cursor wrapping the provided underlying in-memory buffer.
37 ///
38 /// Cursor initial position is `0` even if underlying buffer (e.g., `Vec`)
39 /// is not empty. So writing to cursor starts with overwriting `Vec`
40 /// content, not with appending to it.
41 pub fn new(inner: T) -> Cursor<T> {
42 Cursor { pos: 0, inner }
43 }
44
45 /// Consumes this cursor, returning the underlying value.
46 pub fn into_inner(self) -> T {
47 self.inner
48 }
49
50 /// Gets a reference to the underlying value in this cursor.
51 pub fn get_ref(&self) -> &T {
52 &self.inner
53 }
54
55 /// Gets a mutable reference to the underlying value in this cursor.
56 ///
57 /// Care should be taken to avoid modifying the internal I/O state of the
58 /// underlying value as it may corrupt this cursor's position.
59 pub fn get_mut(&mut self) -> &mut T {
60 &mut self.inner
61 }
62
63 /// Returns the current position of this cursor.
64 pub fn position(&self) -> u64 {
65 self.pos
66 }
67
68 /// Sets the position of this cursor.
69 pub fn set_position(&mut self, pos: u64) {
70 self.pos = pos;
71 }
72}
73
74impl<T> io::Seek for Cursor<T>
75where
76 T: AsRef<[u8]>,
77{
78 fn seek(&mut self, style: SeekFrom) -> io::Result<u64> {
79 let (base_pos, offset) = match style {
80 SeekFrom::Start(n) => {
81 self.pos = n;
82 return Ok(n);
83 }
84 SeekFrom::End(n) => (self.inner.as_ref().len() as u64, n),
85 SeekFrom::Current(n) => (self.pos, n),
86 };
87 let new_pos = if offset >= 0 {
88 base_pos.checked_add(offset as u64)
89 } else {
90 base_pos.checked_sub((offset.wrapping_neg()) as u64)
91 };
92 match new_pos {
93 Some(n) => {
94 self.pos = n;
95 Ok(self.pos)
96 }
97 None => Err(Error::new(
98 ErrorKind::InvalidInput,
99 "invalid seek to a negative or overflowing position".into(),
100 )),
101 }
102 }
103
104 fn stream_len(&mut self) -> io::Result<u64> {
105 Ok(self.inner.as_ref().len() as u64)
106 }
107
108 fn stream_position(&mut self) -> io::Result<u64> {
109 Ok(self.pos)
110 }
111}
112
113impl<T> Read for Cursor<T>
114where
115 T: AsRef<[u8]>,
116{
117 fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
118 let n = Read::read(&mut self.fill_buf()?, buf)?;
119 self.pos += n as u64;
120 Ok(n)
121 }
122
123 fn read_exact(&mut self, buf: &mut [u8]) -> io::Result<()> {
124 let n = buf.len();
125 Read::read_exact(&mut self.fill_buf()?, buf)?;
126 self.pos += n as u64;
127 Ok(())
128 }
129
130 #[inline]
131 unsafe fn initializer(&self) -> Initializer {
132 unsafe { Initializer::nop() }
133 }
134}
135
136impl<T> BufRead for Cursor<T>
137where
138 T: AsRef<[u8]>,
139{
140 fn fill_buf(&mut self) -> io::Result<&[u8]> {
141 let amt = cmp::min(self.pos, self.inner.as_ref().len() as u64);
142 Ok(&self.inner.as_ref()[(amt as usize)..])
143 }
144 fn consume(&mut self, amt: usize) {
145 self.pos += amt as u64;
146 }
147}
148
149// Non-resizing write implementation
150#[inline]
151fn slice_write(pos_mut: &mut u64, slice: &mut [u8], buf: &[u8]) -> io::Result<usize> {
152 let pos = cmp::min(*pos_mut, slice.len() as u64);
153 let amt = (&mut slice[(pos as usize)..]).write(buf)?;
154 *pos_mut += amt as u64;
155 Ok(amt)
156}
157
158// Resizing write implementation
159#[cfg(feature = "alloc")]
160fn vec_write(pos_mut: &mut u64, vec: &mut Vec<u8>, buf: &[u8]) -> io::Result<usize> {
161 let pos: usize = (*pos_mut).try_into().map_err(|_| {
162 Error::new(
163 ErrorKind::InvalidInput,
164 "cursor position exceeds maximum possible vector length".into(),
165 )
166 })?;
167 // Make sure the internal buffer is as least as big as where we
168 // currently are
169 let len = vec.len();
170 if len < pos {
171 // use `resize` so that the zero filling is as efficient as possible
172 vec.resize(pos, 0);
173 }
174 // Figure out what bytes will be used to overwrite what's currently
175 // there (left), and what will be appended on the end (right)
176 {
177 let space = vec.len() - pos;
178 let (left, right) = buf.split_at(cmp::min(space, buf.len()));
179 vec[pos..pos + left.len()].copy_from_slice(left);
180 vec.extend_from_slice(right);
181 }
182
183 // Bump us forward
184 *pos_mut = (pos + buf.len()) as u64;
185 Ok(buf.len())
186}
187
188impl Write for Cursor<&mut [u8]> {
189 #[inline]
190 fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
191 slice_write(&mut self.pos, self.inner, buf)
192 }
193
194 #[inline]
195 fn flush(&mut self) -> io::Result<()> {
196 Ok(())
197 }
198}
199
200#[cfg(feature = "alloc")]
201impl Write for Cursor<&mut Vec<u8>> {
202 fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
203 vec_write(&mut self.pos, self.inner, buf)
204 }
205
206 #[inline]
207 fn flush(&mut self) -> io::Result<()> {
208 Ok(())
209 }
210}
211
212#[cfg(feature = "alloc")]
213impl Write for Cursor<Vec<u8>> {
214 fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
215 vec_write(&mut self.pos, &mut self.inner, buf)
216 }
217
218 #[inline]
219 fn flush(&mut self) -> io::Result<()> {
220 Ok(())
221 }
222}
223
224#[cfg(feature = "alloc")]
225impl Write for Cursor<Box<[u8]>> {
226 #[inline]
227 fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
228 slice_write(&mut self.pos, &mut self.inner, buf)
229 }
230
231 #[inline]
232 fn flush(&mut self) -> io::Result<()> {
233 Ok(())
234 }
235}
236
237#[cfg(all(test, not(loom)))]
238mod tests {
239 #[cfg(feature = "alloc")]
240 use crate::alloc::{vec, vec::Vec};
241 use crate::io::prelude::*;
242 use crate::io::{Cursor, SeekFrom};
243
244 #[test]
245 #[cfg(feature = "alloc")]
246 fn test_vec_writer() {
247 let mut writer = Vec::new();
248 assert_eq!(writer.write(&[0]).unwrap(), 1);
249 assert_eq!(writer.write(&[1, 2, 3]).unwrap(), 3);
250 assert_eq!(writer.write(&[4, 5, 6, 7]).unwrap(), 4);
251 let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7];
252 assert_eq!(writer, b);
253 }
254
255 #[test]
256 #[cfg(feature = "alloc")]
257 fn test_mem_writer() {
258 let mut writer = Cursor::new(Vec::new());
259 assert_eq!(writer.write(&[0]).unwrap(), 1);
260 assert_eq!(writer.write(&[1, 2, 3]).unwrap(), 3);
261 assert_eq!(writer.write(&[4, 5, 6, 7]).unwrap(), 4);
262 let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7];
263 assert_eq!(&writer.get_ref()[..], b);
264 }
265
266 #[test]
267 #[cfg(feature = "alloc")]
268 fn test_mem_mut_writer() {
269 let mut vec = Vec::new();
270 let mut writer = Cursor::new(&mut vec);
271 assert_eq!(writer.write(&[0]).unwrap(), 1);
272 assert_eq!(writer.write(&[1, 2, 3]).unwrap(), 3);
273 assert_eq!(writer.write(&[4, 5, 6, 7]).unwrap(), 4);
274 let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7];
275 assert_eq!(&writer.get_ref()[..], b);
276 }
277
278 #[test]
279 #[cfg(feature = "alloc")]
280 fn test_box_slice_writer() {
281 let mut writer = Cursor::new(vec![0u8; 9].into_boxed_slice());
282 assert_eq!(writer.position(), 0);
283 assert_eq!(writer.write(&[0]).unwrap(), 1);
284 assert_eq!(writer.position(), 1);
285 assert_eq!(writer.write(&[1, 2, 3]).unwrap(), 3);
286 assert_eq!(writer.write(&[4, 5, 6, 7]).unwrap(), 4);
287 assert_eq!(writer.position(), 8);
288 assert_eq!(writer.write(&[]).unwrap(), 0);
289 assert_eq!(writer.position(), 8);
290
291 assert_eq!(writer.write(&[8, 9]).unwrap(), 1);
292 assert_eq!(writer.write(&[10]).unwrap(), 0);
293 let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8];
294 assert_eq!(&**writer.get_ref(), b);
295 }
296
297 #[test]
298 fn test_buf_writer() {
299 let mut buf = [0u8; 9];
300 {
301 let mut writer = Cursor::new(&mut buf[..]);
302 assert_eq!(writer.position(), 0);
303 assert_eq!(writer.write(&[0]).unwrap(), 1);
304 assert_eq!(writer.position(), 1);
305 assert_eq!(writer.write(&[1, 2, 3]).unwrap(), 3);
306 assert_eq!(writer.write(&[4, 5, 6, 7]).unwrap(), 4);
307 assert_eq!(writer.position(), 8);
308 assert_eq!(writer.write(&[]).unwrap(), 0);
309 assert_eq!(writer.position(), 8);
310
311 assert_eq!(writer.write(&[8, 9]).unwrap(), 1);
312 assert_eq!(writer.write(&[10]).unwrap(), 0);
313 }
314 let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8];
315 assert_eq!(buf, b);
316 }
317
318 #[test]
319 fn test_buf_writer_seek() {
320 let mut buf = [0u8; 8];
321 {
322 let mut writer = Cursor::new(&mut buf[..]);
323 assert_eq!(writer.position(), 0);
324 assert_eq!(writer.write(&[1]).unwrap(), 1);
325 assert_eq!(writer.position(), 1);
326
327 assert_eq!(writer.seek(SeekFrom::Start(2)).unwrap(), 2);
328 assert_eq!(writer.position(), 2);
329 assert_eq!(writer.write(&[2]).unwrap(), 1);
330 assert_eq!(writer.position(), 3);
331
332 assert_eq!(writer.seek(SeekFrom::Current(-2)).unwrap(), 1);
333 assert_eq!(writer.position(), 1);
334 assert_eq!(writer.write(&[3]).unwrap(), 1);
335 assert_eq!(writer.position(), 2);
336
337 assert_eq!(writer.seek(SeekFrom::End(-1)).unwrap(), 7);
338 assert_eq!(writer.position(), 7);
339 assert_eq!(writer.write(&[4]).unwrap(), 1);
340 assert_eq!(writer.position(), 8);
341 }
342 let b: &[_] = &[1, 3, 2, 0, 0, 0, 0, 4];
343 assert_eq!(buf, b);
344 }
345
346 #[test]
347 fn test_buf_writer_error() {
348 let mut buf = [0u8; 2];
349 let mut writer = Cursor::new(&mut buf[..]);
350 assert_eq!(writer.write(&[0]).unwrap(), 1);
351 assert_eq!(writer.write(&[0, 0]).unwrap(), 1);
352 assert_eq!(writer.write(&[0, 0]).unwrap(), 0);
353 }
354
355 #[test]
356 #[cfg(feature = "alloc")]
357 fn test_mem_reader() {
358 let mut reader = Cursor::new(vec![0, 1, 2, 3, 4, 5, 6, 7]);
359 let mut buf = [];
360 assert_eq!(reader.read(&mut buf).unwrap(), 0);
361 assert_eq!(reader.position(), 0);
362 let mut buf = [0];
363 assert_eq!(reader.read(&mut buf).unwrap(), 1);
364 assert_eq!(reader.position(), 1);
365 let b: &[_] = &[0];
366 assert_eq!(buf, b);
367 let mut buf = [0; 4];
368 assert_eq!(reader.read(&mut buf).unwrap(), 4);
369 assert_eq!(reader.position(), 5);
370 let b: &[_] = &[1, 2, 3, 4];
371 assert_eq!(buf, b);
372 assert_eq!(reader.read(&mut buf).unwrap(), 3);
373 let b: &[_] = &[5, 6, 7];
374 assert_eq!(&buf[..3], b);
375 assert_eq!(reader.read(&mut buf).unwrap(), 0);
376 }
377
378 #[test]
379 #[cfg(feature = "alloc")]
380 fn test_boxed_slice_reader() {
381 let mut reader = Cursor::new(vec![0, 1, 2, 3, 4, 5, 6, 7].into_boxed_slice());
382 let mut buf = [];
383 assert_eq!(reader.read(&mut buf).unwrap(), 0);
384 assert_eq!(reader.position(), 0);
385 let mut buf = [0];
386 assert_eq!(reader.read(&mut buf).unwrap(), 1);
387 assert_eq!(reader.position(), 1);
388 let b: &[_] = &[0];
389 assert_eq!(buf, b);
390 let mut buf = [0; 4];
391 assert_eq!(reader.read(&mut buf).unwrap(), 4);
392 assert_eq!(reader.position(), 5);
393 let b: &[_] = &[1, 2, 3, 4];
394 assert_eq!(buf, b);
395 assert_eq!(reader.read(&mut buf).unwrap(), 3);
396 let b: &[_] = &[5, 6, 7];
397 assert_eq!(&buf[..3], b);
398 assert_eq!(reader.read(&mut buf).unwrap(), 0);
399 }
400
401 #[test]
402 #[cfg(feature = "alloc")]
403 fn read_to_end() {
404 let mut reader = Cursor::new(vec![0, 1, 2, 3, 4, 5, 6, 7]);
405 let mut v = Vec::new();
406 reader.read_to_end(&mut v).unwrap();
407 assert_eq!(v, [0, 1, 2, 3, 4, 5, 6, 7]);
408 }
409
410 #[test]
411 #[cfg(feature = "alloc")]
412 fn test_slice_reader() {
413 let in_buf = [0, 1, 2, 3, 4, 5, 6, 7];
414 let reader = &mut &in_buf[..];
415 let mut buf = [];
416 assert_eq!(reader.read(&mut buf).unwrap(), 0);
417 let mut buf = [0];
418 assert_eq!(reader.read(&mut buf).unwrap(), 1);
419 assert_eq!(reader.len(), 7);
420 let b: &[_] = &[0];
421 assert_eq!(&buf[..], b);
422 let mut buf = [0; 4];
423 assert_eq!(reader.read(&mut buf).unwrap(), 4);
424 assert_eq!(reader.len(), 3);
425 let b: &[_] = &[1, 2, 3, 4];
426 assert_eq!(&buf[..], b);
427 assert_eq!(reader.read(&mut buf).unwrap(), 3);
428 let b: &[_] = &[5, 6, 7];
429 assert_eq!(&buf[..3], b);
430 assert_eq!(reader.read(&mut buf).unwrap(), 0);
431 }
432
433 #[test]
434 #[cfg(feature = "alloc")]
435 fn test_read_exact() {
436 let in_buf = [0, 1, 2, 3, 4, 5, 6, 7];
437 let reader = &mut &in_buf[..];
438 let mut buf = [];
439 reader
440 .read_exact(&mut buf)
441 .expect("read_exact must succeed");
442 let mut buf = [8];
443 reader
444 .read_exact(&mut buf)
445 .expect("read_exact must succeed");
446 assert_eq!(buf[0], 0);
447 assert_eq!(reader.len(), 7);
448 let mut buf = [0, 0, 0, 0, 0, 0, 0];
449 reader
450 .read_exact(&mut buf)
451 .expect("read_exact must succeed");
452 assert_eq!(buf, [1, 2, 3, 4, 5, 6, 7]);
453 assert_eq!(reader.len(), 0);
454 let mut buf = [0];
455 reader
456 .read_exact(&mut buf)
457 .expect_err("read_exact on empty buffer must fail");
458 }
459
460 #[test]
461 #[cfg(feature = "alloc")]
462 fn test_buf_reader() {
463 let in_buf = [0, 1, 2, 3, 4, 5, 6, 7];
464 let mut reader = Cursor::new(&in_buf[..]);
465 let mut buf = [];
466 assert_eq!(reader.read(&mut buf).unwrap(), 0);
467 assert_eq!(reader.position(), 0);
468 let mut buf = [0];
469 assert_eq!(reader.read(&mut buf).unwrap(), 1);
470 assert_eq!(reader.position(), 1);
471 let b: &[_] = &[0];
472 assert_eq!(buf, b);
473 let mut buf = [0; 4];
474 assert_eq!(reader.read(&mut buf).unwrap(), 4);
475 assert_eq!(reader.position(), 5);
476 let b: &[_] = &[1, 2, 3, 4];
477 assert_eq!(buf, b);
478 assert_eq!(reader.read(&mut buf).unwrap(), 3);
479 let b: &[_] = &[5, 6, 7];
480 assert_eq!(&buf[..3], b);
481 assert_eq!(reader.read(&mut buf).unwrap(), 0);
482 }
483
484 #[test]
485 fn seek_past_end() {
486 let buf = [0xff];
487 let mut r = Cursor::new(&buf[..]);
488 assert_eq!(r.seek(SeekFrom::Start(10)).unwrap(), 10);
489 assert_eq!(r.read(&mut [0]).unwrap(), 0);
490
491 let mut r = Cursor::new(vec![10]);
492 assert_eq!(r.seek(SeekFrom::Start(10)).unwrap(), 10);
493 assert_eq!(r.read(&mut [0]).unwrap(), 0);
494
495 let mut buf = [0];
496 let mut r = Cursor::new(&mut buf[..]);
497 assert_eq!(r.seek(SeekFrom::Start(10)).unwrap(), 10);
498 assert_eq!(r.write(&[3]).unwrap(), 0);
499
500 #[cfg(feature = "alloc")]
501 {
502 let mut r = Cursor::new(vec![10].into_boxed_slice());
503 assert_eq!(r.seek(SeekFrom::Start(10)).unwrap(), 10);
504 assert_eq!(r.write(&[3]).unwrap(), 0);
505 }
506 }
507
508 #[test]
509 fn seek_past_i64() {
510 let buf = [0xff];
511 let mut r = Cursor::new(&buf[..]);
512 assert_eq!(r.seek(SeekFrom::Start(6)).unwrap(), 6);
513 assert_eq!(
514 r.seek(SeekFrom::Current(0x7ffffffffffffff0)).unwrap(),
515 0x7ffffffffffffff6
516 );
517 assert_eq!(r.seek(SeekFrom::Current(0x10)).unwrap(), 0x8000000000000006);
518 assert_eq!(r.seek(SeekFrom::Current(0)).unwrap(), 0x8000000000000006);
519 r.seek(SeekFrom::Current(0x7ffffffffffffffd))
520 .expect_err("`seek` with big offset must fail");
521 assert_eq!(r.seek(SeekFrom::Current(-0x8000000000000000)).unwrap(), 6);
522
523 let mut r = Cursor::new(vec![10]);
524 assert_eq!(r.seek(SeekFrom::Start(6)).unwrap(), 6);
525 assert_eq!(
526 r.seek(SeekFrom::Current(0x7ffffffffffffff0)).unwrap(),
527 0x7ffffffffffffff6
528 );
529 assert_eq!(r.seek(SeekFrom::Current(0x10)).unwrap(), 0x8000000000000006);
530 assert_eq!(r.seek(SeekFrom::Current(0)).unwrap(), 0x8000000000000006);
531 r.seek(SeekFrom::Current(0x7ffffffffffffffd))
532 .expect_err("`seek` with big offset must fail");
533 assert_eq!(r.seek(SeekFrom::Current(-0x8000000000000000)).unwrap(), 6);
534
535 let mut buf = [0];
536 let mut r = Cursor::new(&mut buf[..]);
537 assert_eq!(r.seek(SeekFrom::Start(6)).unwrap(), 6);
538 assert_eq!(
539 r.seek(SeekFrom::Current(0x7ffffffffffffff0)).unwrap(),
540 0x7ffffffffffffff6
541 );
542 assert_eq!(r.seek(SeekFrom::Current(0x10)).unwrap(), 0x8000000000000006);
543 assert_eq!(r.seek(SeekFrom::Current(0)).unwrap(), 0x8000000000000006);
544 r.seek(SeekFrom::Current(0x7ffffffffffffffd))
545 .expect_err("`seek` with big offset must fail");
546 assert_eq!(r.seek(SeekFrom::Current(-0x8000000000000000)).unwrap(), 6);
547
548 #[cfg(feature = "alloc")]
549 {
550 let mut r = Cursor::new(vec![10].into_boxed_slice());
551 assert_eq!(r.seek(SeekFrom::Start(6)).unwrap(), 6);
552 assert_eq!(
553 r.seek(SeekFrom::Current(0x7ffffffffffffff0)).unwrap(),
554 0x7ffffffffffffff6
555 );
556 assert_eq!(r.seek(SeekFrom::Current(0x10)).unwrap(), 0x8000000000000006);
557 assert_eq!(r.seek(SeekFrom::Current(0)).unwrap(), 0x8000000000000006);
558 r.seek(SeekFrom::Current(0x7ffffffffffffffd))
559 .expect_err("`seek` with big offset must fail");
560 assert_eq!(r.seek(SeekFrom::Current(-0x8000000000000000)).unwrap(), 6);
561 }
562 }
563
564 #[test]
565 fn seek_before_0() {
566 let buf = [0xff];
567 let mut r = Cursor::new(&buf[..]);
568 r.seek(SeekFrom::End(-2))
569 .expect_err("`seek` before 0 must fail");
570
571 let mut r = Cursor::new(vec![10]);
572 r.seek(SeekFrom::End(-2))
573 .expect_err("`seek` before 0 must fail");
574
575 let mut buf = [0];
576 let mut r = Cursor::new(&mut buf[..]);
577 r.seek(SeekFrom::End(-2))
578 .expect_err("`seek` before 0 must fail");
579
580 #[cfg(feature = "alloc")]
581 {
582 let mut r = Cursor::new(vec![10].into_boxed_slice());
583 r.seek(SeekFrom::End(-2))
584 .expect_err("`seek` before 0 must fail");
585 }
586 }
587
588 #[test]
589 #[cfg(feature = "alloc")]
590 fn test_seekable_mem_writer() {
591 let mut writer = Cursor::new(Vec::<u8>::new());
592 assert_eq!(writer.position(), 0);
593 assert_eq!(writer.write(&[0]).unwrap(), 1);
594 assert_eq!(writer.position(), 1);
595 assert_eq!(writer.write(&[1, 2, 3]).unwrap(), 3);
596 assert_eq!(writer.write(&[4, 5, 6, 7]).unwrap(), 4);
597 assert_eq!(writer.position(), 8);
598 let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7];
599 assert_eq!(&writer.get_ref()[..], b);
600
601 assert_eq!(writer.seek(SeekFrom::Start(0)).unwrap(), 0);
602 assert_eq!(writer.position(), 0);
603 assert_eq!(writer.write(&[3, 4]).unwrap(), 2);
604 let b: &[_] = &[3, 4, 2, 3, 4, 5, 6, 7];
605 assert_eq!(&writer.get_ref()[..], b);
606
607 assert_eq!(writer.seek(SeekFrom::Current(1)).unwrap(), 3);
608 assert_eq!(writer.write(&[0, 1]).unwrap(), 2);
609 let b: &[_] = &[3, 4, 2, 0, 1, 5, 6, 7];
610 assert_eq!(&writer.get_ref()[..], b);
611
612 assert_eq!(writer.seek(SeekFrom::End(-1)).unwrap(), 7);
613 assert_eq!(writer.write(&[1, 2]).unwrap(), 2);
614 let b: &[_] = &[3, 4, 2, 0, 1, 5, 6, 1, 2];
615 assert_eq!(&writer.get_ref()[..], b);
616
617 assert_eq!(writer.seek(SeekFrom::End(1)).unwrap(), 10);
618 assert_eq!(writer.write(&[1]).unwrap(), 1);
619 let b: &[_] = &[3, 4, 2, 0, 1, 5, 6, 1, 2, 0, 1];
620 assert_eq!(&writer.get_ref()[..], b);
621 }
622
623 #[test]
624 #[cfg(feature = "alloc")]
625 fn vec_seek_past_end() {
626 let mut r = Cursor::new(Vec::new());
627 assert_eq!(r.seek(SeekFrom::Start(10)).unwrap(), 10);
628 assert_eq!(r.write(&[3]).unwrap(), 1);
629 }
630
631 #[test]
632 #[cfg(feature = "alloc")]
633 fn vec_seek_before_0() {
634 let mut r = Cursor::new(Vec::new());
635 r.seek(SeekFrom::End(-2))
636 .expect_err("`seek` before 0 must fail");
637 }
638
639 #[test]
640 #[cfg(target_pointer_width = "32")]
641 #[cfg(feature = "alloc")]
642 fn vec_seek_and_write_past_usize_max() {
643 let mut c = Cursor::new(Vec::new());
644 c.set_position(<usize>::max_value() as u64 + 1);
645 assert!(c.write_all(&[1, 2, 3]).is_err());
646 }
647}