bufkit 0.7.0

use core::ops::{Bound, RangeBounds};

use crate::{error::TryAdvanceError, EmptyChunk};

use super::{check_out_of_bounds, must_non_zero, panic_advance, Chunk};

/// A peeker for reading from a buffer without advancing the original buffer's cursor.
///
/// `Peeker` provides a non-destructive way to examine buffer contents by maintaining
/// its own independent cursor position. This is particularly useful when you need to:
/// - Look ahead in a buffer before deciding how to process the data
/// - Parse data that might need to be rolled back
/// - Implement backtracking algorithms
/// - Share read access to the same buffer data from different positions
///
/// The peeker can be constrained to a specific range within the buffer, making it
/// safe for parsing operations that should not read beyond certain boundaries.
///
/// # Examples
///
/// ```rust
/// use bufkit::{Chunk, Peeker};
///
/// let data = b"Hello, World!";
/// let buf = &data[..];
/// let mut peeker = Peeker::new(buf);
///
/// // Read without affecting the original buffer
/// assert_eq!(peeker.read_u8(), b'H');
/// assert_eq!(peeker.read_u8(), b'e');
/// assert_eq!(buf.remaining(), 13); // Original buffer unchanged
///
/// // Create a constrained peeker for safe parsing
/// let mut word_peeker = peeker.segment(0..5); // "Hello"
/// assert_eq!(word_peeker.remaining(), 5);
/// ```
#[derive(Debug, PartialEq, Eq)]
pub struct Peeker<B: ?Sized> {
  cursor: usize,
  /// The original start bound of the peeker, used for resetting.
  start: Bound<usize>,
  /// The original end bound of the peeker, used for resetting.
  end: Bound<usize>,
  /// Current limit bound of the peeker
  limit: Bound<usize>,
  buf: B,
}

impl<B> From<B> for Peeker<B> {
  #[inline]
  fn from(buf: B) -> Self {
    Self::new(buf)
  }
}

impl<B: Clone> Clone for Peeker<B> {
  #[inline]
  fn clone(&self) -> Self {
    Self {
      cursor: self.cursor,
      start: self.start,
      end: self.end,
      limit: self.limit,
      buf: self.buf.clone(),
    }
  }
}

impl<B: Copy> Copy for Peeker<B> {}

impl<B> Peeker<B> {
  /// Creates a new `Peeker` instance with the given buffer.
  ///
  /// The peeker starts at the beginning of the buffer's current position
  /// and can read all remaining bytes in the buffer.
  ///
  /// # Examples
  ///
  /// ```rust
  /// use bufkit::{Chunk, Peeker};
  ///
  /// let data = [1, 2, 3, 4, 5];
  /// let buf = &data[..];
  /// let peeker = Peeker::new(buf);
  /// assert_eq!(peeker.remaining(), 5);
  /// ```
  #[inline]
  pub const fn new(buf: B) -> Self {
    Self::with_cursor_and_bounds_inner(buf, 0, Bound::Unbounded, Bound::Unbounded)
  }

  /// Creates a new `Peeker` constrained to a specific length.
  ///
  /// This is useful when you want to ensure the peeker cannot read beyond
  /// a certain number of bytes, providing additional safety for parsing operations.
  ///
  /// # Examples
  ///
  /// ```rust
  /// use bufkit::{Chunk, Peeker};
  ///
  /// let data = b"Hello, World!";
  /// let buf = &data[..];
  /// let peeker = Peeker::with_limit(buf, 5); // Only peek first 5 bytes
  /// assert_eq!(peeker.remaining(), 5);
  /// ```
  #[inline]
  pub const fn with_limit(buf: B, limit: usize) -> Self {
    Self::with_cursor_and_bounds_inner(buf, 0, Bound::Unbounded, Bound::Excluded(limit))
  }

