debugpy 1.8.0__zip → 1.8.2__zip

debugpy-1.8.0/src/debugpy/_vendored/pydevd/tests_python/test_suspended_frames_manager.py

@@ -1,134 +0,0 @@
-import sys
-from _pydevd_bundle.pydevd_constants import int_types, GENERATED_LEN_ATTR_NAME
-from _pydevd_bundle.pydevd_resolver import TOO_LARGE_ATTR
-from _pydevd_bundle import pydevd_resolver, pydevd_constants
-from _pydevd_bundle import pydevd_frame_utils
-import pytest
-
-
-def get_frame():
-    var1 = 1
-    var2 = [var1]
-    var3 = {33: [var1]}
-    return sys._getframe()
-
-
-def check_vars_dict_expected(as_dict, expected):
-    assert as_dict == expected
-
-
-class _DummyPyDB(object):
-
-    def __init__(self):
-        from _pydevd_bundle.pydevd_api import PyDevdAPI
-        self.variable_presentation = PyDevdAPI.VariablePresentation()
-
-
-def test_suspended_frames_manager():
-    from _pydevd_bundle.pydevd_suspended_frames import SuspendedFramesManager
-    from _pydevd_bundle.pydevd_utils import DAPGrouper
-    suspended_frames_manager = SuspendedFramesManager()
-    py_db = _DummyPyDB()
-    with suspended_frames_manager.track_frames(py_db) as tracker:
-        # : :type tracker: _FramesTracker
-        thread_id = 'thread1'
-        frame = get_frame()
-        tracker.track(thread_id, pydevd_frame_utils.create_frames_list_from_frame(frame))
-
-        assert suspended_frames_manager.get_thread_id_for_variable_reference(id(frame)) == thread_id
-
-        variable = suspended_frames_manager.get_variable(id(frame))
-
-        # Should be properly sorted.
-        assert ['var1', 'var2', 'var3'] == [x.get_name()for x in variable.get_children_variables()]
-
-        as_dict = dict((x.get_name(), x.get_var_data()) for x in variable.get_children_variables())
-        var_reference = as_dict['var2'].pop('variablesReference')
-        assert isinstance(var_reference, int_types)  # The variable reference is always a new int.
-        assert isinstance(as_dict['var3'].pop('variablesReference'), int_types)  # The variable reference is always a new int.
-
-        check_vars_dict_expected(as_dict, {
-            'var1': {'name': 'var1', 'value': '1', 'type': 'int', 'evaluateName': 'var1', 'variablesReference': 0},
-            'var2': {'name': 'var2', 'value': '[1]', 'type': 'list', 'evaluateName': 'var2'},
-            'var3': {'name': 'var3', 'value': '{33: [1]}', 'type': 'dict', 'evaluateName': 'var3'}
-        })
-
-        # Now, same thing with a different format.
-        as_dict = dict((x.get_name(), x.get_var_data(fmt={'hex': True})) for x in variable.get_children_variables())
-        var_reference = as_dict['var2'].pop('variablesReference')
-        assert isinstance(var_reference, int_types)  # The variable reference is always a new int.
-        assert isinstance(as_dict['var3'].pop('variablesReference'), int_types)  # The variable reference is always a new int.
-
-        check_vars_dict_expected(as_dict, {
-            'var1': {'name': 'var1', 'value': '0x1', 'type': 'int', 'evaluateName': 'var1', 'variablesReference': 0},
-            'var2': {'name': 'var2', 'value': '[0x1]', 'type': 'list', 'evaluateName': 'var2'},
-            'var3': {'name': 'var3', 'value': '{0x21: [0x1]}', 'type': 'dict', 'evaluateName': 'var3'}
-        })
-
-        var2 = dict((x.get_name(), x) for x in variable.get_children_variables())['var2']
-        children_vars = var2.get_children_variables()
-        as_dict = (dict([x.get_name(), x.get_var_data()] for x in children_vars if x.get_name() not in DAPGrouper.SCOPES_SORTED))
-        assert as_dict == {
-            '0': {'name': '0', 'value': '1', 'type': 'int', 'evaluateName': 'var2[0]', 'variablesReference': 0 },
-            GENERATED_LEN_ATTR_NAME: {'name': GENERATED_LEN_ATTR_NAME, 'value': '1', 'type': 'int', 'evaluateName': 'len(var2)', 'variablesReference': 0, 'presentationHint': {'attributes': ['readOnly']}, },
-        }
-
-        var3 = dict((x.get_name(), x) for x in variable.get_children_variables())['var3']
-        children_vars = var3.get_children_variables()
-        as_dict = (dict([x.get_name(), x.get_var_data()] for x in children_vars if x.get_name() not in DAPGrouper.SCOPES_SORTED))
-        assert isinstance(as_dict['33'].pop('variablesReference'), int_types)  # The variable reference is always a new int.
-
-        check_vars_dict_expected(as_dict, {
-            '33': {'name': '33', 'value': "[1]", 'type': 'list', 'evaluateName': 'var3[33]'},
-            GENERATED_LEN_ATTR_NAME: {'name': GENERATED_LEN_ATTR_NAME, 'value': '1', 'type': 'int', 'evaluateName': 'len(var3)', 'variablesReference': 0, 'presentationHint': {'attributes': ['readOnly']}, }
-        })
-
-
-def get_dict_large_frame():
-    obj = {}
-    for idx in range(pydevd_constants.PYDEVD_CONTAINER_RANDOM_ACCESS_MAX_ITEMS + +300):
-        obj[idx] = (1)
-    return sys._getframe()
-
-
-def get_set_large_frame():
-    obj = set()
-    for idx in range(pydevd_constants.PYDEVD_CONTAINER_RANDOM_ACCESS_MAX_ITEMS + +300):
-        obj.add(idx)
-    return sys._getframe()
-
-
-def test_get_child_variables():
-    from _pydevd_bundle.pydevd_suspended_frames import SuspendedFramesManager
-    suspended_frames_manager = SuspendedFramesManager()
-    py_db = _DummyPyDB()
-    for frame in (
-        get_dict_large_frame(),
-        get_set_large_frame(),
-        ):
-        with suspended_frames_manager.track_frames(py_db) as tracker:
-            # : :type tracker: _FramesTracker
-            thread_id = 'thread1'
-            tracker.track(thread_id, pydevd_frame_utils.create_frames_list_from_frame(frame))
-
-            assert suspended_frames_manager.get_thread_id_for_variable_reference(id(frame)) == thread_id
-
-            variable = suspended_frames_manager.get_variable(id(frame))
-
-            children_variables = variable.get_child_variable_named('obj').get_children_variables()
-
-            found_too_large = False
-            found_len = False
-            for x in children_variables:
-                if x.name == TOO_LARGE_ATTR:
-                    var_data = x.get_var_data()
-                    assert 'readOnly' in var_data['presentationHint']['attributes']
-                    found_too_large = True
-                elif x.name == GENERATED_LEN_ATTR_NAME:
-                    found_len = True
-
-            if not found_too_large:
-                raise AssertionError('Expected to find variable named: %s' % (TOO_LARGE_ATTR,))
-            if not found_len:
-                raise AssertionError('Expected to find variable named: len()')
-

