fix atexit

Author: youknowone

Lib/test/test_threading.py

@@ -1008,8 +1008,6 @@ def test_1_join_on_shutdown(self):
 
     @unittest.skipUnless(hasattr(os, 'fork'), "needs os.fork()")
     @unittest.skipIf(sys.platform in platforms_to_skip, "due to known OS bug")
-    # TODO: RUSTPYTHON need to fix test_1_join_on_shutdown then this might work
-    @unittest.expectedFailure
     def test_2_join_in_forked_process(self):
         # Like the test above, but from a forked interpreter
         script = """if 1:
@@ -1730,8 +1728,6 @@ def worker(started, cont, interrupted):
 
 class AtexitTests(unittest.TestCase):
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_atexit_output(self):
         rc, out, err = assert_python_ok("-c", """if True:
             import threading

crates/vm/src/vm/interpreter.rs

@@ -110,11 +110,12 @@ impl Interpreter {
 
     /// Finalize vm and turns an exception to exit code.
     ///
-    /// Finalization steps including 4 steps:
+    /// Finalization steps (matching Py_FinalizeEx):
     /// 1. Flush stdout and stderr.
-    /// 1. Handle exit exception and turn it to exit code.
-    /// 1. Run atexit exit functions.
-    /// 1. Mark vm as finalized.
+    /// 2. Handle exit exception and turn it to exit code.
+    /// 3. Wait for thread shutdown (call threading._shutdown).
+    /// 4. Mark vm as finalizing.
+    /// 5. Run atexit exit functions.
     ///
     /// Note that calling `finalize` is not necessary by purpose though.
     pub fn finalize(self, exc: Option<PyBaseExceptionRef>) -> u32 {
@@ -128,10 +129,21 @@ impl Interpreter {
                 0
             };
 
-            atexit::_run_exitfuncs(vm);
+            // Wait for thread shutdown - call threading._shutdown() if available.
+            // This waits for all non-daemon threads to complete.
+            // threading module may not be imported, so ignore import errors.
+            if let Ok(threading) = vm.import("threading", 0)
+                && let Ok(shutdown) = threading.get_attr("_shutdown", vm)
+            {
+                let _ = shutdown.call((), vm);
+            }
 
+            // Mark as finalizing AFTER thread shutdown (matches CPython)
             vm.state.finalizing.store(true, Ordering::Release);
 
+            // Run atexit exit functions
+            atexit::_run_exitfuncs(vm);
+
             vm.flush_std();
 
             exit_code

crates/vm/src/vm/mod.rs

@@ -472,6 +472,17 @@ impl VirtualMachine {
 
     #[cold]
     pub fn run_unraisable(&self, e: PyBaseExceptionRef, msg: Option<String>, object: PyObjectRef) {
+        // Suppress unraisable exceptions during interpreter finalization.
+        // This matches CPython behavior where daemon thread exceptions and
+        // __del__ errors are silently ignored during shutdown.
+        if self
+            .state
+            .finalizing
+            .load(std::sync::atomic::Ordering::Acquire)
+        {
+            return;
+        }
+
         let sys_module = self.import("sys", 0).unwrap();
         let unraisablehook = sys_module.get_attr("unraisablehook", self).unwrap();