o
    ¨Ýj)�  ã                   @   sX   d Z ddlZddlZddlZddlZddlmZ G dd„ deƒZedkr*e 	¡  dS dS )u:  
Tests for greenlet behavior during interpreter shutdown (Py_FinalizeEx).

These tests are organized into four groups:

  A. Core safety (smoke): no crashes with active greenlets at shutdown.
  B. Cleanup semantics: GreenletExit / finally still works during
     normal thread exit (the standard production path).
  C. Atexit "still works" tests: getcurrent() / greenlet construction
     during atexit handlers registered AFTER greenlet import (i.e.
     BEFORE greenlet's cleanup handler in LIFO order) must return
     valid objects â€” verifies the guards don't over-block.
  D. TDD-certified regression tests: getcurrent() must return None
     when called AFTER greenlet's cleanup (GC finalization phase
     or late atexit phase).  These tests fail on greenlet 3.3.2
     and pass with the fix across Python 3.10-3.14.
é    N)ÚTestCasec                   @   sÌ   e Zd Zdd„ Zdd„ Zdd„ Zdd„ Zd	d
„ Zdd„ Zdd„ Z	dd„ Z
dd„ Zdd„ Zdd„ Zdd„ Zdd„ Zdd„ Zdd„ Zdd „ Zd!d"„ Zd#d$„ Zd%d&„ Zd'd(„ Zd)d*„ Zd+d,„ Zd-d.„ Zd/d0„ Zd1S )2ÚTestInterpreterShutdownc                 C   s6   t  |¡}tjtjd|gddddd�}|j|j|jfS )z˜
        Run a Python script in a subprocess that exercises greenlet
        during interpreter shutdown. Returns (returncode, stdout, stderr).
        z-cTé   F)Úcapture_outputÚtextÚtimeoutÚcheck)	ÚtextwrapÚdedentÚ
subprocessÚrunÚsysÚ
executableÚ
returncodeÚstdoutÚstderr)ÚselfZscript_bodyZfull_scriptÚresult© r   úc/var/www/html/chatgpt/venv/lib/python3.10/site-packages/greenlet/tests/test_interpreter_shutdown.pyÚ_run_shutdown_script   s   

ûz,TestInterpreterShutdown._run_shutdown_scriptc              	   C   ó>   |   d¡\}}}|  |dd|› d|› |› �¡ |  d|¡ d S )NaT              import greenlet

            def worker():
                greenlet.getcurrent().parent.switch("from worker")
                return "done"

            g = greenlet.greenlet(worker)
            result = g.switch()
            assert result == "from worker", result
            print("OK: exiting with active greenlet")
        r   úProcess crashed (rc=ú):
