def save_cache(self, state): # Do not overwrite the old file (yet) with lock: parser.dump(state, self._cache_backup) # Atomic operation (sort of) # (just in case the interpreter hard crashes) os.rename(self._cache_backup, cache_file)
def run(self): try: while True: interrupt_point() with self._lock: testfile = self._testcases.pop() left = len(self._testcases) log.info('running %s on monitor %s (%d left)' % (testfile, self._monitor.name, left)) test = parser.load(testfile) name = os.path.split(testfile)[1] logfile = os.path.join( self._out_dir, os.path.splitext(name)[0]) + '.log' stdout = StringIO.StringIO() with self._monitor.open(logfile, stdout): interrupt_point() # Perform each action in the test try: for event in test: event.perform(self._monitor) time.sleep(self._steptime) interrupt_point() # Take final snapshot of the state and save it snapshot = self._monitor.take_snapshot() parser.dump(snapshot, os.path.join( self._out_dir, name)) except Exception, e: log.exception(e) self._results.error( testfile, message = str(e), stdout = stdout.getvalue()) else: # Validate with oracles for oracle in self._oracles: reason = oracle.validate( self._monitor, snapshot, testfile, test) if reason: log.error('test %s failed (oracle %s)' % (testfile, type(oracle))) self._results.failure( testfile, message = '%s\nreason: %s' % (type(oracle), reason), stdout = stdout.getvalue()) break else: self._results.success( testfile, stdout = stdout.getvalue())
except Exception, e: self._monitor.log.exception(e) # interrupt other tasks interrupt_ripper() tasks = [Task(m) for m in monitors] for t in tasks: t.start() while any(( task.is_alive() for task in tasks )): time.sleep(steptime) if not interrupt: # Dump gui file to disk only if it wasn't interrupted parser.dump(state.efg, efg_file) log.info('total events: %d' % len(state.efg.nodes())) log.info('visited: %d' % len(state.visited)) log.info('skipped: %d' % len(state.skipped)) log.info('failures: %d' % len(state.failures)) # Dump cache file if skipped is empty and we are finished #if len(state.skipped) == 0 and len(state.queue) == 0: # os.remove(cache_file) else: parser.dump(state, '%s.cache' % efg_file) return 0 if not interrupt else 1 if __name__ == '__main__':
testgenerator.add_options(cfg) max = float(cfg.get('testgenerator', 'max')) progress = util.ProgressBar(max) counter = util.counter(max, progress.update) start_nodes = [x for x in gr if 'start_node' in gr.node_attributes(x)] tests = testgenerator.generate(gr, start_nodes, cfg, counter) # Write each one of these tests to a separate test file print 'writing test files to disk' progress = util.ProgressBar(len(tests)) output_dir = cfg.get('testgenerator', 'folder') if not os.path.exists(output_dir): log.debug('creating folder %s' % os.path.abspath(output_dir)) os.makedirs(output_dir) format = cfg.get('testgenerator', 'format') for i, t in enumerate(tests): name = 't_%s.%s' % ('_'.join(['e%u' % hash(m) for m in t]), format) file_ = os.path.join(output_dir, name) progress.update(i+1) log.debug('writing test case %s' % file_) parser.dump(t, file_) print log.info('%d test cases total' % len(tests)) return 0 if __name__ == '__main__': sys.exit(main(sys.argv))