Example #1
0
    def handle(self, *args, **options):
        global good_regex
        global bad_regex
        args = list(args)
        command = args.pop(0)
        global_options['include_builtins'] = options['include_builtins']
        global_options['include_stdlib'] = options['include_stdlib']
        global_options['module_only'] = options['module_only']
        global_options['calls_only'] = options['calls_only']
        global_options['good'] = options['good']
        global_options['bad'] = options['bad']
        global_options['good_regex'] = options['good_regex']
        global_options['bad_regex'] = options['bad_regex']
        global_options['good_preset'] = options['good_preset']
        global_options['bad_preset'] = options['bad_preset']

        good_regex = re.compile(global_options['good_regex'])
        bad_regex = re.compile(global_options['bad_regex'])

        sys.settrace(traceit)

        options = dict(
            use_reloader=False,
        )
        management.call_command(command, *args, **options)
Example #2
0
 def setBreakpoint(self, breakpoint):
     import sys
     debugInstance = self._getDebugger()
     debugInstance.do_break(debugInstance.precmd(breakpoint))
     debugInstance.quitting = True
     sys.settrace(debugInstance.trace_dispatch)
     debugInstance.quitting = False
    def execute (self, cmd):
        """ Execute a given command """

        sys.stdout, self.stdout = self.stdout, sys.stdout
        sys.stderr, self.stderr = self.stderr, sys.stderr
        sys.stdin,  self.stdin  = self.stdin,  sys.stdin
        sys.settrace (self.idle)

        try:
            try:
                r = eval (cmd, self.namespace, self.namespace)
                
                if r is not None:
                    print(r)
            except SyntaxError:
                exec cmd in self.namespace
        except:
            if hasattr (sys, 'last_type') and sys.last_type == SystemExit:
                self.quit_handler()
            else:
                try:
                    info = sys.exc_info()
                    tb = info[2]
                    if tb:
                        tb = tb.tb_next
                    traceback.print_exception (info[0], info[1], tb)
                except:
                    sys.stderr, self.stderr = self.stderr, sys.stderr
                    traceback.print_exc()
        sys.settrace (None)
        sys.stdout, self.stdout = self.stdout, sys.stdout
        sys.stderr, self.stderr = self.stderr, sys.stderr
        sys.stdin,  self.stdin  = self.stdin,  sys.stdin
Example #4
0
 def __init__(self, *args, **kwargs):
     global tracer
     global q
     self._response_headers = []
     # print DEBUG_ENABLED
     # self.http_version = "1.1"
     DBG("START")
     # STDERR("START: debug_enable=%s"%DEBUG_ENABLED)
     if DEBUG_ENABLED:
         # STDERR("bps: %s" % tracer.get_all_breaks())
         if tracer.get_all_breaks():
             q.put("set_continue")
         tracer.set_trace()
         tracer.process_pending_commands()
         # STDERR("bps: %s" % tracer.get_all_breaks())
         # STDERR("%d" % q.unfinished_tasks)
     else:
         # Debug is not enable and there are no breakpoints
         # continue without debugger overhead
         # STDERR(repr(tracer.get_all_breaks()))
         sys.settrace(None)
     WSGIRequestHandler.__init__(self, *args, **kwargs)
     # STDOUT("aqui")
     # print self.requestline
     # print self.headers
     try:
         WSOUT("REQUEST_HEADERS", "%s\n%s\n%s" % ("-" * 20, self.requestline, self.headers))
     except AttributeError:
         pass
     DBG("STOP")
Example #5
0
def trace_process (**kwargs):
    
    """Literally log every line of python code as it runs.
    
    Keyword arguments:
    log -- file (name) to log to (default stderr)
    scope -- base scope to log to (default Cobalt)"""
    
    file_name = kwargs.get("log", None)
    if file_name is not None:
        log_file = open(file_name, "w")
    else:
        log_file = sys.stderr
    
    scope = kwargs.get("scope", "Cobalt")
    
    def traceit (frame, event, arg):
        if event == "line":
            lineno = frame.f_lineno
            filename = frame.f_globals["__file__"]
            if (filename.endswith(".pyc") or
                filename.endswith(".pyo")):
                filename = filename[:-1]
            name = frame.f_globals["__name__"]
            line = linecache.getline(filename, lineno)
            print >> log_file, "%s:%s: %s" % (name, lineno, line.rstrip())
        return traceit
    
    sys.settrace(traceit)