  /// Creates a new `Peeker` with specific start and end bounds.
  ///
  /// This provides maximum flexibility in defining the peeker's range,
  /// allowing for more complex parsing scenarios.
  ///
  /// # Examples
  ///
  /// ```rust
  /// use core::ops::Bound;
  /// use bufkit::{Chunk, Peeker};
  ///
  /// let data = b"Hello, World!";
  /// let buf = &data[..];
  ///
  /// // Peek from index 2 to 7 (exclusive)
  /// let peeker = Peeker::with_range(buf, 2..7);
  /// assert_eq!(peeker.remaining(), 5);
  /// ```
  #[inline]
  pub fn with_range(buf: B, range: impl RangeBounds<usize>) -> Self
  where
    B: Chunk,
  {
    let start = range.start_bound().cloned();
    let end = range.end_bound().cloned();
    let start_pos = Self::resolve_start_bound(start, &buf);
    Self::with_cursor_and_bounds_inner(buf, start_pos, Bound::Included(start_pos), end)
  }

  /// Returns the current position of the internal cursor relative to the start of the buffer.
  ///
  /// This represents how far the peeker's cursor has advanced from its starting position.
  ///
  /// # Examples
  ///
  /// ```rust
  /// use bufkit::{Chunk, Peeker};
  ///
  /// let data = [1, 2, 3, 4, 5];
  /// let buf = &data[..];
  /// let mut peeker = Peeker::new(buf);
  ///
  /// assert_eq!(peeker.position(), 0);
  /// peeker.read_u8();
  /// assert_eq!(peeker.position(), 1);
  /// peeker.advance(2);
  /// assert_eq!(peeker.position(), 3);
  /// ```
  #[inline]
  pub const fn position(&self) -> usize {
    let start_pos = Self::resolve_start_bound_without_check(self.start);
    self.cursor.saturating_sub(start_pos)
  }

  /// Returns the absolute position of the peeker's cursor in the original buffer.
  ///
  /// This is useful for understanding where the peeker is currently reading
  /// in relation to the entire buffer, especially when the peeker has been advanced
  /// or segmented.
  ///
  /// # Examples
  ///
  /// ```rust
  /// use bufkit::{Chunk, Peeker};
  ///
  /// let data = [1, 2, 3, 4, 5];
  /// let buf = &data[..];
  /// let mut peeker = Peeker::new(buf);
  ///
  /// let mut seg = peeker.segment(1..4);
  /// seg.advance(2);
  /// assert_eq!(seg.absolute_position(), 3); // 1 (start) + 2 (advanced)
  ///
  /// // Resetting the peeker will bring it back to the start position
  /// seg.reset();
  /// assert_eq!(seg.absolute_position(), 1); // Back to the start
  /// ```
  #[inline]
  pub const fn absolute_position(&self) -> usize {
    self.cursor
  }

  /// Returns the bounds of the peeker.
  ///
  /// This is useful for understanding the range within which the peeker can read.
  /// The bounds are represented as a tuple of `Bound<usize>`, indicating the start
  /// and end positions.
  ///
  /// # Examples
  ///
  /// ```rust
  /// use core::ops::Bound;
  /// use bufkit::{Chunk, Peeker};
  ///
  /// let data = [1, 2, 3, 4, 5];
  /// let buf = &data[..];
  /// let peeker = Peeker::with_range(buf, 1..4);
  /// assert_eq!(peeker.bounds(), (Bound::Included(1), Bound::Excluded(4)));
  /// ```
  #[inline]
  pub const fn bounds(&self) -> (Bound<usize>, Bound<usize>) {
    (self.start, self.end)
  }

