Python Qdb.disable方法代码示例

# 需要导入模块: from qdb import Qdb [as 别名]
# 或者: from qdb.Qdb import disable [as 别名]
    def test_set_step(self):
        """
        Tests the functionality of set_step by asserting that it only executes
        the next line and no more.
        """
        db = Qdb(cmd_manager=QueueCommandManager)

        # Queue up a step command.
        db.cmd_manager.enqueue(lambda t: t.set_step())

        stepped = False
        with Timeout(0.1, False):
            db.set_trace()
            stepped = True

        self.assertTrue(stepped)

        db.disable()

        db = Qdb(cmd_manager=QueueCommandManager)

        db.cmd_manager.enqueue(lambda t: t.set_step())
        db.cmd_manager.user_wait(0.2)

        stepped = over_stepped = False
        with Timeout(0.1, False):
            db.set_trace()
            stepped = True
            over_stepped = True

        self.assertTrue(stepped)
        self.assertFalse(over_stepped)

# 需要导入模块: from qdb import Qdb [as 别名]
# 或者: from qdb.Qdb import disable [as 别名]
    def test_set_trace_without_stop(self):
        """
        Asserts that calling set_trace with stop=False will start tracing
        but not stop.
        WARNING: This test relies on the relative line numbers inside the test.
        """
        db = Qdb(cmd_manager=QueueCommandManager)
        line_offset = 8  # The difference in the set_break call and line_3.
        db.set_break(
            self.filename,
            sys._getframe().f_lineno + line_offset,
        )
        db.cmd_manager.user_wait(0.2)
        line_1 = line_2 = line_3 = False
        with Timeout(0.1, False):
            db.set_trace(stop=False)  # Should not stop us here.
            line_1 = True
            line_2 = True
            line_3 = True

        # Since we are stepping, we should not hit this line.
        self.assertTrue(line_1)
        self.assertTrue(line_2)
        # We should have still stopped at this breakpoint if we are tracing.
        self.assertFalse(line_3)

        db.disable()

        db = Qdb(cmd_manager=NopCommandManager)
        line_1 = False
        with Timeout(0.1, False):
            db.set_trace(stop=False)
            line_1 = True

        self.assertTrue(line_1)

# 需要导入模块: from qdb import Qdb [as 别名]
# 或者: from qdb.Qdb import disable [as 别名]
    def test_function_call_next_step(self):
        """
        Tests the functionality of next and step when calling functions.
        This checks to make sure the function is stepped into and can be
        stepped over.
        """
        cmd_manager = QueueCommandManager()
        db = Qdb(cmd_manager=cmd_manager)

        # Queue up a next command to next over the function call.
        cmd_manager.enqueue(lambda t: t.set_next(t.curframe))
        # Queue up a sleep so that we block after calling next.
        # This would cause us to NOT execute the f_called[0] = True line of f
        # had we only called set_step. This is asserted afterwards.
        cmd_manager.user_wait(0.2)

        # A mutable structure to check if f is called.
        f_called = NonLocal(False)

        def f():
            f_called.value = True

        with Timeout(0.1, False):
            db.set_trace()
            f()

        # We hit that line in f, so it should now be True.
        self.assertTrue(f_called.value)

        # Assert that we are currently executing the line we think we should
        # be executing. Since we are just stepping, this should be setting
        # curframe each time.
        self.assertEqual(
            db.get_line(self.filename, db.curframe.f_lineno),
            '            db.get_line(self.filename, db.curframe.f_lineno),'
        )

        db.disable()
        cmd_manager = QueueCommandManager()
        db = Qdb(cmd_manager=cmd_manager)

        f_called = NonLocal(False)

        # This time we will be only stepping, so we should not execute the
        # entire call to f.
        cmd_manager.enqueue(lambda t: t.set_step())
        cmd_manager.user_wait(1.2)

        with Timeout(0.1, False):
            db.set_trace()
            f()

        # We should not have hit this line in f.
        self.assertFalse(f_called.value)
        # Since we only stepped once, this is the last time we set the frame.
        self.assertEqual(
            db.get_line(self.filename, db.curframe.f_lineno),
            '            f_called.value = True'
        )

