]>
Commit | Line | Data |
---|---|---|
532ac7d7 XL |
1 | use crate::io::prelude::*; |
2 | ||
3 | use crate::cmp; | |
dfeec247 | 4 | use crate::io::{self, Error, ErrorKind, Initializer, IoSlice, IoSliceMut, SeekFrom}; |
85aaf69f | 5 | |
8faf50e0 | 6 | use core::convert::TryInto; |
85aaf69f | 7 | |
8faf50e0 | 8 | /// A `Cursor` wraps an in-memory buffer and provides it with a |
c30ab7b3 | 9 | /// [`Seek`] implementation. |
85aaf69f | 10 | /// |
8faf50e0 XL |
11 | /// `Cursor`s are used with in-memory buffers, anything implementing |
12 | /// `AsRef<[u8]>`, to allow them to implement [`Read`] and/or [`Write`], | |
13 | /// allowing these buffers to be used anywhere you might use a reader or writer | |
14 | /// that does actual I/O. | |
85aaf69f | 15 | /// |
c1a9b12d | 16 | /// The standard library implements some I/O traits on various types which |
c30ab7b3 SL |
17 | /// are commonly used as a buffer, like `Cursor<`[`Vec`]`<u8>>` and |
18 | /// `Cursor<`[`&[u8]`][bytes]`>`. | |
c1a9b12d SL |
19 | /// |
20 | /// # Examples | |
21 | /// | |
c30ab7b3 | 22 | /// We may want to write bytes to a [`File`] in our production |
c1a9b12d SL |
23 | /// code, but use an in-memory buffer in our tests. We can do this with |
24 | /// `Cursor`: | |
25 | /// | |
c30ab7b3 SL |
26 | /// [`Seek`]: trait.Seek.html |
27 | /// [`Read`]: ../../std/io/trait.Read.html | |
28 | /// [`Write`]: ../../std/io/trait.Write.html | |
29 | /// [`Vec`]: ../../std/vec/struct.Vec.html | |
30 | /// [bytes]: ../../std/primitive.slice.html | |
31 | /// [`File`]: ../fs/struct.File.html | |
c1a9b12d SL |
32 | /// |
33 | /// ```no_run | |
34 | /// use std::io::prelude::*; | |
35 | /// use std::io::{self, SeekFrom}; | |
36 | /// use std::fs::File; | |
37 | /// | |
38 | /// // a library function we've written | |
39 | /// fn write_ten_bytes_at_end<W: Write + Seek>(writer: &mut W) -> io::Result<()> { | |
32a655c1 | 40 | /// writer.seek(SeekFrom::End(-10))?; |
c1a9b12d SL |
41 | /// |
42 | /// for i in 0..10 { | |
32a655c1 | 43 | /// writer.write(&[i])?; |
c1a9b12d SL |
44 | /// } |
45 | /// | |
46 | /// // all went well | |
47 | /// Ok(()) | |
48 | /// } | |
49 | /// | |
50 | /// # fn foo() -> io::Result<()> { | |
51 | /// // Here's some code that uses this library function. | |
52 | /// // | |
53 | /// // We might want to use a BufReader here for efficiency, but let's | |
54 | /// // keep this example focused. | |
32a655c1 | 55 | /// let mut file = File::create("foo.txt")?; |
c1a9b12d | 56 | /// |
32a655c1 | 57 | /// write_ten_bytes_at_end(&mut file)?; |
c1a9b12d SL |
58 | /// # Ok(()) |
59 | /// # } | |
60 | /// | |
61 | /// // now let's write a test | |
62 | /// #[test] | |
63 | /// fn test_writes_bytes() { | |
3b2f2976 | 64 | /// // setting up a real File is much slower than an in-memory buffer, |
c1a9b12d SL |
65 | /// // let's use a cursor instead |
66 | /// use std::io::Cursor; | |
67 | /// let mut buff = Cursor::new(vec![0; 15]); | |
68 | /// | |
b039eaaf | 69 | /// write_ten_bytes_at_end(&mut buff).unwrap(); |
c1a9b12d SL |
70 | /// |
71 | /// assert_eq!(&buff.get_ref()[5..15], &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]); | |
72 | /// } | |
73 | /// ``` | |
c34b1796 | 74 | #[stable(feature = "rust1", since = "1.0.0")] |
dfeec247 | 75 | #[derive(Clone, Debug, Default, Eq, PartialEq)] |
85aaf69f SL |
76 | pub struct Cursor<T> { |
77 | inner: T, | |
78 | pos: u64, | |
79 | } | |
80 | ||
81 | impl<T> Cursor<T> { | |
8faf50e0 | 82 | /// Creates a new cursor wrapping the provided underlying in-memory buffer. |
c1a9b12d | 83 | /// |
0731742a | 84 | /// Cursor initial position is `0` even if underlying buffer (e.g., `Vec`) |
8faf50e0 XL |
85 | /// is not empty. So writing to cursor starts with overwriting `Vec` |
86 | /// content, not with appending to it. | |
cc61c64b | 87 | /// |
c1a9b12d SL |
88 | /// # Examples |
89 | /// | |
90 | /// ``` | |
91 | /// use std::io::Cursor; | |
92 | /// | |
93 | /// let buff = Cursor::new(Vec::new()); | |
94 | /// # fn force_inference(_: &Cursor<Vec<u8>>) {} | |
95 | /// # force_inference(&buff); | |
96 | /// ``` | |
c34b1796 | 97 | #[stable(feature = "rust1", since = "1.0.0")] |
85aaf69f | 98 | pub fn new(inner: T) -> Cursor<T> { |
74b04a01 | 99 | Cursor { pos: 0, inner } |
85aaf69f SL |
100 | } |
101 | ||
9346a6ac | 102 | /// Consumes this cursor, returning the underlying value. |
c1a9b12d SL |
103 | /// |
104 | /// # Examples | |
105 | /// | |
106 | /// ``` | |
107 | /// use std::io::Cursor; | |
108 | /// | |
109 | /// let buff = Cursor::new(Vec::new()); | |
110 | /// # fn force_inference(_: &Cursor<Vec<u8>>) {} | |
111 | /// # force_inference(&buff); | |
112 | /// | |
113 | /// let vec = buff.into_inner(); | |
114 | /// ``` | |
c34b1796 | 115 | #[stable(feature = "rust1", since = "1.0.0")] |
dfeec247 XL |
116 | pub fn into_inner(self) -> T { |
117 | self.inner | |
118 | } | |
85aaf69f | 119 | |
9346a6ac | 120 | /// Gets a reference to the underlying value in this cursor. |
c1a9b12d SL |
121 | /// |
122 | /// # Examples | |
123 | /// | |
124 | /// ``` | |
125 | /// use std::io::Cursor; | |
126 | /// | |
127 | /// let buff = Cursor::new(Vec::new()); | |
128 | /// # fn force_inference(_: &Cursor<Vec<u8>>) {} | |
129 | /// # force_inference(&buff); | |
130 | /// | |
131 | /// let reference = buff.get_ref(); | |
132 | /// ``` | |
c34b1796 | 133 | #[stable(feature = "rust1", since = "1.0.0")] |
dfeec247 XL |
134 | pub fn get_ref(&self) -> &T { |
135 | &self.inner | |
136 | } | |
85aaf69f | 137 | |
9346a6ac | 138 | /// Gets a mutable reference to the underlying value in this cursor. |
85aaf69f SL |
139 | /// |
140 | /// Care should be taken to avoid modifying the internal I/O state of the | |
141 | /// underlying value as it may corrupt this cursor's position. | |
c1a9b12d SL |
142 | /// |
143 | /// # Examples | |
144 | /// | |
145 | /// ``` | |
146 | /// use std::io::Cursor; | |
147 | /// | |
148 | /// let mut buff = Cursor::new(Vec::new()); | |
149 | /// # fn force_inference(_: &Cursor<Vec<u8>>) {} | |
150 | /// # force_inference(&buff); | |
151 | /// | |
152 | /// let reference = buff.get_mut(); | |
153 | /// ``` | |
c34b1796 | 154 | #[stable(feature = "rust1", since = "1.0.0")] |
dfeec247 XL |
155 | pub fn get_mut(&mut self) -> &mut T { |
156 | &mut self.inner | |
157 | } | |
85aaf69f | 158 | |
c1a9b12d SL |
159 | /// Returns the current position of this cursor. |
160 | /// | |
161 | /// # Examples | |
162 | /// | |
163 | /// ``` | |
164 | /// use std::io::Cursor; | |
165 | /// use std::io::prelude::*; | |
166 | /// use std::io::SeekFrom; | |
167 | /// | |
168 | /// let mut buff = Cursor::new(vec![1, 2, 3, 4, 5]); | |
169 | /// | |
170 | /// assert_eq!(buff.position(), 0); | |
171 | /// | |
172 | /// buff.seek(SeekFrom::Current(2)).unwrap(); | |
173 | /// assert_eq!(buff.position(), 2); | |
174 | /// | |
175 | /// buff.seek(SeekFrom::Current(-1)).unwrap(); | |
176 | /// assert_eq!(buff.position(), 1); | |
177 | /// ``` | |
c34b1796 | 178 | #[stable(feature = "rust1", since = "1.0.0")] |
dfeec247 XL |
179 | pub fn position(&self) -> u64 { |
180 | self.pos | |
181 | } | |
85aaf69f | 182 | |
c1a9b12d SL |
183 | /// Sets the position of this cursor. |
184 | /// | |
185 | /// # Examples | |
186 | /// | |
187 | /// ``` | |
188 | /// use std::io::Cursor; | |
189 | /// | |
190 | /// let mut buff = Cursor::new(vec![1, 2, 3, 4, 5]); | |
191 | /// | |
192 | /// assert_eq!(buff.position(), 0); | |
193 | /// | |
194 | /// buff.set_position(2); | |
195 | /// assert_eq!(buff.position(), 2); | |
196 | /// | |
197 | /// buff.set_position(4); | |
198 | /// assert_eq!(buff.position(), 4); | |
199 | /// ``` | |
c34b1796 | 200 | #[stable(feature = "rust1", since = "1.0.0")] |
dfeec247 XL |
201 | pub fn set_position(&mut self, pos: u64) { |
202 | self.pos = pos; | |
203 | } | |
85aaf69f SL |
204 | } |
205 | ||
b039eaaf | 206 | #[stable(feature = "rust1", since = "1.0.0")] |
dfeec247 XL |
207 | impl<T> io::Seek for Cursor<T> |
208 | where | |
209 | T: AsRef<[u8]>, | |
210 | { | |
b039eaaf | 211 | fn seek(&mut self, style: SeekFrom) -> io::Result<u64> { |
8bb4bdeb | 212 | let (base_pos, offset) = match style { |
dfeec247 XL |
213 | SeekFrom::Start(n) => { |
214 | self.pos = n; | |
215 | return Ok(n); | |
216 | } | |
8bb4bdeb XL |
217 | SeekFrom::End(n) => (self.inner.as_ref().len() as u64, n), |
218 | SeekFrom::Current(n) => (self.pos, n), | |
b039eaaf | 219 | }; |
8bb4bdeb XL |
220 | let new_pos = if offset >= 0 { |
221 | base_pos.checked_add(offset as u64) | |
b039eaaf | 222 | } else { |
8bb4bdeb XL |
223 | base_pos.checked_sub((offset.wrapping_neg()) as u64) |
224 | }; | |
225 | match new_pos { | |
dfeec247 XL |
226 | Some(n) => { |
227 | self.pos = n; | |
228 | Ok(self.pos) | |
229 | } | |
230 | None => Err(Error::new( | |
231 | ErrorKind::InvalidInput, | |
232 | "invalid seek to a negative or overflowing position", | |
233 | )), | |
85aaf69f SL |
234 | } |
235 | } | |
532ac7d7 XL |
236 | |
237 | fn stream_len(&mut self) -> io::Result<u64> { | |
238 | Ok(self.inner.as_ref().len() as u64) | |
239 | } | |
240 | ||
241 | fn stream_position(&mut self) -> io::Result<u64> { | |
242 | Ok(self.pos) | |
243 | } | |
85aaf69f SL |
244 | } |
245 | ||
c34b1796 | 246 | #[stable(feature = "rust1", since = "1.0.0")] |
dfeec247 XL |
247 | impl<T> Read for Cursor<T> |
248 | where | |
249 | T: AsRef<[u8]>, | |
250 | { | |
b039eaaf | 251 | fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> { |
54a0048b | 252 | let n = Read::read(&mut self.fill_buf()?, buf)?; |
b039eaaf SL |
253 | self.pos += n as u64; |
254 | Ok(n) | |
85aaf69f | 255 | } |
041b39d2 | 256 | |
48663c56 | 257 | fn read_vectored(&mut self, bufs: &mut [IoSliceMut<'_>]) -> io::Result<usize> { |
9fa01778 XL |
258 | let mut nread = 0; |
259 | for buf in bufs { | |
260 | let n = self.read(buf)?; | |
261 | nread += n; | |
262 | if n < buf.len() { | |
263 | break; | |
264 | } | |
265 | } | |
266 | Ok(nread) | |
267 | } | |
268 | ||
f9f354fc XL |
269 | fn is_read_vectored(&self) -> bool { |
270 | true | |
271 | } | |
272 | ||
ff7c6d11 XL |
273 | fn read_exact(&mut self, buf: &mut [u8]) -> io::Result<()> { |
274 | let n = buf.len(); | |
275 | Read::read_exact(&mut self.fill_buf()?, buf)?; | |
276 | self.pos += n as u64; | |
277 | Ok(()) | |
278 | } | |
279 | ||
041b39d2 XL |
280 | #[inline] |
281 | unsafe fn initializer(&self) -> Initializer { | |
282 | Initializer::nop() | |
283 | } | |
85aaf69f SL |
284 | } |
285 | ||
c34b1796 | 286 | #[stable(feature = "rust1", since = "1.0.0")] |
dfeec247 XL |
287 | impl<T> BufRead for Cursor<T> |
288 | where | |
289 | T: AsRef<[u8]>, | |
290 | { | |
b039eaaf SL |
291 | fn fill_buf(&mut self) -> io::Result<&[u8]> { |
292 | let amt = cmp::min(self.pos, self.inner.as_ref().len() as u64); | |
293 | Ok(&self.inner.as_ref()[(amt as usize)..]) | |
85aaf69f | 294 | } |
dfeec247 XL |
295 | fn consume(&mut self, amt: usize) { |
296 | self.pos += amt as u64; | |
297 | } | |
85aaf69f SL |
298 | } |
299 | ||
2c00a5a8 | 300 | // Non-resizing write implementation |
48663c56 | 301 | #[inline] |
2c00a5a8 XL |
302 | fn slice_write(pos_mut: &mut u64, slice: &mut [u8], buf: &[u8]) -> io::Result<usize> { |
303 | let pos = cmp::min(*pos_mut, slice.len() as u64); | |
304 | let amt = (&mut slice[(pos as usize)..]).write(buf)?; | |
305 | *pos_mut += amt as u64; | |
306 | Ok(amt) | |
307 | } | |
308 | ||
48663c56 | 309 | #[inline] |
9fa01778 XL |
310 | fn slice_write_vectored( |
311 | pos_mut: &mut u64, | |
312 | slice: &mut [u8], | |
48663c56 | 313 | bufs: &[IoSlice<'_>], |
dfeec247 | 314 | ) -> io::Result<usize> { |
9fa01778 XL |
315 | let mut nwritten = 0; |
316 | for buf in bufs { | |
317 | let n = slice_write(pos_mut, slice, buf)?; | |
318 | nwritten += n; | |
319 | if n < buf.len() { | |
320 | break; | |
321 | } | |
322 | } | |
323 | Ok(nwritten) | |
324 | } | |
325 | ||
2c00a5a8 XL |
326 | // Resizing write implementation |
327 | fn vec_write(pos_mut: &mut u64, vec: &mut Vec<u8>, buf: &[u8]) -> io::Result<usize> { | |
8faf50e0 | 328 | let pos: usize = (*pos_mut).try_into().map_err(|_| { |
dfeec247 XL |
329 | Error::new( |
330 | ErrorKind::InvalidInput, | |
331 | "cursor position exceeds maximum possible vector length", | |
332 | ) | |
2c00a5a8 XL |
333 | })?; |
334 | // Make sure the internal buffer is as least as big as where we | |
335 | // currently are | |
336 | let len = vec.len(); | |
337 | if len < pos { | |
338 | // use `resize` so that the zero filling is as efficient as possible | |
339 | vec.resize(pos, 0); | |
340 | } | |
341 | // Figure out what bytes will be used to overwrite what's currently | |
342 | // there (left), and what will be appended on the end (right) | |
343 | { | |
344 | let space = vec.len() - pos; | |
345 | let (left, right) = buf.split_at(cmp::min(space, buf.len())); | |
346 | vec[pos..pos + left.len()].copy_from_slice(left); | |
347 | vec.extend_from_slice(right); | |
348 | } | |
349 | ||
350 | // Bump us forward | |
351 | *pos_mut = (pos + buf.len()) as u64; | |
352 | Ok(buf.len()) | |
353 | } | |
354 | ||
9fa01778 XL |
355 | fn vec_write_vectored( |
356 | pos_mut: &mut u64, | |
357 | vec: &mut Vec<u8>, | |
48663c56 | 358 | bufs: &[IoSlice<'_>], |
dfeec247 | 359 | ) -> io::Result<usize> { |
9fa01778 XL |
360 | let mut nwritten = 0; |
361 | for buf in bufs { | |
362 | nwritten += vec_write(pos_mut, vec, buf)?; | |
363 | } | |
364 | Ok(nwritten) | |
365 | } | |
366 | ||
c34b1796 | 367 | #[stable(feature = "rust1", since = "1.0.0")] |
9fa01778 | 368 | impl Write for Cursor<&mut [u8]> { |
3157f602 | 369 | #[inline] |
2c00a5a8 XL |
370 | fn write(&mut self, buf: &[u8]) -> io::Result<usize> { |
371 | slice_write(&mut self.pos, self.inner, buf) | |
372 | } | |
9fa01778 XL |
373 | |
374 | #[inline] | |
48663c56 | 375 | fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> { |
9fa01778 XL |
376 | slice_write_vectored(&mut self.pos, self.inner, bufs) |
377 | } | |
378 | ||
f9f354fc XL |
379 | #[inline] |
380 | fn is_write_vectored(&self) -> bool { | |
381 | true | |
382 | } | |
383 | ||
48663c56 | 384 | #[inline] |
dfeec247 XL |
385 | fn flush(&mut self) -> io::Result<()> { |
386 | Ok(()) | |
387 | } | |
2c00a5a8 XL |
388 | } |
389 | ||
0531ce1d | 390 | #[stable(feature = "cursor_mut_vec", since = "1.25.0")] |
9fa01778 | 391 | impl Write for Cursor<&mut Vec<u8>> { |
2c00a5a8 XL |
392 | fn write(&mut self, buf: &[u8]) -> io::Result<usize> { |
393 | vec_write(&mut self.pos, self.inner, buf) | |
85aaf69f | 394 | } |
9fa01778 | 395 | |
48663c56 | 396 | fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> { |
9fa01778 XL |
397 | vec_write_vectored(&mut self.pos, self.inner, bufs) |
398 | } | |
399 | ||
f9f354fc XL |
400 | #[inline] |
401 | fn is_write_vectored(&self) -> bool { | |
402 | true | |
403 | } | |
404 | ||
48663c56 | 405 | #[inline] |
dfeec247 XL |
406 | fn flush(&mut self) -> io::Result<()> { |
407 | Ok(()) | |
408 | } | |
85aaf69f SL |
409 | } |
410 | ||
c34b1796 | 411 | #[stable(feature = "rust1", since = "1.0.0")] |
85aaf69f SL |
412 | impl Write for Cursor<Vec<u8>> { |
413 | fn write(&mut self, buf: &[u8]) -> io::Result<usize> { | |
2c00a5a8 | 414 | vec_write(&mut self.pos, &mut self.inner, buf) |
85aaf69f | 415 | } |
9fa01778 | 416 | |
48663c56 | 417 | fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> { |
9fa01778 XL |
418 | vec_write_vectored(&mut self.pos, &mut self.inner, bufs) |
419 | } | |
420 | ||
f9f354fc XL |
421 | #[inline] |
422 | fn is_write_vectored(&self) -> bool { | |
423 | true | |
424 | } | |
425 | ||
48663c56 | 426 | #[inline] |
dfeec247 XL |
427 | fn flush(&mut self) -> io::Result<()> { |
428 | Ok(()) | |
429 | } | |
85aaf69f SL |
430 | } |
431 | ||
b039eaaf SL |
432 | #[stable(feature = "cursor_box_slice", since = "1.5.0")] |
433 | impl Write for Cursor<Box<[u8]>> { | |
3157f602 | 434 | #[inline] |
b039eaaf | 435 | fn write(&mut self, buf: &[u8]) -> io::Result<usize> { |
2c00a5a8 | 436 | slice_write(&mut self.pos, &mut self.inner, buf) |
b039eaaf | 437 | } |
9fa01778 XL |
438 | |
439 | #[inline] | |
48663c56 | 440 | fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> { |
9fa01778 XL |
441 | slice_write_vectored(&mut self.pos, &mut self.inner, bufs) |
442 | } | |
443 | ||
f9f354fc XL |
444 | #[inline] |
445 | fn is_write_vectored(&self) -> bool { | |
446 | true | |
447 | } | |
448 | ||
48663c56 | 449 | #[inline] |
dfeec247 XL |
450 | fn flush(&mut self) -> io::Result<()> { |
451 | Ok(()) | |
452 | } | |
b039eaaf | 453 | } |
85aaf69f SL |
454 | |
455 | #[cfg(test)] | |
456 | mod tests { | |
532ac7d7 | 457 | use crate::io::prelude::*; |
dfeec247 | 458 | use crate::io::{Cursor, IoSlice, IoSliceMut, SeekFrom}; |
85aaf69f SL |
459 | |
460 | #[test] | |
461 | fn test_vec_writer() { | |
462 | let mut writer = Vec::new(); | |
c34b1796 AL |
463 | assert_eq!(writer.write(&[0]).unwrap(), 1); |
464 | assert_eq!(writer.write(&[1, 2, 3]).unwrap(), 3); | |
465 | assert_eq!(writer.write(&[4, 5, 6, 7]).unwrap(), 4); | |
dfeec247 XL |
466 | assert_eq!( |
467 | writer | |
468 | .write_vectored(&[IoSlice::new(&[]), IoSlice::new(&[8, 9]), IoSlice::new(&[10])],) | |
469 | .unwrap(), | |
470 | 3 | |
471 | ); | |
9fa01778 | 472 | let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]; |
85aaf69f SL |
473 | assert_eq!(writer, b); |
474 | } | |
475 | ||
476 | #[test] | |
477 | fn test_mem_writer() { | |
478 | let mut writer = Cursor::new(Vec::new()); | |
c34b1796 AL |
479 | assert_eq!(writer.write(&[0]).unwrap(), 1); |
480 | assert_eq!(writer.write(&[1, 2, 3]).unwrap(), 3); | |
481 | assert_eq!(writer.write(&[4, 5, 6, 7]).unwrap(), 4); | |
dfeec247 XL |
482 | assert_eq!( |
483 | writer | |
484 | .write_vectored(&[IoSlice::new(&[]), IoSlice::new(&[8, 9]), IoSlice::new(&[10])],) | |
485 | .unwrap(), | |
486 | 3 | |
487 | ); | |
9fa01778 | 488 | let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]; |
c34b1796 | 489 | assert_eq!(&writer.get_ref()[..], b); |
85aaf69f SL |
490 | } |
491 | ||
2c00a5a8 XL |
492 | #[test] |
493 | fn test_mem_mut_writer() { | |
494 | let mut vec = Vec::new(); | |
495 | let mut writer = Cursor::new(&mut vec); | |
496 | assert_eq!(writer.write(&[0]).unwrap(), 1); | |
497 | assert_eq!(writer.write(&[1, 2, 3]).unwrap(), 3); | |
498 | assert_eq!(writer.write(&[4, 5, 6, 7]).unwrap(), 4); | |
dfeec247 XL |
499 | assert_eq!( |
500 | writer | |
501 | .write_vectored(&[IoSlice::new(&[]), IoSlice::new(&[8, 9]), IoSlice::new(&[10])],) | |
502 | .unwrap(), | |
503 | 3 | |
504 | ); | |
9fa01778 | 505 | let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]; |
2c00a5a8 XL |
506 | assert_eq!(&writer.get_ref()[..], b); |
507 | } | |
508 | ||
b039eaaf SL |
509 | #[test] |
510 | fn test_box_slice_writer() { | |
511 | let mut writer = Cursor::new(vec![0u8; 9].into_boxed_slice()); | |
512 | assert_eq!(writer.position(), 0); | |
513 | assert_eq!(writer.write(&[0]).unwrap(), 1); | |
514 | assert_eq!(writer.position(), 1); | |
515 | assert_eq!(writer.write(&[1, 2, 3]).unwrap(), 3); | |
516 | assert_eq!(writer.write(&[4, 5, 6, 7]).unwrap(), 4); | |
517 | assert_eq!(writer.position(), 8); | |
518 | assert_eq!(writer.write(&[]).unwrap(), 0); | |
519 | assert_eq!(writer.position(), 8); | |
520 | ||
521 | assert_eq!(writer.write(&[8, 9]).unwrap(), 1); | |
522 | assert_eq!(writer.write(&[10]).unwrap(), 0); | |
523 | let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8]; | |
524 | assert_eq!(&**writer.get_ref(), b); | |
525 | } | |
526 | ||
9fa01778 XL |
527 | #[test] |
528 | fn test_box_slice_writer_vectored() { | |
529 | let mut writer = Cursor::new(vec![0u8; 9].into_boxed_slice()); | |
530 | assert_eq!(writer.position(), 0); | |
48663c56 | 531 | assert_eq!(writer.write_vectored(&[IoSlice::new(&[0])]).unwrap(), 1); |
9fa01778 XL |
532 | assert_eq!(writer.position(), 1); |
533 | assert_eq!( | |
dfeec247 XL |
534 | writer |
535 | .write_vectored(&[IoSlice::new(&[1, 2, 3]), IoSlice::new(&[4, 5, 6, 7]),]) | |
536 | .unwrap(), | |
9fa01778 XL |
537 | 7, |
538 | ); | |
539 | assert_eq!(writer.position(), 8); | |
540 | assert_eq!(writer.write_vectored(&[]).unwrap(), 0); | |
541 | assert_eq!(writer.position(), 8); | |
542 | ||
48663c56 XL |
543 | assert_eq!(writer.write_vectored(&[IoSlice::new(&[8, 9])]).unwrap(), 1); |
544 | assert_eq!(writer.write_vectored(&[IoSlice::new(&[10])]).unwrap(), 0); | |
9fa01778 XL |
545 | let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8]; |
546 | assert_eq!(&**writer.get_ref(), b); | |
547 | } | |
548 | ||
85aaf69f SL |
549 | #[test] |
550 | fn test_buf_writer() { | |
551 | let mut buf = [0 as u8; 9]; | |
552 | { | |
553 | let mut writer = Cursor::new(&mut buf[..]); | |
554 | assert_eq!(writer.position(), 0); | |
c34b1796 | 555 | assert_eq!(writer.write(&[0]).unwrap(), 1); |
85aaf69f | 556 | assert_eq!(writer.position(), 1); |
c34b1796 AL |
557 | assert_eq!(writer.write(&[1, 2, 3]).unwrap(), 3); |
558 | assert_eq!(writer.write(&[4, 5, 6, 7]).unwrap(), 4); | |
85aaf69f | 559 | assert_eq!(writer.position(), 8); |
c34b1796 | 560 | assert_eq!(writer.write(&[]).unwrap(), 0); |
85aaf69f SL |
561 | assert_eq!(writer.position(), 8); |
562 | ||
c34b1796 AL |
563 | assert_eq!(writer.write(&[8, 9]).unwrap(), 1); |
564 | assert_eq!(writer.write(&[10]).unwrap(), 0); | |
85aaf69f SL |
565 | } |
566 | let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8]; | |
567 | assert_eq!(buf, b); | |
568 | } | |
569 | ||
9fa01778 XL |
570 | #[test] |
571 | fn test_buf_writer_vectored() { | |
572 | let mut buf = [0 as u8; 9]; | |
573 | { | |
574 | let mut writer = Cursor::new(&mut buf[..]); | |
575 | assert_eq!(writer.position(), 0); | |
48663c56 | 576 | assert_eq!(writer.write_vectored(&[IoSlice::new(&[0])]).unwrap(), 1); |
9fa01778 XL |
577 | assert_eq!(writer.position(), 1); |
578 | assert_eq!( | |
dfeec247 XL |
579 | writer |
580 | .write_vectored(&[IoSlice::new(&[1, 2, 3]), IoSlice::new(&[4, 5, 6, 7])],) | |
581 | .unwrap(), | |
9fa01778 XL |
582 | 7, |
583 | ); | |
584 | assert_eq!(writer.position(), 8); | |
585 | assert_eq!(writer.write_vectored(&[]).unwrap(), 0); | |
586 | assert_eq!(writer.position(), 8); | |
587 | ||
48663c56 XL |
588 | assert_eq!(writer.write_vectored(&[IoSlice::new(&[8, 9])]).unwrap(), 1); |
589 | assert_eq!(writer.write_vectored(&[IoSlice::new(&[10])]).unwrap(), 0); | |
9fa01778 XL |
590 | } |
591 | let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8]; | |
592 | assert_eq!(buf, b); | |
593 | } | |
594 | ||
85aaf69f SL |
595 | #[test] |
596 | fn test_buf_writer_seek() { | |
597 | let mut buf = [0 as u8; 8]; | |
598 | { | |
599 | let mut writer = Cursor::new(&mut buf[..]); | |
600 | assert_eq!(writer.position(), 0); | |
c34b1796 | 601 | assert_eq!(writer.write(&[1]).unwrap(), 1); |
85aaf69f SL |
602 | assert_eq!(writer.position(), 1); |
603 | ||
c34b1796 | 604 | assert_eq!(writer.seek(SeekFrom::Start(2)).unwrap(), 2); |
85aaf69f | 605 | assert_eq!(writer.position(), 2); |
c34b1796 | 606 | assert_eq!(writer.write(&[2]).unwrap(), 1); |
85aaf69f SL |
607 | assert_eq!(writer.position(), 3); |
608 | ||
c34b1796 | 609 | assert_eq!(writer.seek(SeekFrom::Current(-2)).unwrap(), 1); |
85aaf69f | 610 | assert_eq!(writer.position(), 1); |
c34b1796 | 611 | assert_eq!(writer.write(&[3]).unwrap(), 1); |
85aaf69f SL |
612 | assert_eq!(writer.position(), 2); |
613 | ||
c34b1796 | 614 | assert_eq!(writer.seek(SeekFrom::End(-1)).unwrap(), 7); |
85aaf69f | 615 | assert_eq!(writer.position(), 7); |
c34b1796 | 616 | assert_eq!(writer.write(&[4]).unwrap(), 1); |
85aaf69f | 617 | assert_eq!(writer.position(), 8); |
85aaf69f SL |
618 | } |
619 | let b: &[_] = &[1, 3, 2, 0, 0, 0, 0, 4]; | |
620 | assert_eq!(buf, b); | |
621 | } | |
622 | ||
623 | #[test] | |
624 | fn test_buf_writer_error() { | |
625 | let mut buf = [0 as u8; 2]; | |
626 | let mut writer = Cursor::new(&mut buf[..]); | |
c34b1796 AL |
627 | assert_eq!(writer.write(&[0]).unwrap(), 1); |
628 | assert_eq!(writer.write(&[0, 0]).unwrap(), 1); | |
629 | assert_eq!(writer.write(&[0, 0]).unwrap(), 0); | |
85aaf69f SL |
630 | } |
631 | ||
632 | #[test] | |
633 | fn test_mem_reader() { | |
c30ab7b3 | 634 | let mut reader = Cursor::new(vec![0, 1, 2, 3, 4, 5, 6, 7]); |
85aaf69f | 635 | let mut buf = []; |
c34b1796 | 636 | assert_eq!(reader.read(&mut buf).unwrap(), 0); |
85aaf69f SL |
637 | assert_eq!(reader.position(), 0); |
638 | let mut buf = [0]; | |
c34b1796 | 639 | assert_eq!(reader.read(&mut buf).unwrap(), 1); |
85aaf69f SL |
640 | assert_eq!(reader.position(), 1); |
641 | let b: &[_] = &[0]; | |
642 | assert_eq!(buf, b); | |
643 | let mut buf = [0; 4]; | |
c34b1796 | 644 | assert_eq!(reader.read(&mut buf).unwrap(), 4); |
85aaf69f SL |
645 | assert_eq!(reader.position(), 5); |
646 | let b: &[_] = &[1, 2, 3, 4]; | |
647 | assert_eq!(buf, b); | |
c34b1796 | 648 | assert_eq!(reader.read(&mut buf).unwrap(), 3); |
85aaf69f SL |
649 | let b: &[_] = &[5, 6, 7]; |
650 | assert_eq!(&buf[..3], b); | |
c34b1796 | 651 | assert_eq!(reader.read(&mut buf).unwrap(), 0); |
85aaf69f SL |
652 | } |
653 | ||
9fa01778 XL |
654 | #[test] |
655 | fn test_mem_reader_vectored() { | |
656 | let mut reader = Cursor::new(vec![0, 1, 2, 3, 4, 5, 6, 7]); | |
657 | let mut buf = []; | |
48663c56 | 658 | assert_eq!(reader.read_vectored(&mut [IoSliceMut::new(&mut buf)]).unwrap(), 0); |
9fa01778 XL |
659 | assert_eq!(reader.position(), 0); |
660 | let mut buf = [0]; | |
661 | assert_eq!( | |
dfeec247 XL |
662 | reader |
663 | .read_vectored(&mut [IoSliceMut::new(&mut []), IoSliceMut::new(&mut buf),]) | |
664 | .unwrap(), | |
9fa01778 XL |
665 | 1, |
666 | ); | |
667 | assert_eq!(reader.position(), 1); | |
668 | let b: &[_] = &[0]; | |
669 | assert_eq!(buf, b); | |
670 | let mut buf1 = [0; 4]; | |
671 | let mut buf2 = [0; 4]; | |
672 | assert_eq!( | |
dfeec247 XL |
673 | reader |
674 | .read_vectored(&mut [IoSliceMut::new(&mut buf1), IoSliceMut::new(&mut buf2),]) | |
675 | .unwrap(), | |
9fa01778 XL |
676 | 7, |
677 | ); | |
678 | let b1: &[_] = &[1, 2, 3, 4]; | |
679 | let b2: &[_] = &[5, 6, 7]; | |
680 | assert_eq!(buf1, b1); | |
681 | assert_eq!(&buf2[..3], b2); | |
682 | assert_eq!(reader.read(&mut buf).unwrap(), 0); | |
683 | } | |
684 | ||
b039eaaf SL |
685 | #[test] |
686 | fn test_boxed_slice_reader() { | |
c30ab7b3 | 687 | let mut reader = Cursor::new(vec![0, 1, 2, 3, 4, 5, 6, 7].into_boxed_slice()); |
b039eaaf SL |
688 | let mut buf = []; |
689 | assert_eq!(reader.read(&mut buf).unwrap(), 0); | |
690 | assert_eq!(reader.position(), 0); | |
691 | let mut buf = [0]; | |
692 | assert_eq!(reader.read(&mut buf).unwrap(), 1); | |
693 | assert_eq!(reader.position(), 1); | |
694 | let b: &[_] = &[0]; | |
695 | assert_eq!(buf, b); | |
696 | let mut buf = [0; 4]; | |
697 | assert_eq!(reader.read(&mut buf).unwrap(), 4); | |
698 | assert_eq!(reader.position(), 5); | |
699 | let b: &[_] = &[1, 2, 3, 4]; | |
700 | assert_eq!(buf, b); | |
701 | assert_eq!(reader.read(&mut buf).unwrap(), 3); | |
702 | let b: &[_] = &[5, 6, 7]; | |
703 | assert_eq!(&buf[..3], b); | |
704 | assert_eq!(reader.read(&mut buf).unwrap(), 0); | |
705 | } | |
706 | ||
9fa01778 XL |
707 | #[test] |
708 | fn test_boxed_slice_reader_vectored() { | |
709 | let mut reader = Cursor::new(vec![0, 1, 2, 3, 4, 5, 6, 7].into_boxed_slice()); | |
710 | let mut buf = []; | |
48663c56 | 711 | assert_eq!(reader.read_vectored(&mut [IoSliceMut::new(&mut buf)]).unwrap(), 0); |
9fa01778 XL |
712 | assert_eq!(reader.position(), 0); |
713 | let mut buf = [0]; | |
714 | assert_eq!( | |
dfeec247 XL |
715 | reader |
716 | .read_vectored(&mut [IoSliceMut::new(&mut []), IoSliceMut::new(&mut buf),]) | |
717 | .unwrap(), | |
9fa01778 XL |
718 | 1, |
719 | ); | |
720 | assert_eq!(reader.position(), 1); | |
721 | let b: &[_] = &[0]; | |
722 | assert_eq!(buf, b); | |
723 | let mut buf1 = [0; 4]; | |
724 | let mut buf2 = [0; 4]; | |
725 | assert_eq!( | |
dfeec247 XL |
726 | reader |
727 | .read_vectored(&mut [IoSliceMut::new(&mut buf1), IoSliceMut::new(&mut buf2)],) | |
728 | .unwrap(), | |
9fa01778 XL |
729 | 7, |
730 | ); | |
731 | let b1: &[_] = &[1, 2, 3, 4]; | |
732 | let b2: &[_] = &[5, 6, 7]; | |
733 | assert_eq!(buf1, b1); | |
734 | assert_eq!(&buf2[..3], b2); | |
735 | assert_eq!(reader.read(&mut buf).unwrap(), 0); | |
736 | } | |
737 | ||
85aaf69f SL |
738 | #[test] |
739 | fn read_to_end() { | |
c30ab7b3 | 740 | let mut reader = Cursor::new(vec![0, 1, 2, 3, 4, 5, 6, 7]); |
85aaf69f | 741 | let mut v = Vec::new(); |
c34b1796 | 742 | reader.read_to_end(&mut v).unwrap(); |
85aaf69f SL |
743 | assert_eq!(v, [0, 1, 2, 3, 4, 5, 6, 7]); |
744 | } | |
745 | ||
746 | #[test] | |
747 | fn test_slice_reader() { | |
c34b1796 | 748 | let in_buf = vec![0, 1, 2, 3, 4, 5, 6, 7]; |
3b2f2976 | 749 | let reader = &mut &in_buf[..]; |
85aaf69f | 750 | let mut buf = []; |
c34b1796 | 751 | assert_eq!(reader.read(&mut buf).unwrap(), 0); |
85aaf69f | 752 | let mut buf = [0]; |
c34b1796 | 753 | assert_eq!(reader.read(&mut buf).unwrap(), 1); |
85aaf69f SL |
754 | assert_eq!(reader.len(), 7); |
755 | let b: &[_] = &[0]; | |
c34b1796 | 756 | assert_eq!(&buf[..], b); |
85aaf69f | 757 | let mut buf = [0; 4]; |
c34b1796 | 758 | assert_eq!(reader.read(&mut buf).unwrap(), 4); |
85aaf69f SL |
759 | assert_eq!(reader.len(), 3); |
760 | let b: &[_] = &[1, 2, 3, 4]; | |
c34b1796 AL |
761 | assert_eq!(&buf[..], b); |
762 | assert_eq!(reader.read(&mut buf).unwrap(), 3); | |
85aaf69f SL |
763 | let b: &[_] = &[5, 6, 7]; |
764 | assert_eq!(&buf[..3], b); | |
c34b1796 | 765 | assert_eq!(reader.read(&mut buf).unwrap(), 0); |
85aaf69f SL |
766 | } |
767 | ||
9fa01778 XL |
768 | #[test] |
769 | fn test_slice_reader_vectored() { | |
770 | let in_buf = vec![0, 1, 2, 3, 4, 5, 6, 7]; | |
771 | let reader = &mut &in_buf[..]; | |
772 | let mut buf = []; | |
48663c56 | 773 | assert_eq!(reader.read_vectored(&mut [IoSliceMut::new(&mut buf)]).unwrap(), 0); |
9fa01778 XL |
774 | let mut buf = [0]; |
775 | assert_eq!( | |
dfeec247 XL |
776 | reader |
777 | .read_vectored(&mut [IoSliceMut::new(&mut []), IoSliceMut::new(&mut buf),]) | |
778 | .unwrap(), | |
9fa01778 XL |
779 | 1, |
780 | ); | |
781 | assert_eq!(reader.len(), 7); | |
782 | let b: &[_] = &[0]; | |
783 | assert_eq!(buf, b); | |
784 | let mut buf1 = [0; 4]; | |
785 | let mut buf2 = [0; 4]; | |
786 | assert_eq!( | |
dfeec247 XL |
787 | reader |
788 | .read_vectored(&mut [IoSliceMut::new(&mut buf1), IoSliceMut::new(&mut buf2)],) | |
789 | .unwrap(), | |
9fa01778 XL |
790 | 7, |
791 | ); | |
792 | let b1: &[_] = &[1, 2, 3, 4]; | |
793 | let b2: &[_] = &[5, 6, 7]; | |
794 | assert_eq!(buf1, b1); | |
795 | assert_eq!(&buf2[..3], b2); | |
796 | assert_eq!(reader.read(&mut buf).unwrap(), 0); | |
797 | } | |
798 | ||
ff7c6d11 XL |
799 | #[test] |
800 | fn test_read_exact() { | |
801 | let in_buf = vec![0, 1, 2, 3, 4, 5, 6, 7]; | |
802 | let reader = &mut &in_buf[..]; | |
803 | let mut buf = []; | |
804 | assert!(reader.read_exact(&mut buf).is_ok()); | |
805 | let mut buf = [8]; | |
806 | assert!(reader.read_exact(&mut buf).is_ok()); | |
807 | assert_eq!(buf[0], 0); | |
808 | assert_eq!(reader.len(), 7); | |
809 | let mut buf = [0, 0, 0, 0, 0, 0, 0]; | |
810 | assert!(reader.read_exact(&mut buf).is_ok()); | |
811 | assert_eq!(buf, [1, 2, 3, 4, 5, 6, 7]); | |
812 | assert_eq!(reader.len(), 0); | |
813 | let mut buf = [0]; | |
814 | assert!(reader.read_exact(&mut buf).is_err()); | |
815 | } | |
816 | ||
85aaf69f SL |
817 | #[test] |
818 | fn test_buf_reader() { | |
c34b1796 AL |
819 | let in_buf = vec![0, 1, 2, 3, 4, 5, 6, 7]; |
820 | let mut reader = Cursor::new(&in_buf[..]); | |
85aaf69f | 821 | let mut buf = []; |
c34b1796 | 822 | assert_eq!(reader.read(&mut buf).unwrap(), 0); |
85aaf69f SL |
823 | assert_eq!(reader.position(), 0); |
824 | let mut buf = [0]; | |
c34b1796 | 825 | assert_eq!(reader.read(&mut buf).unwrap(), 1); |
85aaf69f SL |
826 | assert_eq!(reader.position(), 1); |
827 | let b: &[_] = &[0]; | |
828 | assert_eq!(buf, b); | |
829 | let mut buf = [0; 4]; | |
c34b1796 | 830 | assert_eq!(reader.read(&mut buf).unwrap(), 4); |
85aaf69f SL |
831 | assert_eq!(reader.position(), 5); |
832 | let b: &[_] = &[1, 2, 3, 4]; | |
833 | assert_eq!(buf, b); | |
c34b1796 | 834 | assert_eq!(reader.read(&mut buf).unwrap(), 3); |
85aaf69f SL |
835 | let b: &[_] = &[5, 6, 7]; |
836 | assert_eq!(&buf[..3], b); | |
c34b1796 | 837 | assert_eq!(reader.read(&mut buf).unwrap(), 0); |
85aaf69f SL |
838 | } |
839 | ||
85aaf69f SL |
840 | #[test] |
841 | fn seek_past_end() { | |
842 | let buf = [0xff]; | |
843 | let mut r = Cursor::new(&buf[..]); | |
c34b1796 AL |
844 | assert_eq!(r.seek(SeekFrom::Start(10)).unwrap(), 10); |
845 | assert_eq!(r.read(&mut [0]).unwrap(), 0); | |
85aaf69f | 846 | |
c30ab7b3 | 847 | let mut r = Cursor::new(vec![10]); |
c34b1796 AL |
848 | assert_eq!(r.seek(SeekFrom::Start(10)).unwrap(), 10); |
849 | assert_eq!(r.read(&mut [0]).unwrap(), 0); | |
85aaf69f SL |
850 | |
851 | let mut buf = [0]; | |
852 | let mut r = Cursor::new(&mut buf[..]); | |
c34b1796 AL |
853 | assert_eq!(r.seek(SeekFrom::Start(10)).unwrap(), 10); |
854 | assert_eq!(r.write(&[3]).unwrap(), 0); | |
b039eaaf SL |
855 | |
856 | let mut r = Cursor::new(vec![10].into_boxed_slice()); | |
857 | assert_eq!(r.seek(SeekFrom::Start(10)).unwrap(), 10); | |
858 | assert_eq!(r.write(&[3]).unwrap(), 0); | |
85aaf69f SL |
859 | } |
860 | ||
8bb4bdeb XL |
861 | #[test] |
862 | fn seek_past_i64() { | |
863 | let buf = [0xff]; | |
864 | let mut r = Cursor::new(&buf[..]); | |
865 | assert_eq!(r.seek(SeekFrom::Start(6)).unwrap(), 6); | |
866 | assert_eq!(r.seek(SeekFrom::Current(0x7ffffffffffffff0)).unwrap(), 0x7ffffffffffffff6); | |
867 | assert_eq!(r.seek(SeekFrom::Current(0x10)).unwrap(), 0x8000000000000006); | |
868 | assert_eq!(r.seek(SeekFrom::Current(0)).unwrap(), 0x8000000000000006); | |
869 | assert!(r.seek(SeekFrom::Current(0x7ffffffffffffffd)).is_err()); | |
870 | assert_eq!(r.seek(SeekFrom::Current(-0x8000000000000000)).unwrap(), 6); | |
871 | ||
872 | let mut r = Cursor::new(vec![10]); | |
873 | assert_eq!(r.seek(SeekFrom::Start(6)).unwrap(), 6); | |
874 | assert_eq!(r.seek(SeekFrom::Current(0x7ffffffffffffff0)).unwrap(), 0x7ffffffffffffff6); | |
875 | assert_eq!(r.seek(SeekFrom::Current(0x10)).unwrap(), 0x8000000000000006); | |
876 | assert_eq!(r.seek(SeekFrom::Current(0)).unwrap(), 0x8000000000000006); | |
877 | assert!(r.seek(SeekFrom::Current(0x7ffffffffffffffd)).is_err()); | |
878 | assert_eq!(r.seek(SeekFrom::Current(-0x8000000000000000)).unwrap(), 6); | |
879 | ||
880 | let mut buf = [0]; | |
881 | let mut r = Cursor::new(&mut buf[..]); | |
882 | assert_eq!(r.seek(SeekFrom::Start(6)).unwrap(), 6); | |
883 | assert_eq!(r.seek(SeekFrom::Current(0x7ffffffffffffff0)).unwrap(), 0x7ffffffffffffff6); | |
884 | assert_eq!(r.seek(SeekFrom::Current(0x10)).unwrap(), 0x8000000000000006); | |
885 | assert_eq!(r.seek(SeekFrom::Current(0)).unwrap(), 0x8000000000000006); | |
886 | assert!(r.seek(SeekFrom::Current(0x7ffffffffffffffd)).is_err()); | |
887 | assert_eq!(r.seek(SeekFrom::Current(-0x8000000000000000)).unwrap(), 6); | |
888 | ||
889 | let mut r = Cursor::new(vec![10].into_boxed_slice()); | |
890 | assert_eq!(r.seek(SeekFrom::Start(6)).unwrap(), 6); | |
891 | assert_eq!(r.seek(SeekFrom::Current(0x7ffffffffffffff0)).unwrap(), 0x7ffffffffffffff6); | |
892 | assert_eq!(r.seek(SeekFrom::Current(0x10)).unwrap(), 0x8000000000000006); | |
893 | assert_eq!(r.seek(SeekFrom::Current(0)).unwrap(), 0x8000000000000006); | |
894 | assert!(r.seek(SeekFrom::Current(0x7ffffffffffffffd)).is_err()); | |
895 | assert_eq!(r.seek(SeekFrom::Current(-0x8000000000000000)).unwrap(), 6); | |
896 | } | |
897 | ||
85aaf69f SL |
898 | #[test] |
899 | fn seek_before_0() { | |
c34b1796 | 900 | let buf = [0xff]; |
85aaf69f SL |
901 | let mut r = Cursor::new(&buf[..]); |
902 | assert!(r.seek(SeekFrom::End(-2)).is_err()); | |
903 | ||
c30ab7b3 | 904 | let mut r = Cursor::new(vec![10]); |
85aaf69f SL |
905 | assert!(r.seek(SeekFrom::End(-2)).is_err()); |
906 | ||
907 | let mut buf = [0]; | |
908 | let mut r = Cursor::new(&mut buf[..]); | |
909 | assert!(r.seek(SeekFrom::End(-2)).is_err()); | |
b039eaaf | 910 | |
c30ab7b3 | 911 | let mut r = Cursor::new(vec![10].into_boxed_slice()); |
b039eaaf | 912 | assert!(r.seek(SeekFrom::End(-2)).is_err()); |
85aaf69f SL |
913 | } |
914 | ||
915 | #[test] | |
916 | fn test_seekable_mem_writer() { | |
917 | let mut writer = Cursor::new(Vec::<u8>::new()); | |
918 | assert_eq!(writer.position(), 0); | |
c34b1796 | 919 | assert_eq!(writer.write(&[0]).unwrap(), 1); |
85aaf69f | 920 | assert_eq!(writer.position(), 1); |
c34b1796 AL |
921 | assert_eq!(writer.write(&[1, 2, 3]).unwrap(), 3); |
922 | assert_eq!(writer.write(&[4, 5, 6, 7]).unwrap(), 4); | |
85aaf69f SL |
923 | assert_eq!(writer.position(), 8); |
924 | let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7]; | |
c34b1796 | 925 | assert_eq!(&writer.get_ref()[..], b); |
85aaf69f | 926 | |
c34b1796 | 927 | assert_eq!(writer.seek(SeekFrom::Start(0)).unwrap(), 0); |
85aaf69f | 928 | assert_eq!(writer.position(), 0); |
c34b1796 | 929 | assert_eq!(writer.write(&[3, 4]).unwrap(), 2); |
85aaf69f | 930 | let b: &[_] = &[3, 4, 2, 3, 4, 5, 6, 7]; |
c34b1796 | 931 | assert_eq!(&writer.get_ref()[..], b); |
85aaf69f | 932 | |
c34b1796 AL |
933 | assert_eq!(writer.seek(SeekFrom::Current(1)).unwrap(), 3); |
934 | assert_eq!(writer.write(&[0, 1]).unwrap(), 2); | |
85aaf69f | 935 | let b: &[_] = &[3, 4, 2, 0, 1, 5, 6, 7]; |
c34b1796 | 936 | assert_eq!(&writer.get_ref()[..], b); |
85aaf69f | 937 | |
c34b1796 AL |
938 | assert_eq!(writer.seek(SeekFrom::End(-1)).unwrap(), 7); |
939 | assert_eq!(writer.write(&[1, 2]).unwrap(), 2); | |
85aaf69f | 940 | let b: &[_] = &[3, 4, 2, 0, 1, 5, 6, 1, 2]; |
c34b1796 | 941 | assert_eq!(&writer.get_ref()[..], b); |
85aaf69f | 942 | |
c34b1796 AL |
943 | assert_eq!(writer.seek(SeekFrom::End(1)).unwrap(), 10); |
944 | assert_eq!(writer.write(&[1]).unwrap(), 1); | |
85aaf69f | 945 | let b: &[_] = &[3, 4, 2, 0, 1, 5, 6, 1, 2, 0, 1]; |
c34b1796 | 946 | assert_eq!(&writer.get_ref()[..], b); |
85aaf69f SL |
947 | } |
948 | ||
949 | #[test] | |
950 | fn vec_seek_past_end() { | |
951 | let mut r = Cursor::new(Vec::new()); | |
c34b1796 AL |
952 | assert_eq!(r.seek(SeekFrom::Start(10)).unwrap(), 10); |
953 | assert_eq!(r.write(&[3]).unwrap(), 1); | |
85aaf69f SL |
954 | } |
955 | ||
956 | #[test] | |
957 | fn vec_seek_before_0() { | |
958 | let mut r = Cursor::new(Vec::new()); | |
959 | assert!(r.seek(SeekFrom::End(-2)).is_err()); | |
960 | } | |
c30ab7b3 SL |
961 | |
962 | #[test] | |
963 | #[cfg(target_pointer_width = "32")] | |
964 | fn vec_seek_and_write_past_usize_max() { | |
965 | let mut c = Cursor::new(Vec::new()); | |
966 | c.set_position(<usize>::max_value() as u64 + 1); | |
967 | assert!(c.write_all(&[1, 2, 3]).is_err()); | |
968 | } | |
dfeec247 XL |
969 | |
970 | #[test] | |
971 | fn test_partial_eq() { | |
972 | assert_eq!(Cursor::new(Vec::<u8>::new()), Cursor::new(Vec::<u8>::new())); | |
973 | } | |
974 | ||
975 | #[test] | |
976 | fn test_eq() { | |
977 | struct AssertEq<T: Eq>(pub T); | |
978 | ||
979 | let _: AssertEq<Cursor<Vec<u8>>> = AssertEq(Cursor::new(Vec::new())); | |
980 | } | |
85aaf69f | 981 | } |