  /// Resets the peeker's cursor to the beginning.
  ///
  /// After calling this method, the peeker will start reading from the same
  /// position where it was initially created.
  ///
  /// # Examples
  ///
  /// ```rust
  /// use bufkit::{Chunk, Peeker};
  ///
  /// let data = [1, 2, 3, 4, 5];
  /// let buf = &data[..];
  /// let mut peeker = Peeker::new(buf);
  ///
  /// peeker.advance(3);
  /// assert_eq!(peeker.position(), 3);
  ///
  /// peeker.reset();
  /// assert_eq!(peeker.position(), 0);
  /// assert_eq!(peeker.remaining(), 5);
  /// ```
  #[inline]
  pub const fn reset(&mut self) {
    self.cursor = Self::resolve_start_bound_without_check(self.start);
    self.limit = self.end;
  }

  /// Consumes the peeker and returns the underlying buffer.
  ///
  /// This is useful when you want to retrieve the original buffer
  /// after peeking operations are complete.
  ///
  /// # Examples
  ///
  /// ```rust
  /// use bufkit::{Chunk, Peeker};
  ///
  /// let data = [1, 2, 3, 4, 5];
  /// let buf = &data[..];
  /// let peeker = Peeker::new(buf);
  /// let original_buf = peeker.into_inner();
  /// assert_eq!(original_buf.remaining(), 5);
  /// ```
  #[inline]
  pub fn into_inner(self) -> B {
    self.buf
  }

  #[inline]
  const fn with_cursor_and_bounds_inner(
    buf: B,
    cursor: usize,
    start: Bound<usize>,
    end: Bound<usize>,
  ) -> Self {
    Self {
      buf,
      cursor,
      start,
      end,
      limit: end,
    }
  }

  #[inline]
  const fn resolve_start_bound_without_check(bound: Bound<usize>) -> usize {
    match bound {
      Bound::Included(n) => n,
      Bound::Excluded(n) => n.saturating_add(1),
      Bound::Unbounded => 0,
    }
  }

  #[inline]
  fn resolve_start_bound(bound: Bound<usize>, buf: &B) -> usize
  where
    B: Chunk,
  {
    let pos = match bound {
      Bound::Included(n) => n,
      Bound::Excluded(n) => n.saturating_add(1),
      Bound::Unbounded => 0,
    };
    pos.min(buf.remaining())
  }

  #[inline]
  fn resolve_end_bound(&self, bound: Bound<usize>) -> usize
  where
    B: Chunk,
  {
    match bound {
      Bound::Included(n) => n.saturating_add(1),
      Bound::Excluded(n) => n,
      Bound::Unbounded => self.buf.remaining(),
    }
  }
}

impl<B: EmptyChunk> EmptyChunk for Peeker<B> {
  /// ```rust
  /// use bufkit::{Chunk, EmptyChunk, Peeker};
  ///
  /// let empty_peeker = Peeker::<&[u8]>::empty();
  /// assert_eq!(empty_peeker.remaining(), 0);
  /// assert!(!empty_peeker.has_remaining());
  /// ```
  #[inline]
  fn empty() -> Self
  where
    Self: Sized,
  {
    Self::new(B::empty())
  }
}

impl<B: Chunk> Chunk for Peeker<B> {
  #[inline]
  fn remaining(&self) -> usize {
    let end_pos = self.resolve_end_bound(self.limit);
    end_pos.saturating_sub(self.cursor)
  }

  #[inline]
  fn buffer(&self) -> &[u8] {
    let start = self.cursor.min(self.buf.remaining());
    let end_pos = self.resolve_end_bound(self.limit);
    &self.buf.buffer()[start..end_pos]
  }

  #[inline]
  fn advance(&mut self, cnt: usize) {
    let remaining = self.remaining();
    if cnt > remaining {
      panic_advance(&TryAdvanceError::new(must_non_zero(cnt), remaining));
    }
    self.cursor += cnt;
  }

  #[inline]
  fn try_advance(&mut self, cnt: usize) -> Result<(), TryAdvanceError> {
    let remaining = self.remaining();
    if cnt > remaining {
      return Err(TryAdvanceError::new(must_non_zero(cnt), remaining));
    }
    self.cursor += cnt;
    Ok(())
  }