# 需要导入模块: from qdb import Qdb [as 别名]
# 或者: from qdb.Qdb import disable [as 别名]
    def test_conditional_breakpoint_timeout(self):
        """
        Tests conditional breakpoints that cause timeouts.
        WARNING: This test relies on the relative line numbers inside the test.
        """
        stopped = [False]

        def stop():
            stopped[0] = True
            return True  # Execute the assertion.

        line = None
        cond = 'g()'

        cmd_manager = QueueCommandManager()
        db = Qdb(cmd_manager=cmd_manager, execution_timeout=1)
        cmd_manager.enqueue(lambda t: stop() and self.assertEqual(line, 1))
        line_offset = 10
        # Set a condition that will time out.
        db.set_break(
            self.filename,
            sys._getframe().f_lineno + line_offset,
            cond='g()',
        )
        db.set_trace(stop=False)

        def g():
            while True:
                pass

        line = 1
        line = 2
        line = 3

        db.disable()
        errors = [e['p'] for e in cmd_manager.sent if e['e'] == 'error']
        self.assertEqual(len(errors), 1)

        error = errors[0]
        self.assertEqual(error['type'], 'condition')

        negative_line_offset = 14
        exc = QdbExecutionTimeout(cond, db.execution_timeout)
        self.assertEqual(
            error['data'], {
                'line': sys._getframe().f_lineno - negative_line_offset,
                'cond': cond,
                'exc': type(exc).__name__,
                'output': db.exception_serializer(exc),
            }
        )
        # Make sure we stopped when we raised the exception.
        self.assertTrue(stopped[0])

# 需要导入模块: from qdb import Qdb [as 别名]
# 或者: from qdb.Qdb import disable [as 别名]
    def test_conditional_breakpoint_raises(self):
        """
        Tests conditional breakpoints that raise an exception.
        WARNING: This test relies on the relative line numbers inside the test.
        """
        line = None
        exc = ValueError('lol wut r u doing?')
        cond = 'raiser()'

        stopped = [False]

        def stop():
            stopped[0] = True
            return True  # Execute the assertion.

        cmd_manager = QueueCommandManager()
        db = Qdb(cmd_manager=cmd_manager)
        cmd_manager.enqueue(lambda t: stop() and self.assertEqual(line, 1))
        line_offset = 9
        # Set a condition that will raise a ValueError.
        db.set_break(
            self.filename,
            sys._getframe().f_lineno + line_offset,
            cond=cond,
        )
        db.set_trace(stop=False)

        def raiser():
            raise exc

        line = 1
        line = 2  # This line number is used in the data assertion.
        line = 3

        db.disable()
        errors = [e['p'] for e in cmd_manager.sent if e['e'] == 'error']
        self.assertEqual(len(errors), 1)

        error = errors[0]
        self.assertEqual(error['type'], 'condition')

        negative_line_offset = 13
        self.assertEqual(
            error['data'], {
                'line': sys._getframe().f_lineno - negative_line_offset,
                'cond': cond,
                'exc': type(exc).__name__,
                'output': db.exception_serializer(exc),
            }
        )
        # Make sure we stopped when we raised the exception.
        self.assertTrue(stopped[0])

# 需要导入模块: from qdb import Qdb [as 别名]
# 或者: from qdb.Qdb import disable [as 别名]
    def test_redirect_stderr(self):
        """
        Tests that stderr is stored on the tracer.
        """
        sys.stderr = stderr = StringIO()
        db = Qdb(cmd_manager=NopCommandManager)

        data_to_write = 'stderr'
        db.set_trace(stop=False)

        print >> sys.stderr, data_to_write,  # Write some data to stderr.

        db.disable()
        self.assertEqual(db.stderr.getvalue(), data_to_write)

        # Assert that the stream was restored.
        self.assertIs(sys.stderr, stderr)

# 需要导入模块: from qdb import Qdb [as 别名]
# 或者: from qdb.Qdb import disable [as 别名]
    def test_redirect_stdout(self):
        """
        Tests that stdout is stored on the tracer.
        """
        sys.stdout = stdout = StringIO()
        db = Qdb(cmd_manager=OutputCatchingNopCommandManager)

        data_to_write = 'stdout'
        db.set_trace(stop=False)

        print data_to_write,  # Write some data to stdout.

        db.disable()
        msg = db.cmd_manager.msgs[0]
        self.assertEqual(msg.input_, '<stdout>')
        self.assertFalse(msg.exc)
        self.assertEqual(msg.output, data_to_write)
        self.assertEqual(stdout.getvalue(), data_to_write)

        # Assert that the stream was restored.
        self.assertIs(sys.stdout, stdout)

