rename some variables in tests

Author: sunshowers

src/cursor/tests.rs

@@ -21,15 +21,15 @@ fn proptest_cursor_ops(
 ) {
     let bytes = buf_list.clone().copy_to_bytes(buf_list.remaining());
     let mut buf_list_cursor = crate::Cursor::new(&buf_list);
-    let mut upstream_cursor = io::Cursor::new(bytes.as_ref());
+    let mut oracle_cursor = io::Cursor::new(bytes.as_ref());
 
     eprintln!("\n**** start!");
 
     for (index, cursor_op) in ops.into_iter().enumerate() {
         // apply_and_compare prints out the rest of the line.
         eprint!("** index {}, operation {:?}: ", index, cursor_op);
         cursor_op
-            .apply_and_compare(&mut buf_list_cursor, &mut upstream_cursor)
+            .apply_and_compare(&mut buf_list_cursor, &mut oracle_cursor)
             .with_context(|| format!("for index {}", index))
             .unwrap();
     }
@@ -53,7 +53,7 @@ enum CursorOp {
         Vec<prop::sample::Index>,
     ),
     ReadExact(prop::sample::Index),
-    // fill_buf can't be tested here because upstream is a contiguous block. Instead, we check its
+    // fill_buf can't be tested here because oracle is a contiguous block. Instead, we check its
     // return value separately.
     Consume(prop::sample::Index),
     // No need to test futures03 imps since they're simple wrappers around the main imps.
@@ -69,7 +69,7 @@ impl CursorOp {
         self,
         // The "mut" here is used in the branches corresponding to optional features.
         #[allow(unused_mut)] mut buf_list: &mut crate::Cursor<&BufList>,
-        #[allow(unused_mut)] mut upstream: &mut io::Cursor<&[u8]>,
+        #[allow(unused_mut)] mut oracle: &mut io::Cursor<&[u8]>,
     ) -> Result<()> {
         let num_bytes = buf_list.get_ref().num_bytes();
         match self {
@@ -79,16 +79,16 @@ impl CursorOp {
                 eprintln!("set position: {}", index);
 
                 buf_list.set_position(index);
-                upstream.set_position(index);
+                oracle.set_position(index);
             }
             Self::SeekStart(index) => {
                 // Allow going past the end of the list a bit.
                 let style = SeekFrom::Start(index.index(1 + num_bytes * 5 / 4) as u64);
                 eprintln!("style: {:?}", style);
 
-                let buf_list_pos = buf_list.seek(style);
-                let upstream_pos = upstream.seek(style);
-                Self::assert_io_error_eq(buf_list_pos, upstream_pos)
+                let buf_list_res = buf_list.seek(style);
+                let oracle_res = oracle.seek(style);
+                Self::assert_io_result_eq(buf_list_res, oracle_res)
                     .context("operation result didn't match")?;
             }
             Self::SeekEnd(index) => {
@@ -97,9 +97,9 @@ impl CursorOp {
                 let style = SeekFrom::End(index - (1 + num_bytes * 5 / 4) as i64);
                 eprintln!("style: {:?}", style);
 
-                let buf_list_pos = buf_list.seek(style);
-                let upstream_pos = upstream.seek(style);
-                Self::assert_io_error_eq(buf_list_pos, upstream_pos)
+                let buf_list_res = buf_list.seek(style);
+                let oracle_res = oracle.seek(style);
+                Self::assert_io_result_eq(buf_list_res, oracle_res)
                     .context("operation result didn't match")?;
             }
             Self::SeekCurrent(index) => {
@@ -108,9 +108,9 @@ impl CursorOp {
                 let style = SeekFrom::Current(index - (num_bytes * 3 / 4) as i64);
                 eprintln!("style: {:?}", style);
 
-                let buf_list_pos = buf_list.seek(style);
-                let upstream_pos = upstream.seek(style);
-                Self::assert_io_error_eq(buf_list_pos, upstream_pos)
+                let buf_list_res = buf_list.seek(style);
+                let oracle_res = oracle.seek(style);
+                Self::assert_io_result_eq(buf_list_res, oracle_res)
                     .context("operation result didn't match")?;
             }
             Self::Read(index) => {
@@ -120,13 +120,13 @@ impl CursorOp {
                 // Must initialize the whole vec here so &mut returns the whole buffer -- can't use
                 // with_capacity!
                 let mut buf_list_buf = vec![0u8; buf_size];
-                let mut upstream_buf = vec![0u8; buf_size];
+                let mut oracle_buf = vec![0u8; buf_size];
 
-                let buf_list_nread = buf_list.read(&mut buf_list_buf);
-                let upstream_nread = upstream.read(&mut upstream_buf);
-                Self::assert_io_error_eq(buf_list_nread, upstream_nread)
+                let buf_list_res = buf_list.read(&mut buf_list_buf);
+                let oracle_res = oracle.read(&mut oracle_buf);
+                Self::assert_io_result_eq(buf_list_res, oracle_res)
                     .context("operation result didn't match")?;
-                ensure!(buf_list_buf == upstream_buf, "read buffer matches");
+                ensure!(buf_list_buf == oracle_buf, "read buffer matches");
             }
             Self::ReadVectored(indexes) => {
                 // Build a bunch of IoSliceMuts.
@@ -139,28 +139,26 @@ impl CursorOp {
                         vec![0u8; buf_size]
                     })
                     .collect();
-                let mut upstream_vecs = buf_list_vecs.clone();
+                let mut oracle_vecs = buf_list_vecs.clone();
 
                 let mut buf_list_slices: Vec<_> = buf_list_vecs
                     .iter_mut()
                     .map(|v| IoSliceMut::new(v))
                     .collect();
-                let mut upstream_slices: Vec<_> = upstream_vecs
-                    .iter_mut()
-                    .map(|v| IoSliceMut::new(v))
-                    .collect();
+                let mut oracle_slices: Vec<_> =
+                    oracle_vecs.iter_mut().map(|v| IoSliceMut::new(v)).collect();
 
                 let buf_list_res = buf_list.read_vectored(&mut buf_list_slices);
-                let upstream_res = upstream.read_vectored(&mut upstream_slices);
-                Self::assert_io_error_eq(buf_list_res, upstream_res)
+                let oracle_res = oracle.read_vectored(&mut oracle_slices);
+                Self::assert_io_result_eq(buf_list_res, oracle_res)
                     .context("operation result didn't match")?;
 
                 // Also check that the slices read match exactly.
                 ensure!(
-                    buf_list_vecs == upstream_vecs,
-                    "read vecs didn't match: buf_list: {:?} == upstream: {:?}",
+                    buf_list_vecs == oracle_vecs,
+                    "read vecs didn't match: buf_list: {:?} == oracle: {:?}",
                     buf_list_vecs,
-                    upstream_vecs
+                    oracle_vecs
                 );
             }
             Self::ReadExact(index) => {
@@ -170,20 +168,20 @@ impl CursorOp {
                 // Must initialize the whole vec here so &mut returns the whole buffer -- can't use
                 // with_capacity!
                 let mut buf_list_buf = vec![0u8; buf_size];
-                let mut upstream_buf = vec![0u8; buf_size];
+                let mut oracle_buf = vec![0u8; buf_size];
 
                 let buf_list_res = buf_list.read_exact(&mut buf_list_buf);
-                let upstream_res = upstream.read_exact(&mut upstream_buf);
-                Self::assert_io_error_eq(buf_list_res, upstream_res)
+                let oracle_res = oracle.read_exact(&mut oracle_buf);
+                Self::assert_io_result_eq(buf_list_res, oracle_res)
                     .context("operation result didn't match")?;
-                ensure!(buf_list_buf == upstream_buf, "read buffer matches");
+                ensure!(buf_list_buf == oracle_buf, "read buffer matches");
             }
             Self::Consume(index) => {
                 let amt = index.index(1 + num_bytes * 5 / 4);
                 eprintln!("amt: {}", amt);
 
                 buf_list.consume(amt);
-                upstream.consume(amt);
+                oracle.consume(amt);
             }
             #[cfg(feature = "tokio1")]
             Self::PollRead { capacity, filled } => {
@@ -192,7 +190,7 @@ impl CursorOp {
 
                 let capacity = capacity.index(1 + num_bytes * 5 / 4);
                 let mut buf_list_vec = vec![MaybeUninit::uninit(); capacity];
-                let mut upstream_vec = buf_list_vec.clone();
+                let mut oracle_vec = buf_list_vec.clone();
 
                 let mut buf_list_buf = ReadBuf::uninit(&mut buf_list_vec);
 
@@ -202,8 +200,8 @@ impl CursorOp {
                 let fill_vec = vec![0u8; filled_index];
                 buf_list_buf.put_slice(&fill_vec);
 
-                let mut upstream_buf = ReadBuf::uninit(&mut upstream_vec);
-                upstream_buf.put_slice(&fill_vec);
+                let mut oracle_buf = ReadBuf::uninit(&mut oracle_vec);
+                oracle_buf.put_slice(&fill_vec);
 
                 eprintln!("capacity: {}, filled_index: {}", capacity, filled_index);
 
@@ -218,41 +216,41 @@ impl CursorOp {
                     Poll::Pending => unreachable!("buf_list never returns pending"),
                 };
 
-                let mut upstream_pinned = Pin::new(upstream);
-                let upstream_res = match upstream_pinned
+                let mut oracle_pinned = Pin::new(oracle);
+                let oracle_res = match oracle_pinned
                     .as_mut()
-                    .poll_read(&mut context, &mut upstream_buf)
+                    .poll_read(&mut context, &mut oracle_buf)
                 {
                     Poll::Ready(res) => res,
-                    Poll::Pending => unreachable!("upstream cursor never returns pending"),
+                    Poll::Pending => unreachable!("oracle cursor never returns pending"),
                 };
 
-                Self::assert_io_error_eq(buf_list_res, upstream_res)
+                Self::assert_io_result_eq(buf_list_res, oracle_res)
                     .context("result didn't match")?;
                 ensure!(
-                    buf_list_buf.filled() == upstream_buf.filled(),
+                    buf_list_buf.filled() == oracle_buf.filled(),
                     "filled section didn't match"
                 );
                 ensure!(
-                    buf_list_buf.remaining() == upstream_buf.remaining(),
+                    buf_list_buf.remaining() == oracle_buf.remaining(),
                     "remaining count didn't match"
                 );
 
-                // Put buf_list and upstream back into their original places.
+                // Put buf_list and oracle back into their original places.
                 buf_list = buf_list_pinned.get_mut();
-                upstream = upstream_pinned.get_mut();
+                oracle = oracle_pinned.get_mut();
             }
         }
 
         // Also check that the position is the same.
         let buf_list_position = buf_list.position();
         ensure!(
-            buf_list_position == upstream.position(),
-            "position didn't match: buf_list position {} == upstream position {}",
+            buf_list_position == oracle.position(),
+            "position didn't match: buf_list position {} == oracle position {}",
             buf_list_position,
-            upstream.position(),
+            oracle.position(),
         );
-        Self::assert_io_error_eq(buf_list.stream_position(), upstream.stream_position())
+        Self::assert_io_result_eq(buf_list.stream_position(), oracle.stream_position())
             .context("stream position didn't match")?;
 
         // Check that fill_buf returns an empty slice iff it is actually empty.
@@ -279,40 +277,40 @@ impl CursorOp {
         Ok(())
     }
 
-    fn assert_io_error_eq<T: Eq + fmt::Debug>(
+    fn assert_io_result_eq<T: Eq + fmt::Debug>(
         buf_list_res: io::Result<T>,
-        upstream_res: io::Result<T>,
+        oracle_res: io::Result<T>,
     ) -> Result<()> {
-        match (buf_list_res, upstream_res) {
-            (Ok(buf_value), Ok(upstream_value)) => {
+        match (buf_list_res, oracle_res) {
+            (Ok(buf_list_value), Ok(oracle_value)) => {
                 ensure!(
-                    buf_value == upstream_value,
-                    "value didn't match: buf_list value {:?} == upstream value {:?}",
-                    buf_value,
-                    upstream_value
+                    buf_list_value == oracle_value,
+                    "value didn't match: buf_list value {:?} == oracle value {:?}",
+                    buf_list_value,
+                    oracle_value
                 );
             }
-            (Ok(buf_value), Err(upstream_err)) => {
+            (Ok(buf_list_value), Err(oracle_err)) => {
                 bail!(
-                    "BufList value Ok({:?}) is not the same as upstream error Err({})",
-                    buf_value,
-                    upstream_err,
+                    "BufList value Ok({:?}) is not the same as oracle error Err({})",
+                    buf_list_value,
+                    oracle_err,
                 );
             }
-            (Err(buf_err), Ok(upstream_value)) => {
+            (Err(buf_list_err), Ok(oracle_value)) => {
                 bail!(
-                    "BufList error ({}) is not the same as upstream value ({:?})",
-                    buf_err,
-                    upstream_value
+                    "BufList error ({}) is not the same as oracle value ({:?})",
+                    buf_list_err,
+                    oracle_value
                 )
             }
-            (Err(buf_err), Err(upstream_err)) => {
+            (Err(buf_list_err), Err(oracle_err)) => {
                 // The kinds should match.
                 ensure!(
-                    buf_err.kind() == upstream_err.kind(),
-                    "error kind didn't match: buf_list {:?} == upstream {:?}",
-                    buf_err.kind(),
-                    upstream_err.kind()
+                    buf_list_err.kind() == oracle_err.kind(),
+                    "error kind didn't match: buf_list {:?} == oracle {:?}",
+                    buf_list_err.kind(),
+                    oracle_err.kind()
                 );
             }
         }