debugpy-1.8.0/src/debugpy/_vendored/pydevd/tests_python/test_timeout_tracker.py

@@ -1,128 +0,0 @@
-from _pydevd_bundle import pydevd_timeout
-from _pydevd_bundle.pydevd_constants import IS_PYPY, IS_CPYTHON
-from _pydevd_bundle.pydevd_timeout import create_interrupt_this_thread_callback
-from tests_python.debugger_unittest import wait_for_condition
-import pytest
-import threading
-import time
-
-
-@pytest.yield_fixture(autouse=True)
-def _enable_debug_msgs():
-    original = pydevd_timeout._DEBUG
-    pydevd_timeout._DEBUG = True
-    yield
-    pydevd_timeout._DEBUG = original
-
-
-def test_timeout():
-
-    class _DummyPyDb(object):
-
-        def __init__(self):
-            self.created_pydb_daemon_threads = {}
-
-    raise_timeout = pydevd_timeout.create_interrupt_this_thread_callback()
-
-    def on_timeout(arg):
-        assert arg == 1
-        raise_timeout()
-
-    py_db = _DummyPyDb()
-    timeout_tracker = pydevd_timeout.TimeoutTracker(py_db)
-    try:
-        if IS_PYPY:
-            timeout = 2
-        else:
-            timeout = 20
-        with timeout_tracker.call_on_timeout(1, on_timeout, kwargs={'arg': 1}):
-            time.sleep(timeout)
-    except KeyboardInterrupt:
-        pass
-
-
-def test_timeout_0_time():
-
-    class _DummyPyDb(object):
-
-        def __init__(self):
-            self.created_pydb_daemon_threads = {}
-
-    raise_timeout = pydevd_timeout.create_interrupt_this_thread_callback()
-
-    def on_timeout(arg):
-        assert arg == 1
-        raise_timeout()
-
-    py_db = _DummyPyDb()
-    timeout_tracker = pydevd_timeout.TimeoutTracker(py_db)
-    try:
-        with timeout_tracker.call_on_timeout(0, on_timeout, kwargs={'arg': 1}):
-            time.sleep(1)
-    except KeyboardInterrupt:
-        pass
-
-
-@pytest.mark.skipif(not IS_CPYTHON, reason='This only works in CPython.')
-def test_create_interrupt_this_thread_callback():
-
-    class MyThread(threading.Thread):
-
-        def __init__(self):
-            threading.Thread.__init__(self)
-            self.finished = False
-            self.daemon = True
-            self.interrupt_thread = None
-            self.interrupted = False
-
-        def run(self):
-            try:
-                self.interrupt_thread = create_interrupt_this_thread_callback()
-                while True:
-                    time.sleep(.2)
-            except KeyboardInterrupt:
-                self.interrupted = True
-            finally:
-                self.finished = True
-
-    t = MyThread()
-    t.start()
-    wait_for_condition(lambda: t.interrupt_thread is not None)
-
-    t.interrupt_thread()
-
-    wait_for_condition(lambda: t.finished)
-
-    assert t.interrupted
-
-
-@pytest.mark.skipif(True, reason='Skipping because running this test can interrupt the test suite execution.')
-def test_interrupt_main_thread():
-
-    from _pydevd_bundle.pydevd_constants import IS_PY39_OR_GREATER
-
-    class MyThread(threading.Thread):
-
-        def __init__(self, interrupt_thread_callback):
-            threading.Thread.__init__(self)
-            self.interrupt_thread_callback = interrupt_thread_callback
-
-        def run(self):
-            time.sleep(.5)
-            self.interrupt_thread_callback()
-
-    initial_time = time.time()
-    interrupt_only_on_callback = IS_PYPY or IS_PY39_OR_GREATER
-    if interrupt_only_on_callback:
-        timeout = 2
-    else:
-        timeout = 20
-    try:
-        t = MyThread(create_interrupt_this_thread_callback())
-        t.start()
-        time.sleep(timeout)
-    except KeyboardInterrupt:
-        if not interrupt_only_on_callback:
-            assert time.time() - initial_time < timeout
-    else:
-        raise AssertionError('Expected main thread to be interrupted.')