Example #6
0
 def run_test(self, func):
     tracer = JumpTracer(func)
     sys.settrace(tracer.trace)
     output = []
     func(output)
     sys.settrace(None)
     self.compare_jump_output(func.output, output)
Example #7
0
 def run(self):
     # Note: this is important: we have to set the tracing function
     # when the thread is started (we could set threading.settrace
     # before starting this thread to do this externally)
     try:
         global call_finished
         sys.settrace(do_nothing_trace_function)
         exec self._Thread__kwargs['call_string'] in self._Thread__kwargs['kw']
         print "exec call finished!"
         call_finished = True
     except TypeError as t:
         call_finished = True
         self._Thread__kwargs['Exception'] = t
     except AttributeError as a:
         call_finished = True
         self._Thread__kwargs['Exception'] = a
     except SyntaxError as s1:
         call_finished = True
         self._Thread__kwargs['Exception'] = s1
     except SigFinish as sf1:
         call_finished = True
         self._Thread__kwargs['Exception'] = sf1
     except Exception as e1:
         call_finished = True
         self._Thread__kwargs['Exception'] = e1
Example #8
0
 def opt_spew(self):
     """
     Print an insanely verbose log of everything that happens.
     Useful when debugging freezes or locks in complex code.
     """
     from twisted.python.util import spewer
     sys.settrace(spewer)
Example #9
0
 def run_and_compare(self, func, events):
     tracer = Tracer()
     sys.settrace(tracer.trace)
     func()
     sys.settrace(None)
     self.compare_events(func.func_code.co_firstlineno,
                         tracer.events, events)
Example #10
0
 def start(self, parallel_mode=False):
     self.get_ready()
     if self.nesting == 0:                               #pragma: no cover
         sys.settrace(self.t)
         if hasattr(threading, 'settrace'):
             threading.settrace(self.t)
     self.nesting += 1
Example #11
0
    def wrap(*args, **kwargs):
        frames = []

        def tracer(frame, event, arg):
            frames.append(frame)
            sys.settrace(old_tracer)
            if old_tracer is not None:
                return old_tracer(frame, event, arg)

        old_tracer = sys.gettrace()
        # tracer is activated on next call, return or exception
        sys.settrace(tracer)
        try:
            func(*args, **kwargs)
        finally:
            sys.settrace(old_tracer)
        assert len(frames) == 1
        argspec = inspect.getargspec(func)
        argnames = list(argspec.args)
        if argspec.varargs is not None:
            argnames.append(argspec.varargs)
        if argspec.keywords is not None:
            argnames.append(argspec.keywords)
        return {name: value for name, value in frames.pop(0).f_locals.items()
                if name not in argnames}
Example #12
0
def trace_stop():
    global _tracing, _indent
    assert _tracing > 0
    _tracing -= 1
    if not _tracing:
        sys.settrace(None)
        _indent = ''
Example #13
0
def run():
    if len(sys.argv) == 1:
        sys.argv.append("--help")
    config = Options()
    try:
        config.parseOptions()
    except usage.error as ue:
        raise SystemExit("%s: %s" % (sys.argv[0], ue))
    _initialDebugSetup(config)

    try:
        trialRunner = _makeRunner(config)
    except _DebuggerNotFound as e:
        raise SystemExit('%s: %s' % (sys.argv[0], str(e)))

    suite = _getSuite(config)
    if config['until-failure']:
        test_result = trialRunner.runUntilFailure(suite)
    else:
        test_result = trialRunner.run(suite)
    if config.tracer:
        sys.settrace(None)
        results = config.tracer.results()
        results.write_results(show_missing=1, summary=False,
                              coverdir=config.coverdir().path)
    sys.exit(not test_result.wasSuccessful())