z OK: exiting with active greenlet©r   ZassertEqualZassertIn©r   Úrcr   r   r   r   r   Ú)test_active_greenlet_at_shutdown_no_crash0   s   	zATestInterpreterShutdown.test_active_greenlet_at_shutdown_no_crashc              	   C   r   )Na­              import greenlet

            def worker(name):
                greenlet.getcurrent().parent.switch(f"hello from {name}")
                return "done"

            greenlets = []
            for i in range(10):
                g = greenlet.greenlet(worker)
                result = g.switch(f"g{i}")
                greenlets.append(g)

            print(f"OK: {len(greenlets)} active greenlets at shutdown")
        r   r   r   z#OK: 10 active greenlets at shutdownr   r   r   r   r   Ú*test_multiple_active_greenlets_at_shutdownH   s   zBTestInterpreterShutdown.test_multiple_active_greenlets_at_shutdownc              	   C   r   )Naâ              import greenlet

            def inner():
                greenlet.getcurrent().parent.switch("inner done")

            def outer():
                g_inner = greenlet.greenlet(inner)
                g_inner.switch()
                greenlet.getcurrent().parent.switch("outer done")

            g = greenlet.greenlet(outer)
            result = g.switch()
            assert result == "outer done", result
            print("OK: nested greenlets at shutdown")
        r   r   r   z OK: nested greenlets at shutdownr   r   r   r   r   Ú!test_nested_greenlets_at_shutdown^   s   z9TestInterpreterShutdown.test_nested_greenlets_at_shutdownc              	   C   r   )NaÅ              import greenlet
            import threading

            results = []

            def thread_worker():
                def greenlet_func():
                    greenlet.getcurrent().parent.switch("from thread greenlet")
                    return "done"

                g = greenlet.greenlet(greenlet_func)
                val = g.switch()
                results.append((g, val))

            threads = []
            for _ in range(3):
                t = threading.Thread(target=thread_worker)
                t.start()
                threads.append(t)

            for t in threads:
                t.join()

            print(f"OK: {len(results)} threaded greenlets at shutdown")
        r   r   r   z$OK: 3 threaded greenlets at shutdownr   r   r   r   r   Ú#test_threaded_greenlets_at_shutdownt   s   z;TestInterpreterShutdown.test_threaded_greenlets_at_shutdownc              	   C   óJ   |   d¡\}}}|  |dd|› d|› |› �¡ |  d|¡ |  d|¡ d S )Na4              import os
            import threading
            import greenlet

            _write = os.write

            def thread_func():
                def worker(_w=_write,
                           _GreenletExit=greenlet.GreenletExit):
                    try:
                        greenlet.getcurrent().parent.switch("suspended")
                    except _GreenletExit:
                        _w(1, b"CLEANUP: GreenletExit caught\n")
                        raise

                g = greenlet.greenlet(worker)
                g.switch()
                # Thread exits with active greenlet -> thread-state
                # cleanup triggers GreenletExit

            t = threading.Thread(target=thread_func)
            t.start()
            t.join()
            print("OK: thread cleanup done")
        r   r   r   úOK: thread cleanup donezCLEANUP: GreenletExit caughtr   r   r   r   r   Ú(test_greenlet_cleanup_during_thread_exitž   s   z@TestInterpreterShutdown.test_greenlet_cleanup_during_thread_exitc              	   C   r!   )NaR              import os
            import threading
            import greenlet

            _write = os.write

            def thread_func():
                def worker(_w=_write):
                    try:
                        greenlet.getcurrent().parent.switch("suspended")
                    finally:
                        _w(1, b"FINALLY: cleanup executed\n")

                g = greenlet.greenlet(worker)
                g.switch()

            t = threading.Thread(target=thread_func)
            t.start()
            t.join()
            print("OK: thread cleanup done")
        r   r   r   r"   zFINALLY: cleanup executedr   r   r   r   r   Ú%test_finally_block_during_thread_exitÂ   s   z=TestInterpreterShutdown.test_finally_block_during_thread_exitc              	   C   r   )Naï              import sys
            import greenlet

            cleanup_count = 0

            def worker(idx):
                global cleanup_count
                try:
                    greenlet.getcurrent().parent.switch(f"ready-{idx}")
                except greenlet.GreenletExit:
                    cleanup_count += 1
                    raise

            greenlets = []
            for i in range(50):
                g = greenlet.greenlet(worker)
                result = g.switch(i)
                greenlets.append(g)

            print(f"OK: {len(greenlets)} greenlets about to shut down")
            # Note: we can't easily print cleanup_count during shutdown
            # since it happens after the main module's code runs.
        r   r   r   z#OK: 50 greenlets about to shut downr   r   r   r   r   Ú,test_many_greenlets_with_cleanup_at_shutdownß   s   zDTestInterpreterShutdown.test_many_greenlets_with_cleanup_at_shutdownc              	   C   r   )Na¨              import greenlet

            def level(depth, max_depth):
                if depth < max_depth:
                    g = greenlet.greenlet(level)
                    g.switch(depth + 1, max_depth)
                greenlet.getcurrent().parent.switch(f"depth-{depth}")

            g = greenlet.greenlet(level)
            result = g.switch(0, 10)
            print(f"OK: nested to depth 10, got {result}")
        r   r   r   zOK: nested to depth 10r   r   r   r   r   Ú(test_deeply_nested_greenlets_at_shutdownþ   s   z@TestInterpreterShutdown.test_deeply_nested_greenlets_at_shutdownc              	   C   r   )Na              import greenlet

            def worker():
                try:
                    raise ValueError("test error")
                except ValueError:
                    # Suspend while an exception is active on the stack
                    greenlet.getcurrent().parent.switch("suspended with exc")
                return "done"

            g = greenlet.greenlet(worker)
            result = g.switch()
            assert result == "suspended with exc"
            print("OK: greenlet with active exception at shutdown")
        r   r   r   z.OK: greenlet with active exception at shutdownr   r   r   r   r   Ú(test_greenlet_with_traceback_at_shutdown  s   z@TestInterpreterShutdown.test_greenlet_with_traceback_at_shutdownc              	   C   óL   |   d¡\}}}|  |dd|› d|› |› �¡ |  d|¡ |  d|d¡ d S )NaÙ              import atexit
            import greenlet

            def call_getcurrent_at_exit():
                try:
                    g = greenlet.getcurrent()
                    if g is not None and type(g).__name__ == 'greenlet':
                        print(f"OK: getcurrent returned valid greenlet")
                    elif g is None:
                        print("FAIL: getcurrent returned None (over-blocked)")
                    else:
                        print(f"FAIL: unexpected {g!r}")
                except Exception as e:
                    print(f"OK: getcurrent raised {type(e).__name__}: {e}")

            atexit.register(call_getcurrent_at_exit)
            print("OK: atexit registered")
        r   r   r   úOK: atexit registeredú&OK: getcurrent returned valid greenletúigetcurrent() should return a valid greenlet when called before greenlet's cleanup handler (LIFO ordering)r   r   r   r   r   Ú&test_getcurrent_during_atexit_no_crash.  s   ÿz>TestInterpreterShutdown.test_getcurrent_during_atexit_no_crashc              	   C   r   )Na¦              import atexit
            import greenlet

            def check_at_exit():
                try:
                    result = greenlet.gettrace()
                    print(f"OK: gettrace returned {result!r}")
                except Exception as e:
                    print(f"OK: gettrace raised {type(e).__name__}: {e}")

            atexit.register(check_at_exit)
            print("OK: registered")
        r   r   r   úOK: registeredr   r   r   r   r   Ú$test_gettrace_during_atexit_no_crashL  ó   z<TestInterpreterShutdown.test_gettrace_during_atexit_no_crashc              	   C   r   )Na¤              import atexit
            import greenlet

            def check_at_exit():
                try:
                    greenlet.settrace(lambda *args: None)
                    print("OK: settrace succeeded")
                except Exception as e:
                    print(f"OK: settrace raised {type(e).__name__}: {e}")

            atexit.register(check_at_exit)
            print("OK: registered")
        r   r   r   r-   r   r   r   r   r   Ú$test_settrace_during_atexit_no_crash`  r/   z<TestInterpreterShutdown.test_settrace_during_atexit_no_crashc              	   C   r(   )Naò              import atexit
            import greenlet

            def worker():
                greenlet.getcurrent().parent.switch("ready")

            greenlets = []
            for i in range(5):
                g = greenlet.greenlet(worker)
                result = g.switch()
                greenlets.append(g)

            def check_at_exit():
                try:
                    g = greenlet.getcurrent()
                    if g is not None and type(g).__name__ == 'greenlet':
                        print(f"OK: getcurrent returned valid greenlet")
                    elif g is None:
                        print("FAIL: getcurrent returned None (over-blocked)")
                    else:
                        print(f"FAIL: unexpected {g!r}")
                except Exception as e:
                    print(f"OK: getcurrent raised {type(e).__name__}: {e}")

            atexit.register(check_at_exit)
            print(f"OK: {len(greenlets)} active greenlets, atexit registered")
        r   r   r   z)OK: 5 active greenlets, atexit registeredr*   r+   r   r   r   r   r   Ú3test_getcurrent_with_active_greenlets_during_atexitt  s   ÿzKTestInterpreterShutdown.test_getcurrent_with_active_greenlets_during_atexitc              	   C   r!   )Naˆ              import atexit
            import greenlet

            def create_greenlets_at_exit():
                try:
                    def noop():
                        pass
                    g = greenlet.greenlet(noop)
                    if g is not None:
                        print(f"OK: created greenlet successfully")
                    else:
                        print("FAIL: greenlet() returned None")
                except Exception as e:
                    print(f"OK: construction raised {type(e).__name__}: {e}")

            atexit.register(create_greenlets_at_exit)
            print("OK: atexit registered")
        r   r   r   r)   z!OK: created greenlet successfullyr   r   r   r   r   Ú1test_greenlet_construction_during_atexit_no_crash›  s   zITestInterpreterShutdown.test_greenlet_construction_during_atexit_no_crashc              	   C   r   )Naf              import atexit
            import greenlet

            def worker():
                greenlet.getcurrent().parent.switch("ready")

            greenlets = []
            for i in range(10):
                g = greenlet.greenlet(worker)
                g.switch()
                greenlets.append(g)

            def create_at_exit():
                try:
                    new_greenlets = []
                    for i in range(5):
                        g = greenlet.greenlet(lambda: None)
                        new_greenlets.append(g)
                    print(f"OK: created {len(new_greenlets)} greenlets at exit")
                except Exception as e:
                    print(f"OK: raised {type(e).__name__}: {e}")

            atexit.register(create_at_exit)
            print(f"OK: {len(greenlets)} active greenlets, atexit registered")
        r   r   r   ú*OK: 10 active greenlets, atexit registeredr   r   r   r   r   Ú>test_greenlet_construction_with_active_greenlets_during_atexit¶  s   zVTestInterpreterShutdown.test_greenlet_construction_with_active_greenlets_during_atexitc              	   C   r   )Na               import atexit
            import greenlet
            import threading

            cross_thread_refs = []

            def thread_worker():
                # Create greenlets in this thread
                def gl_body():
                    greenlet.getcurrent().parent.switch("ready")
                for _ in range(20):
                    g = greenlet.greenlet(gl_body)
                    g.switch()
                    cross_thread_refs.append(g)

            t = threading.Thread(target=thread_worker)
            t.start()
            t.join()

            # Dropping these references in the main thread
            # causes them to be added to the main thread's
            # deleteme list (deferred cross-thread dealloc).
            cross_thread_refs.clear()

            def create_at_exit():
                try:
                    g = greenlet.greenlet(lambda: None)
                    print(f"OK: created greenlet at exit {g!r}")
                except Exception as e:
                    print(f"OK: raised {type(e).__name__}: {e}")

            atexit.register(create_at_exit)
            print("OK: cross-thread setup done, atexit registered")
        r   r   r   z.OK: cross-thread setup done, atexit registeredr   r   r   r   r   ÚCtest_greenlet_construction_with_cross_thread_deleteme_during_atexitØ  s   #z[TestInterpreterShutdown.test_greenlet_construction_with_cross_thread_deleteme_during_atexitc              	   C   r!   )Na˜              import gc
            import os
            import greenlet

            gc.disable()

            class CleanupChecker:
                def __del__(self):
                    try:
                        try:
                            greenlet.getcurrent()
                        except RuntimeError:
                            os.write(1, b"GUARDED: getcurrent=None\n")
                        else:
                            os.write(1, b"UNGUARDED: getcurrent="
                                     + type(cur).__name__.encode() + b"\n")
                    except Exception as e:
                        os.write(1, b"EXCEPTION: " + str(e).encode() + b"\n")

            # Reference cycle: only collected during Py_FinalizeEx GC pass
            a = CleanupChecker()
            b = {"ref": a}
            a._cycle = b
            del a, b

            print("OK: deferred cycle created")
        r   r   r   zOK: deferred cycle createdúGUARDED: getcurrent=Noner   r   r   r   r   Ú3test_getcurrent_returns_none_during_gc_finalization  s   zKTestInterpreterShutdown.test_getcurrent_returns_none_during_gc_finalizationc              	   C   r!   )NaÓ              import gc
            import os
            import greenlet

            gc.disable()

            class CleanupChecker:
                def __del__(self):
                    try:
                        try:
                            greenlet.getcurrent()
                        except RuntimeError:
                            os.write(1, b"GUARDED: getcurrent=None\n")
                        else:
                            os.write(1, b"UNGUARDED: getcurrent="
                                     + type(cur).__name__.encode() + b"\n")
                    except Exception as e:
                        os.write(1, b"EXCEPTION: " + str(e).encode() + b"\n")

            # Create active greenlets
            greenlets = []
            for _ in range(10):
                def worker():
                    greenlet.getcurrent().parent.switch("suspended")
                g = greenlet.greenlet(worker)
                g.switch()
                greenlets.append(g)

            # Reference cycle deferred to Py_FinalizeEx
            a = CleanupChecker()
            b = {"ref": a}
            a._cycle = b
            del a, b

            print(f"OK: {len(greenlets)} active greenlets, cycle deferred")
        r   r   r   z'OK: 10 active greenlets, cycle deferredr6   r   r   r   r   r   ÚItest_getcurrent_returns_none_during_gc_finalization_with_active_greenlets>  s   %zaTestInterpreterShutdown.test_getcurrent_returns_none_during_gc_finalization_with_active_greenletsc              	   C   r!   )Na›              import gc
            import os
            import threading
            import greenlet

            gc.disable()

            class CleanupChecker:
                def __del__(self):
                    try:
                        try:
                            greenlet.getcurrent()
                        except RuntimeError:
                            os.write(1, b"GUARDED: getcurrent=None\n")
                        else:
                            os.write(1, b"UNGUARDED: getcurrent="
                                     + type(cur).__name__.encode() + b"\n")
                    except Exception as e:
                        os.write(1, b"EXCEPTION: " + str(e).encode() + b"\n")

            # Create cross-thread greenlet references
            cross_refs = []
            def thread_fn():
                for _ in range(20):
                    def body():
                        greenlet.getcurrent().parent.switch("x")
                    g = greenlet.greenlet(body)
                    g.switch()
                    cross_refs.append(g)
            t = threading.Thread(target=thread_fn)
            t.start()
            t.join()
            cross_refs.clear()

            # Reference cycle deferred to Py_FinalizeEx
            a = CleanupChecker()
            b = {"ref": a}
            a._cycle = b
            del a, b

            print("OK: cross-thread cleanup + cycle deferred")
        r   r   r   z)OK: cross-thread cleanup + cycle deferredr6   r   r   r   r   r   Ú@test_getcurrent_returns_none_during_gc_finalization_cross_threadk  s   +zXTestInterpreterShutdown.test_getcurrent_returns_none_during_gc_finalization_cross_threadc              	   C   r!   )Nu�              import atexit
            import os

            def late_checker():
                try:
                    import greenlet
                    cur = greenlet.getcurrent()
                    if cur is None:
                        os.write(1, b"GUARDED: getcurrent=None\n")
                    else:
                        os.write(1, b"UNGUARDED: getcurrent="
                                 + type(cur).__name__.encode() + b"\n")
                except Exception as e:
                    os.write(1, b"EXCEPTION: " + str(e).encode() + b"\n")

            # Register BEFORE importing greenlet.  LIFO order:
            # greenlet's handler (registered at import) runs FIRST,
            # late_checker runs SECOND â€” seeing the flag already set.
            atexit.register(late_checker)

            import greenlet
            print("OK: atexit registered before greenlet import")
        r   r   r   z,OK: atexit registered before greenlet importÚ	UNGUARDEDr   r   r   r   r   Ú0test_getcurrent_returns_none_during_atexit_phase¶  s   zHTestInterpreterShutdown.test_getcurrent_returns_none_during_atexit_phasec              	   C   r!   )NaÛ              import atexit
            import os

            def late_checker():
                try:
                    import greenlet
                    cur = greenlet.getcurrent()
                    if cur is None:
                        os.write(1, b"GUARDED: getcurrent=None\n")
                    else:
                        os.write(1, b"UNGUARDED: getcurrent="
                                 + type(cur).__name__.encode() + b"\n")
                except Exception as e:
                    os.write(1, b"EXCEPTION: " + str(e).encode() + b"\n")

            atexit.register(late_checker)

            import greenlet

            greenlets = []
            for _ in range(10):
                def worker():
                    greenlet.getcurrent().parent.switch("parked")
                g = greenlet.greenlet(worker)
                g.switch()
                greenlets.append(g)

            print(f"OK: {len(greenlets)} active greenlets, atexit registered")
        r   r   r   r3   r:   r   r   r   r   r   ÚFtest_getcurrent_returns_none_during_atexit_phase_with_active_greenlets×  s   z^TestInterpreterShutdown.test_getcurrent_returns_none_during_atexit_phase_with_active_greenletsc              	   C   sJ   |   d¡\}}}|  |dd|› d|› |› �¡ |  d|¡ |  d|¡ d S )Nañ              import greenlet
            from greenlet.tests import _test_extension

            class WithDel:
                # must cache the method we want, because by the time we
                # run, module globals may have been cleaned up.
                def __del__(self, gc=_test_extension.getcurrent_api):
                    print('Destructor running')
                    gc() # Should print an unraisable RuntimeException

            greenlet._greenlet.with_del = WithDel()
        r   r   r   úDestructor runningz)RuntimeError: greenlet is being finalizedr   r   r   r   r   Ú5test_api_getcurrent_no_system_error_at_module_gc_timeû  s   zMTestInterpreterShutdown.test_api_getcurrent_no_system_error_at_module_gc_timec              	   C   r!   )NaÑ              import greenlet
            from greenlet.tests import _test_extension

            gs = []
            # must cache the objects we want, because by the time we
            # run, module globals may have been cleaned up.
            def do_it(gs=gs):
                print('current', gs)
                gs[0].parent.switch(1)


            gs.append(greenlet.greenlet(do_it))
            gs.append(greenlet.greenlet(do_it))
            gs[1].switch()

            class WithDel:
                def __del__(self, gs=gs):
                    print('Destructor running')
                    r = gs[0].switch()
                    print('Result', r)

            greenlet._greenlet.with_del = WithDel()
        r   r   r   r=   zResult 1r   r   r   r   r   Ú&test_switch_no_error_at_module_gc_time  s   z>TestInterpreterShutdown.test_switch_no_error_at_module_gc_timeN)Ú__name__Ú
__module__Ú__qualname__r   r   r   r   r    r#   r$   r%   r&   r'   r,   r.   r0   r1   r2   r4   r5   r7   r8   r9   r;   r<   r>   r?   r   r   r   r   r      s2    *$'">(-K!$r   Ú__main__)
Ú__doc__r   r   Zunittestr	   Zgreenlet.testsr   r   r@   Úmainr   r   r   r   Ú<module>   s          ÿ