  #[inline]
  fn segment(&self, range: impl core::ops::RangeBounds<usize>) -> Self
  where
    Self: Sized,
  {
    let current_remaining = self.remaining();

    let begin = match range.start_bound() {
      Bound::Included(&n) => n,
      Bound::Excluded(&n) => n.checked_add(1).expect("range start overflow"),
      Bound::Unbounded => 0,
    };

    let end = match range.end_bound() {
      Bound::Included(&n) => n.checked_add(1).expect("range end overflow"),
      Bound::Excluded(&n) => n,
      Bound::Unbounded => current_remaining,
    };

    super::check_segment_range_bounds(begin, end, current_remaining);

    let start = self.cursor + begin;
    let start_bound = Bound::Included(start);
    if end == begin {
      let end_bound = Bound::Excluded(start);
      let buf = self.buf.segment(..);
      return Self::with_cursor_and_bounds_inner(buf, start, start_bound, end_bound);
    }

    let end_bound = Bound::Excluded(self.cursor + end);
    Self::with_cursor_and_bounds_inner(self.buf.segment(..), start, start_bound, end_bound)
  }

  #[inline]
  fn truncate(&mut self, len: usize) {
    let current_remaining = self.remaining();
    if len >= current_remaining {
      return; // No truncation needed
    }

    let new_end_pos = self.cursor + len;
    let current_end_pos = self.resolve_end_bound(self.limit);

    // Only truncate if the new limit is more restrictive than the current one
    if new_end_pos < current_end_pos {
      self.limit = Bound::Excluded(new_end_pos);
    }
  }

  #[inline]
  fn split_off(&mut self, at: usize) -> Self
  where
    Self: Sized,
  {
    let remaining = self.remaining();
    check_out_of_bounds("split_off", at, remaining);

    let new_cursor = self.cursor + at;
    let old_limit = self.limit;

    // Truncate self to [0, at) and update end so reset() stays bounded
    let self_end = Bound::Excluded(new_cursor);
    self.limit = self_end;
    self.end = self_end;

    // Return the right part [at, end) with start at the split point
    let start = Bound::Included(new_cursor);
    Self::with_cursor_and_bounds_inner(self.buf.segment(..), new_cursor, start, old_limit)
  }

  #[inline]
  fn split_to(&mut self, at: usize) -> Self
  where
    Self: Sized,
  {
    let remaining = self.remaining();
    check_out_of_bounds("split_to", at, remaining);

    let old_cursor = self.cursor;
    let new_end = self.cursor + at;

    // Advance self to [at, end) and update start/end so reset() stays bounded
    self.cursor += at;
    self.start = Bound::Included(self.cursor);
    self.end = self.limit;

    let start = Bound::Included(old_cursor);
    let end = Bound::Excluded(new_end);
    // Return the left part [0, at)
    Self::with_cursor_and_bounds_inner(self.buf.segment(..), old_cursor, start, end)
  }
}

#[allow(clippy::reversed_empty_ranges, clippy::clone_on_copy)]
#[cfg(test)]
mod tests {
  use super::*;

  #[test]
  fn test_peeker_basic_functionality() {
    let data = [1u8, 2, 3, 4, 5];
    let buf = &data[..];
    let mut peeker = Peeker::new(buf);

    assert_eq!(peeker.remaining(), 5);
    assert_eq!(peeker.position(), 0);

    // Read a byte
    assert_eq!(peeker.read_u8(), 1);
    assert_eq!(peeker.remaining(), 4);
    assert_eq!(peeker.position(), 1);

    // Original buffer should be unchanged
    assert_eq!(buf.remaining(), 5);
  }

  #[test]
  fn test_peeker_with_limit() {
    let data = [1u8, 2, 3, 4, 5];
    let buf = &data[..];
    let mut peeker = Peeker::with_limit(buf, 3);

    assert_eq!(peeker.remaining(), 3);

    // Read within limit
    assert_eq!(peeker.read_u8(), 1);
    assert_eq!(peeker.read_u8(), 2);
    assert_eq!(peeker.read_u8(), 3);

    // Should be at limit now
    assert_eq!(peeker.remaining(), 0);
  }