Example #14
0
def detach():
	"""
	Finish execution tracing, print the results and reset internal state
	"""
	global _gls
	global current_gl
	global _states
	global _curr_states
	global _attach_expiration
	global _trace_began_at

	# do we have a current trace?
	if not _trace_began_at:
		return

	duration = time.time() - _trace_began_at
	_attach_expiration = None
	sys.settrace(None)
	_maybe_flush(_trace_output_file)
	_print_output(duration)
	_gls = {}
	_curr_gl = None
	_states = {}
	_curr_states = {}
	_trace_began_at = None
	curr_state = None
Example #15
0
def main():
    usage = "mactrace.py [-o output_file_path] scriptfile [arg] ..."
    parser = OptionParser(usage=usage)
    parser.allow_interspersed_args = False
    parser.add_option('-o', '--outfile', dest="outfile",
                      help="Save trace to <outfile>", default=None)
    if not sys.argv[1:]:
        parser.print_usage()
        sys.exit(2)

    (options, args) = parser.parse_args()
    sys.argv[:] = args
    if options.outfile:
        twriter = TraceWriter(open(options.outfile, "w"))
    else:
        twriter = TraceWriter()
    sys.settrace(twriter.trace)
    if len(args) > 0:
        progname = args[0]
        sys.path.insert(0, os.path.dirname(progname))
        with open(progname, 'rb') as fp:
            code = compile(fp.read(), progname, 'exec')
        globs = {
            '__file__': progname,
            '__name__': '__main__',
            '__package__': None,
        }
        eval(code, globs)
    else:
        parser.print_usage()
    return parser
Example #16
0
  def __bootstrap(self):
    try:
      self._set_ident()
      self._Thread__started.set()
      threading._active_limbo_lock.acquire()
      threading._active[self._Thread__ident] = self
      del threading._limbo[self]
      threading._active_limbo_lock.release()

      if threading._trace_hook:
        sys.settrace(threading._trace_hook)
      if threading._profile_hook:
        sys.setprofile(threading._profile_hook)

      try:
        self.run()
      finally:
        self._Thread__exc_clear()
    finally:
      with threading._active_limbo_lock:
        self._Thread__stop()
        try:
          del threading._active[threading._get_ident()]
        except:
          pass
Example #17
0
    def test_trace_try_finally(self):
        import sys
        l = []
        def trace(frame, event, arg):
            if event == 'exception':
                l.append(arg)
            return trace

        def g():
            try:
                raise Exception
            finally:
                pass

        def f():
            try:
                g()
            except:
                pass

        sys.settrace(trace)
        f()
        sys.settrace(None)
        assert len(l) == 2
        assert issubclass(l[0][0], Exception)
        assert issubclass(l[1][0], Exception)
Example #18
0
	def __init__(self, func=None, unpack=None, **kwargs):
		self.__defs__ = []
		self.__sizes__ = []
		self.__attrs__ = []
		self.__values__ = {}
		self.__next__ = True
		self.__baked__ = False
		
		if func == None:
			self.__format__()
		else:
			sys.settrace(self.__trace__)
			func()
			for name in func.func_code.co_varnames:
				value = self.__frame__.f_locals[name]
				self.__setattr__(name, value)
		
		self.__baked__ = True
		
		if unpack != None:
			if isinstance(unpack, tuple):
				self.unpack(*unpack)
			else:
				self.unpack(unpack)
		
		if len(kwargs):
			for name in kwargs:
				self.__values__[name] = kwargs[name]
Example #19
0
    def test_trace_hidden_prints(self):
        import sys

        l = []
        def trace(a,b,c):
            l.append((a,b,c))
            return trace

        outputf = open(self.tempfile1, 'w')
        def f():
            print >> outputf, 1
            print >> outputf, 2
            print >> outputf, 3
            return "that's the return value"

        sys.settrace(trace)
        f()
        sys.settrace(None)
        outputf.close()
        # should get 1 "call", 3 "line" and 1 "return" events, and no call
        # or return for the internal app-level implementation of 'print'
        assert len(l) == 6
        assert [what for (frame, what, arg) in l] == [
            'call', 'line', 'line', 'line', 'line', 'return']
        assert l[-1][2] == "that's the return value"
