debugpy 1.8.0__zip → 1.8.2__zip

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

@@ -1,101 +0,0 @@
-import inspect
-import sys
-import unittest
-
-from _pydevd_bundle.pydevd_save_locals import save_locals
-from _pydevd_bundle.pydevd_constants import IS_JYTHON, IS_IRONPYTHON
-import pytest
-
-
-def use_save_locals(name, value):
-    """
-    Attempt to set the local of the given name to value, using locals_to_fast.
-    """
-    frame = inspect.currentframe().f_back
-    locals_dict = frame.f_locals
-    locals_dict[name] = value
-
-    save_locals(frame)
-
-
-def check_method(fn):
-    """
-    A harness for testing methods that attempt to modify the values of locals on the stack.
-    """
-    x = 1
-
-    # The method 'fn' should attempt to set x = 2 in the current frame.
-    fn('x', 2)
-
-    return x
-
-
-
-@pytest.mark.skipif(IS_JYTHON or IS_IRONPYTHON, reason='CPython/pypy only')
-class TestSetLocals(unittest.TestCase):
-    """
-    Test setting locals in one function from another function using several approaches.
-    """
-
-    def test_set_locals_using_save_locals(self):
-        x = check_method(use_save_locals)
-        self.assertEqual(x, 2)  # Expected to succeed
-
-
-    def test_frame_simple_change(self):
-        frame = sys._getframe()
-        a = 20
-        frame.f_locals['a'] = 50
-        save_locals(frame)
-        self.assertEqual(50, a)
-
-
-    def test_frame_co_freevars(self):
-
-        outer_var = 20
-
-        def func():
-            frame = sys._getframe()
-            frame.f_locals['outer_var'] = 50
-            save_locals(frame)
-            self.assertEqual(50, outer_var)
-
-        func()
-
-    def test_frame_co_cellvars(self):
-
-        def check_co_vars(a):
-            frame = sys._getframe()
-            def function2():
-                print(a)
-
-            assert 'a' in frame.f_code.co_cellvars
-            frame = sys._getframe()
-            frame.f_locals['a'] = 50
-            save_locals(frame)
-            self.assertEqual(50, a)
-
-        check_co_vars(1)
-
-
-    def test_frame_change_in_inner_frame(self):
-        def change(f):
-            self.assertTrue(f is not sys._getframe())
-            f.f_locals['a']= 50
-            save_locals(f)
-
-
-        frame = sys._getframe()
-        a = 20
-        change(frame)
-        self.assertEqual(50, a)
-
-
-if __name__ == '__main__':
-    suite = unittest.TestSuite()
-#    suite.addTest(TestSetLocals('test_set_locals_using_dict'))
-#    #suite.addTest(Test('testCase10a'))
-#    unittest.TextTestRunner(verbosity=3).run(suite)
-
-    suite = unittest.makeSuite(TestSetLocals)
-    unittest.TextTestRunner(verbosity=3).run(suite)

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