  #[test]
  fn test_peeker_reset() {
    let data = [1u8, 2, 3, 4, 5];
    let buf = &data[..];
    let mut peeker = Peeker::new(buf);

    peeker.advance(3);
    assert_eq!(peeker.position(), 3);
    assert_eq!(peeker.remaining(), 2);

    peeker.reset();
    assert_eq!(peeker.position(), 0);
    assert_eq!(peeker.remaining(), 5);
  }

  #[test]
  fn test_peeker_segment() {
    let data = b"Hello, World!";
    let buf = &data[..];
    let peeker = Peeker::new(buf);

    // Segment "Hello"
    let mut hello_peeker = peeker.segment(0..5);
    assert_eq!(hello_peeker.remaining(), 5);
    assert_eq!(hello_peeker.read_u8(), b'H');
    assert_eq!(hello_peeker.read_u8(), b'e');

    // Segment "World"
    let mut world_peeker = peeker.segment(7..12);
    assert_eq!(world_peeker.remaining(), 5);
    assert_eq!(world_peeker.read_u8(), b'W');
    assert_eq!(world_peeker.read_u8(), b'o');
  }

  #[test]
  fn test_peeker_segment_edge_1() {
    let buf = [1, 2, 3, 4, 5];
    let slice = &buf[..];
    let slice = Peeker::from(slice);
    let output = slice.segment((Bound::Excluded(1), Bound::Included(3)));
    assert_eq!(output.buffer(), &[3, 4]);
  }

  #[test]
  fn test_peeker_segment_edge_2() {
    let buf = [1, 2, 3, 4, 5];
    let slice = &buf[..];
    let slice = Peeker::from(slice);
    let output = slice.segment(2..);
    assert_eq!(output.buffer(), &[3, 4, 5]);
  }

  #[test]
  fn test_peeker_truncate() {
    let data = [1u8, 2, 3, 4, 5];
    let buf = &data[..];
    let mut peeker = Peeker::from(buf);

    peeker.truncate(3);
    assert_eq!(peeker.remaining(), 3);

    // Should only be able to read 3 bytes
    assert_eq!(peeker.read_u8(), 1);
    assert_eq!(peeker.read_u8(), 2);
    assert_eq!(peeker.read_u8(), 3);
    assert_eq!(peeker.remaining(), 0);

    let mut peeker = Peeker::with_limit(buf, 3);
    assert_eq!(peeker.remaining(), 3);
    peeker.truncate(2);

    assert_eq!(peeker.remaining(), 2);
  }

  #[test]
  #[should_panic]
  fn test_peeker_split_off_panic() {
    let data = [1u8, 2, 3];
    let buf = &data[..];
    let mut peeker = Peeker::new(buf);

    // This should panic because we are trying to split_off more than available
    let _ = peeker.split_off(5);
  }

  #[test]
  fn test_peeker_split_off() {
    let data = [1u8, 2, 3, 4, 5];
    let buf = &data[..];
    let mut peeker = Peeker::new(buf);

    let right_peeker = peeker.split_off(2);

    // Left part should have first 2 bytes
    assert_eq!(peeker.remaining(), 2);
    assert_eq!(peeker.read_u8(), 1);
    assert_eq!(peeker.read_u8(), 2);

    // Right part should have remaining bytes
    assert_eq!(right_peeker.remaining(), 3);
    let mut right = right_peeker;
    assert_eq!(right.position(), 0);
    assert_eq!(right.read_u8(), 3);
    assert_eq!(right.read_u8(), 4);
    assert_eq!(right.read_u8(), 5);
  }