Example #20
0
    def test_trace_return_exc(self):
        import sys
        l = []
        def trace(a,b,c):
            if b in ('exception', 'return'):
                l.append((b, c))
            return trace

        def g():
            raise Exception
        def f():
            try:
                g()
            except:
                pass
        sys.settrace(trace)
        f()
        sys.settrace(None)
        assert len(l) == 4
        assert l[0][0] == 'exception'
        assert isinstance(l[0][1][1], Exception)
        assert l[1] == ('return', None)
        assert l[2][0] == 'exception'
        assert isinstance(l[2][1][1], Exception)
        assert l[3] == ('return', None)
Example #21
0
 def start(self):
     self.get_ready()
     if self.nesting == 0:  # pragma: no cover
         sys.settrace(self.t)
         if hasattr(threading, "settrace"):
             threading.settrace(self.t)
     self.nesting += 1
Example #22
0
def trace_lines(do_trace):
    """Turn on/off printing each executed line.

    Args:
        do_trace: Whether to start tracing (True) or stop it (False).
    """
    def trace(frame, event, arg):
        """Trace function passed to sys.settrace.

        Return:
            Itself, so tracing continues.
        """
        if sys is not None:
            loc = '{}:{}'.format(frame.f_code.co_filename, frame.f_lineno)
            if arg is not None:
                arg = utils.compact_text(str(arg), 200)
            else:
                arg = ''
            print("{:11} {:80} {}".format(event, loc, arg), file=sys.stderr)
            return trace
        else:
            # When tracing while shutting down, it seems sys can be None
            # sometimes... if that's the case, we stop tracing.
            return None
    if do_trace:
        sys.settrace(trace)
    else:
        sys.settrace(None)
Example #23
0
    def TraceFunc(self, frame, event, arg):
        if event == 'call' and frame.f_code.co_name in ('schedule_cb', ):
            sys.settrace(self.NullTraceFunc)
            return self.ResumeTracingTraceFunc
        tasklet = stackless.current
        # print "         TraceFunc: %s %s in %s, line %s" % \
        #  (id(tasklet), event, frame.f_code.co_name, frame.f_lineno)

        ok = True
        if event in ('call', 'line', 'return'):
            key = (id(tasklet), frame.f_lineno)
            try:
                count = self.seen[key]
            except KeyError:
                ok = False
            else:
                self.seen[key] = count + 1
        else:
            ok = False
        if not ok:
            self.unexpected_trace_events.append((tasklet, event,
                                                 frame.f_code.co_name,
                                                 frame.f_lineno))

        if event in ('call', 'line', 'exception'):
            return self.TraceFunc
        return None
Example #24
0
    def __exit__(self, type_=None, value=None, traceback=None):
        reset_Breakpoint()
        sys.settrace(self._original_tracer)

        not_empty = ''
        if self.tracer.set_list:
            not_empty += 'All paired tuples have not been processed, '
            not_empty += ('the last one was number %d' %
                          self.tracer.expect_set_no)

        # Make a BdbNotExpectedError a unittest failure.
        if type_ is not None and issubclass(BdbNotExpectedError, type_):
            if isinstance(value, BaseException) and value.args:
                err_msg = value.args[0]
                if not_empty:
                    err_msg += '\n' + not_empty
                if self.dry_run:
                    print(err_msg)
                    return True
                else:
                    self.test_case.fail(err_msg)
            else:
                assert False, 'BdbNotExpectedError with empty args'

        if not_empty:
            if self.dry_run:
                print(not_empty)
            else:
                self.test_case.fail(not_empty)
Example #25
0
    def test_trace_raise_three_arg(self):
        import sys
        l = []
        def trace(frame, event, arg):
            if event == 'exception':
                l.append(arg)
            return trace

        def g():
            try:
                raise Exception
            except Exception as e:
                import sys
                raise Exception, e, sys.exc_info()[2]

        def f():
            try:
                g()
            except:
                pass

        sys.settrace(trace)
        f()
        sys.settrace(None)
        assert len(l) == 2
        assert issubclass(l[0][0], Exception)
        assert issubclass(l[1][0], Exception)
Example #26
0
    def run(self):
        if _settrace_func:
            _sys.settrace(_settrace_func)
        if _setprofile_func:
            _sys.setprofile(_setprofile_func)

        self.__target(*self.__args, **self.__kwargs)