@@ -1,142 +0,0 @@
-from _pydevd_bundle._debug_adapter.pydevd_schema import InitializeRequest, \
-    InitializeRequestArguments, InitializeResponse, Capabilities
-from _pydevd_bundle._debug_adapter import pydevd_schema, pydevd_base_schema
-from _pydevd_bundle._debug_adapter.pydevd_schema import ThreadsResponse
-
-
-def test_schema():
-
-    json_msg = '''
-{
-    "arguments": {
-        "adapterID": "pydevd",
-        "clientID": "vscode",
-        "clientName": "Visual Studio Code",
-        "columnsStartAt1": true,
-        "linesStartAt1": true,
-        "locale": "en-us",
-        "pathFormat": "path",
-        "supportsRunInTerminalRequest": true,
-        "supportsVariablePaging": true,
-        "supportsVariableType": true
-    },
-    "command": "initialize",
-    "seq": 1,
-    "type": "request"
-}'''
-
-    initialize_request = pydevd_base_schema.from_json(json_msg)
-    assert initialize_request.__class__ == InitializeRequest
-    assert initialize_request.arguments.__class__ == InitializeRequestArguments
-    assert initialize_request.arguments.adapterID == 'pydevd'
-    assert initialize_request.command == 'initialize'
-    assert initialize_request.type == 'request'
-    assert initialize_request.seq == 1
-
-    response = pydevd_base_schema.build_response(initialize_request)
-    assert response.__class__ == InitializeResponse
-    assert response.seq == -1  # Must be set before sending
-    assert response.command == 'initialize'
-    assert response.type == 'response'
-    assert response.body.__class__ == Capabilities
-
-    assert response.to_dict() == {
-        "seq":-1,
-        "type": "response",
-        "request_seq": 1,
-        "success": True,
-        "command": "initialize",
-        "body": {}
-    }
-
-    capabilities = response.body  # : :type capabilities: Capabilities
-    capabilities.supportsCompletionsRequest = True
-    assert response.to_dict() == {
-        "seq":-1,
-        "type": "response",
-        "request_seq": 1,
-        "success": True,
-        "command": "initialize",
-        "body": {'supportsCompletionsRequest':True}
-    }
-
-    initialize_event = pydevd_schema.InitializedEvent()
-    assert initialize_event.to_dict() == {
-        "seq":-1,
-        "type": "event",
-        "event": "initialized"
-    }
-
-
-def test_schema_translation_frame():
-    pydevd_base_schema.BaseSchema.initialize_ids_translation()
-    stack_trace_arguments = pydevd_schema.StackTraceArguments(threadId=1)
-    stack_trace_request = pydevd_schema.StackTraceRequest(stack_trace_arguments)
-
-    stackFrames = [
-        pydevd_schema.StackFrame(id=2 ** 45, name='foo', line=1, column=1).to_dict(),
-        pydevd_schema.StackFrame(id=2 ** 46, name='bar', line=1, column=1).to_dict(),
-    ]
-    body = pydevd_schema.StackTraceResponseBody(stackFrames)
-    stack_trace_response = pydevd_base_schema.build_response(stack_trace_request, kwargs=dict(body=body))
-    as_dict = stack_trace_response.to_dict(update_ids_to_dap=True)
-    assert as_dict == {
-        'type': 'response',
-        'request_seq':-1,
-        'success': True,
-        'command': 'stackTrace',
-        'body': {'stackFrames': [
-            {'id': 1, 'name': 'foo', 'line': 1, 'column': 1, 'source': {}},
-            {'id': 2, 'name': 'bar', 'line': 1, 'column': 1, 'source': {}},
-        ]},
-        'seq':-1}
-
-    reconstructed = pydevd_base_schema.from_dict(as_dict, update_ids_from_dap=True)
-    assert reconstructed.to_dict() == {
-        'type': 'response',
-        'request_seq':-1,
-        'success': True,
-        'command': 'stackTrace',
-        'body': {'stackFrames': [
-            {'id': 2 ** 45, 'name': 'foo', 'line': 1, 'column': 1, 'source': {}},
-            {'id': 2 ** 46, 'name': 'bar', 'line': 1, 'column': 1, 'source': {}}
-        ]},
-        'seq':-1
-    }
-
-
-def test_schema_translation_thread():
-    from _pydevd_bundle._debug_adapter.pydevd_schema import ThreadsRequest
-    pydevd_base_schema.BaseSchema.initialize_ids_translation()
-
-    threads = [
-        pydevd_schema.Thread(id=2 ** 45, name='foo').to_dict(),
-        pydevd_schema.Thread(id=2 ** 46, name='bar').to_dict(),
-    ]
-    body = pydevd_schema.ThreadsResponseBody(threads)
-    threads_request = ThreadsRequest()
-    threads_response = pydevd_base_schema.build_response(threads_request, kwargs=dict(body=body))
-    as_dict = threads_response.to_dict(update_ids_to_dap=True)
-    assert as_dict == {
-        'type': 'response',
-        'request_seq':-1,
-        'success': True,
-        'command': 'threads',
-        'body': {'threads': [
-            {'id': 1, 'name': 'foo'},
-            {'id': 2, 'name': 'bar'},
-        ]},
-        'seq':-1}
-
-    reconstructed = pydevd_base_schema.from_dict(as_dict, update_ids_from_dap=True)
-    assert reconstructed.to_dict() == {
-        'type': 'response',
-        'request_seq':-1,
-        'success': True,
-        'command': 'threads',
-        'body': {'threads': [
-            {'id': 2 ** 45, 'name': 'foo'},
-            {'id': 2 ** 46, 'name': 'bar'}
-        ]},
-        'seq':-1
-    }

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