  #[test]
  fn test_peeker_split_off_reset() {
    let data = [1u8, 2, 3, 4, 5];
    let buf = &data[..];
    let mut peeker = Peeker::new(buf);

    let mut right = peeker.split_off(2);

    // Right part: read some then reset
    assert_eq!(right.position(), 0);
    assert_eq!(right.read_u8(), 3);
    assert_eq!(right.position(), 1);
    right.reset();
    assert_eq!(right.position(), 0);
    assert_eq!(right.remaining(), 3);
    assert_eq!(right.read_u8(), 3); // reads from split point, not original start

    // Left part: read some then reset
    assert_eq!(peeker.position(), 0);
    assert_eq!(peeker.read_u8(), 1);
    peeker.reset();
    assert_eq!(peeker.position(), 0);
    assert_eq!(peeker.remaining(), 2); // bounded to [0, 2), not full buffer
    assert_eq!(peeker.read_u8(), 1);
  }

  #[test]
  #[should_panic]
  fn test_peeker_split_to_panic() {
    let data = [1u8, 2, 3];
    let buf = &data[..];
    let mut peeker = Peeker::new(buf);

    // This should panic because we are trying to split_to more than available
    let _ = peeker.split_to(5);
  }

  #[test]
  fn test_peeker_split_to() {
    let data = [1u8, 2, 3, 4, 5];
    let buf = &data[..];
    let mut peeker = Peeker::new(buf);

    let left_peeker = peeker.split_to(2);

    // Left part should have first 2 bytes
    assert_eq!(left_peeker.remaining(), 2);
    let mut left = left_peeker;
    assert_eq!(left.read_u8(), 1);
    assert_eq!(left.read_u8(), 2);

    // Remaining peeker should have rest
    assert_eq!(peeker.remaining(), 3);
    assert_eq!(peeker.position(), 0);
    assert_eq!(peeker.read_u8(), 3);
    assert_eq!(peeker.read_u8(), 4);
    assert_eq!(peeker.read_u8(), 5);
  }

  #[test]
  fn test_peeker_split_to_reset() {
    let data = [1u8, 2, 3, 4, 5];
    let buf = &data[..];
    let mut peeker = Peeker::new(buf);

    let mut left = peeker.split_to(2);

    // Left part: read some then reset
    assert_eq!(left.read_u8(), 1);
    left.reset();
    assert_eq!(left.position(), 0);
    assert_eq!(left.remaining(), 2);
    assert_eq!(left.read_u8(), 1);

    // Remaining part: read some then reset
    assert_eq!(peeker.position(), 0);
    assert_eq!(peeker.read_u8(), 3);
    assert_eq!(peeker.position(), 1);
    peeker.reset();
    assert_eq!(peeker.position(), 0);
    assert_eq!(peeker.remaining(), 3); // bounded to [2, 5), not full buffer
    assert_eq!(peeker.read_u8(), 3); // reads from split point, not original start
  }

  #[test]
  fn test_peeker_try_advance() {
    let data = [1u8, 2, 3];
    let buf = &data[..];
    let mut peeker = Peeker::new(buf);

    assert!(peeker.try_advance(2).is_ok());
    assert_eq!(peeker.position(), 2);

    // Should fail when trying to advance beyond available data
    assert!(peeker.try_advance(5).is_err());
    assert_eq!(peeker.position(), 2); // Should remain unchanged
  }

  #[test]
  #[should_panic(expected = "advance")]
  fn test_peeker_advance_panic() {
    let data = [1u8, 2, 3];
    let buf = &data[..];
    let mut peeker = Peeker::new(buf);

    peeker.advance(5); // Should panic
  }

  #[test]
  fn test_peeker_empty_segment() {
    let data = [1u8, 2, 3, 4, 5];
    let buf = &data[..];
    let peeker = Peeker::new(buf);

    let empty_peeker = peeker.segment(2..2);
    assert_eq!(empty_peeker.remaining(), 0);
  }