# 需要导入模块: from qdb import Qdb [as 别名]
# 或者: from qdb.Qdb import disable [as 别名]
    def test_send_disabled(self):
        """
        Tests that disabling sends a 'disabled' message back to the server.
        """
        class cmd_manager(self.cmd_manager):
            disabled = False

            def send_disabled(self):
                self.disabled = True

        db = Qdb(
            uuid='send_disabled_test',
            cmd_manager=cmd_manager,
            host=self.tracer_host,
            port=self.tracer_port,
            redirect_output=False,
        )
        sleep(0.01)
        db.set_trace(stop=False)
        db.disable()

        self.assertTrue(db.cmd_manager.disabled)
        self.server.session_store.slaughter(db.uuid)

# 需要导入模块: from qdb import Qdb [as 别名]
# 或者: from qdb.Qdb import disable [as 别名]
    def test_clear_output_buffers(self):
        """
        Tests that we can clear the output buffers to free up some memory.
        """

        db = Qdb(cmd_manager=NopCommandManager)
        stdout_data, stderr_data = 'stdout', 'stderr'
        db.set_trace(stop=False)

        print stdout_data,
        print >> sys.stderr, stderr_data,

        db.disable()

        # Assert that the data actually got written.
        self.assertEqual(db.stdout.getvalue(), stdout_data)
        self.assertEqual(db.stderr.getvalue(), stderr_data)

        db.clear_output_buffers()

        # Assert that the data actually got cleared.
        self.assertEqual(db.stdout.getvalue(), '')
        self.assertEqual(db.stderr.getvalue(), '')

# 需要导入模块: from qdb import Qdb [as 别名]
# 或者: from qdb.Qdb import disable [as 别名]
    def test_redirect_stderr(self):
        """
        Tests that stderr is stored on the tracer.
        """
        sys.stderr = stderr = StringIO()
        cmd_manager = OutputCatchingNopCommandManager()
        db = Qdb(cmd_manager=cmd_manager)

        data_to_write = 'stderr'
        db.set_trace(stop=False)

        # Write some data to stderr.
        print(data_to_write, end='', file=sys.stderr)

        db.disable()

        msg = cmd_manager.msgs[0]
        self.assertEqual(msg.input_, '<stderr>')
        self.assertFalse(msg.exc)
        self.assertEqual(msg.output, data_to_write)
        self.assertEqual(stderr.getvalue(), data_to_write)

        # Assert that the stream was restored.
        self.assertIs(sys.stderr, stderr)

# 需要导入模块: from qdb import Qdb [as 别名]
# 或者: from qdb.Qdb import disable [as 别名]
    def test_set_continue_with_breaks(self):
        """
        Tests the behavior of continue when there are breakpoints in the mix.
        WARNING: This test relies on the relative line numbers inside the test.
        """
        db = Qdb(cmd_manager=QueueCommandManager)
        line_offset = 8  # The difference in the set_break call and line_2.
        db.set_break(
            self.filename,
            sys._getframe().f_lineno + line_offset,
        )
        db.cmd_manager.enqueue(lambda t: t.set_continue())
        db.cmd_manager.user_wait(0.2)
        line_1 = line_2 = line_3 = False
        with Timeout(0.1, False):
            db.set_trace()
            line_1 = True
            line_2 = True
            line_3 = True

        # Assert we only got to line_1 because of the breakpoint.
        # These are split up to give more helpful messages if the test fails.
        self.assertTrue(line_1)
        self.assertFalse(line_2)
        self.assertFalse(line_3)

        # We are still in stepping mode so we should be reporting the stack.
        self.assertEqual(
            db.get_line(self.filename, db.curframe.f_lineno),
            '            db.get_line(self.filename, db.curframe.f_lineno),'
        )

        sys.settrace(None)
        db.disable()
        db = Qdb(cmd_manager=QueueCommandManager)
        line_2_offset = 13  # The difference in the set_break call and line_2.
        line_3_offset = 10   # THe difference in the set_break call and line_3.
        db.set_break(
            self.filename,
            sys._getframe().f_lineno + line_2_offset,
        )
        db.set_break(
            self.filename,
            sys._getframe().f_lineno + line_3_offset,
        )
        db.cmd_manager.enqueue(lambda t: t.set_continue())
        db.cmd_manager.enqueue(lambda t: t.set_continue())
        db.cmd_manager.user_wait(0.2)
        line_1 = line_2 = line_3 = False
        with Timeout(0.1, False):
            db.set_trace()
            line_1 = True
            line_2 = True
            line_3 = True

        self.assertTrue(line_1)
        self.assertTrue(line_2)
        self.assertFalse(line_3)

        self.assertEqual(
            db.get_line(self.filename, db.curframe.f_lineno),
            '            db.get_line(self.filename, db.curframe.f_lineno),'
        )