1 files changed, 107 insertions, 113 deletions
diff --git a/library/std/src/io/readbuf/tests.rs b/library/std/src/io/readbuf/tests.rs
index 3b7a5a56d22..cc1b423f2dd 100644
--- a/library/std/src/io/readbuf/tests.rs
+++ b/library/std/src/io/readbuf/tests.rs
@@ -1,181 +1,175 @@
-use super::ReadBuf;
+use super::BorrowedBuf;
 use crate::mem::MaybeUninit;
 
-/// Test that ReadBuf has the correct numbers when created with new
+/// Test that BorrowedBuf has the correct numbers when created with new
 #[test]
 fn new() {
-    let mut buf = [0; 16];
-    let rbuf = ReadBuf::new(&mut buf);
+    let buf: &mut [_] = &mut [0; 16];
+    let mut rbuf: BorrowedBuf<'_> = buf.into();
 
-    assert_eq!(rbuf.filled_len(), 0);
-    assert_eq!(rbuf.initialized_len(), 16);
+    assert_eq!(rbuf.filled().len(), 0);
+    assert_eq!(rbuf.init_len(), 16);
     assert_eq!(rbuf.capacity(), 16);
-    assert_eq!(rbuf.remaining(), 16);
+    assert_eq!(rbuf.unfilled().capacity(), 16);
 }
 
-/// Test that ReadBuf has the correct numbers when created with uninit
+/// Test that BorrowedBuf has the correct numbers when created with uninit
 #[test]
 fn uninit() {
-    let mut buf = [MaybeUninit::uninit(); 16];
-    let rbuf = ReadBuf::uninit(&mut buf);
+    let buf: &mut [_] = &mut [MaybeUninit::uninit(); 16];
+    let mut rbuf: BorrowedBuf<'_> = buf.into();
 
-    assert_eq!(rbuf.filled_len(), 0);
-    assert_eq!(rbuf.initialized_len(), 0);
+    assert_eq!(rbuf.filled().len(), 0);
+    assert_eq!(rbuf.init_len(), 0);
     assert_eq!(rbuf.capacity(), 16);
-    assert_eq!(rbuf.remaining(), 16);
+    assert_eq!(rbuf.unfilled().capacity(), 16);
 }
 
 #[test]
 fn initialize_unfilled() {
-    let mut buf = [MaybeUninit::uninit(); 16];
-    let mut rbuf = ReadBuf::uninit(&mut buf);
+    let buf: &mut [_] = &mut [MaybeUninit::uninit(); 16];
+    let mut rbuf: BorrowedBuf<'_> = buf.into();
 
-    rbuf.initialize_unfilled();
+    rbuf.unfilled().ensure_init();
 
-    assert_eq!(rbuf.initialized_len(), 16);
+    assert_eq!(rbuf.init_len(), 16);
 }
 
 #[test]
