Remove expectedFailure for tests now passing with Windows SemLock

youknowone · Feb 24, 2026 · Feb 17, 2026 · Feb 22, 2026 · Feb 22, 2026 · Feb 22, 2026
commit c40092bcce84637bf057d5559d17e9b66adc1948
diff --git a/Lib/test/test_logging.py b/Lib/test/test_logging.py
@@ -4119,8 +4119,6 @@ def test_90195(self):
         # Logger should be enabled, since explicitly mentioned
         self.assertFalse(logger.disabled)
 
-    # TODO: RUSTPYTHON - SemLock not implemented on Windows
-    @unittest.expectedFailureIfWindows("TODO: RUSTPYTHON")
     def test_111615(self):
         # See gh-111615
         import_helper.import_module('_multiprocessing')  # see gh-113692

diff --git a/Lib/test/test_socket.py b/Lib/test/test_socket.py
@@ -6620,7 +6620,6 @@ def remoteProcessServer(cls, q):
         s2.close()
         s.close()
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON; multiprocessing.SemLock not implemented
     def testShare(self):
         # Transfer the listening server socket to another process
         # and service it from there.

diff --git a/crates/stdlib/src/multiprocessing.rs b/crates/stdlib/src/multiprocessing.rs
@@ -11,18 +11,14 @@ mod _multiprocessing {
     };
     use core::sync::atomic::{AtomicI32, AtomicU32, Ordering};
     use windows_sys::Win32::Foundation::{
-        CloseHandle, HANDLE, INVALID_HANDLE_VALUE, WAIT_EVENT, WAIT_OBJECT_0,
+        CloseHandle, ERROR_TOO_MANY_POSTS, HANDLE, INVALID_HANDLE_VALUE, WAIT_FAILED,
+        WAIT_OBJECT_0, WAIT_TIMEOUT,
     };
     use windows_sys::Win32::Networking::WinSock::{self, SOCKET};
     use windows_sys::Win32::System::Threading::{
-        CreateSemaphoreW, GetCurrentThreadId, ReleaseSemaphore, WaitForSingleObjectEx,
+        CreateSemaphoreW, GetCurrentThreadId, INFINITE, ReleaseSemaphore, WaitForSingleObjectEx,
     };
 
-    const INFINITE: u32 = 0xFFFFFFFF;
-    const WAIT_TIMEOUT: WAIT_EVENT = 258; // 0x102
-    const WAIT_FAILED: WAIT_EVENT = 0xFFFFFFFF;
-    const ERROR_TOO_MANY_POSTS: u32 = 298;
-
     // These match the values in Lib/multiprocessing/synchronize.py
     const RECURSIVE_MUTEX: i32 = 0;
     const SEMAPHORE: i32 = 1;
@@ -171,11 +167,15 @@ mod _multiprocessing {
             }
 
             // Check whether we can acquire without blocking
-            if unsafe { WaitForSingleObjectEx(self.handle.as_raw(), 0, 0) } == WAIT_OBJECT_0 {
-                self.last_tid
-                    .store(unsafe { GetCurrentThreadId() }, Ordering::Release);
-                self.count.fetch_add(1, Ordering::Release);
-                return Ok(true);
+            match unsafe { WaitForSingleObjectEx(self.handle.as_raw(), 0, 0) } {
+                WAIT_OBJECT_0 => {
+                    self.last_tid
+                        .store(unsafe { GetCurrentThreadId() }, Ordering::Release);
+                    self.count.fetch_add(1, Ordering::Release);
+                    return Ok(true);
+                }
+                WAIT_FAILED => return Err(vm.new_last_os_error()),
+                _ => {}
             }
 
             // Poll with signal checking (CPython uses WaitForMultipleObjectsEx
@@ -193,8 +193,7 @@ mod _multiprocessing {
                     remaining.min(poll_ms)
                 };
 
-                let res =
-                    unsafe { WaitForSingleObjectEx(self.handle.as_raw(), wait_ms, 0) };
+                let res = unsafe { WaitForSingleObjectEx(self.handle.as_raw(), wait_ms, 0) };
 
                 match res {
                     WAIT_OBJECT_0 => {
@@ -213,7 +212,7 @@ mod _multiprocessing {
                     _ => {
                         return Err(vm.new_runtime_error(format!(
                             "WaitForSingleObject() gave unrecognized value {res}"
-                        )))
+                        )));
                     }
                 }
             }

diff --git a/crates/vm/src/exceptions.rs b/crates/vm/src/exceptions.rs
@@ -2061,18 +2061,17 @@ pub(super) mod types {
                     if !vm.is_none(&filename) {
                         let mut args_reduced: Vec<PyObjectRef> = vec![errno, msg, filename];
 
-                        let filename2 =
-                            obj.get_attr("filename2", vm).ok().filter(|f| !vm.is_none(f));
+                        let filename2 = obj
+                            .get_attr("filename2", vm)
+                            .ok()
+                            .filter(|f| !vm.is_none(f));
                         #[cfg(windows)]
-                        let winerror =
-                            obj.get_attr("winerror", vm).ok().filter(|w| !vm.is_none(w));
+                        let winerror = obj.get_attr("winerror", vm).ok().filter(|w| !vm.is_none(w));
 
                         if let Some(filename2) = filename2 {
                             #[cfg(windows)]
                             {
-                                args_reduced.push(
-                                    winerror.unwrap_or_else(|| vm.ctx.none()),
-                                );
+                                args_reduced.push(winerror.unwrap_or_else(|| vm.ctx.none()));
                             }
                             #[cfg(not(windows))]
                             args_reduced.push(vm.ctx.none());