  #[test]
  fn test_peeker_clone_and_copy() {
    let data = [1u8, 2, 3, 4, 5];
    let buf = &data[..];
    let mut peeker = Peeker::new(buf);

    peeker.advance(2);

    let peeker_clone = peeker.clone();
    let peeker_copy = peeker;

    assert_eq!(peeker_clone.position(), 2);
    assert_eq!(peeker_copy.position(), 2);
    assert_eq!(peeker_clone.remaining(), peeker_copy.remaining());
  }

  #[test]
  fn test_peeker_with_advanced_buffer() {
    let data = [1u8, 2, 3, 4, 5];
    let mut buf = &data[..];

    // Advance the original buffer
    buf.advance(2);
    assert_eq!(buf.remaining(), 3);

    // Peeker should work with the advanced buffer
    let mut peeker = Peeker::new(buf);
    assert_eq!(peeker.remaining(), 3);
    assert_eq!(peeker.read_u8(), 3); // Should read the 3rd byte
  }

  #[test]
  #[should_panic]
  fn test_peeker_segment_panic_1() {
    let data = b"Hello, World!";
    let buf = &data[..];
    let peeker = Peeker::new(buf);

    // This should panic because the segment end is out of bounds
    let _ = peeker.segment(3..1);
  }

  #[test]
  #[should_panic]
  fn test_peeker_segment_panic_2() {
    let data = b"Hello, World!";
    let buf = &data[..];
    let peeker = Peeker::new(buf);

    // This should panic because the segment end is out of bounds
    let _ = peeker.segment(..20);
  }

  #[test]
  fn test_peeker_multi_level_segments() {
    let data = b"Hello, World!";
    let buf = &data[..];
    let peeker = Peeker::new(buf);

    // Create a segment, then segment that
    let hello_comma = peeker.segment(0..6); // "Hello,"
    let hello = hello_comma.segment(0..5); // "Hello"

    assert_eq!(hello.remaining(), 5);
    let mut hello_mut = hello;
    assert_eq!(hello_mut.read_u8(), b'H');
    assert_eq!(hello_mut.read_u8(), b'e');
  }

  #[test]
  fn test_peeker_range() {
    let data = b"Hello, World!";
    let buf = &data[..];

    // Peek from index 2 to 7 (inclusive)
    let mut peeker = Peeker::with_range(buf, 2..=7);
    assert_eq!(peeker.remaining(), 6);
    assert_eq!(peeker.buffer(), b"llo, W");
    assert_eq!(peeker.position(), 0);
    assert_eq!(peeker.absolute_position(), 2);

    peeker.read_u8();
    assert_eq!(peeker.position(), 1);
    assert_eq!(peeker.absolute_position(), 3);
    peeker.reset();
    assert_eq!(peeker.position(), 0);
    assert_eq!(peeker.absolute_position(), 2);

    let mut peeker = Peeker::with_range(buf, ..5);
    assert_eq!(peeker.remaining(), 5);
    assert_eq!(peeker.buffer(), b"Hello");
    assert_eq!(peeker.position(), 0);
    assert_eq!(peeker.absolute_position(), 0);

    peeker.read_u8();
    assert_eq!(peeker.position(), 1);
    assert_eq!(peeker.absolute_position(), 1);
    peeker.reset();
    assert_eq!(peeker.position(), 0);
    assert_eq!(peeker.absolute_position(), 0);

    let mut peeker = Peeker::with_range(buf, (Bound::Excluded(1), Bound::Unbounded));
    assert_eq!(peeker.remaining(), 11);
    assert_eq!(peeker.buffer(), b"llo, World!");
    assert_eq!(peeker.position(), 0);
    assert_eq!(peeker.absolute_position(), 2);

    peeker.read_u8();
    assert_eq!(peeker.position(), 1);
    assert_eq!(peeker.absolute_position(), 3);
    peeker.reset();
    assert_eq!(peeker.position(), 0);
    assert_eq!(peeker.absolute_position(), 2);
  }
}