def test_complete_brkpts(self):
bpmgr = Mbreakpoint.BreakpointManager()
bp = bpmgr.add_breakpoint('foo', 10, 5)
for find in ('1'):
self.assertEqual(Mcomplete.complete_brkpts(bpmgr, find), ['1'],
"breakpoint completion of '%s'" % find)
for find in ('2', '11'):
self.assertEqual(Mcomplete.complete_brkpts(bpmgr, find), [],
"breakpoint non-completion of '%s'" % find)
pass
return
def __init__(self, debugger):
self.debugger = debugger
self.execution_status = "Pre-execution"
self.filename_cache = {}
self.ignore_filter = tracefilter.TraceFilter([])
self.bpmgr = breakpoint.BreakpointManager()
self.processor = MockProcessor(self)
self.step_ignore = -1
self.stop_frame = None
self.last_lineno = None
self.last_filename = None
self.different_line = None
return
def test_breakpoint(self):
'Test breakpoint'
bpmgr = Mbreakpoint.BreakpointManager()
self.assertEqual(0, bpmgr.last())
bp = bpmgr.add_breakpoint('foo', 10, 5)
# FIXME:
# self.assertFalse(not
# re.search('1 breakpoint keep yes .* at .*foo:5',
# str(bp)), str(bp))
self.assertEqual('B', bp.icon_char())
self.assertEqual(True, bp.enabled)
bp.disable()
# self.assertFalse(not
# re.search('1 breakpoint keep no .* at .*foo:5',
# str(bp)))
self.assertEqual(False, bp.enabled)
self.assertEqual('b', bp.icon_char())
self.assertEqual(1, bpmgr.last())
self.assertEqual((False, 'Breakpoint number 10 out of range 1..1.'),
bpmgr.delete_breakpoint_by_number(10))
self.assertEqual(['1'], bpmgr.bpnumbers(),
"Extracting disabled breakpoint-numbers")
self.assertEqual((True, ''), bpmgr.delete_breakpoint_by_number(1))
self.assertEqual((False, 'Breakpoint 1 previously deleted.'),
bpmgr.delete_breakpoint_by_number(1))
bp2 = bpmgr.add_breakpoint('foo', 5, 10, temporary=True)
self.assertEqual('t', bp2.icon_char())
self.assertEqual(['2'], bpmgr.bpnumbers(),
"Extracting breakpoint-numbers")
count = 3
for i in range(count):
bp = bpmgr.add_breakpoint('bar', 10, 6)
filename = bp.filename
# self.assertEqual(count, len(bpmgr.delete_breakpoints_by_lineno(filename, 6)),
# "delete_breakpoints_by_line when there are some")
self.assertEqual(0,
len(bpmgr.delete_breakpoints_by_lineno(filename, 6)),
"delete_breakpoints_by_line when there are none")
self.assertNotEqual(
0, len(bpmgr.bplist),
"There should still be some breakpoints before reset")
bpmgr.reset()
self.assertEqual(0, len(bpmgr.bplist),
"reset should remove all breakpoints")
return
def test_checkfuncname(self):
'Test Mbreakpoint.checkfuncname()'
import inspect
frame = inspect.currentframe()
bpmgr = Mbreakpoint.BreakpointManager()
bp = bpmgr.add_breakpoint('foo', 5)
self.assertEqual(False, Mbreakpoint.checkfuncname(bp, frame))
def foo(bp, bpmgr):
frame = inspect.currentframe()
self.assertEqual(True, Mbreakpoint.checkfuncname(bp, frame))
# frame.f_lineno is constantly updated. So adjust for the
# line difference between the add_breakpoint and the check.
bp3 = bpmgr.add_breakpoint('foo', frame.f_lineno + 1)
self.assertEqual(True, Mbreakpoint.checkfuncname(bp3, frame))
self.assertEqual(False, Mbreakpoint.checkfuncname(bp3, frame))
return
bp2 = bpmgr.add_breakpoint(None, None, False, None, 'foo')
foo(bp2, bpmgr)
return
def __init__(self, debugger, opts=None):
""" Create a debugger object. But depending on the value of
key 'start' inside hash `opts', we may or may not initially
start tracing events (i.e. enter the debugger).
See also `start' and `stop'.
"""
import trepan.bwprocessor as Mbwproc
get_option = lambda key: Mmisc.option_set(opts, key,
self.DEFAULT_INIT_OPTS)
self.bpmgr = breakpoint.BreakpointManager()
self.current_bp = None
self.debugger = debugger
# Threading lock ensures that we don't have other traced threads
# running when we enter the debugger. Later we may want to have
# a switch to control.
self.debugger_lock = threading.Lock()
self.filename_cache = {}
# Initially the event parameter of the event hook.
# We can however modify it, such as for breakpoints
self.event = None
# Is debugged program currently under execution?
self.execution_status = 'Pre-execution'
# main_dirname is the directory where the script resides.
# Filenames in co_filename are often relative to this.
self.main_dirname = os.curdir
# What event processor and processor options do we use?
self.processor = get_option('processor')
proc_opts = get_option('proc_opts')
if not self.processor:
self.processor = Mcmdproc.CommandProcessor(self, opts=proc_opts)
elif self.processor == 'bullwinkle':
self.processor = Mbwproc.BWProcessor(self, opts=proc_opts)
pass
# What events are considered in stepping. Note: 'None' means *all*.
self.step_events = None
# How many line events to skip before entering event processor?
# If stop_level is None all breaks are counted otherwise just
# those which less than or equal to stop_level.
self.step_ignore = get_option('step_ignore')
# If stop_level is not None, then we are next'ing or
# finish'ing and will ignore frames greater than stop_level.
# We also will cache the last frame and thread number encountered
# so we don't have to compute the current level all the time.
self.last_frame = None
self.last_level = 10000
self.last_thread = None
self.stop_level = None
self.stop_on_finish = False
self.last_lineno = None
self.last_filename = None
self.different_line = None
# The reason we have stopped, e.g. 'breakpoint hit', 'next',
# 'finish', 'step', or 'exception'.
self.stop_reason = ''
self.trace_processor = Mtrace.PrintProcessor(self)
# What routines (keyed by f_code) will we not trace into?
self.ignore_filter = get_option('ignore_filter')
self.search_path = sys.path # Source filename search path
# When trace_hook_suspend is set True, we'll suspend
# debugging.
self.trace_hook_suspend = False
self.until_condition = get_option('until_condition')
return