debugpy-1.8.0/src/debugpy/_vendored/pydevd/tests_python/test_tracing_gotchas.py

@@ -1,101 +0,0 @@
-import pytest
-import sys
-from _pydevd_bundle.pydevd_constants import NO_FTRACE
-from tests_python.debugger_unittest import IS_JYTHON
-
-
-class Tracer(object):
-
-    def __init__(self):
-        self.call_calls = 0
-        self.line_calls = 0
-
-    def trace_func(self, frame, event, arg):
-        if event == 'call':
-            self.call_calls += 1
-            return self.on_call()
-
-        elif event == 'line':
-            self.line_calls += 1
-            # Should disable tracing when None is returned (but doesn't).
-            return self.on_line(frame, event, arg)
-
-        else:
-            return self.trace_func
-
-    def on_call(self):
-        return self.trace_func
-
-    def on_line(self, frame, event, arg):
-        return None
-
-
-class TracerSettingNone(Tracer):
-
-    def on_line(self, frame, event, arg):
-        frame.f_trace = NO_FTRACE
-        return NO_FTRACE
-
-
-class TracerChangeToOtherTracing(Tracer):
-
-    def on_line(self, frame, event, arg):
-        return self._no_trace
-
-    def _no_trace(self, frame, event, arg):
-        return self._no_trace
-
-
-class TracerDisableOnCall(Tracer):
-
-    def on_call(self):
-        return None
-
-
-def test_tracing_gotchas():
-    '''
-    Summary of the gotchas tested:
-
-    If 'call' is used, a None return value is used for the tracing. Afterwards the return may or may
-    not be ignored depending on the Python version.
-
-    Also, on Python 2.6, the trace function may not be set to None as it'll give an error
-    afterwards (it needs to be set to an empty tracing function).
-
-    All of the versions seem to work when the return value is a new callable though.
-
-    Note: according to: https://docs.python.org/3/library/sys.html#sys.settrace the behavior
-    does not follow the spec (but we have to work with it nonetheless).
-
-    Note: Jython seems to do what's written in the docs.
-    '''
-
-    def method():
-        _a = 1
-        _b = 1
-        _c = 1
-        _d = 1
-
-    for tracer, line_events in (
-        (Tracer(), 1 if IS_JYTHON else 4),
-        (TracerSettingNone(), 1),
-        (TracerChangeToOtherTracing(), 1),
-        (TracerDisableOnCall(), 0),
-        ):
-        curr_trace_func = sys.gettrace()
-        try:
-            sys.settrace(tracer.trace_func)
-
-            method()
-
-            if tracer.call_calls != 1:
-                pytest.fail('Expected a single call event. Found: %s' % (tracer.call_calls))
-
-            if tracer.line_calls != line_events:
-                pytest.fail('Expected %s line events. Found: %s. Tracer: %s' % (line_events, tracer.line_calls, tracer))
-        finally:
-            sys.settrace(curr_trace_func)
-
-
-if __name__ == '__main__':
-    pytest.main(['-k', 'test_tracing_gotchas'])