@@ -1,297 +0,0 @@
-from functools import partial
-import itertools
-from pydevd import AbstractSingleNotificationBehavior
-import time
-
-import pytest
-
-from _pydevd_bundle.pydevd_daemon_thread import run_as_pydevd_daemon_thread
-from tests_python.debugger_unittest import CMD_THREAD_SUSPEND, CMD_STEP_OVER, CMD_SET_BREAK
-from _pydev_bundle.pydev_override import overrides
-import threading
-
-STATE_RUN = 1
-STATE_SUSPEND = 2
-
-
-class _ThreadInfo(object):
-
-    next_thread_id = partial(next, itertools.count())
-
-    def __init__(self):
-        self.state = STATE_RUN
-        self.thread = threading.Thread()
-        self.thread_id = self.next_thread_id()
-
-
-class _CustomSingleNotificationBehavior(AbstractSingleNotificationBehavior):
-
-    NOTIFY_OF_PAUSE_TIMEOUT = .01
-
-    __slots__ = AbstractSingleNotificationBehavior.__slots__ + ['notification_queue']
-
-    def __init__(self, py_db):
-        try:
-            from queue import Queue
-        except ImportError:
-            from Queue import Queue
-        super(_CustomSingleNotificationBehavior, self).__init__(py_db)
-        self.notification_queue = Queue()
-
-    @overrides(AbstractSingleNotificationBehavior.send_resume_notification)
-    def send_resume_notification(self, *args, **kwargs):
-        # print('put resume', threading.current_thread())
-        self.notification_queue.put('resume')
-
-    @overrides(AbstractSingleNotificationBehavior.send_suspend_notification)
-    def send_suspend_notification(self, *args, **kwargs):
-        # print('put suspend', threading.current_thread())
-        self.notification_queue.put('suspend')
-
-    def do_wait_suspend(self, thread_info, stop_reason):
-        with self.notify_thread_suspended(thread_info.thread_id, thread_info.thread, stop_reason=stop_reason):
-            while thread_info.state == STATE_SUSPEND:
-                time.sleep(.1)
-
-
-@pytest.fixture
-def _dummy_pydb():
-    return _DummyPyDB()
-
-
-@pytest.fixture(
-    name='single_notification_behavior',
-#     params=range(50)  #  uncomment to run the tests many times.
-)
-def _single_notification_behavior(_dummy_pydb):
-    single_notification_behavior = _CustomSingleNotificationBehavior(_dummy_pydb)
-    return single_notification_behavior
-
-
-@pytest.fixture(name='notification_queue')
-def _notification_queue(single_notification_behavior):
-    return single_notification_behavior.notification_queue
-
-
-def wait_for_notification(notification_queue, msg):
-    __tracebackhide__ = True
-    try:
-        from Queue import Empty
-    except ImportError:
-        from queue import Empty
-    try:
-        found = notification_queue.get(timeout=2)
-        assert found == msg
-    except Empty:
-        raise AssertionError('Timed out while waiting for %s notification.' % (msg,))
-
-
-def join_thread(t):
-    __tracebackhide__ = True
-    t.join(2)
-    assert not t.is_alive(), 'Thread still alive after timeout.s'
-
-
-class _DummyPyDB(object):
-
-    def __init__(self):
-        from _pydevd_bundle.pydevd_timeout import TimeoutTracker
-        self.created_pydb_daemon_threads = {}
-        self.timeout_tracker = TimeoutTracker(self)
-
-
-def test_single_notification_1(single_notification_behavior, notification_queue):
-    '''
-    1. Resume before pausing 2nd thread
-
-    - user pauses all (2) threads
-    - break first -> send notification
-    - user presses continue all before second is paused
-      - 2nd should not pause nor send notification
-      - resume all notification should be sent
-    '''
-    thread_info1 = _ThreadInfo()
-    thread_info2 = _ThreadInfo()
-
-    # pause all = set_suspend both
-    single_notification_behavior.increment_suspend_time()
-    single_notification_behavior.on_pause()
-    thread_info1.state = STATE_SUSPEND
-    thread_info2.state = STATE_SUSPEND
-
-    dummy_py_db = _DummyPyDB()
-
-    t = run_as_pydevd_daemon_thread(dummy_py_db, single_notification_behavior.do_wait_suspend, thread_info1, CMD_THREAD_SUSPEND)
-    thread_info1.state = STATE_RUN
-    # Set 2 to run before it starts (should not send additional message).
-    thread_info2.state = STATE_RUN
-    t.join()
-
-    assert notification_queue.qsize() == 2
-    assert notification_queue.get() == 'suspend'
-    assert notification_queue.get() == 'resume'
-    assert notification_queue.qsize() == 0
-
-    # Run thread 2 only now (no additional notification).
-    t = run_as_pydevd_daemon_thread(dummy_py_db, single_notification_behavior.do_wait_suspend, thread_info1, CMD_THREAD_SUSPEND)
-    t.join()
-
-    assert notification_queue.qsize() == 0
-
-
-def test_single_notification_2(single_notification_behavior, notification_queue):
-    '''
-    2. Pausing all then stepping
-
-    - user pauses all (2) threads
-    - break first -> send notification
-    - break second (no notification)
-    - user steps in second
-    - suspend in second -> send resume/pause notification on step
-    '''
-    thread_info1 = _ThreadInfo()
-    thread_info2 = _ThreadInfo()
-
-    dummy_py_db = _DummyPyDB()
-
-    # pause all = set_suspend both
-    single_notification_behavior.increment_suspend_time()
-    single_notification_behavior.on_pause()
-    thread_info1.state = STATE_SUSPEND
-    thread_info2.state = STATE_SUSPEND
-
-    # Leave both in break mode
-    t1 = run_as_pydevd_daemon_thread(dummy_py_db, single_notification_behavior.do_wait_suspend, thread_info1, CMD_THREAD_SUSPEND)
-    wait_for_notification(notification_queue, 'suspend')
-
-    t2 = run_as_pydevd_daemon_thread(dummy_py_db, single_notification_behavior.do_wait_suspend, thread_info2, CMD_THREAD_SUSPEND)
-
-    # Step would actually be set state to STEP, which would result in resuming
-    # and then stopping again as if it was a SUSPEND (which calls a set_supend again with
-    # the step mode).
-    thread_info2.state = STATE_RUN
-    join_thread(t2)
-    wait_for_notification(notification_queue, 'resume')
-
-    single_notification_behavior.increment_suspend_time()
-    thread_info2.state = STATE_SUSPEND
-    t2 = run_as_pydevd_daemon_thread(dummy_py_db, single_notification_behavior.do_wait_suspend, thread_info2, CMD_STEP_OVER)
-    wait_for_notification(notification_queue, 'suspend')
-
-    thread_info1.state = STATE_RUN
-    thread_info2.state = STATE_RUN
-    # First does a resume notification, the other remains quiet.
-    wait_for_notification(notification_queue, 'resume')
-
-    join_thread(t2)
-    join_thread(t1)
-    assert notification_queue.qsize() == 0
-
-
-def test_single_notification_3(single_notification_behavior, notification_queue, _dummy_pydb):
-    '''
-    3. Deadlocked thread
-
-    - user adds breakpoint in thread.join() -- just before threads becomes deadlocked
-    - breakpoint hits -> send notification
-      - pauses 2nd thread (no notification)
-    - user steps over thead.join() -> never completes
-    - user presses pause
-      - second thread is already stopped
-        - send notification regarding 2nd thread (still stopped).
-    - leave both threads running: no suspend should be shown as there are no stopped threads
-    - when thread is paused, show suspend notification
-    '''
-
-    # i.e.: stopping at breakpoint
-    thread_info1 = _ThreadInfo()
-    single_notification_behavior.increment_suspend_time()
-    thread_info1.state = STATE_SUSPEND
-    t1 = run_as_pydevd_daemon_thread(_dummy_pydb, single_notification_behavior.do_wait_suspend, thread_info1, CMD_SET_BREAK)
-
-    # i.e.: stop because of breakpoint
-    thread_info2 = _ThreadInfo()
-    thread_info2.state = STATE_SUSPEND
-    t2 = run_as_pydevd_daemon_thread(_dummy_pydb, single_notification_behavior.do_wait_suspend, thread_info2, CMD_SET_BREAK)
-
-    wait_for_notification(notification_queue, 'suspend')
-
-    # i.e.: step over (thread 2 is still suspended and this one never completes)
-    thread_info1.state = STATE_RUN
-    wait_for_notification(notification_queue, 'resume')
-
-    join_thread(t1)
-
-    # On pause we should notify that the thread 2 is suspended (after timeout if no other thread suspends first).
-    single_notification_behavior.increment_suspend_time()
-    single_notification_behavior.on_pause()
-    thread_info1.state = STATE_SUSPEND
-    thread_info2.state = STATE_SUSPEND
-    wait_for_notification(notification_queue, 'suspend')
-
-    thread_info2.state = STATE_RUN
-    wait_for_notification(notification_queue, 'resume')
-
-    join_thread(t2)
-    assert notification_queue.qsize() == 0
-    assert not single_notification_behavior._suspended_thread_id_to_thread
-
-    # Now, no threads are running and pause is pressed
-    # (maybe we could do a thread dump in this case as this
-    # means nothing is stopped after pause is requested and
-    # the timeout elapses).
-    single_notification_behavior.increment_suspend_time()
-    single_notification_behavior.on_pause()
-    thread_info1.state = STATE_SUSPEND
-    thread_info2.state = STATE_SUSPEND
-
-    time.sleep(single_notification_behavior.NOTIFY_OF_PAUSE_TIMEOUT * 2)
-    assert notification_queue.qsize() == 0
-
-    t1 = run_as_pydevd_daemon_thread(_dummy_pydb, single_notification_behavior.do_wait_suspend, thread_info1, CMD_THREAD_SUSPEND)
-    wait_for_notification(notification_queue, 'suspend')
-    thread_info1.state = STATE_RUN
-    wait_for_notification(notification_queue, 'resume')
-    join_thread(t1)
-    assert notification_queue.qsize() == 0
-
-
-def test_single_notification_4(single_notification_behavior, notification_queue, _dummy_pydb):
-    '''
-    4. Delayed stop
-
-    - user presses pause
-    - stops first (2nd keeps running)
-    - user steps on first
-    - 2nd hits before first ends step (should not send any notification)
-    - when step finishes send notification
-    '''
-    thread_info1 = _ThreadInfo()
-    thread_info2 = _ThreadInfo()
-
-    single_notification_behavior.increment_suspend_time()
-    single_notification_behavior.on_pause()
-    thread_info1.state = STATE_SUSPEND
-    thread_info2.state = STATE_SUSPEND
-
-    t1 = run_as_pydevd_daemon_thread(_dummy_pydb, single_notification_behavior.do_wait_suspend, thread_info1, CMD_THREAD_SUSPEND)
-    wait_for_notification(notification_queue, 'suspend')
-    thread_info1.state = STATE_RUN
-    wait_for_notification(notification_queue, 'resume')
-    join_thread(t1)
-
-    t2 = run_as_pydevd_daemon_thread(_dummy_pydb, single_notification_behavior.do_wait_suspend, thread_info1, CMD_THREAD_SUSPEND)
-    time.sleep(.1)
-    assert notification_queue.qsize() == 0
-
-    single_notification_behavior.increment_suspend_time()
-    thread_info1.state = STATE_SUSPEND
-    t1 = run_as_pydevd_daemon_thread(_dummy_pydb, single_notification_behavior.do_wait_suspend, thread_info1, CMD_STEP_OVER)
-    wait_for_notification(notification_queue, 'suspend')
-    thread_info2.state = STATE_RUN
-    thread_info1.state = STATE_RUN
-    join_thread(t1)
-    join_thread(t2)
-    wait_for_notification(notification_queue, 'resume')
-    assert notification_queue.qsize() == 0
-