def handle_error(self, ex, val, tb): if self._debug: import debugger debugger.post_mortem(ex, val, tb) else: import traceback traceback.print_exception(ex, val, tb)
def _lambda(*iargs, **ikwargs): try: return meth(*iargs, **ikwargs) except: ex, val, tb = sys.exc_info() import debugger debugger.post_mortem(ex, val, tb)
def _finalize(self, rv): try: self.finalize() except: ex, val, tb = sys.exc_info() self.diagnostic("%s (%s)" % (ex, val)) if self._debug: debugger.post_mortem(ex, val, tb) rv = self.abort("Test finalize failed!") return rv
def shell_hook(type, value, tb): if type in (NameError, SyntaxError): do_shell(value) elif type in (IndentationError,): sys.__excepthook__(type, value, tb) else: print if __debug__: debugger.post_mortem(tb, type, value) else: import traceback traceback.print_exception(type, value, tb)
def shell_hook(type, value, tb): if type in (NameError, SyntaxError): do_shell(value) elif type in (IndentationError, ): sys.__excepthook__(type, value, tb) else: print if __debug__: debugger.post_mortem(tb, type, value) else: import traceback traceback.print_exception(type, value, tb)
def mainloop(self, debug=False): try: self.parser.interact() except KeyboardInterrupt: self.syslog.message("EXITING", "User interrupt") return except: exc, val, tb = sys.exc_info() self.syslog.message("EXCEPTION", "internal error: %s(%s)" % (exc, val)) if debug: import debugger debugger.post_mortem(exc, val, tb) else: self.syslog.message("EXITING", "User exited")
def _initialize(self, args, kwargs): self.report.add_heading("Test suite: %s" % self.__class__.__name__, 1) # initialize the suite try: rv = self.initialize(*args, **kwargs) except KeyboardInterrupt: self.info("Suite aborted by user in initialize().") raise TestSuiteAbort except: ex, val, tb = sys.exc_info() if self._debug: ex, val, tb = sys.exc_info() debugger.post_mortem(ex, val, tb) self.info("Suite failed to initialize: %s (%s)" % (ex, val)) raise TestSuiteAbort, val
def __call__(self, *args, **kw): cf = self.config if os.path.isfile(self.configfile): pass else: #try another path alternate_conf_file = os.path.join(cf.conf_dir, "%s.conf" % (self.test_name)) if os.path.isfile(alternate_conf_file): self.configfile = alternate_conf_file if os.path.isfile(self.configfile): print "CONF file is: %s" % self.configfile cf.mergefile(self.configfile) try: cf.config_ID = os.path.basename(cf.config_ID.split()[1]) except AttributeError: cf.config_ID = None except IndexError: cf.config_ID = "<undefined>" print >>sys.stderr, 'Make sure your config file is type "ktext" in Perforce.' else: cf.config_ID = None # this heading displays the test name just as a PREREQUISITES entry needs. self._ui.add_heading(repr_test(self.test_name, args, kw), 2) self._report.add_heading(repr_test(self.test_name, args, kw), 2) if cf.config_ID: self.info("Configuration ID: %s" % (cf.config_ID,)) self.starttime = timelib.now() self.info("STARTTIME: %s" % self.timestamp(self.starttime)) rv = None # in case of exception rv = self._initialize(rv) if rv is not None: # an exception happened return rv # test elapsed time does not include initializer time. teststarttime = timelib.now() # run test_method testloops = int(cf.get("testloops", 1)) try: for l in xrange(testloops): rv = apply(self.test_method, args, kw) except KeyboardInterrupt: if self._debug: ex, val, tb = sys.exc_info() debugger.post_mortem(ex, val, tb) rv = self.abort("%s: aborted by user." % self.test_name) self._finalize(rv) raise except TestFailError, errval: rv = self.failed("Caught Fail exception: %s" % (errval,))
def _finalize(self): # finalize the suite try: self.finalize() except KeyboardInterrupt: if self._nested: raise TestSuiteAbort, "Suite '%s' aborted by user in finalize()." % (self.suite_name,) else: self.info("Suite aborted by user in finalize().") except: ex, val, tb = sys.exc_info() if self._debug: debugger.post_mortem(ex, val, tb) self.info("Suite failed to finalize: %s (%s)" % (ex, val)) if self._nested: raise TestSuiteAbort, "subordinate suite '%s' failed to finalize." % (self.test_name,) self._report_summary()
def __call__(self, *args, **kw): # this heading displays the test name just as a PREREQUISITES entry needs. self._report.add_heading(repr_test(self.test_name, args, kw), 2) self.starttime = timelib.now() self.info("STARTTIME: %s" % (timelib.strftime("%a, %d %b %Y %H:%M:%S %Z", timelib.localtime(self.starttime)),)) rv = None # in case of exception rv = self._initialize(rv) if rv is not None: # an exception happened return rv # test elapsed time does not include initializer time. teststarttime = timelib.now() # run test_method try: rv = apply(self.test_method, args, kw) except KeyboardInterrupt: if self._debug: ex, val, tb = sys.exc_info() debugger.post_mortem(ex, val, tb) rv = self.abort("%s: aborted by user." % self.test_name) self._finalize(rv) raise except TestFailError, errval: rv = self.failed("Caught Fail exception: %s" % (errval,))
except OSError, errno: if errno[0] == EEXIST: pass else: raise os.chmod(cf.resultsdir, 0777) # firstly, run the module-level initialize function. if hasattr(mod, "initialize") and callable(mod.initialize): if cf.flags.DEBUG: try: mod.initialize(cf) except: ex, val, tb = sys.exc_info() import debugger debugger.post_mortem(ex, val, tb) else: mod.initialize(cf) rpt = cf.get_report() cf.reportfilenames = rpt.filenames # Report file's names. save for future use. rpt.initialize() rpt.logfile(cf.logfilename) rpt.add_title("Test Results for module %r." % (mod.__name__, )) rpt.add_message("ARGUMENTS", " ".join(cf.arguments)) # get the build version version_file = os.path.join(os.environ["STRATATEST_HOME"], 'etc', 'VERSION') self.rpt = rpt # new report object. try: vf = open(version_file)
def run_module(self, mod): """run_module(module) Runs the module. The parameter should be a module object, but if it is a string then a module object with that name will be imported. """ cf = self._config if type(mod) is str: mod = self.get_module(mod) if mod: try: cf.module_ID = mod._ID except AttributeError: cf.module_ID = "<unknown>" cf.reportbasename = mod.__name__.replace(".", "_") cf.logbasename = "%s.log" % (cf.reportbasename,) # merge any test-module specific config files. testconf = os.path.join(os.path.dirname(mod.__file__) , "%s.conf" % (mod.__name__.split(".")[-1],)) cf.mergefile(testconf) # resultsdir is where you would place any resulting data files. starttime = timelib.now() cf.resultsdir = os.path.join( cf.get("resultsdirbase", os.environ["HOME"]), "%s-%s" % (cf.reportbasename, timelib.strftime("%Y%m%d%H%M", timelib.localtime(starttime))) ) # make collection dir try: os.mkdir(cf.resultsdir) except OSError, errno: if errno[0] == EEXIST: pass else: raise # firstly, run the module-level initialize function. if hasattr(mod, "initialize") and callable(mod.initialize): if cf.flags.DEBUG: try: mod.initialize(cf) except: ex, val, tb = sys.exc_info() import debugger debugger.post_mortem(ex, val, tb) else: mod.initialize(cf) rpt = cf.get_report() cf.reportfilenames = rpt.filenames # Report file's names. save for future use. rpt.initialize() rpt.logfile(cf.logfilename) rpt.add_title("Test Results for module %r." % (mod.__name__, )) rpt.add_message("ARGUMENTS", " ".join(cf.arguments)) note = self.get_note() if note: rpt.add_message("NOTE", note) self._config.comment = note else: self._config.comment = "<none>" self._reporturl(rpt) rpt.add_message("MODULESTART", timelib.strftime("%a, %d %b %Y %H:%M:%S %Z", timelib.localtime(starttime))) mod.run(cf) # run the test! rpt.add_message("MODULEEND", timelib.localtimestamp()) rpt.finalize() # force close of report and logfile between modules cf.logfile.flush() del cf.report ; del cf.logfile # lastly, run the module-level finalize function. if hasattr(mod, "finalize") and callable(mod.finalize): if cf.flags.DEBUG: try: mod.finalize(cf) except: ex, val, tb = sys.exc_info() import debugger debugger.post_mortem(ex, val, tb) else: mod.finalize(cf)
def _initialize(self, args, kwargs): self.report.add_heading("Test suite: %s" % self.__class__.__name__, 1) self.verify_testbed() if self._testbed_needed: self.report.add_message("TESTBED", self.config.testbed.name) # initialize the suite try: rv = self.initialize(*args, **kwargs) except KeyboardInterrupt: self.info("Suite aborted by user in initialize().") raise TestSuiteAbort except: ex, val, tb = sys.exc_info() if self._debug: ex, val, tb = sys.exc_info() debugger.post_mortem(ex, val, tb) self.error("Suite failed to initialize: %s (%s)" % (ex, val)) raise TestSuiteAbort, val # run all the tests # verify any prerequisites are met at run time. Note that this # currently only checks this particular suite. def check_prerequisites(self, currententry, upto): for prereq in currententry.prerequisites(): for entry in self._tests[:upto]: if entry.match_prerequisite(prereq): if entry.result == PASSED: continue else: self.report.add_heading(repr(currententry), 2) self.info("WARNING: prerequisite of %s did not pass." % (currententry,)) self.info("%s: %s" % (prereq, entry.result)) currententry.abort() return False return True # no prerequisite def get_testbeds(self): """Get a list of available testbeds that will work will all tests in the suite. Generally, this is called before the suite is run. """ tblist = [] tbneeded = False for entry in self._tests: if entry.inst.ITEST is None: continue tbneeded = True tbs = entry.inst.get_testbeds() if tbs: tblist.extend(tbs) tblist = removedups(tblist) # prune testbeds that wont work for some tests for entry in self._tests: for tb in tblist[:]: if not entry.inst.testbed_will_work(tb): tblist.remove(tb) break self._testbed_needed = tbneeded return tblist def verify_testbed(self): if not self.testbed_needed: return True tbr = self.config.testbed if tbr is None: for entry in self._tests: if entry.inst.ITEST is not None: raise TestSuiteAbort, "No testbed specified or found." return True # no testbed needed for entry in self._tests: if not entry.inst.testbed_will_work(tbr._testbed): reason = entry.inst.why_testbed_wont_work(tbr._testbed) raise TestSuiteAbort, "Cannot use testbed %s: %s" % (tbr._testbed.name, reason) def _get_tbneeded(self): if self._testbed_needed is None: self.get_testbeds() return self._testbed_needed def _del_tbneeded(self): self._testbed_needed = None testbed_needed = property(_get_tbneeded, None, _del_tbneeded, "Is a testbed needed for this suite?") def run_tests(self): self.config.rv_dict = {} for i, entry in enumerate(self._tests): if not self.check_prerequisites(entry, i): continue try: self.config.logfile.note("%s: %r" % (timelib.localtimestamp(), entry)) rv = entry() except KeyboardInterrupt: self.info("Test suite aborted by user.") if self._nested: raise TestSuiteAbort, "aborted by user" else: break except TestSuiteAbort, err: self.info("Suite aborted by test %s (%s)." % (entry.name(), err)) rv = ABORT