def list_tests(): test_dir = Paths.join(Paths.flow123d_root(), 'tests') tests = Paths.walk(test_dir, [ PathFilters.filter_type_is_file(), PathFilters.filter_endswith('.yaml'), PathFilters.filter_not(PathFilters.filter_name('config.yaml')), ]) result = dict() for r in tests: dirname = Paths.dirname(r) basename = Paths.basename(r) if Paths.dirname(dirname) != test_dir: continue if dirname not in result: result[dirname] = list() result[dirname].append(basename) keys = sorted(result.keys()) for dirname in keys: printf.warning(Paths.relpath(dirname, test_dir)) with printf: paths = list() wrap = 2 for basename in result[dirname]: paths.append(basename) for i in range(0, len(paths), wrap): printf.out(' '.join( ['{:<40s}'.format(x) for x in paths[i:i + wrap]])) printf.sep()
def get_result(self): if self.clean.returncode != 0: printf.out("{} Could not clean directory '{c[dir]}': {c[error]}", self.get_status_line(self.clean), c=self.clean) return if self.pypy.returncode != 0: printf.out("{} Run error, case: {p[name]}", self.get_status_line(self.pypy), p=self.pypy) self.print_log_file(self.pypy.log, self.n_lines) return elif self.batch: self.print_log_file(self.pypy.log, self.n_lines) if self.comp.returncode not in (0, None): printf.out("{} Compare error, case: {p[name]}, Details: ", self.get_status_line(self.comp), p=self.pypy) self.print_log_file(self.pypy.log, self.n_lines) with printf: with printf: for c in self.comp.tests: rc = c.returncode if rc == 0: printf.out('[{:^6}]: {}', 'OK', c.name) else: printf.out('[{:^6}]: {}', 'FAILED', c.name) return elif self.batch: self.print_log_file(self.comp.log, self.n_lines)
def print_log_file(cls, f, n_lines): log_file = IO.read(f) if log_file: if n_lines == 0: printf.out('Full log from file {}:', f) else: printf.out('Last {} lines from file {}:', abs(n_lines), f) printf.stream(format_n_lines(log_file.rstrip(), -n_lines))
def get_result(self): if self.returncode != 0: if self.returncode != 0: printf.out("{} Run error, case: {p.name}", RuntestParser.get_status_line(self), p=self) RuntestParser.print_log_file(self.log, self.n_lines) return elif self.batch: RuntestParser.print_log_file(self.log, self.n_lines)
def _run(self): """ Run method for this module """ printf.important('configuration:').sep() with printf: overrides = ('memory_limit', 'time_limit', 'cpu') global_changes = { k: self.arg_options.get(k) for k in overrides if self.arg_options.get(k) } for k, v in global_changes.items(): printf.important('{:16s} {:10s} (global override)', str(k), str(v)) # --------------------------------------------- if self.arg_options.random_output_dir: import scripts.yamlc as yamlc yamlc.TEST_RESULTS = 'test_results-{}'.format( self.arg_options.random_output_dir) # --------------------------------------------- self.all_yamls = self._walk_files() printf.important("{:16s} {}", 'yaml files', len(self.all_yamls)) if not self.all_yamls: printf.warning('No yaml files found in following locations:') with printf: printf.opt(default='IMPORTANT').stream( self.arg_options.args) sys.exit(0) # --------------------------------------------- self.configs = self.read_configs(self.all_yamls) self.configs.update( proc=self.arg_options.cpu, time_limit=self.arg_options.time_limit, memory_limit=self.arg_options.memory_limit, ) # filter tags for includes and excludes self.configs.filter_tags(include=self.include, exclude=self.exclude) if self.arg_options.queue: if printf.verbosity() is printf.OutputVerbosity.FULL: printf.out('Running in PBS mode') return self.run_pbs_mode() else: if printf.verbosity() is printf.OutputVerbosity.FULL: printf.out('Running in LOCAL mode') return self.run_local_mode()
def on_update(self, pypy=None): self._check_limits() if self.terminated: return for fmt in ensure_iterable(self.update_format): if printf.tty(): printf.rewrite(fmt, monitor=self) else: printf.out(fmt, monitor=self)
def massif_hook(pypy): """ Function will initialize ValgrindMassif and print result on success :type pypy: scripts.core.pypy.PyPy """ vm = ValgrindMassif(pypy.case.fs.valgrind_out) vm.output = OutputMode.variable_output() vm.start() vm.join() # if ms_print ended successfully we print first 32 lines (where graph is) if vm.returncode == 0: output = vm.output.read() lines = str(output).splitlines()[0:32] printf.out('\n '.join(lines))
def do_work(arg_options=None, debug=False): """ Main method which invokes ModuleRuntest :rtype: ParallelThreads :type debug: bool :type arg_options: utils.argparser.RuntestArgs """ module = ModuleRuntest(arg_options) result = module.run(debug) # type: ParallelThreads if not arg_options.queue: printf.sep() if arg_options.save_to_db: from scripts.artifacts.collect.loader import load_data, save_to_database from scripts.artifacts.collect.modules.flow123d_profiler import Flow123dProfiler for t in result.threads: thread = t # type: RuntestMultiThread with printf: printf.out('Processing %s' % thread.pypy.case.fs.output) data = load_data(thread.pypy.case.fs.output, Flow123dProfiler()) if data: with printf: printf.out(' - found %d file(s)' % len(data)) with printf: for item in data: printf.out(' %d element(s)' % len(item.items)) else: printf.error('No profiler data found') save_to_database(data) # pickle out result on demand if arg_options.dump: try: import pickle pickle.dump(result.dump(), open(arg_options.dump, 'wb')) except: pass return result.returncode, result
def print_test_result(cls, thread, formatter=TestPrinterStatus): """ :type formatter: TestPrinterStatus :type thread: scripts.core.threads.RuntestMultiThread """ status_name = '[ {} ]'.format(formatter.get(str( thread.returncode))).upper() case_name = thread.pypy.case.as_string detail = '' thread_names = ['clean', 'pypy', 'comp'] thread_rcs = dict() thread_msg = dict() for ti in thread_names: subthread = getattr(thread, ti) thread_rcs[ti] = subthread.returncode thread_msg[ti] = getattr(formatter, 'detail_{}'.format(ti))(thread) # first non zero rc will be formatted # otherwise first non empty detail for ti in thread_names: subthread = getattr(thread, ti) if subthread.returncode.failed: sub_detail = thread_msg[ti] detail = formatter.errors[ti].format(**locals()) printf.error(formatter.template.format(**locals())) return # first non empty detail for ti in thread_names: subthread = getattr(thread, ti) sub_detail = thread_msg[ti] if sub_detail: detail = formatter.errors[ti].format(**locals()) printf.out(formatter.template.format(**locals())) return if str(thread.returncode).upper() == 'NONE': printf.warning(formatter.template.format(**locals())) else: printf.success(formatter.template.format(**locals()))
def on_complete(self, pypy=None): if self.log_file: IO.write(self.log_file, self.content) # finish after update if self.update_format and (not self.complete_format and not self.color_complete_format): printf.finish_rewrite() # print regular messages for fmt in ensure_iterable(self.complete_format): printf.out(fmt, monitor=self) # print messages if error if self.pypy.with_error(): for fmt in ensure_iterable(self.error_complete_format): printf.error(fmt, monitor=self) # print regular color messages based on result for fmt in ensure_iterable(self.color_complete_format): if self.pypy.returncode() == 0: printf.success(fmt, monitor=self) elif self.pypy.returncode() is None: printf.warning(fmt, monitor=self) else: printf.error(fmt, monitor=self) with printf: if printf.verbosity() is printf.OutputVerbosity.FULL: printf.sep() printf.out('Output from file {self.pypy.full_output}'.format( **locals())) printf.opt(raw=True).stream( format_n_lines(self.content, pypy.was_successful())) elif printf.verbosity( ) is printf.OutputVerbosity.SMART and pypy.with_error(): printf.sep() printf.out( 'Last 50 lines from file {self.pypy.full_output}'.format( **locals())) printf.opt(raw=True).stream( format_n_lines(self.content, success=False, n_lines=-50)) elif printf.verbosity( ) is printf.OutputVerbosity.MINIMAL and pypy.with_error(): printf.sep() printf.out( 'Last 50 lines from file {self.pypy.full_output}'.format( **locals())) printf.opt(raw=True).stream( format_n_lines(self.content, success=False, n_lines=-50))
def run_local_mode(self): """ Runs this module in local mode. At this point all configuration files has been loaded what is left to do is to prepare execution arguments start whole process """ with printf: runner = ParallelThreads(self.arg_options.parallel) runner.stop_on_error = not self.arg_options.keep_going pypy_index = 1 for yaml_file, yaml_config in list(self.configs.files.items()): for case in yaml_config.get_one(yaml_file): if printf.verbosity() is printf.OutputVerbosity.FULL: printf.out(' - found case {} in {}', case, yaml_file) # create main process which first clean output dir # and then execute test following with comparisons multi_process = self.create_process_from_case(case) multi_process.pypy.extra['runner'] = runner multi_process.pypy.extra['index'] = pypy_index pypy_index += 1 runner.add(multi_process) printf.important('{:16s} {}', 'total cases', runner.total) if printf.verbosity() is printf.OutputVerbosity.FULL: printf.out(' - {:16s} {}', 'includes', self.include) printf.out(' - {:16s} {}', 'excludes', self.exclude) printf.important('cases') with printf: for thread in runner.threads: try: printf.out(' - {}', thread.pypy.case) except: printf.out(' - {}', thread) printf.sep().important('execution:') with printf: # run! runner.start() while runner.is_running(): time.sleep(1) printf.sep().important('SUMMARY ').sep() with printf: for thread in runner.threads: multithread = thread # type: RuntestMultiThread StatusPrinter.print_test_result(multithread) printf.sep() StatusPrinter.print_runner_stat(runner) # exit with runner's exit code GlobalResult.returncode = runner.returncode return runner
def on_start(self, pypy=None): self.process = self.pypy.executor.process for fmt in ensure_iterable(self.start_format): printf.out(fmt, monitor=self)