RustPython · youknowone · Oct 7, 2021 · Aug 23, 2021 · Aug 24, 2021 · Aug 24, 2021
diff --git a/Lib/test/test_exception_hierarchy.py b/Lib/test/test_exception_hierarchy.py
@@ -81,8 +81,6 @@ def _make_map(s):
         return _map
     _map = _make_map(_pep_map)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_errno_mapping(self):
         # The OSError constructor maps errnos to subclasses
         # A sample test for the basic functionality

diff --git a/Lib/test/test_subprocess.py b/Lib/test/test_subprocess.py
@@ -361,10 +361,6 @@ def test_executable_takes_precedence(self):
                           self._assert_python, pre_args,
                           executable=NONEXISTING_CMD[0])
 
-    # TODO: RUSTPYTHON
-    if sys.platform != "win32":
-        test_executable_takes_precedence = unittest.expectedFailure(test_executable_takes_precedence)
-
     @unittest.skipIf(mswindows, "executable argument replaces shell")
     def test_executable_replaces_shell(self):
         # Check that the executable argument replaces the default shell
@@ -431,8 +427,6 @@ def test_cwd_with_pathlike(self):
         temp_dir = self._normalize_cwd(temp_dir)
         self._assert_cwd(temp_dir, sys.executable, cwd=FakePath(temp_dir))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @unittest.skipIf(mswindows, "pending resolution of issue #15533")
     def test_cwd_with_relative_arg(self):
         # Check that Popen looks for args[0] relative to cwd if args[0]
@@ -449,8 +443,6 @@ def test_cwd_with_relative_arg(self):
             python_dir = self._normalize_cwd(python_dir)
             self._assert_cwd(python_dir, rel_python, cwd=python_dir)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @unittest.skipIf(mswindows, "pending resolution of issue #15533")
     def test_cwd_with_relative_executable(self):
         # Check that Popen looks for executable relative to cwd if executable
@@ -484,10 +476,6 @@ def test_cwd_with_absolute_arg(self):
             wrong_dir = self._normalize_cwd(wrong_dir)
             self._assert_cwd(wrong_dir, abs_python, cwd=wrong_dir)
 
-    # TODO: RUSTPYTHON
-    if sys.platform != "win32":
-        test_cwd_with_absolute_arg = unittest.expectedFailure(test_cwd_with_absolute_arg)
-
     @unittest.skipIf(sys.base_prefix != sys.prefix,
                      'Test is not venv-compatible')
     def test_executable_with_cwd(self):
@@ -1257,10 +1245,6 @@ def test_leaking_fds_on_error(self):
                                  stdout=subprocess.PIPE,
                                  stderr=subprocess.PIPE)
 
-    # TODO: RUSTPYTHON
-    if sys.platform != "win32":
-        test_leaking_fds_on_error = unittest.expectedFailure(test_leaking_fds_on_error)
-
     def test_nonexisting_with_pipes(self):
         # bpo-30121: Popen with pipes must close properly pipes on error.
         # Previously, os.close() was called with a Windows handle which is not
@@ -1755,8 +1739,6 @@ class PopenNoDestructor(subprocess.Popen):
         def __del__(self):
             pass
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @mock.patch("subprocess._posixsubprocess.fork_exec")
     def test_exception_errpipe_normal(self, fork_exec):
         """Test error passing done through errpipe_write in the good case"""
@@ -3513,10 +3495,6 @@ def test_invalid_args(self):
                                   stderr=subprocess.PIPE) as proc:
                 pass
 
