debugpy 1.8.0__zip → 1.8.2__zip

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

@@ -1,499 +0,0 @@
-from _pydevd_bundle.pydevd_constants import IS_PY36_OR_GREATER, GENERATED_LEN_ATTR_NAME
-from _pydevd_bundle import pydevd_constants, pydevd_frame_utils
-import pytest
-import sys
-
-
-def check_len_entry(len_entry, first_2_params):
-    assert len_entry[:2] == first_2_params
-    assert callable(len_entry[2])
-    assert len_entry[2]('check') == 'len(check)'
-
-
-def test_dict_resolver():
-    from _pydevd_bundle.pydevd_resolver import DictResolver
-    dict_resolver = DictResolver()
-    dct = {(1, 2): 2, u'22': 22}
-    contents_debug_adapter_protocol = clear_contents_debug_adapter_protocol(dict_resolver.get_contents_debug_adapter_protocol(dct))
-    len_entry = contents_debug_adapter_protocol.pop(-1)
-    check_len_entry(len_entry, (GENERATED_LEN_ATTR_NAME, 2))
-    if IS_PY36_OR_GREATER:
-        assert contents_debug_adapter_protocol == [
-            ('(1, 2)', 2, '[(1, 2)]'), ("'22'", 22, "['22']")]
-
-    else:
-        assert contents_debug_adapter_protocol == [
-            ("'22'", 22, "['22']"), ('(1, 2)', 2, '[(1, 2)]')]
-
-
-def test_dict_resolver_hex():
-    from _pydevd_bundle.pydevd_resolver import DictResolver
-    dict_resolver = DictResolver()
-    dct = {(1, 10, 100): (10000, 100000, 100000)}
-    contents_debug_adapter_protocol = clear_contents_debug_adapter_protocol(
-        dict_resolver.get_contents_debug_adapter_protocol(dct, fmt={'hex': True}))
-    len_entry = contents_debug_adapter_protocol.pop(-1)
-    check_len_entry(len_entry, (GENERATED_LEN_ATTR_NAME, 1))
-    assert contents_debug_adapter_protocol == [
-        ('(0x1, 0xa, 0x64)', (10000, 100000, 100000), '[(1, 10, 100)]'), ]
-
-
-def test_object_resolver_simple():
-    from _pydevd_bundle.pydevd_resolver import DefaultResolver
-    default_resolver = DefaultResolver()
-
-    class MyObject(object):
-
-        def __init__(self):
-            self.a = 10
-            self.b = 20
-
-    obj = MyObject()
-    dictionary = clear_contents_dictionary(default_resolver.get_dictionary(obj))
-    assert dictionary == {'a': 10, 'b': 20}
-
-    contents_debug_adapter_protocol = clear_contents_debug_adapter_protocol(default_resolver.get_contents_debug_adapter_protocol(obj))
-    assert contents_debug_adapter_protocol == [('a', 10, '.a'), ('b', 20, '.b')]
-
-
-def test_object_resolver_error():
-    from _pydevd_bundle.pydevd_resolver import DefaultResolver
-    default_resolver = DefaultResolver()
-
-    class MyObject(object):
-
-        def __init__(self):
-            self.a = 10
-
-        def __dir__(self):
-            return ['a', 'b']
-
-        def __getattribute__(self, attr_name):
-            if attr_name == 'b':
-                raise RuntimeError('unavailable')
-            return object.__getattribute__(self, attr_name)
-
-    obj = MyObject()
-    dictionary = default_resolver.get_dictionary(obj)
-    b_value = dictionary.pop('b')
-    assert dictionary == {'a': 10}
-    assert "raise RuntimeError('unavailable')" in b_value
-
-    contents_debug_adapter_protocol = default_resolver.get_contents_debug_adapter_protocol(obj)
-    b_value = contents_debug_adapter_protocol.pop(-1)
-    assert contents_debug_adapter_protocol == [('a', 10, '.a')]
-    assert b_value[0] == 'b'
-    assert "raise RuntimeError('unavailable')" in b_value[1]
-    assert b_value[2] == '.b'
-
-
-def test_object_resolver_hasattr_error():
-    from _pydevd_bundle.pydevd_resolver import DefaultResolver
-    from _pydevd_bundle.pydevd_xml import get_type
-    default_resolver = DefaultResolver()
-
-    class MyObject(object):
-
-        def __getattribute__(self, attr_name):
-            raise RuntimeError()
-
-    obj = MyObject()
-    dictionary = default_resolver.get_dictionary(obj)
-    assert dictionary == {}
-
-    _type_object, type_name, _resolver = get_type(obj)
-    assert type_name == 'MyObject'
-
-
-def test_object_resolver__dict__non_strings():
-    from _pydevd_bundle.pydevd_resolver import DefaultResolver
-    default_resolver = DefaultResolver()
-
-    class MyObject(object):
-
-        def __init__(self):
-            self.__dict__[(1, 2)] = (3, 4)
-
-    obj = MyObject()
-    dictionary = clear_contents_dictionary(default_resolver.get_dictionary(obj))
-    assert dictionary == {'(1, 2)': (3, 4)}
-
-    contents_debug_adapter_protocol = clear_contents_debug_adapter_protocol(
-        default_resolver.get_contents_debug_adapter_protocol(obj))
-    assert contents_debug_adapter_protocol == [('(1, 2)', (3, 4), '.__dict__[(1, 2)]')]
-
-
-def test_django_forms_resolver():
-    from _pydevd_bundle.pydevd_resolver import DjangoFormResolver
-    django_form_resolver = DjangoFormResolver()
-
-    class MyObject(object):
-
-        def __init__(self):
-            self.__dict__[(1, 2)] = (3, 4)
-            self.__dict__['errors'] = 'foo'
-
-    obj = MyObject()
-
-    dictionary = clear_contents_dictionary(django_form_resolver.get_dictionary(obj))
-    assert dictionary == {'(1, 2)': (3, 4), 'errors': None}
-
-    obj._errors = 'bar'
-    dictionary = clear_contents_dictionary(django_form_resolver.get_dictionary(obj))
-    assert dictionary == {'(1, 2)': (3, 4), 'errors': 'bar', '_errors': 'bar'}
-
-
-def clear_contents_debug_adapter_protocol(contents_debug_adapter_protocol):
-    lst = []
-    for x in contents_debug_adapter_protocol:
-        if not x[0].startswith('__'):
-
-            if '<built-in method' in str(x[1]) or '<method-wrapper' in str(x[1]) or '<bound method' in str(x[1]):
-                continue
-
-            lst.append(x)
-
-    return lst
-
-
-def clear_contents_dictionary(dictionary):
-    dictionary = dictionary.copy()
-    for key in list(dictionary):
-        if key.startswith('__') or key in ('count', 'index'):
-            del dictionary[key]
-    return dictionary
-
-
-def test_tuple_resolver():
-    from _pydevd_bundle.pydevd_resolver import TupleResolver
-    tuple_resolver = TupleResolver()
-    fmt = {'hex': True}
-    lst = tuple(range(11))
-    contents_debug_adapter_protocol = clear_contents_debug_adapter_protocol(
-        tuple_resolver.get_contents_debug_adapter_protocol(lst))
-    len_entry = contents_debug_adapter_protocol.pop(-1)
-    assert contents_debug_adapter_protocol == [
-        ('00', 0, '[0]'),
-        ('01', 1, '[1]'),
-        ('02', 2, '[2]'),
-        ('03', 3, '[3]'),
-        ('04', 4, '[4]'),
-        ('05', 5, '[5]'),
-        ('06', 6, '[6]'),
-        ('07', 7, '[7]'),
-        ('08', 8, '[8]'),
-        ('09', 9, '[9]'),
-        ('10', 10, '[10]'),
-    ]
-    check_len_entry(len_entry, (GENERATED_LEN_ATTR_NAME, 11))
-
-    assert clear_contents_dictionary(tuple_resolver.get_dictionary(lst)) == {
-        '00': 0,
-        '01': 1,
-        '02': 2,
-        '03': 3,
-        '04': 4,
-        '05': 5,
-        '06': 6,
-        '07': 7,
-        '08': 8,
-        '09': 9,
-        '10': 10,
-        GENERATED_LEN_ATTR_NAME: 11
-    }
-
-    lst = tuple(range(17))
-    contents_debug_adapter_protocol = clear_contents_debug_adapter_protocol(
-        tuple_resolver.get_contents_debug_adapter_protocol(lst, fmt=fmt))
-    len_entry = contents_debug_adapter_protocol.pop(-1)
-    assert contents_debug_adapter_protocol == [
-        ('0x00', 0, '[0]'),
-        ('0x01', 1, '[1]'),
-        ('0x02', 2, '[2]'),
-        ('0x03', 3, '[3]'),
-        ('0x04', 4, '[4]'),
-        ('0x05', 5, '[5]'),
-        ('0x06', 6, '[6]'),
-        ('0x07', 7, '[7]'),
-        ('0x08', 8, '[8]'),
-        ('0x09', 9, '[9]'),
-        ('0x0a', 10, '[10]'),
-        ('0x0b', 11, '[11]'),
-        ('0x0c', 12, '[12]'),
-        ('0x0d', 13, '[13]'),
-        ('0x0e', 14, '[14]'),
-        ('0x0f', 15, '[15]'),
-        ('0x10', 16, '[16]'),
-    ]
-    check_len_entry(len_entry, (GENERATED_LEN_ATTR_NAME, 17))
-
-    assert clear_contents_dictionary(tuple_resolver.get_dictionary(lst, fmt=fmt)) == {
-        '0x00': 0,
-        '0x01': 1,
-        '0x02': 2,
-        '0x03': 3,
-        '0x04': 4,
-        '0x05': 5,
-        '0x06': 6,
-        '0x07': 7,
-        '0x08': 8,
-        '0x09': 9,
-        '0x0a': 10,
-        '0x0b': 11,
-        '0x0c': 12,
-        '0x0d': 13,
-        '0x0e': 14,
-        '0x0f': 15,
-        '0x10': 16,
-        GENERATED_LEN_ATTR_NAME: 17
-    }
-
-    lst = tuple(range(10))
-    contents_debug_adapter_protocol = clear_contents_debug_adapter_protocol(tuple_resolver.get_contents_debug_adapter_protocol(lst))
-    len_entry = contents_debug_adapter_protocol.pop(-1)
-    assert contents_debug_adapter_protocol == [
-        ('0', 0, '[0]'),
-        ('1', 1, '[1]'),
-        ('2', 2, '[2]'),
-        ('3', 3, '[3]'),
-        ('4', 4, '[4]'),
-        ('5', 5, '[5]'),
-        ('6', 6, '[6]'),
-        ('7', 7, '[7]'),
-        ('8', 8, '[8]'),
-        ('9', 9, '[9]'),
-    ]
-    check_len_entry(len_entry, (GENERATED_LEN_ATTR_NAME, 10))
-
-    assert clear_contents_dictionary(tuple_resolver.get_dictionary(lst)) == {
-        '0': 0,
-        '1': 1,
-        '2': 2,
-        '3': 3,
-        '4': 4,
-        '5': 5,
-        '6': 6,
-        '7': 7,
-        '8': 8,
-        '9': 9,
-        GENERATED_LEN_ATTR_NAME: 10
-    }
-
-    contents_debug_adapter_protocol = clear_contents_debug_adapter_protocol(tuple_resolver.get_contents_debug_adapter_protocol(lst, fmt=fmt))
-    len_entry = contents_debug_adapter_protocol.pop(-1)
-    assert contents_debug_adapter_protocol == [
-        ('0x0', 0, '[0]'),
-        ('0x1', 1, '[1]'),
-        ('0x2', 2, '[2]'),
-        ('0x3', 3, '[3]'),
-        ('0x4', 4, '[4]'),
-        ('0x5', 5, '[5]'),
-        ('0x6', 6, '[6]'),
-        ('0x7', 7, '[7]'),
-        ('0x8', 8, '[8]'),
-        ('0x9', 9, '[9]'),
-    ]
-    check_len_entry(len_entry, (GENERATED_LEN_ATTR_NAME, 10))
-
-    assert clear_contents_dictionary(tuple_resolver.get_dictionary(lst, fmt=fmt)) == {
-        '0x0': 0,
-        '0x1': 1,
-        '0x2': 2,
-        '0x3': 3,
-        '0x4': 4,
-        '0x5': 5,
-        '0x6': 6,
-        '0x7': 7,
-        '0x8': 8,
-        '0x9': 9,
-        GENERATED_LEN_ATTR_NAME: 10
-    }
-
-
-def test_tuple_resolver_mixed():
-    from _pydevd_bundle.pydevd_resolver import TupleResolver
-    tuple_resolver = TupleResolver()
-
-    class CustomTuple(tuple):
-        pass
-
-    my_tuple = CustomTuple([1, 2])
-    my_tuple.some_value = 10
-    contents_debug_adapter_protocol = clear_contents_debug_adapter_protocol(tuple_resolver.get_contents_debug_adapter_protocol(my_tuple))
-    len_entry = contents_debug_adapter_protocol.pop(-1)
-    check_len_entry(len_entry, (GENERATED_LEN_ATTR_NAME, 2))
-    assert contents_debug_adapter_protocol == [
-        ('some_value', 10, '.some_value'), ('0', 1, '[0]'), ('1', 2, '[1]'), ]
-
-
-def test_tuple_resolver_ctypes():
-    import ctypes
-    from _pydevd_bundle.pydevd_xml import get_type
-
-    array_type = ctypes.c_int32 * 3
-    array_value = array_type(1, 2, 3)
-    _, _, resolver = get_type(array_value)
-
-    contents_dap = resolver.get_contents_debug_adapter_protocol(array_value)
-    # We only care about the array elements and len() here, so remove all preceding entries.
-    while True:
-        _, _, path = contents_dap[0]
-        if path.startswith("["):
-            break
-        contents_dap.pop(0)
-
-    len_entry = contents_dap.pop(-1)
-    assert contents_dap == [
-        ('0', 1, '[0]'),
-        ('1', 2, '[1]'),
-        ('2', 3, '[2]'),
-    ]
-    check_len_entry(len_entry, (GENERATED_LEN_ATTR_NAME, 3))
-
-    dict_dap = resolver.get_dictionary(array_value)
-    # We only care about the array elements and len() here, so remove all other entries.
-    dict_dap = {
-        k: v
-        for k, v in dict_dap.items()
-        if k.isdigit() or k == GENERATED_LEN_ATTR_NAME
-    }
-    assert dict_dap == {
-        '0': 1,
-        '1': 2,
-        '2': 3,
-        GENERATED_LEN_ATTR_NAME: 3
-    }
-
-
-def get_tuple_recursive():
-    obj = [
-        tuple(range(9)),
-        [
-            tuple(range(5)),
-        ]
-    ]
-
-    return sys._getframe()
-
-
-def get_dict_recursive():
-    obj = {
-        1:1,
-        2:{
-            3:3,
-            4:4,
-            5:5,
-            6:6,
-            7:{
-                8:8,
-                9:9,
-                10:10}
-        }
-    }
-
-    return sys._getframe()
-
-
-class _DummyPyDB(object):
-
-    def __init__(self):
-        from _pydevd_bundle.pydevd_api import PyDevdAPI
-        self.variable_presentation = PyDevdAPI.VariablePresentation()
-
-
-class _DAPCheckChildVars:
-
-    def __init__(self, data_regression, monkeypatch):
-        self.data_regression = data_regression
-        self.monkeypatch = monkeypatch
-
-    def check(self, frame, initial_expanded):
-        self.monkeypatch.setattr(pydevd_constants, 'PYDEVD_CONTAINER_INITIAL_EXPANDED_ITEMS', initial_expanded + 2)
-        self.monkeypatch.setattr(pydevd_constants, 'PYDEVD_CONTAINER_BUCKET_SIZE', initial_expanded)
-
-        from _pydevd_bundle.pydevd_suspended_frames import SuspendedFramesManager
-        suspended_frames_manager = SuspendedFramesManager()
-        py_db = _DummyPyDB()
-
-        # Now, let's enable the list packing with less items.
-        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
-
-            found = []
-            frame_var = suspended_frames_manager.get_variable(id(frame))
-            for level, variable in self.collect_all_dap(frame_var.get_child_variable_named('obj')):
-                found.append((('    ' * level) + variable.name + ': ' + str(variable.value)))
-
-            self.data_regression.check(found)
-
-    def collect_all_dap(self, variable, level=0):
-        children_variables = variable.get_children_variables()
-        for var in children_variables:
-            if var.name in ('special variables', 'function variables'):
-                continue
-            yield level, var
-            yield from self.collect_all_dap(var, level + 1)
-
-
-@pytest.fixture
-def dap_check_child_vars(data_regression, monkeypatch):
-    yield _DAPCheckChildVars(data_regression, monkeypatch)
-
-
-@pytest.mark.parametrize('initial_expanded', [300, 2])
-def test_get_child_variables_multiple_levels_dap(initial_expanded, dap_check_child_vars):
-    frame = get_tuple_recursive()
-    dap_check_child_vars.check(frame, initial_expanded)
-
-
-@pytest.mark.parametrize('initial_expanded', [300, 2])
-def test_get_child_variables_dict_multiple_levels_dap(initial_expanded, dap_check_child_vars, monkeypatch):
-    monkeypatch.setattr(pydevd_constants, 'PYDEVD_CONTAINER_RANDOM_ACCESS_MAX_ITEMS', initial_expanded)
-    frame = get_dict_recursive()
-    dap_check_child_vars.check(frame, initial_expanded)
-
-
-@pytest.mark.parametrize('initial_expanded', [300, 2])
-def test_get_child_variables_multiple_levels_resolver(data_regression, initial_expanded, monkeypatch):
-    monkeypatch.setattr(pydevd_constants, 'PYDEVD_CONTAINER_INITIAL_EXPANDED_ITEMS', initial_expanded + 2)
-    monkeypatch.setattr(pydevd_constants, 'PYDEVD_CONTAINER_BUCKET_SIZE', initial_expanded)
-
-    obj = [
-        tuple(range(9)),
-        [
-            tuple(range(5)),
-        ]
-    ]
-    found = []
-    for level, key, val in collect_resolver_dictionary(obj):
-        found.append((('    ' * level) + key + ': ' + str(val)))
-
-    data_regression.check(found)
-
-
-def _skip_key_in_dict(key):
-    try:
-        int(key)
-    except ValueError:
-        if 'more' in key or '[' in key:
-            return False
-        return True
-    return False
-
-
-def collect_resolver_dictionary(obj, level=0):
-    from _pydevd_bundle.pydevd_xml import get_type
-    resolver = get_type(obj)[-1]
-    if resolver is None:
-        return
-
-    dct = resolver.get_dictionary(obj)
-    for key, val in dct.items():
-        if _skip_key_in_dict(key):
-            continue
-        yield level, key, val
-        yield from collect_resolver_dictionary(val, level + 1)

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

