def _run_module(self, module_with_run): try: rv = module_with_run.run(self.config, self.environment, self._ui) except: if self.config.flags.DEBUG: ex, val, tb = sys.exc_info() debugger.post_mortem(tb, ex, val) else: logging.exception_error(module_with_run.__name__) return TestResult.INCOMPLETE else: return rv
def _run_module_hack(self, module_with_exec): tcinst = core.TestCase(self.config, self.environment, self._ui) tcinst.set_test_options() tcinst.test_name = module_with_exec.__name__ # Pull out essential functions. execute = getattr(module_with_exec, "execute") initialize = getattr(module_with_exec, "initialize", None) finalize = getattr(module_with_exec, "finalize", None) # Make functions bound methods of temporary TestCase instance. MethodType = type(tcinst.execute) def wrap_execute(s): return execute() setattr(tcinst, "execute", MethodType(wrap_execute, tcinst)) if initialize is not None: def wrap_initialize(s): return initialize() setattr(tcinst, "initialize", MethodType(wrap_initialize, tcinst)) if finalize is not None: def wrap_finalize(s): return finalize() setattr(tcinst, "finalize", MethodType(wrap_finalize, tcinst)) # Put TestCase instance methods into module namespace. # This enables execute function to call disposition methods as globals. for name in _EXPORTED_METHODS: value = getattr(tcinst, name) setattr(module_with_exec, name, value) module_with_exec.config = self.config module_with_exec.environment = self.environment module_with_exec.UI = self._ui module_with_exec.print = tcinst.info module_with_exec.input = self._ui.user_input # Run inside a TestEntry, which handles result reporting. try: entry = core.TestEntry(tcinst) rv = entry.run() except: if self.config.flags.DEBUG: ex, val, tb = sys.exc_info() debugger.post_mortem(tb, ex, val) else: logging.exception_error(module_with_exec.__name__) rv = TestResult.INCOMPLETE # Clean up del module_with_exec.config del module_with_exec.environment del module_with_exec.UI del module_with_exec.print del module_with_exec.input for name in _EXPORTED_METHODS: delattr(module_with_exec, name) return rv
def clear(self): if self._eqcache: eqc = self._eqcache self._eqcache = {} while eqc: name, obj = eqc.popitem() try: obj.clear() except: logging.exception_error("environment clear: {!r}".format(obj)) gc.collect() for obj in gc.garbage: try: obj.close() except: logging.exception_warning("environment garbage collect: {!r}".format(obj)) del gc.garbage[:] scheduler.sleep(2) # some devices need time to fully clear or disconnect
def clear(self, delay=0): if self._eqcache: eqc = self._eqcache self._eqcache = {} while eqc: name, obj = eqc.popitem() try: obj.clear() except: logging.exception_error( "environment clear: {!r}".format(obj)) gc.collect() for obj in gc.garbage: try: obj.close() except: logging.exception_warning( "environment garbage collect: {!r}".format(obj)) del gc.garbage[:] if delay: scheduler.sleep(delay)
def clear(self): if self._eqcache: eqc = self._eqcache self._eqcache = {} while eqc: name, obj = eqc.popitem() try: obj.clear() except: logging.exception_error( "environment clear: {!r}".format(obj)) gc.collect() for obj in gc.garbage: try: obj.close() except: logging.exception_warning( "environment garbage collect: {!r}".format(obj)) del gc.garbage[:] scheduler.sleep( 2) # some devices need time to fully clear or disconnect
os.close(1) os.close(2) os.dup2(p2cread, 0) # sys.stdin = os.fdopen(0, mode="r") os.dup2(c2pwrite, 1) # sys.stdout = os.fdopen(1, mode="w") if merge: os.dup2(c2pwrite, 2) # sys.stderr = os.fdopen(2, mode="w") else: os.dup2(c2perr, 2) # sys.stderr = os.fdopen(2, mode="w") if pwent: run_as(pwent) except Exception: logging.exception_error("CoProcessPipe") os.close(p2cread) os.close(c2pwrite) if c2perr: os.close(c2perr) # simply forks this python process class SubProcess(Process): def __init__(self, pwent=None, _pgid=0): super().__init__(sys.argv[0]) pid = os.fork() if pid == 0: sys.excepthook = sys.__excepthook__ # remove any debugger hook if pwent: run_as(pwent)