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
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)
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)
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)