-fn initialize_unfilled_to() {
-    let mut buf = [MaybeUninit::uninit(); 16];
-    let mut rbuf = ReadBuf::uninit(&mut buf);
+fn addvance_filled() {
+    let buf: &mut [_] = &mut [0; 16];
+    let mut rbuf: BorrowedBuf<'_> = buf.into();
 
-    rbuf.initialize_unfilled_to(8);
-
-    assert_eq!(rbuf.initialized_len(), 8);
-
-    rbuf.initialize_unfilled_to(4);
-
-    assert_eq!(rbuf.initialized_len(), 8);
-
-    rbuf.set_filled(8);
-
-    rbuf.initialize_unfilled_to(6);
-
-    assert_eq!(rbuf.initialized_len(), 14);
-
-    rbuf.initialize_unfilled_to(8);
-
-    assert_eq!(rbuf.initialized_len(), 16);
-}
-
-#[test]
-fn add_filled() {
-    let mut buf = [0; 16];
-    let mut rbuf = ReadBuf::new(&mut buf);
-
-    rbuf.add_filled(1);
-
-    assert_eq!(rbuf.filled_len(), 1);
-    assert_eq!(rbuf.remaining(), 15);
-}
-
-#[test]
-#[should_panic]
-fn add_filled_panic() {
-    let mut buf = [MaybeUninit::uninit(); 16];
-    let mut rbuf = ReadBuf::uninit(&mut buf);
-
-    rbuf.add_filled(1);
-}
-
-#[test]
-fn set_filled() {
-    let mut buf = [0; 16];
-    let mut rbuf = ReadBuf::new(&mut buf);
-
-    rbuf.set_filled(16);
-
-    assert_eq!(rbuf.filled_len(), 16);
-    assert_eq!(rbuf.remaining(), 0);
-
-    rbuf.set_filled(6);
-
-    assert_eq!(rbuf.filled_len(), 6);
-    assert_eq!(rbuf.remaining(), 10);
-}
-
-#[test]
-#[should_panic]
-fn set_filled_panic() {
-    let mut buf = [MaybeUninit::uninit(); 16];
-    let mut rbuf = ReadBuf::uninit(&mut buf);
+    unsafe {
+        rbuf.unfilled().advance(1);
+    }
 
-    rbuf.set_filled(16);
+    assert_eq!(rbuf.filled().len(), 1);
+    assert_eq!(rbuf.unfilled().capacity(), 15);
 }
 
 #[test]
 fn clear() {
-    let mut buf = [255; 16];
-    let mut rbuf = ReadBuf::new(&mut buf);
+    let buf: &mut [_] = &mut [255; 16];
+    let mut rbuf: BorrowedBuf<'_> = buf.into();
 
-    rbuf.set_filled(16);
+    unsafe {
+        rbuf.unfilled().advance(16);
+    }
 
-    assert_eq!(rbuf.filled_len(), 16);
-    assert_eq!(rbuf.remaining(), 0);
+    assert_eq!(rbuf.filled().len(), 16);
+    assert_eq!(rbuf.unfilled().capacity(), 0);
 
     rbuf.clear();
 
-    assert_eq!(rbuf.filled_len(), 0);
-    assert_eq!(rbuf.remaining(), 16);
+    assert_eq!(rbuf.filled().len(), 0);
+    assert_eq!(rbuf.unfilled().capacity(), 16);
 
-    assert_eq!(rbuf.initialized(), [255; 16]);
+    assert_eq!(rbuf.unfilled().init_ref(), [255; 16]);
 }
 
 #[test]
-fn assume_init() {
-    let mut buf = [MaybeUninit::uninit(); 16];
-    let mut rbuf = ReadBuf::uninit(&mut buf);
+fn set_init() {
+    let buf: &mut [_] = &mut [MaybeUninit::uninit(); 16];
+    let mut rbuf: BorrowedBuf<'_> = buf.into();
 
     unsafe {
-        rbuf.assume_init(8);
+        rbuf.set_init(8);
     }
 
-    assert_eq!(rbuf.initialized_len(), 8);
+    assert_eq!(rbuf.init_len(), 8);
 
-    rbuf.add_filled(4);
+    unsafe {
+        rbuf.unfilled().advance(4);
+    }
 
     unsafe {
-        rbuf.assume_init(2);
+        rbuf.set_init(2);
     }
 
-    assert_eq!(rbuf.initialized_len(), 8);
+    assert_eq!(rbuf.init_len(), 8);
 
     unsafe {
-        rbuf.assume_init(8);
+        rbuf.set_init(8);
     }
 
-    assert_eq!(rbuf.initialized_len(), 12);
+    assert_eq!(rbuf.init_len(), 8);
 }
 
 #[test]
 fn append() {
-    let mut buf = [MaybeUninit::new(255); 16];
-    let mut rbuf = ReadBuf::uninit(&mut buf);
+    let buf: &mut [_] = &mut [MaybeUninit::new(255); 16];
+    let mut rbuf: BorrowedBuf<'_> = buf.into();
 
-    rbuf.append(&[0; 8]);
+    rbuf.unfilled().append(&[0; 8]);
 
-    assert_eq!(rbuf.initialized_len(), 8);
-    assert_eq!(rbuf.filled_len(), 8);
+    assert_eq!(rbuf.init_len(), 8);
+    assert_eq!(rbuf.filled().len(), 8);
     assert_eq!(rbuf.filled(), [0; 8]);
 
     rbuf.clear();
 
-    rbuf.append(&[1; 16]);
+    rbuf.unfilled().append(&[1; 16]);
 
-    assert_eq!(rbuf.initialized_len(), 16);
-    assert_eq!(rbuf.filled_len(), 16);
+    assert_eq!(rbuf.init_len(), 16);
+    assert_eq!(rbuf.filled().len(), 16);
     assert_eq!(rbuf.filled(), [1; 16]);
 }
 
 #[test]
-fn filled_mut() {
-    let mut buf = [0; 16];
-    let mut rbuf = ReadBuf::new(&mut buf);
+fn reborrow_written() {
+    let buf: &mut [_] = &mut [MaybeUninit::new(0); 32];
+    let mut buf: BorrowedBuf<'_> = buf.into();
+
+    let mut cursor = buf.unfilled();
+    cursor.append(&[1; 16]);
+
+    let mut cursor2 = cursor.reborrow();
+    cursor2.append(&[2; 16]);
+
+    assert_eq!(cursor2.written(), 32);
+    assert_eq!(cursor.written(), 32);
+
+    assert_eq!(buf.unfilled().written(), 0);
+    assert_eq!(buf.init_len(), 32);
+    assert_eq!(buf.filled().len(), 32);
+    let filled = buf.filled();
+    assert_eq!(&filled[..16], [1; 16]);
+    assert_eq!(&filled[16..], [2; 16]);
+}
+
+#[test]
+fn cursor_set_init() {
+    let buf: &mut [_] = &mut [MaybeUninit::uninit(); 16];
+    let mut rbuf: BorrowedBuf<'_> = buf.into();
+
+    unsafe {
+        rbuf.unfilled().set_init(8);
+    }
 
-    rbuf.add_filled(8);
+    assert_eq!(rbuf.init_len(), 8);
+    assert_eq!(rbuf.unfilled().init_ref().len(), 8);
+    assert_eq!(rbuf.unfilled().init_mut().len(), 8);
+    assert_eq!(rbuf.unfilled().uninit_mut().len(), 8);
+    assert_eq!(unsafe { rbuf.unfilled().as_mut() }.len(), 16);
+
+    unsafe {
+        rbuf.unfilled().advance(4);
+    }
 
-    let filled = rbuf.filled().to_vec();
+    unsafe {
+        rbuf.unfilled().set_init(2);
+    }
+
+    assert_eq!(rbuf.init_len(), 8);
+
+    unsafe {
+        rbuf.unfilled().set_init(8);
+    }
 
-    assert_eq!(&*filled, &*rbuf.filled_mut());
+    assert_eq!(rbuf.init_len(), 12);
+    assert_eq!(rbuf.unfilled().init_ref().len(), 8);
+    assert_eq!(rbuf.unfilled().init_mut().len(), 8);
+    assert_eq!(rbuf.unfilled().uninit_mut().len(), 4);
+    assert_eq!(unsafe { rbuf.unfilled().as_mut() }.len(), 12);
 }