Move recursion validation test to nocover

Author: jobh

hypothesis-python/tests/cover/test_deadline.py

@@ -155,76 +155,3 @@ def delay(phase, _info):
         test()
     finally:
         gc.callbacks.remove(delay)
-
-
-@pytest.mark.skipif(
-    not hasattr(gc, "callbacks"), reason="PyPy has weird stack-limit behaviour"
-)
-def test_gc_hooks_do_not_cause_unraisable_recursionerror():
-    # We were concerned in #3979 that we might see bad results from a RecursionError
-    # inside the GC hook, if the stack was already deep and someone (e.g. Pytest)
-    # had installed a sys.unraisablehook which raises that later.
-
-    NUM_CYCLES = 10_000
-
-    def probe_depth():
-        try:
-            return probe_depth() + 1
-        except RecursionError:
-            return 0
-
-    def at_depth(depth, fn):
-        if depth <= 1:
-            return fn()
-        else:
-            # Recurse towards requested depth
-            return at_depth(depth - 1, fn)
-
-    def gen_cycles():
-        # We may be at the recursion limit, no free stack frames. Generate lots
-        # of reference cycles. Beware: there may not even be room for raising new
-        # exceptions here, anything will end up as a RecursionError.
-        for i in range(NUM_CYCLES):
-            a = [None]
-            b = [a]
-            a[0] = b
-
-    def gen_cycles_at_depth(depth, *, gc_disable):
-        try:
-            if gc_disable:
-                gc.disable()
-            at_depth(depth, gen_cycles)
-            if gc_disable:
-                assert gc.collect() >= 2 * NUM_CYCLES
-            else:
-                assert gc.collect() < 2 * NUM_CYCLES  # collection was triggered
-        finally:
-            gc.enable()
-
-    @given(st.booleans())
-    def inner_test(_):
-        max_depth = probe_depth()  # would have to be called twice on PyPy
-
-        # Lower the limit to where we can successfully generate cycles
-        while True:
-            try:
-                gen_cycles_at_depth(max_depth, gc_disable=True)
-            except RecursionError:
-                max_depth -= 1
-            else:
-                break
-
-        # Verify limits w/o any gc interfering
-        gen_cycles_at_depth(max_depth - 1, gc_disable=True)
-        # the previous line raises RecursionError on Pypy, while the next doesn't (!)
-        gen_cycles_at_depth(max_depth, gc_disable=True)
-        with pytest.raises(RecursionError):
-            gen_cycles_at_depth(max_depth + 1, gc_disable=True)
-
-        # Check that the limit is unchanged with gc enabled
-        gen_cycles_at_depth(max_depth - 1, gc_disable=False)
-        gen_cycles_at_depth(max_depth, gc_disable=False)
-        with pytest.raises(RecursionError):
-            gen_cycles_at_depth(max_depth + 1, gc_disable=False)
-
-    inner_test()

hypothesis-python/tests/nocover/test_recursive.py

@@ -8,11 +8,13 @@
 # v. 2.0. If a copy of the MPL was not distributed with this file, You can
 # obtain one at https://mozilla.org/MPL/2.0/.
 
+import gc
 import sys
 import threading
 import warnings
 
 from hypothesis import HealthCheck, given, settings, strategies as st
+import pytest
 
 from tests.common.debug import find_any, minimal
 from tests.common.utils import flaky
@@ -182,3 +184,82 @@ def test(data):
 def test_self_ref_regression(_):
     # See https://github.com/HypothesisWorks/hypothesis/issues/2794
     pass
+
+
+@flaky(min_passes=1, max_runs=2)
+def test_gc_hooks_do_not_cause_unraisable_recursionerror():
+    # We were concerned in #3979 that we might see bad results from a RecursionError
+    # inside the GC hook, if the stack was already deep and someone (e.g. Pytest)
+    # had installed a sys.unraisablehook which raises that later.
+
+    # This test is potentially flaky, because the stack usage of a function is not
+    # constant. Regardless, if the test passes just once that's sufficient proof that
+    # it's not the GC (or accounting of it) that is at fault.
+
+    NUM_CYCLES = 10_000
+
+    def probe_depth():
+        try:
+            return probe_depth() + 1
+        except RecursionError:
+            return 0
+
+    def at_depth(depth, fn):
+        if depth <= 1:
+            return fn()
+        else:
+            # Recurse towards requested depth
+            return at_depth(depth - 1, fn)
+
+    def gen_cycles():
+        # We may be at the recursion limit, no free stack frames. Generate lots
+        # of reference cycles, to trigger GC (if enabled). Beware: there may not
+        # even be room for raising new exceptions here, anything will end up as
+        # a RecursionError.
+        for i in range(NUM_CYCLES):
+            a = [None]
+            b = [a]
+            a[0] = b
+
+    def gen_cycles_at_depth(depth, *, gc_disable):
+        try:
+            if gc_disable:
+                gc.disable()
+            at_depth(depth, gen_cycles)
+            dead_objects = gc.collect()
+            if dead_objects is not None:  # == None on PyPy
+                if gc_disable:
+                    assert dead_objects >= 2 * NUM_CYCLES
+                else:
+                    assert dead_objects < 2 * NUM_CYCLES  # collection was triggered
+        finally:
+            gc.enable()
+
+    @given(st.booleans())
+    def inner_test(_):
+        max_depth = probe_depth()
+        max_depth = probe_depth()  # Executing probe twice de-flakes PyPy
+
+        while True:
+            # Lower the limit to where we can successfully generate cycles
+            try:
+                gen_cycles_at_depth(max_depth, gc_disable=True)
+            except RecursionError:
+                max_depth -= 1
+            else:
+                break
+
+        # Verify limits w/o any gc interfering
+
+        # gen_cycles_at_depth(max_depth - 1, gc_disable=True)  # RecursionError on PyPy (!)
+        gen_cycles_at_depth(max_depth, gc_disable=True)
+        with pytest.raises(RecursionError):
+            gen_cycles_at_depth(max_depth + 1, gc_disable=True)
+
+        # Check that the limit is unchanged with gc enabled
+
+        gen_cycles_at_depth(max_depth, gc_disable=False)
+        with pytest.raises(RecursionError):
+            gen_cycles_at_depth(max_depth + 1, gc_disable=False)
+
+    inner_test()