Example #27
0
 def test_set_unset_f_trace(self):
     import sys
     seen = []
     def trace1(frame, what, arg):
         seen.append((1, frame, frame.f_lineno, what, arg))
         return trace1
     def trace2(frame, what, arg):
         seen.append((2, frame, frame.f_lineno, what, arg))
         return trace2
     def set_the_trace(f):
         f.f_trace = trace1
         sys.settrace(trace2)
         len(seen)     # take one line: should not be traced
     f = sys._getframe()
     set_the_trace(f)
     len(seen)     # take one line: should not be traced
     len(seen)     # take one line: should not be traced
     sys.settrace(None)   # and this line should be the last line traced
     len(seen)     # take one line
     del f.f_trace
     len(seen)     # take one line
     firstline = set_the_trace.func_code.co_firstlineno
     assert seen == [(1, f, firstline + 6, 'line', None),
                     (1, f, firstline + 7, 'line', None),
                     (1, f, firstline + 8, 'line', None)]
Example #28
0
 def probe_func( frame, event, arg ):
     if event=='return':
         l = frame.f_locals
         for key in keys:
             dictionary[key] = l.get( key )
         sys.settrace( None )
     return probe_func
Example #29
0
    def unsettrace(self, irc, msg, args):
        """takes no arguments

        Stops tracing function calls on stdout.
        """
        sys.settrace(None)
        irc.replySuccess()
Example #30
0
 def trace_dispatch(self, frame, event, arg):
     """
     Public method wrapping the trace_dispatch of bdb.py.
     
     It wraps the call to dispatch tracing into
     bdb to make sure we have locked the client to prevent multiple
     threads from entering the client event loop.
     
     @param frame The current stack frame.
     @param event The trace event (string)
     @param arg The arguments
     @return local trace function
     """
     try:
         self._dbgClient.lockClient()
         # if this thread came out of a lock, and we are quitting
         # and we are still running, then get rid of tracing for this thread
         if self.quitting and self._threadRunning:
             sys.settrace(None)
             sys.setprofile(None)
         import threading
         self.__name = threading.currentThread().getName()
         retval = DebugBase.trace_dispatch(self, frame, event, arg)
     finally:
         self._dbgClient.unlockClient()
     
     return retval
Example #31
0
oldprint = print


def newprint(text):
    global _summary_text_
    oldprint(text)
    if _summary_text_ != "":
        _summary_text_ += "\n"
    _summary_text_ += text


print = newprint

import sys
sys.settrace(None)

outstructs = []
outstrings = []


class Logger(object):
    def __init__(self):
        self.terminal = sys.stdout
        self.log = open("Summary.txt", "w")

    def write(self, message):
        self.terminal.write(message)
        self.log.write(message)

    def flush(self):
Example #32
0
 def __exit__(self, exc_type, exc_val, exc_tbf):
     """Disables events tracker."""
     sys.settrace(self._original_trace_function)
Example #33
0
 def set_quit(self):
     sys.settrace(None)
Example #34
0
 def __run(self):
     """Hacked run function, which installs the trace."""
     sys.settrace(self.globaltrace)
     self.__run_backup()
     self.run = self.__run_backup
Example #35
0
 def __run(self):
     sys.settrace(self.globaltrace)
     self.__run_backup()
     self.run = self.__run_backup
Example #36
0
 def teardown(self):
     sys.setprofile(None)
     sys.settrace(None)
Example #37
0
 def __enter__(self):
     """Enables events tracker."""
     sys.settrace(self._trace_memory_usage)
     return self
