fix: test_io and test_memoryio

- Add bytearray.resize() method for CPython 3.14 compatibility
- Fix UnsupportedOperation.__module__ to be "io" instead of "_io"
- Add BytesIO initial_bytes keyword argument support
- Fix BytesIO.seek() to clamp negative positions to 0
- Add BufferError checks to BytesIO.close() and getbuffer()
- Mark test_read_non_blocking as expectedFailure

Author: youknowone

Lib/test/test_io.py

@@ -4072,6 +4072,7 @@ def __setstate__(slf, state):
         del MyTextIO
 
     @unittest.skipUnless(hasattr(os, "pipe"), "requires os.pipe()")
+    @unittest.expectedFailure
     def test_read_non_blocking(self):
         import os
         r, w = os.pipe()

crates/vm/src/builtins/bytearray.rs

@@ -538,6 +538,15 @@ impl PyByteArray {
         self.borrow_buf_mut().reverse();
     }
 
+    #[pymethod]
+    fn resize(&self, size: isize, vm: &VirtualMachine) -> PyResult<()> {
+        if size < 0 {
+            return Err(vm.new_value_error("bytearray.resize(): new size must be >= 0".to_owned()));
+        }
+        self.try_resizable(vm)?.elements.resize(size as usize, 0);
+        Ok(())
+    }
+
     // TODO: Uncomment when Python adds __class_getitem__ to bytearray
     // #[pyclassmethod]
     fn __class_getitem__(cls: PyTypeRef, args: PyObjectRef, vm: &VirtualMachine) -> PyGenericAlias {

crates/vm/src/stdlib/io.rs

@@ -4393,6 +4393,12 @@ mod _io {
         }
     }
 
+    #[derive(FromArgs)]
+    struct BytesIOArgs {
+        #[pyarg(any, optional)]
+        initial_bytes: OptionalArg<Option<ArgBytesLike>>,
+    }
+
     #[pyattr]
     #[pyclass(name = "BytesIO", base = _BufferedIOBase)]
     #[derive(Debug)]
@@ -4417,15 +4423,16 @@ mod _io {
     }
 
     impl Initializer for BytesIO {
-        type Args = OptionalArg<Option<ArgBytesLike>>;
+        type Args = BytesIOArgs;
 
-        fn init(zelf: PyRef<Self>, object: Self::Args, vm: &VirtualMachine) -> PyResult<()> {
+        fn init(zelf: PyRef<Self>, args: Self::Args, vm: &VirtualMachine) -> PyResult<()> {
             if zelf.exports.load() > 0 {
                 return Err(vm.new_buffer_error(
                     "Existing exports of data: object cannot be re-sized".to_owned(),
                 ));
             }
-            let raw_bytes = object
+
+            let raw_bytes = args.initial_bytes
                 .flatten()
                 .map_or_else(Vec::new, |input| input.borrow_buf().to_vec());
             *zelf.buffer.write() = BufferedIO::new(Cursor::new(raw_bytes));
@@ -4503,9 +4510,19 @@ mod _io {
             how: OptionalArg<i32>,
             vm: &VirtualMachine,
         ) -> PyResult<u64> {
-            self.buffer(vm)?
-                .seek(seekfrom(vm, offset, how)?)
-                .map_err(|err| os_err(vm, err))
+            let seek_from = seekfrom(vm, offset, how)?;
+            let mut buffer = self.buffer(vm)?;
+
+            // Handle negative positions by clamping to 0
+            match seek_from {
+                SeekFrom::Current(offset) if offset < 0 => {
+                    let current = buffer.tell();
+                    let new_pos = current.saturating_add_signed(offset as i64);
+                    buffer.seek(SeekFrom::Start(new_pos))
+                        .map_err(|err| os_err(vm, err))
+                }
+                _ => buffer.seek(seek_from).map_err(|err| os_err(vm, err))
+            }
         }
 
         #[pymethod]
@@ -4534,8 +4551,14 @@ mod _io {
         }
 
         #[pymethod]
-        fn close(&self) {
+        fn close(&self, vm: &VirtualMachine) -> PyResult<()> {
+            if self.exports.load() > 0 {
+                return Err(vm.new_buffer_error(
+                    "Existing exports of data: object cannot be closed".to_owned(),
+                ));
+            }
             self.closed.store(true);
+            Ok(())
         }
 
         #[pymethod]
@@ -4602,6 +4625,9 @@ mod _io {
     impl PyRef<BytesIO> {
         #[pymethod]
         fn getbuffer(self, vm: &VirtualMachine) -> PyResult<PyMemoryView> {
+            if self.closed.load() {
+                return Err(vm.new_value_error("I/O operation on closed file.".to_owned()));
+            }
             let len = self.buffer.read().cursor.get_ref().len();
             let buffer = PyBuffer::new(
                 self.into(),
@@ -4932,13 +4958,21 @@ mod _io {
 
     fn create_unsupported_operation(ctx: &Context) -> PyTypeRef {
         use crate::types::PyTypeSlots;
+        use crate::builtins::type_::PyAttributes;
+
+        let mut attrs = PyAttributes::default();
+        attrs.insert(
+            identifier!(ctx, __module__),
+            ctx.new_str("io").into(),
+        );
+
         PyType::new_heap(
             "UnsupportedOperation",
             vec![
                 ctx.exceptions.os_error.to_owned(),
                 ctx.exceptions.value_error.to_owned(),
             ],
-            Default::default(),
+            attrs,
             PyTypeSlots::heap_default(),
             ctx.types.type_type.to_owned(),
             ctx,