@@ -1,115 +0,0 @@
-import pytest
-pytest_plugins = [
-    str('_pytest.pytester'),
-]
-
-
-def _run_and_check(testdir_or_pytester, path, check_for='Worked'):
-    result = testdir_or_pytester.runpython(path)
-    result.stdout.fnmatch_lines([
-        check_for
-    ])
-
-
-if hasattr(pytest, 'version_tuple') and pytest.version_tuple[0] >= 7:
-
-    @pytest.fixture
-    def testdir_or_pytester(pytester):
-        return pytester
-
-else:
-
-    @pytest.fixture
-    def testdir_or_pytester(testdir):
-        return testdir
-
-
-def test_run(testdir_or_pytester):
-    from tests_python import debugger_unittest
-    import sys
-    import os
-
-    foo_dir = debugger_unittest._get_debugger_test_file(os.path.join('resources', 'launch', 'foo'))
-    foo_module = 'tests_python.resources.launch.foo'
-
-    pydevd_dir = os.path.dirname(os.path.dirname(__file__))
-    assert os.path.exists(os.path.join(pydevd_dir, 'pydevd.py'))
-
-    _run_and_check(testdir_or_pytester, testdir_or_pytester.makepyfile('''
-import sys
-sys.path.append(%(pydevd_dir)r)
-import pydevd
-py_db = pydevd.PyDB()
-py_db.ready_to_run = True
-py_db.run(%(foo_dir)r)
-''' % locals()))
-
-    _run_and_check(testdir_or_pytester, testdir_or_pytester.makepyfile('''
-import sys
-sys.path.append(%(pydevd_dir)r)
-import pydevd
-py_db = pydevd.PyDB()
-py_db.run(%(foo_dir)r, set_trace=False)
-''' % locals()))
-
-    if sys.version_info[0:2] == (2, 6):
-        # Not valid for Python 2.6
-        return
-
-    _run_and_check(testdir_or_pytester, testdir_or_pytester.makepyfile('''
-import sys
-sys.path.append(%(pydevd_dir)r)
-sys.argv.append('--as-module')
-import pydevd
-py_db = pydevd.PyDB()
-py_db.ready_to_run = True
-py_db.run(%(foo_module)r, is_module=True)
-''' % locals()))
-
-    _run_and_check(testdir_or_pytester, testdir_or_pytester.makepyfile('''
-import sys
-sys.argv.append('--as-module')
-sys.path.append(%(pydevd_dir)r)
-import pydevd
-py_db = pydevd.PyDB()
-py_db.run(%(foo_module)r, is_module=True, set_trace=False)
-''' % locals()))
-
-
-def test_run_on_local_module_without_adding_to_pythonpath(testdir_or_pytester):
-    import sys
-    import os
-
-    pydevd_dir = os.path.dirname(os.path.dirname(__file__))
-    assert os.path.exists(os.path.join(pydevd_dir, 'pydevd.py'))
-
-    foo_module = 'local_foo'
-    with open(os.path.join(os.getcwd(), 'local_foo.py'), 'w') as stream:
-        stream.write('print("WorkedLocalFoo")')
-
-    _run_and_check(testdir_or_pytester, testdir_or_pytester.makepyfile('''
-import sys
-import os
-sys.path.append(%(pydevd_dir)r)
-sys.argv.append('--as-module')
-cwd = os.path.abspath(os.getcwd())
-while cwd in sys.path:
-    sys.path.remove(cwd)
-import pydevd
-py_db = pydevd.PyDB()
-py_db.ready_to_run = True
-py_db.run(%(foo_module)r, is_module=True)
-''' % locals()), check_for='WorkedLocalFoo')
-
-    _run_and_check(testdir_or_pytester, testdir_or_pytester.makepyfile('''
-import sys
-import os
-sys.argv.append('--as-module')
-sys.path.append(%(pydevd_dir)r)
-cwd = os.path.abspath(os.getcwd())
-while cwd in sys.path:
-    sys.path.remove(cwd)
-import pydevd
-py_db = pydevd.PyDB()
-py_db.run(%(foo_module)r, is_module=True, set_trace=False)
-''' % locals()), check_for='WorkedLocalFoo')