Example #38
0
def run(args):
    global verbosity

    preffile = os.path.join(os.environ['HOME'], '.openipmigui.startup')
    histfile = os.path.join(os.environ['HOME'], '.openipmigui.history')

    debug_msg = False
    debug_rawmsg = False
    debug_mem = False
    do_trace = False
    read_preffile = True
    log_file = None

    # Skip program name.
    carg = 1

    while (carg < len(args)):
        arg = args[carg]
        carg += 1
        if (arg == "--dmsg"):
            debug_msg = True
        elif (arg == "--drawmsg"):
            debug_msg = True
        elif (arg == "--dmem"):
            debug_mem = True
        elif (arg == "--verbose"):
            verbosity += 1
        elif (arg == "--trace"):
            do_trace = True
        elif (arg == "--logstderr"):
            log_file = sys.stderr
        elif (arg == "--logstdout"):
            log_file = sys.stdout
        elif (arg == "-n"):
            read_preffile = False
        elif (arg == '-p'):
            if (len(args) == 0):
                print "No argument given for -p"
                return
            preffile = args[carg]
            carg += 1
        else:
            print "Unknown argument: " + arg
            return
        pass

    if (debug_mem):
        OpenIPMI.enable_debug_malloc()
        pass

    top = TopHandler(preffile, log_file, histfile)

    # Detect if we need a separate OpenIPMI driver thread.  See the
    # openipmi_driver function above for the reason.
    try:
        import thread
        try:
            top.tk.getvar("tcl_platform", "threaded")
            # Tcl is threaded, no need for another thread.
            need_separate_openipmi_thread = False
        except:
            # Python is threaded, but Tcl is not.  Need to run the
            # OpenIPMI event loop in another thread.
            need_separate_openipmi_thread = True
            pass
        pass
    except:
        # No thread support, can't use another thread.
        need_separate_openipmi_thread = False
        pass

    if (need_separate_openipmi_thread):
        if (verbosity >= 1):
            print "Creating separate OpenIPMI event driver thread"
            pass
        rv = OpenIPMI.init()
        if (rv != 0):
            print "Unable to initialize OpenIPMI"
            return
        thread.start_new_thread(openipmi_driver, ())
        pass
    else:
        if (verbosity >= 1):
            print "Using TCL event loop, no threads"
            pass
        rv = OpenIPMI.init_tcl()
        if (rv != 0):
            print "Unable to initialize OpenIPMI, probably no TCL support"
            return
        pass

    if (debug_rawmsg):
        OpenIPMI.enable_debug_rawmsg()
        pass
    if (debug_msg):
        OpenIPMI.enable_debug_msg()
        pass
    if (do_trace):
        sys.settrace(trace)
        pass

    if (read_preffile):
        _saveprefs.restore(preffile)
    gui_cmdwin._HistoryRestore(histfile)

    mainhandler = top

    OpenIPMI.add_domain_change_handler(_domain.DomainWatcher(mainhandler))

    mainhandler.debug_mem = debug_mem
    top.title('OpenIPMI GUI')

    ui = gui.IPMIGUI(top, mainhandler)
    mainhandler.SetUI(ui)

    OpenIPMI.add_domain_change_handler(mainhandler)
    OpenIPMI.set_log_handler(mainhandler)

    _domain.RestoreDomains(mainhandler)

    OpenIPMI.set_cmdlang_event_handler(CmdlangEventHandler(mainhandler))

    top.mainloop()

    mainhandler.quit()
Example #39
0
    co = frame.f_code
    func_name = co.co_name
    line_no = frame.f_lineno
    filename = co.co_filename
    print '  %s line %s -- %d' % (func_name, line_no,
                                  int(round(time.time() * 1000)) - lastTime)
    global lastTime
    lastTime = int(round(time.time() * 1000))


def trace_calls(frame, event, arg):
    if event != 'call':
        return
    co = frame.f_code
    func_name = co.co_name
    line_no = frame.f_lineno
    filename = co.co_filename
    print 'Call to %s on line %s of %s' % (func_name, line_no, filename)

    return trace_lines
    #return


def g():
    print "here"
    time.sleep(4)
    time.sleep(3)