-    # TODO: RUSTPYTHON
-    if sys.platform != "win32":
-        test_invalid_args = unittest.expectedFailure(test_invalid_args)
-
     def test_broken_pipe_cleanup(self):
         """Broken pipe error should not prevent wait() (Issue 21619)"""
         proc = subprocess.Popen(ZERO_RETURN_CMD,

diff --git a/vm/src/exceptions.rs b/vm/src/exceptions.rs
@@ -950,9 +950,10 @@ impl<C: widestring::UChar> IntoPyException for widestring::NulError<C> {
 pub(super) mod types {
     use crate::common::lock::PyRwLock;
     use crate::{
-        builtins::{traceback::PyTracebackRef, PyTupleRef, PyTypeRef},
-        function::FuncArgs,
-        PyRef, PyResult, VirtualMachine,
+        builtins::{traceback::PyTracebackRef, PyInt, PyTupleRef, PyTypeRef},
+        exceptions::invoke,
+        function::{FuncArgs, IntoPyResult},
+        PyObjectRef, PyRef, PyResult, VirtualMachine,
     };
     use crossbeam_utils::atomic::AtomicCell;
 
@@ -1146,8 +1147,90 @@ pub(super) mod types {
         PyOSError,
         PyException,
         os_error,
-        "Base class for I/O related errors."
+        "Base class for I/O related errors.",
+        os_error_new,
+        base_exception_init,
     }
+    #[cfg(not(target_arch = "wasm32"))]
+    fn os_error_optional_new(
+        args: Vec<PyObjectRef>,
+        vm: &VirtualMachine,
+    ) -> Option<PyResult<PyBaseExceptionRef>> {
+        use crate::stdlib::errno::errors;
+
+        let len = args.len();
+        if len >= 2 {
+            let args = args.as_slice();
+            let errno = &args[0];
+            let error = match errno.payload_if_subclass::<PyInt>(vm) {
+                Some(errno) => match errno.try_to_primitive::<i32>(vm) {
+                    Ok(errno) => {
+                        let excs = &vm.ctx.exceptions;
+                        let error = match errno {
+                            errors::EWOULDBLOCK => Some(excs.blocking_io_error.clone()),
+                            errors::EALREADY => Some(excs.blocking_io_error.clone()),
+                            errors::EINPROGRESS => Some(excs.blocking_io_error.clone()),
+                            errors::EPIPE => Some(excs.broken_pipe_error.clone()),
+                            errors::ESHUTDOWN => Some(excs.broken_pipe_error.clone()),
+                            errors::ECHILD => Some(excs.child_process_error.clone()),
+                            errors::ECONNABORTED => Some(excs.connection_aborted_error.clone()),
+                            errors::ECONNREFUSED => Some(excs.connection_refused_error.clone()),
+                            errors::ECONNRESET => Some(excs.connection_reset_error.clone()),
+                            errors::EEXIST => Some(excs.file_exists_error.clone()),
+                            errors::ENOENT => Some(excs.file_not_found_error.clone()),
+                            errors::EISDIR => Some(excs.is_a_directory_error.clone()),
+                            errors::ENOTDIR => Some(excs.not_a_directory_error.clone()),
+                            errors::EINTR => Some(excs.interrupted_error.clone()),
+                            errors::EACCES => Some(excs.permission_error.clone()),
+                            errors::EPERM => Some(excs.permission_error.clone()),
+                            errors::ESRCH => Some(excs.process_lookup_error.clone()),
+                            errors::ETIMEDOUT => Some(excs.timeout_error.clone()),
+                            _ => None,
+                        };
+
+                        if error.is_some() {
+                            Some(invoke(error?, args.to_vec(), vm))
+                        } else {
+                            None
+                        }
+                    }
+                    Err(_) => None,
+                },
+                None => None,
+            };
+
+            error
+        } else {
+            None
+        }
+    }
+    #[cfg(not(target_arch = "wasm32"))]
+    fn os_error_new(cls: PyTypeRef, args: FuncArgs, vm: &VirtualMachine) -> PyResult {
+        // We need this method, because of how `CPython` copies `init`
+        // from `BaseException` in `SimpleExtendsException` macro.
+        // See: `BaseException_new`
+        if cls.name() == vm.ctx.exceptions.os_error.name() {
+            match os_error_optional_new(args.args.to_vec(), vm) {
+                Some(error) => error.unwrap().into_pyresult(vm),
+                None => PyBaseException::slot_new(cls, args, vm),
+            }
+        } else {
+            PyBaseException::slot_new(cls, args, vm)
+        }
+    }
+    #[cfg(target_arch = "wasm32")]
+    fn os_error_new(cls: PyTypeRef, args: FuncArgs, vm: &VirtualMachine) -> PyResult {
+        PyBaseException::slot_new(cls, args, vm)
+    }
+
+    fn base_exception_init(
+        zelf: PyRef<PyBaseException>,
+        args: FuncArgs,
+        vm: &VirtualMachine,
+    ) -> PyResult<()> {
+        PyBaseException::init(zelf, args, vm)
+    }
+
     define_exception! {
         PyBlockingIOError,
         PyOSError,

diff --git a/vm/src/stdlib/errno.rs b/vm/src/stdlib/errno.rs
@@ -39,7 +39,7 @@ pub mod errors {
     }
 }
 
-#[cfg(any(unix, windows))]
+#[cfg(any(unix, windows, target_os = "wasi"))]
 macro_rules! e {
     ($name:ident) => {
         (stringify!($name), errors::$name as _)
@@ -50,7 +50,7 @@ macro_rules! e {
     };
 }
 
-#[cfg(any(unix, windows))]
+#[cfg(any(unix, windows, target_os = "wasi"))]
 const ERROR_CODES: &[(&str, i32)] = &[
     e!(ENODEV),
     e!(EHOSTUNREACH),
@@ -218,5 +218,5 @@ const ERROR_CODES: &[(&str, i32)] = &[
     e!(cfg(windows), WSAENETRESET),
 ];
 
-#[cfg(not(any(unix, windows)))]
+#[cfg(not(any(unix, windows, target_os = "wasi")))]
 const ERROR_CODES: &[(&str, i32)] = &[];
diff --git a/vm/src/stdlib/mod.rs b/vm/src/stdlib/mod.rs
@@ -4,7 +4,7 @@ mod atexit;
 pub mod builtins;
 mod codecs;
 mod collections;
-mod errno;
+pub mod errno;
 mod functools;
 mod imp;
 pub mod io;