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