Загрузить файлы в «venv/Lib/site-packages/greenlet/tests»
This commit is contained in:
@@ -0,0 +1,55 @@
|
||||
"""
|
||||
Like fail_switch_three_greenlets, but the call into g1_run would actually be
|
||||
valid.
|
||||
"""
|
||||
import greenlet
|
||||
|
||||
g1 = None
|
||||
g2 = None
|
||||
|
||||
switch_to_g2 = True
|
||||
|
||||
results = []
|
||||
|
||||
def tracefunc(*args):
|
||||
results.append(('trace', args[0]))
|
||||
print('TRACE', *args)
|
||||
global switch_to_g2
|
||||
if switch_to_g2:
|
||||
switch_to_g2 = False
|
||||
g2.switch('g2 from tracefunc')
|
||||
print('\tLEAVE TRACE', *args)
|
||||
|
||||
def g1_run(arg):
|
||||
results.append(('g1 arg', arg))
|
||||
print('In g1_run')
|
||||
from_parent = greenlet.getcurrent().parent.switch('from g1_run')
|
||||
results.append(('g1 from parent', from_parent))
|
||||
return 'g1 done'
|
||||
|
||||
def g2_run(arg):
|
||||
#g1.switch()
|
||||
results.append(('g2 arg', arg))
|
||||
parent = greenlet.getcurrent().parent.switch('from g2_run')
|
||||
global switch_to_g2
|
||||
switch_to_g2 = False
|
||||
results.append(('g2 from parent', parent))
|
||||
return 'g2 done'
|
||||
|
||||
|
||||
greenlet.settrace(tracefunc)
|
||||
|
||||
g1 = greenlet.greenlet(g1_run)
|
||||
g2 = greenlet.greenlet(g2_run)
|
||||
|
||||
x = g1.switch('g1 from main')
|
||||
results.append(('main g1', x))
|
||||
print('Back in main', x)
|
||||
x = g1.switch('g2 from main')
|
||||
results.append(('main g2', x))
|
||||
print('back in amain again', x)
|
||||
x = g1.switch('g1 from main 2')
|
||||
results.append(('main g1.2', x))
|
||||
x = g2.switch()
|
||||
results.append(('main g2.2', x))
|
||||
print("RESULTS:", results)
|
||||
@@ -0,0 +1,41 @@
|
||||
"""
|
||||
Uses a trace function to switch greenlets at unexpected times.
|
||||
|
||||
In the trace function, we switch from the current greenlet to another
|
||||
greenlet, which switches
|
||||
"""
|
||||
import greenlet
|
||||
|
||||
g1 = None
|
||||
g2 = None
|
||||
|
||||
switch_to_g2 = False
|
||||
|
||||
def tracefunc(*args):
|
||||
print('TRACE', *args)
|
||||
global switch_to_g2
|
||||
if switch_to_g2:
|
||||
switch_to_g2 = False
|
||||
g2.switch()
|
||||
print('\tLEAVE TRACE', *args)
|
||||
|
||||
def g1_run():
|
||||
print('In g1_run')
|
||||
global switch_to_g2
|
||||
switch_to_g2 = True
|
||||
greenlet.getcurrent().parent.switch()
|
||||
print('Return to g1_run')
|
||||
print('Falling off end of g1_run')
|
||||
|
||||
def g2_run():
|
||||
g1.switch()
|
||||
print('Falling off end of g2')
|
||||
|
||||
greenlet.settrace(tracefunc)
|
||||
|
||||
g1 = greenlet.greenlet(g1_run)
|
||||
g2 = greenlet.greenlet(g2_run)
|
||||
|
||||
g1.switch()
|
||||
print('Falling off end of main')
|
||||
g2.switch()
|
||||
363
venv/Lib/site-packages/greenlet/tests/leakcheck.py
Normal file
363
venv/Lib/site-packages/greenlet/tests/leakcheck.py
Normal file
@@ -0,0 +1,363 @@
|
||||
# Copyright (c) 2018 gevent community
|
||||
# Copyright (c) 2021 greenlet community
|
||||
#
|
||||
# This was originally part of gevent's test suite. The main author
|
||||
# (Jason Madden) vendored a copy of it into greenlet.
|
||||
#
|
||||
# Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
# of this software and associated documentation files (the "Software"), to deal
|
||||
# in the Software without restriction, including without limitation the rights
|
||||
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
# copies of the Software, and to permit persons to whom the Software is
|
||||
# furnished to do so, subject to the following conditions:
|
||||
#
|
||||
# The above copyright notice and this permission notice shall be included in
|
||||
# all copies or substantial portions of the Software.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||||
# THE SOFTWARE.
|
||||
import os
|
||||
import sys
|
||||
import gc
|
||||
|
||||
from functools import wraps
|
||||
import unittest
|
||||
|
||||
|
||||
import objgraph
|
||||
|
||||
# graphviz 0.18 (Nov 7 2021), available only on Python 3.6 and newer,
|
||||
# has added type hints (sigh). It wants to use ``typing.Literal`` for
|
||||
# some stuff, but that's only available on Python 3.9+. If that's not
|
||||
# found, it creates a ``unittest.mock.MagicMock`` object and annotates
|
||||
# with that. These are GC'able objects, and doing almost *anything*
|
||||
# with them results in an explosion of objects. For example, trying to
|
||||
# compare them for equality creates new objects. This causes our
|
||||
# leakchecks to fail, with reports like:
|
||||
#
|
||||
# greenlet.tests.leakcheck.LeakCheckError: refcount increased by [337, 1333, 343, 430, 530, 643, 769]
|
||||
# _Call 1820 +546
|
||||
# dict 4094 +76
|
||||
# MagicProxy 585 +73
|
||||
# tuple 2693 +66
|
||||
# _CallList 24 +3
|
||||
# weakref 1441 +1
|
||||
# function 5996 +1
|
||||
# type 736 +1
|
||||
# cell 592 +1
|
||||
# MagicMock 8 +1
|
||||
#
|
||||
# To avoid this, we *could* filter this type of object out early. In
|
||||
# principle it could leak, but we don't use mocks in greenlet, so it
|
||||
# doesn't leak from us. However, a further issue is that ``MagicMock``
|
||||
# objects have subobjects that are also GC'able, like ``_Call``, and
|
||||
# those create new mocks of their own too. So we'd have to filter them
|
||||
# as well, and they're not public. That's OK, we can workaround the
|
||||
# problem by being very careful to never compare by equality or other
|
||||
# user-defined operators, only using object identity or other builtin
|
||||
# functions.
|
||||
|
||||
RUNNING_ON_GITHUB_ACTIONS = os.environ.get('GITHUB_ACTIONS')
|
||||
RUNNING_ON_TRAVIS = os.environ.get('TRAVIS') or RUNNING_ON_GITHUB_ACTIONS
|
||||
RUNNING_ON_APPVEYOR = os.environ.get('APPVEYOR')
|
||||
RUNNING_ON_CI = RUNNING_ON_TRAVIS or RUNNING_ON_APPVEYOR
|
||||
RUNNING_ON_MANYLINUX = os.environ.get('GREENLET_MANYLINUX')
|
||||
SKIP_LEAKCHECKS = RUNNING_ON_MANYLINUX or os.environ.get('GREENLET_SKIP_LEAKCHECKS')
|
||||
SKIP_FAILING_LEAKCHECKS = os.environ.get('GREENLET_SKIP_FAILING_LEAKCHECKS')
|
||||
ONLY_FAILING_LEAKCHECKS = os.environ.get('GREENLET_ONLY_FAILING_LEAKCHECKS')
|
||||
|
||||
def ignores_leakcheck(func):
|
||||
"""
|
||||
Ignore the given object during leakchecks.
|
||||
|
||||
Can be applied to a method, in which case the method will run, but
|
||||
will not be subject to leak checks.
|
||||
|
||||
If applied to a class, the entire class will be skipped during leakchecks. This
|
||||
is intended to be used for classes that are very slow and cause problems such as
|
||||
test timeouts; typically it will be used for classes that are subclasses of a base
|
||||
class and specify variants of behaviour (such as pool sizes).
|
||||
"""
|
||||
func.ignore_leakcheck = True
|
||||
return func
|
||||
|
||||
def ignores_leakcheck_if(condition, message):
|
||||
"""
|
||||
Return a decorator that marks the function to be ignored during
|
||||
leakchecks (see `ignores_leakcheck`) when *condition* is true.
|
||||
|
||||
*message* describes why the leakcheck is ignored. When *condition*
|
||||
is false, the function is returned unchanged.
|
||||
"""
|
||||
def decorator(func):
|
||||
if condition:
|
||||
func = ignores_leakcheck(func)
|
||||
func.ignore_leakcheck_reason = message
|
||||
return func
|
||||
return decorator
|
||||
|
||||
def fails_leakcheck(func):
|
||||
"""
|
||||
Mark that the function is known to leak.
|
||||
"""
|
||||
func.fails_leakcheck = True
|
||||
if SKIP_FAILING_LEAKCHECKS:
|
||||
func = unittest.skip("Skipping known failures")(func)
|
||||
return func
|
||||
|
||||
def fails_leakcheck_on_py314_or_less(func):
|
||||
"""
|
||||
Mark the function as known to leak (fails refcount leakchecks) on Python 3.14 or less.
|
||||
"""
|
||||
if sys.version_info[:2] <= (3, 14):
|
||||
return fails_leakcheck(func)
|
||||
return func
|
||||
|
||||
class LeakCheckError(AssertionError):
|
||||
pass
|
||||
|
||||
if hasattr(sys, 'getobjects'):
|
||||
# In a Python build with ``--with-trace-refs``, make objgraph
|
||||
# trace *all* the objects, not just those that are tracked by the
|
||||
# GC
|
||||
class _MockGC(object):
|
||||
def get_objects(self):
|
||||
return sys.getobjects(0) # pylint:disable=no-member
|
||||
def __getattr__(self, name):
|
||||
return getattr(gc, name)
|
||||
objgraph.gc = _MockGC()
|
||||
fails_strict_leakcheck = fails_leakcheck
|
||||
else:
|
||||
def fails_strict_leakcheck(func):
|
||||
"""
|
||||
Decorator for a function that is known to fail when running
|
||||
strict (``sys.getobjects()``) leakchecks.
|
||||
|
||||
This type of leakcheck finds all objects, even those, such as
|
||||
strings, which are not tracked by the garbage collector.
|
||||
"""
|
||||
return func
|
||||
|
||||
class ignores_types_in_strict_leakcheck(object):
|
||||
def __init__(self, types):
|
||||
self.types = types
|
||||
def __call__(self, func):
|
||||
func.leakcheck_ignore_types = self.types
|
||||
return func
|
||||
|
||||
class _RefCountChecker(object):
|
||||
|
||||
# Some builtin things that we ignore
|
||||
# XXX: Those things were ignored by gevent, but they're important here,
|
||||
# presumably.
|
||||
IGNORED_TYPES = () #(tuple, dict, types.FrameType, types.TracebackType)
|
||||
|
||||
# Names of types that should be ignored. Use this when we cannot
|
||||
# or don't want to import the class directly.
|
||||
IGNORED_TYPE_NAMES = (
|
||||
# This appears in Python3.14 with the JIT enabled. It
|
||||
# doesn't seem to be directly exposed to Python; the only way to get
|
||||
# one is to cause code to get jitted and then look for all objects
|
||||
# and find one with this name. But they multiply as code
|
||||
# executes and gets jitted, in ways we don't want to rely on.
|
||||
# So just ignore it.
|
||||
'uop_executor',
|
||||
)
|
||||
|
||||
def __init__(self, testcase, function):
|
||||
self.testcase = testcase
|
||||
self.function = function
|
||||
self.deltas = []
|
||||
self.peak_stats = {}
|
||||
self.ignored_types = ()
|
||||
|
||||
# The very first time we are called, we have already been
|
||||
# self.setUp() by the test runner, so we don't need to do it again.
|
||||
self.needs_setUp = False
|
||||
|
||||
def _include_object_p(self, obj):
|
||||
# pylint:disable=too-many-return-statements
|
||||
#
|
||||
# See the comment block at the top. We must be careful to
|
||||
# avoid invoking user-defined operations.
|
||||
if obj is self:
|
||||
return False
|
||||
kind = type(obj)
|
||||
# ``self._include_object_p == obj`` returns NotImplemented
|
||||
# for non-function objects, which causes the interpreter
|
||||
# to try to reverse the order of arguments...which leads
|
||||
# to the explosion of mock objects. We don't want that, so we implement
|
||||
# the check manually.
|
||||
if kind == type(self._include_object_p): # pylint: disable=unidiomatic-typecheck
|
||||
try:
|
||||
# pylint:disable=not-callable
|
||||
exact_method_equals = self._include_object_p.__eq__(obj)
|
||||
except AttributeError:
|
||||
# Python 2.7 methods may only have __cmp__, and that raises a
|
||||
# TypeError for non-method arguments
|
||||
# pylint:disable=no-member
|
||||
exact_method_equals = self._include_object_p.__cmp__(obj) == 0
|
||||
|
||||
if exact_method_equals is not NotImplemented and exact_method_equals:
|
||||
return False
|
||||
|
||||
# Similarly, we need to check identity in our __dict__ to avoid mock explosions.
|
||||
for x in self.__dict__.values():
|
||||
if obj is x:
|
||||
return False
|
||||
|
||||
|
||||
if (
|
||||
kind in self.ignored_types
|
||||
or kind in self.IGNORED_TYPES
|
||||
or kind.__name__ in self.IGNORED_TYPE_NAMES
|
||||
):
|
||||
return False
|
||||
|
||||
|
||||
return True
|
||||
|
||||
def _growth(self):
|
||||
return objgraph.growth(limit=None, peak_stats=self.peak_stats,
|
||||
filter=self._include_object_p)
|
||||
|
||||
def _report_diff(self, growth):
|
||||
if not growth:
|
||||
return "<Unable to calculate growth>"
|
||||
|
||||
lines = []
|
||||
width = max(len(name) for name, _, _ in growth)
|
||||
for name, count, delta in growth:
|
||||
lines.append('%-*s%9d %+9d' % (width, name, count, delta))
|
||||
|
||||
diff = '\n'.join(lines)
|
||||
return diff
|
||||
|
||||
|
||||
def _run_test(self, args, kwargs):
|
||||
gc_enabled = gc.isenabled()
|
||||
gc.disable()
|
||||
|
||||
if self.needs_setUp:
|
||||
self.testcase.setUp()
|
||||
self.testcase.skipTearDown = False
|
||||
try:
|
||||
self.function(self.testcase, *args, **kwargs)
|
||||
finally:
|
||||
self.testcase.tearDown()
|
||||
self.testcase.doCleanups()
|
||||
self.testcase.skipTearDown = True
|
||||
self.needs_setUp = True
|
||||
if gc_enabled:
|
||||
gc.enable()
|
||||
|
||||
def _growth_after(self):
|
||||
# Grab post snapshot
|
||||
# pylint:disable=no-member
|
||||
if 'urlparse' in sys.modules:
|
||||
sys.modules['urlparse'].clear_cache()
|
||||
if 'urllib.parse' in sys.modules:
|
||||
sys.modules['urllib.parse'].clear_cache()
|
||||
|
||||
return self._growth()
|
||||
|
||||
def _check_deltas(self, growth):
|
||||
# Return false when we have decided there is no leak,
|
||||
# true if we should keep looping, raises an assertion
|
||||
# if we have decided there is a leak.
|
||||
|
||||
deltas = self.deltas
|
||||
if not deltas:
|
||||
# We haven't run yet, no data, keep looping
|
||||
return True
|
||||
|
||||
if gc.garbage:
|
||||
raise LeakCheckError("Generated uncollectable garbage %r" % (gc.garbage,))
|
||||
|
||||
|
||||
# the following configurations are classified as "no leak"
|
||||
# [0, 0]
|
||||
# [x, 0, 0]
|
||||
# [... a, b, c, d] where a+b+c+d = 0
|
||||
#
|
||||
# the following configurations are classified as "leak"
|
||||
# [... z, z, z] where z > 0
|
||||
|
||||
if deltas[-2:] == [0, 0] and len(deltas) in (2, 3):
|
||||
return False
|
||||
|
||||
if deltas[-3:] == [0, 0, 0]:
|
||||
return False
|
||||
|
||||
if len(deltas) >= 4 and sum(deltas[-4:]) == 0:
|
||||
return False
|
||||
|
||||
if len(deltas) >= 3 and deltas[-1] > 0 and deltas[-1] == deltas[-2] and deltas[-2] == deltas[-3]:
|
||||
diff = self._report_diff(growth)
|
||||
raise LeakCheckError('refcount increased by %r\n%s' % (deltas, diff))
|
||||
|
||||
# OK, we don't know for sure yet. Let's search for more
|
||||
if sum(deltas[-3:]) <= 0 or sum(deltas[-4:]) <= 0 or deltas[-4:].count(0) >= 2:
|
||||
# this is suspicious, so give a few more runs
|
||||
limit = 11
|
||||
else:
|
||||
limit = 7
|
||||
if len(deltas) >= limit:
|
||||
raise LeakCheckError('refcount increased by %r\n%s'
|
||||
% (deltas,
|
||||
self._report_diff(growth)))
|
||||
|
||||
# We couldn't decide yet, keep going
|
||||
return True
|
||||
|
||||
def __call__(self, args, kwargs):
|
||||
for _ in range(3):
|
||||
gc.collect()
|
||||
|
||||
expect_failure = getattr(self.function, 'fails_leakcheck', False)
|
||||
if expect_failure:
|
||||
self.testcase.expect_greenlet_leak = True
|
||||
self.ignored_types = getattr(self.function, "leakcheck_ignore_types", ())
|
||||
|
||||
# Capture state before; the incremental will be
|
||||
# updated by each call to _growth_after
|
||||
growth = self._growth()
|
||||
|
||||
try:
|
||||
while self._check_deltas(growth):
|
||||
self._run_test(args, kwargs)
|
||||
|
||||
growth = self._growth_after()
|
||||
|
||||
self.deltas.append(sum((stat[2] for stat in growth)))
|
||||
except LeakCheckError:
|
||||
if not expect_failure:
|
||||
raise
|
||||
else:
|
||||
if expect_failure:
|
||||
raise LeakCheckError("Expected %s to leak but it did not." % (self.function,))
|
||||
|
||||
def wrap_refcount(method):
|
||||
if getattr(method, 'ignore_leakcheck', False) or SKIP_LEAKCHECKS:
|
||||
reason = getattr(method, 'ignore_leakcheck_reason', None)
|
||||
if reason and not SKIP_LEAKCHECKS:
|
||||
print(
|
||||
"Ignoring leakchecks for %s: %s" % (method.__name__, reason),
|
||||
file=sys.stderr,
|
||||
)
|
||||
return method
|
||||
|
||||
@wraps(method)
|
||||
def wrapper(self, *args, **kwargs): # pylint:disable=too-many-branches
|
||||
if getattr(self, 'ignore_leakcheck', False):
|
||||
raise unittest.SkipTest("This class ignored during leakchecks")
|
||||
if ONLY_FAILING_LEAKCHECKS and not getattr(method, 'fails_leakcheck', False):
|
||||
raise unittest.SkipTest("Only running tests that fail leakchecks.")
|
||||
return _RefCountChecker(self, method)(args, kwargs)
|
||||
|
||||
return wrapper
|
||||
282
venv/Lib/site-packages/greenlet/tests/test_contextvars.py
Normal file
282
venv/Lib/site-packages/greenlet/tests/test_contextvars.py
Normal file
@@ -0,0 +1,282 @@
|
||||
import gc
|
||||
import sys
|
||||
import unittest
|
||||
from contextvars import Context
|
||||
from contextvars import ContextVar
|
||||
from contextvars import copy_context
|
||||
from functools import partial
|
||||
|
||||
from greenlet import getcurrent
|
||||
from greenlet import greenlet
|
||||
|
||||
from . import PY314
|
||||
from . import TestCase
|
||||
|
||||
# From the documentation:
|
||||
#
|
||||
# Important: Context Variables should be created at the top module
|
||||
# level and never in closures. Context objects hold strong
|
||||
# references to context variables which prevents context variables
|
||||
# from being properly garbage collected.
|
||||
ID_VAR = ContextVar("id", default=None)
|
||||
VAR_VAR = ContextVar("var", default=None)
|
||||
ContextVar = None
|
||||
|
||||
|
||||
class ContextVarsTests(TestCase):
|
||||
def _new_ctx_run(self, *args, **kwargs):
|
||||
return copy_context().run(*args, **kwargs)
|
||||
|
||||
def _increment(self, greenlet_id, callback, counts, expect):
|
||||
ctx_var = ID_VAR
|
||||
if expect is None:
|
||||
self.assertIsNone(ctx_var.get())
|
||||
else:
|
||||
self.assertEqual(ctx_var.get(), expect)
|
||||
ctx_var.set(greenlet_id)
|
||||
for _ in range(2):
|
||||
counts[ctx_var.get()] += 1
|
||||
callback()
|
||||
|
||||
def _test_context(self, propagate_by):
|
||||
# pylint:disable=too-many-branches
|
||||
ID_VAR.set(0)
|
||||
|
||||
callback = getcurrent().switch
|
||||
counts = dict((i, 0) for i in range(5))
|
||||
|
||||
lets = [
|
||||
greenlet(partial(
|
||||
partial(
|
||||
copy_context().run,
|
||||
self._increment
|
||||
) if propagate_by == "run" else self._increment,
|
||||
greenlet_id=i,
|
||||
callback=callback,
|
||||
counts=counts,
|
||||
expect=(
|
||||
i - 1 if propagate_by == "share" else
|
||||
0 if propagate_by in ("set", "run") else None
|
||||
)
|
||||
))
|
||||
for i in range(1, 5)
|
||||
]
|
||||
|
||||
for let in lets:
|
||||
if propagate_by == "set":
|
||||
let.gr_context = copy_context()
|
||||
elif propagate_by == "share":
|
||||
let.gr_context = getcurrent().gr_context
|
||||
|
||||
for i in range(2):
|
||||
counts[ID_VAR.get()] += 1
|
||||
for let in lets:
|
||||
let.switch()
|
||||
|
||||
if propagate_by == "run":
|
||||
# Must leave each context.run() in reverse order of entry
|
||||
for let in reversed(lets):
|
||||
let.switch()
|
||||
else:
|
||||
# No context.run(), so fine to exit in any order.
|
||||
for let in lets:
|
||||
let.switch()
|
||||
|
||||
for let in lets:
|
||||
self.assertTrue(let.dead)
|
||||
# When using run(), we leave the run() as the greenlet dies,
|
||||
# and there's no context "underneath". When not using run(),
|
||||
# gr_context still reflects the context the greenlet was
|
||||
# running in.
|
||||
if propagate_by == 'run':
|
||||
self.assertIsNone(let.gr_context)
|
||||
else:
|
||||
self.assertIsNotNone(let.gr_context)
|
||||
|
||||
|
||||
if propagate_by == "share":
|
||||
self.assertEqual(counts, {0: 1, 1: 1, 2: 1, 3: 1, 4: 6})
|
||||
else:
|
||||
self.assertEqual(set(counts.values()), set([2]))
|
||||
|
||||
def test_context_propagated_by_context_run(self):
|
||||
self._new_ctx_run(self._test_context, "run")
|
||||
|
||||
def test_context_propagated_by_setting_attribute(self):
|
||||
self._new_ctx_run(self._test_context, "set")
|
||||
|
||||
def test_context_not_propagated(self):
|
||||
self._new_ctx_run(self._test_context, None)
|
||||
|
||||
def test_context_shared(self):
|
||||
self._new_ctx_run(self._test_context, "share")
|
||||
|
||||
def test_break_ctxvars(self):
|
||||
let1 = greenlet(copy_context().run)
|
||||
let2 = greenlet(copy_context().run)
|
||||
let1.switch(getcurrent().switch)
|
||||
let2.switch(getcurrent().switch)
|
||||
# Since let2 entered the current context and let1 exits its own, the
|
||||
# interpreter emits:
|
||||
# RuntimeError: cannot exit context: thread state references a different context object
|
||||
let1.switch()
|
||||
|
||||
def test_not_broken_if_using_attribute_instead_of_context_run(self):
|
||||
let1 = greenlet(getcurrent().switch)
|
||||
let2 = greenlet(getcurrent().switch)
|
||||
let1.gr_context = copy_context()
|
||||
let2.gr_context = copy_context()
|
||||
let1.switch()
|
||||
let2.switch()
|
||||
let1.switch()
|
||||
let2.switch()
|
||||
|
||||
def test_context_assignment_while_running(self):
|
||||
# pylint:disable=too-many-statements
|
||||
ID_VAR.set(None)
|
||||
|
||||
def target():
|
||||
self.assertIsNone(ID_VAR.get())
|
||||
self.assertIsNone(gr.gr_context)
|
||||
|
||||
# Context is created on first use
|
||||
ID_VAR.set(1)
|
||||
self.assertIsInstance(gr.gr_context, Context)
|
||||
self.assertEqual(ID_VAR.get(), 1)
|
||||
self.assertEqual(gr.gr_context[ID_VAR], 1)
|
||||
|
||||
# Clearing the context makes it get re-created as another
|
||||
# empty context when next used
|
||||
old_context = gr.gr_context
|
||||
gr.gr_context = None # assign None while running
|
||||
self.assertIsNone(ID_VAR.get())
|
||||
self.assertIsNone(gr.gr_context)
|
||||
ID_VAR.set(2)
|
||||
self.assertIsInstance(gr.gr_context, Context)
|
||||
self.assertEqual(ID_VAR.get(), 2)
|
||||
self.assertEqual(gr.gr_context[ID_VAR], 2)
|
||||
|
||||
new_context = gr.gr_context
|
||||
getcurrent().parent.switch((old_context, new_context))
|
||||
# parent switches us back to old_context
|
||||
|
||||
self.assertEqual(ID_VAR.get(), 1)
|
||||
gr.gr_context = new_context # assign non-None while running
|
||||
self.assertEqual(ID_VAR.get(), 2)
|
||||
|
||||
getcurrent().parent.switch()
|
||||
# parent switches us back to no context
|
||||
self.assertIsNone(ID_VAR.get())
|
||||
self.assertIsNone(gr.gr_context)
|
||||
gr.gr_context = old_context
|
||||
self.assertEqual(ID_VAR.get(), 1)
|
||||
|
||||
getcurrent().parent.switch()
|
||||
# parent switches us back to no context
|
||||
self.assertIsNone(ID_VAR.get())
|
||||
self.assertIsNone(gr.gr_context)
|
||||
|
||||
gr = greenlet(target)
|
||||
|
||||
with self.assertRaisesRegex(AttributeError, "can't delete context attribute"):
|
||||
del gr.gr_context
|
||||
|
||||
self.assertIsNone(gr.gr_context)
|
||||
old_context, new_context = gr.switch()
|
||||
self.assertIs(new_context, gr.gr_context)
|
||||
self.assertEqual(old_context[ID_VAR], 1)
|
||||
self.assertEqual(new_context[ID_VAR], 2)
|
||||
self.assertEqual(new_context.run(ID_VAR.get), 2)
|
||||
gr.gr_context = old_context # assign non-None while suspended
|
||||
gr.switch()
|
||||
self.assertIs(gr.gr_context, new_context)
|
||||
gr.gr_context = None # assign None while suspended
|
||||
gr.switch()
|
||||
self.assertIs(gr.gr_context, old_context)
|
||||
gr.gr_context = None
|
||||
gr.switch()
|
||||
self.assertIsNone(gr.gr_context)
|
||||
|
||||
# Make sure there are no reference leaks
|
||||
gr = None
|
||||
gc.collect()
|
||||
# Python 3.14 elides reference counting operations
|
||||
# in some cases. See https://github.com/python/cpython/pull/130708
|
||||
self.assertEqual(sys.getrefcount(old_context), 2 if not PY314 else 1)
|
||||
self.assertEqual(sys.getrefcount(new_context), 2 if not PY314 else 1)
|
||||
|
||||
def test_context_assignment_different_thread(self):
|
||||
import threading
|
||||
VAR_VAR.set(None)
|
||||
ctx = Context()
|
||||
|
||||
is_running = threading.Event()
|
||||
should_suspend = threading.Event()
|
||||
did_suspend = threading.Event()
|
||||
should_exit = threading.Event()
|
||||
holder = []
|
||||
|
||||
def greenlet_in_thread_fn():
|
||||
VAR_VAR.set(1)
|
||||
is_running.set()
|
||||
should_suspend.wait(10)
|
||||
VAR_VAR.set(2)
|
||||
getcurrent().parent.switch()
|
||||
holder.append(VAR_VAR.get())
|
||||
|
||||
def thread_fn():
|
||||
gr = greenlet(greenlet_in_thread_fn)
|
||||
gr.gr_context = ctx
|
||||
holder.append(gr)
|
||||
gr.switch()
|
||||
did_suspend.set()
|
||||
should_exit.wait(10)
|
||||
gr.switch()
|
||||
del gr
|
||||
greenlet() # trigger cleanup
|
||||
|
||||
thread = threading.Thread(target=thread_fn, daemon=True)
|
||||
thread.start()
|
||||
is_running.wait(10)
|
||||
gr = holder[0]
|
||||
|
||||
# Can't access or modify context if the greenlet is running
|
||||
# in a different thread
|
||||
with self.assertRaisesRegex(ValueError, "running in a different"):
|
||||
getattr(gr, 'gr_context')
|
||||
with self.assertRaisesRegex(ValueError, "running in a different"):
|
||||
gr.gr_context = None
|
||||
|
||||
should_suspend.set()
|
||||
did_suspend.wait(10)
|
||||
|
||||
# OK to access and modify context if greenlet is suspended
|
||||
self.assertIs(gr.gr_context, ctx)
|
||||
self.assertEqual(gr.gr_context[VAR_VAR], 2)
|
||||
gr.gr_context = None
|
||||
|
||||
should_exit.set()
|
||||
thread.join(10)
|
||||
|
||||
self.assertEqual(holder, [gr, None])
|
||||
|
||||
# Context can still be accessed/modified when greenlet is dead:
|
||||
self.assertIsNone(gr.gr_context)
|
||||
gr.gr_context = ctx
|
||||
self.assertIs(gr.gr_context, ctx)
|
||||
|
||||
# Otherwise we leak greenlets on some platforms.
|
||||
# XXX: Should be able to do this automatically
|
||||
del holder[:]
|
||||
gr = None
|
||||
thread = None
|
||||
|
||||
def test_context_assignment_wrong_type(self):
|
||||
g = greenlet()
|
||||
with self.assertRaisesRegex(TypeError,
|
||||
"greenlet context must be a contextvars.Context or None"):
|
||||
g.gr_context = self
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main()
|
||||
91
venv/Lib/site-packages/greenlet/tests/test_cpp.py
Normal file
91
venv/Lib/site-packages/greenlet/tests/test_cpp.py
Normal file
@@ -0,0 +1,91 @@
|
||||
import gc
|
||||
import subprocess
|
||||
import unittest
|
||||
|
||||
import greenlet
|
||||
import objgraph
|
||||
|
||||
from . import WIN
|
||||
from . import TestCase
|
||||
from . import _test_extension_cpp
|
||||
|
||||
|
||||
class CPPTests(TestCase):
|
||||
def test_exception_switch(self):
|
||||
greenlets = []
|
||||
for i in range(4):
|
||||
g = greenlet.greenlet(_test_extension_cpp.test_exception_switch)
|
||||
g.switch(i)
|
||||
greenlets.append(g)
|
||||
for i, g in enumerate(greenlets):
|
||||
self.assertEqual(g.switch(), i)
|
||||
|
||||
def _do_test_unhandled_exception(self, target):
|
||||
import os
|
||||
import sys
|
||||
script = os.path.join(
|
||||
os.path.dirname(__file__),
|
||||
'fail_cpp_exception.py',
|
||||
)
|
||||
args = [sys.executable, script, target.__name__ if not isinstance(target, str) else target]
|
||||
__traceback_info__ = args
|
||||
with self.assertRaises(subprocess.CalledProcessError) as exc:
|
||||
subprocess.check_output(
|
||||
args,
|
||||
encoding='utf-8',
|
||||
stderr=subprocess.STDOUT
|
||||
)
|
||||
|
||||
ex = exc.exception
|
||||
expected_exit = self.get_expected_returncodes_for_aborted_process()
|
||||
self.assertIn(ex.returncode, expected_exit)
|
||||
self.assertIn('fail_cpp_exception is running', ex.output)
|
||||
return ex.output
|
||||
|
||||
|
||||
def test_unhandled_nonstd_exception_aborts(self):
|
||||
# verify that plain unhandled throw aborts
|
||||
self._do_test_unhandled_exception(_test_extension_cpp.test_exception_throw_nonstd)
|
||||
|
||||
def test_unhandled_std_exception_aborts(self):
|
||||
# verify that plain unhandled throw aborts
|
||||
self._do_test_unhandled_exception(_test_extension_cpp.test_exception_throw_std)
|
||||
|
||||
@unittest.skipIf(WIN, "XXX: This does not crash on Windows")
|
||||
# Meaning the exception is getting lost somewhere...
|
||||
def test_unhandled_std_exception_as_greenlet_function_aborts(self):
|
||||
# verify that plain unhandled throw aborts
|
||||
output = self._do_test_unhandled_exception('run_as_greenlet_target')
|
||||
self.assertIn(
|
||||
# We really expect this to be prefixed with "greenlet: Unhandled C++ exception:"
|
||||
# as added by our handler for std::exception (see TUserGreenlet.cpp), but
|
||||
# that's not correct everywhere --- our handler never runs before std::terminate
|
||||
# gets called (for example, on arm32).
|
||||
'Thrown from an extension.',
|
||||
output
|
||||
)
|
||||
|
||||
def test_unhandled_exception_in_greenlet_aborts(self):
|
||||
# verify that unhandled throw called in greenlet aborts too
|
||||
self._do_test_unhandled_exception('run_unhandled_exception_in_greenlet_aborts')
|
||||
|
||||
|
||||
def test_leak_test_exception_switch_and_do_in_g2(self):
|
||||
def raiser():
|
||||
raise ValueError("boom")
|
||||
|
||||
gc.collect()
|
||||
before = objgraph.count("greenlet")
|
||||
|
||||
for _ in range(1000):
|
||||
with self.assertRaises(ValueError):
|
||||
_test_extension_cpp.test_exception_switch_and_do_in_g2(raiser)
|
||||
|
||||
gc.collect()
|
||||
after = objgraph.count("greenlet")
|
||||
leaked = after - before
|
||||
self.assertEqual(0, leaked)
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main()
|
||||
Reference in New Issue
Block a user