sys.settrace(trace_calls)
g()
Example #40
0
def test_debug(main, mocker):

    # store the tracing function
    trace_function = sys.gettrace()

    class event_loop(object):
        '''Used to mock the QEventLoop for the debugger component
        '''
        def __init__(self, callbacks):

            self.callbacks = callbacks
            self.i = 0

        def exec_(self):

            if self.i < len(self.callbacks):
                self.callbacks[self.i]()
                self.i += 1

        def exit(self, *args):

            pass

    def assert_func(x):
        '''Neddedd to perform asserts in lambdas
        '''
        assert (x)

    def patch_debugger(debugger, event_loop_mock):

        debugger.inner_event_loop.exec_ = event_loop_mock.exec_
        debugger.inner_event_loop.exit = event_loop_mock.exit

    qtbot, win = main

    #clear all
    obj_tree = win.components['object_tree']
    obj_tree.toolbarActions()[0].triggered.emit()

    editor = win.components['editor']
    editor.set_text(code)

    debugger = win.components['debugger']
    actions = debugger._actions['Run']
    run, debug, step, step_in, cont = actions

    variables = win.components['variables_viewer']

    viewer = win.components['viewer']
    assert (number_visible_items(viewer) == 3)

    #check breakpoints
    assert (debugger.breakpoints == [])

    #check _frames
    assert (debugger._frames == [])

    #test step through
    ev = event_loop([
        lambda: (assert_func(variables.model().rowCount() == 4),
                 assert_func(number_visible_items(viewer) == 3),
                 step.triggered.emit()), lambda:
        (assert_func(variables.model().rowCount() == 4),
         assert_func(number_visible_items(viewer) == 3), step.triggered.emit()
         ), lambda: (assert_func(variables.model().rowCount() == 5),
                     assert_func(number_visible_items(viewer) == 3),
                     step.triggered.emit()), lambda:
        (assert_func(variables.model().rowCount() == 5),
         assert_func(number_visible_items(viewer) == 4), cont.triggered.emit())
    ])

    patch_debugger(debugger, ev)

    debug.triggered.emit(True)
    assert (variables.model().rowCount() == 2)
    assert (number_visible_items(viewer) == 4)

    #test exit debug
    ev = event_loop([
        lambda: (step.triggered.emit(), ), lambda: (
            assert_func(variables.model().rowCount() == 1),
            assert_func(number_visible_items(viewer) == 3),
            debug.triggered.emit(False),
        )
    ])

    patch_debugger(debugger, ev)

    debug.triggered.emit(True)

    assert (variables.model().rowCount() == 1)
    assert (number_visible_items(viewer) == 3)

    #test breakpoint
    ev = event_loop([
        lambda: (cont.triggered.emit(), ), lambda: (
            assert_func(variables.model().rowCount() == 5),
            assert_func(number_visible_items(viewer) == 4),
            cont.triggered.emit(),
        )
    ])

    patch_debugger(debugger, ev)

    editor.debugger.set_breakpoints([(4, None)])

    debug.triggered.emit(True)

    assert (variables.model().rowCount() == 2)
    assert (number_visible_items(viewer) == 4)

    #test breakpoint without using singals
    ev = event_loop([
        lambda: (cont.triggered.emit(), ), lambda: (
            assert_func(variables.model().rowCount() == 5),
            assert_func(number_visible_items(viewer) == 4),
            cont.triggered.emit(),
        )
    ])

    patch_debugger(debugger, ev)

    editor.debugger.set_breakpoints([(4, None)])

    debugger.debug(True)

    assert (variables.model().rowCount() == 2)
    assert (number_visible_items(viewer) == 4)

    #test debug() without using singals
    ev = event_loop([
        lambda: (cont.triggered.emit(), ), lambda: (
            assert_func(variables.model().rowCount() == 5),
            assert_func(number_visible_items(viewer) == 4),
            cont.triggered.emit(),
        )
    ])

    patch_debugger(debugger, ev)

    editor.set_text(code_debug_Workplane)
    editor.debugger.set_breakpoints([(4, None)])

    debugger.debug(True)

    CQ = obj_tree.CQ

    # object 1 (defualt color)
    r, g, b, a = get_rgba(CQ.child(0).ais)
    assert (a == pytest.approx(0.2))
    assert (r == 1.0)

    assert (variables.model().rowCount() == 2)
    assert (number_visible_items(viewer) == 4)

    # restore the tracing function
    sys.settrace(trace_function)
Example #41
0
 def probeFunc(frame, event, arg):
     if event == 'return':
         locals = frame.f_locals
         func_locals.update(dict((k,locals.get(k)) for k in keys))
         sys.settrace(None)
     return probeFunc