I’m facing an issue with BufReader in Rust when attempting to read data into two separate temporary buffers under different conditions.

Below is a breakdown along with the added code.

• First Buffer Read (first_tmp_buf): It successfully reads 500 bytes of data.
  • Output example: [44, 32, 49, 50, 47, 55, ..., 55] ✅
• Second Buffer Read (second_tmp_buf): During the first iteration, it’s intended to read 1500 bytes. However, only the first 1000 bytes are valid, and the last 500 bytes are unexpectedly zeros. I suspect this issue arises from the initial 500-byte read into first_tmp_buf, which may be influencing the read position.
  • Output example: [44, 32, 49, 50, ..., 0, ..., 0] ❌
• Subsequent Reads (second_tmp_buf): These operations perform as expected, consistently returning 1500 valid bytes and completely filling the buffer.
  • Output example: [44, 32, 49, 50, 47, 55, ..., 55] ✅

I suspect the problem is linked to how the read position is managed across different buffer contexts, but I’m not certain how to address this effectively.

use std::io::{BufReader, Read, Cursor};

fn main() -> std::io::Result<()> {
    let huge_string_data = vec![0_u8; 200_00_00]; // Simulating a large dataset
    let src_buf = Reader::from_vec(huge_string_data);

    let mut first_tmp_buf = vec![0_u8; 500];
    // First read into `first_tmp_buf`:
    // ✅ Successfully returns 500 bytes of data.
    // Eg output: [44, 32, 49, 50, 47, 55, ..., 55]
    let bytes_read = src_buf.inner.read(&mut first_tmp_buf)?;

    let mut second_tmp_buf = vec![0_u8; 1500];
    let mut iter = 0;
    while condition {
        let bytes_read = src_buf.inner.read(&mut second_tmp_buf)?;

        // Second read into `second_tmp_buf` during first iteration:
        // When `(iter=0)`
        // ❌ Returns 1000 bytes of valid data, but last 500 bytes are zeros, not good.
        // Eg output: [44, 32, 49, 50, ..., 0, 0, 0, ..., 0]


        // Third read into `second_tmp_buf`:
        // When `(iter=1)`
        // ✅ Successfully returns 1500 bytes of data.
        // Eg output: [44, 32, 49, 50, 47, 55, ..., 55]
        
        
        iter += 1;
    }

    Ok(())
}

struct Reader {
    pub inner: BufReader<Box<dyn Read>>,
}

impl Reader {
    fn from_vec(v: Vec<u8>) -> Self {
        let cursor = Cursor::new(v);
        let boxed_reader = Box::new(cursor);

        Self {
            inner: BufReader::with_capacity(0x4000, boxed_reader),
        }
    }
}

Could anyone shed light on why BufReader behaves this way and suggest the best approach to ensure consistent reads across varying buffer sizes and contexts?