def parse(self): if (not path.exists(self.summary_file_path)): log.warning("_summary file " + self.summary_file_path + " does not exist!") self.is_failure = True return summary_file = open(self.summary_file_path, 'r') self.bytes_analyzed = self._get_value_from_next_line_with_colon( summary_file) self.bytes_not_executed = self._get_value_from_next_line_with_colon( summary_file) self.percentage_executed = self._get_value_from_next_line_with_colon( summary_file) self.percentage_not_executed = self._get_value_from_next_line_with_colon( summary_file) self.ranges_uncovered = self._get_value_from_next_line_with_colon( summary_file) self.branches_total = self._get_value_from_next_line_with_colon( summary_file) self.branches_uncovered = self._get_value_from_next_line_with_colon( summary_file) self.branches_always_taken = self._get_value_from_next_line_without_colon( summary_file) self.branches_never_taken = self._get_value_from_next_line_without_colon( summary_file) summary_file.close() if not self.branches_uncovered == '' and not self.branches_total == '': self.percentage_branches_covered = 1 - float( self.branches_uncovered) / float(self.branches_total) else: self.percentage_branches_covered = 0.0 return
def _select(self, config, ls): if len(ls) != 2: log.warning('invalid select statement') else: r = self.macros.set_read_map(ls[1]) log.trace('config: %s: _select: %s %s %r' % \ (self.init_name, r, ls[1], self.macros.maps()))
def _process_data(self, results, directive, info, data): new_data = [] for l in results[1]: if l.startswith('%error'): l = self._expand(l) raise error.general('config error: %s' % (l[7:])) elif l.startswith('%warning'): l = self._expand(l) log.stderr('warning: %s' % (l[9:])) log.warning(l[9:]) if not directive: l = self._expand(l) ls = self.tags.split(l, 1) log.trace('config: %s: _tag: %s %s' % (self.init_name, l, ls)) if len(ls) > 1: info = ls[0].lower() if info[-1] == ':': info = info[:-1] info_data = ls[1].strip() else: info_data = ls[0].strip() if info is not None: self._info_append(info, info_data) else: log.warning("invalid format: '%s'" % (info_data[:-1])) else: log.trace('config: %s: _data: %s %s' % (self.init_name, l, new_data)) new_data.append(l) return (directive, info, data + new_data)
def _disable(self, config, ls): if len(ls) != 2: log.warning('invalid disable statement') else: if ls[1] == 'select': self.macros.lock_read_map() log.trace('config: %s: _disable_select: %s' % (self.init_name, ls[1])) else: log.warning('invalid disable statement: %s' % (ls[1]))
def _undefine(self, config, ls): if len(ls) <= 1: log.warning('invalid macro definition') else: mn = self._label(ls[1]) if mn in self.macros: del self.macros[mn] else: log.warning("macro '%s' not defined" % (mn))
def copy_tree(src, dst): hsrc = host(src) hdst = host(dst) if os.path.exists(src) and os.path.isdir(src): names = os.listdir(src) else: names = [basename(src)] src = dirname(src) if not os.path.isdir(dst): os.makedirs(dst) for name in names: srcname = os.path.join(src, name) dstname = os.path.join(dst, name) try: if os.path.islink(srcname): linkto = os.readlink(srcname) if os.path.exists(dstname): if os.path.islink(dstname): dstlinkto = os.readlink(dstname) if linkto != dstlinkto: log.warning('copying tree: update of link does not match: %s -> %s' % \ (dstname, dstlinkto)) os.remove(dstname) else: log.warning('copying tree: destination is not a link: %s' % \ (dstname)) os.remove(dstname) else: os.symlink(linkto, dstname) elif os.path.isdir(srcname): copy_tree(srcname, dstname) else: shutil.copy2(srcname, dstname) except shutil.Error as err: raise error.general('copying tree: %s -> %s: %s' % (src, dst, str(err))) except EnvironmentError as why: raise error.general('copying tree: %s -> %s: %s' % (srcname, dstname, str(why))) try: shutil.copystat(src, dst) except OSError as why: ok = False if windows: if WindowsError is not None and isinstance(why, WindowsError): ok = True if not ok: raise error.general('copying tree: %s -> %s: %s' % (src, dst, str(why)))
def _define(self, config, ls): if len(ls) <= 1: log.warning('invalid macro definition') else: d = self._label(ls[1]) if self.disable_macro_reassign: if (d not in self.macros) or \ (d in self.macros and len(self.macros[d]) == 0): if len(ls) == 2: self.macros[d] = '1' else: self.macros[d] = ' '.join([f.strip() for f in ls[2:]]) else: log.warning("macro '%s' already defined" % (d)) else: if len(ls) == 2: self.macros[d] = '1' else: self.macros[d] = ' '.join([f.strip() for f in ls[2:]])
def parse(self): if(not path.exists(self.summaryFilePath)): log.warning("Summary file " + self.summaryFilePath + " does not exist!") self.isFailure = True return summaryFile = open(self.summaryFilePath,'r') self.bytes_analyzed = self._getValueFromNextLineWithColon(summaryFile) self.bytes_notExecuted = self._getValueFromNextLineWithColon(summaryFile) self.percentage_executed = self._getValueFromNextLineWithColon(summaryFile) self.percentage_notExecuted = self._getValueFromNextLineWithColon(summaryFile) self.ranges_uncovered = self._getValueFromNextLineWithColon(summaryFile) self.branches_total = self._getValueFromNextLineWithColon(summaryFile) self.branches_uncovered = self._getValueFromNextLineWithColon(summaryFile) self.branches_alwaysTaken = self._getValueFromNextLineWithoutColon(summaryFile) self.branches_neverTaken = self._getValueFromNextLineWithoutColon(summaryFile) summaryFile.close() self.percentage_branchesCovered = 1 - float(self.branches_uncovered) / float(self.branches_total) return
def run(args, command_path=None): import sys tests = [] stdtty = console.save() opts = None default_exefilter = '*.exe' try: optargs = { '--rtems-tools': 'The path to the RTEMS tools', '--rtems-bsp': 'The RTEMS BSP to run the test on', '--user-config': 'Path to your local user configuration INI file', '--report-path': 'Report output base path (file extension will be added)', '--report-format': 'Formats in which to report test results in addition to txt: json', '--log-mode': 'Reporting modes, failures (default),all,none', '--list-bsps': 'List the supported BSPs', '--debug-trace': 'Debug trace based on specific flags (console,gdb,output,cov)', '--filter': 'Glob that executables must match to run (default: ' + default_exefilter + ')', '--stacktrace': 'Dump a stack trace on a user termination (^C)', '--coverage': 'Perform coverage analysis of test executables.' } mailer.append_options(optargs) opts = options.load(args, optargs=optargs, command_path=command_path) mail = None output = None if opts.find_arg('--mail'): mail = mailer.mail(opts) # Request these now to generate any errors. from_addr = mail.from_address() smtp_host = mail.smtp_host() to_addr = opts.find_arg('--mail-to') if to_addr: to_addr = to_addr[1] else: to_addr = '*****@*****.**' output = log_capture() report_location = opts.find_arg('--report-path') if report_location is not None: report_location = report_location[1] report_formats = opts.find_arg('--report-format') if report_formats is not None: if len(report_formats) != 2: raise error.general('invalid RTEMS report formats option') report_formats = report_formats[1].split(',') check_report_formats(report_formats, report_location) else: report_formats = [] log.notice('RTEMS Testing - Tester, %s' % (version.string())) if opts.find_arg('--list-bsps'): bsps.list(opts) exe_filter = opts.find_arg('--filter') if exe_filter: exe_filter = exe_filter[1] else: exe_filter = default_exefilter opts.log_info() log.output('Host: ' + host.label(mode='all')) executables = find_executables(opts.params(), exe_filter) debug_trace = opts.find_arg('--debug-trace') if debug_trace: if len(debug_trace) != 1: debug_trace = debug_trace[1] else: raise error.general( 'no debug flags, can be: console,gdb,output,cov') else: debug_trace = '' opts.defaults['exe_trace'] = debug_trace job_trace = 'jobs' in debug_trace.split(',') rtems_tools = opts.find_arg('--rtems-tools') if rtems_tools is not None: if len(rtems_tools) != 2: raise error.general('invalid RTEMS tools option') rtems_tools = rtems_tools[1] bsp = opts.find_arg('--rtems-bsp') if bsp is None or len(bsp) != 2: raise error.general('RTEMS BSP not provided or an invalid option') bsp = config.load(bsp[1], opts) bsp_config = opts.defaults.expand(opts.defaults['tester']) coverage_enabled = opts.find_arg('--coverage') if coverage_enabled: cov_trace = 'cov' in debug_trace.split(',') if len(coverage_enabled) == 2: coverage_runner = coverage.coverage_run( opts.defaults, executables, rtems_tools, symbol_set=coverage_enabled[1], trace=cov_trace) else: coverage_runner = coverage.coverage_run(opts.defaults, executables, rtems_tools, trace=cov_trace) log_mode = opts.find_arg('--log-mode') if log_mode: if log_mode[1] != 'failures' and \ log_mode[1] != 'all' and \ log_mode[1] != 'none': raise error.general('invalid report mode') log_mode = log_mode[1] else: log_mode = 'failures' if len(executables) == 0: raise error.general('no executables supplied') start_time = datetime.datetime.now() total = len(executables) reports = report.report(total) reporting = 1 jobs = int(opts.jobs(opts.defaults['_ncpus'])) exe = 0 finished = [] if jobs > len(executables): jobs = len(executables) while exe < total or len(tests) > 0: if exe < total and len(tests) < jobs: tst = test_run(exe + 1, total, reports, executables[exe], rtems_tools, bsp, bsp_config, opts) exe += 1 tests += [tst] if job_trace: _job_trace(tst, 'create', total, exe, tests, reporting) tst.run() else: dead = [t for t in tests if not t.is_alive()] tests[:] = [t for t in tests if t not in dead] for tst in dead: if job_trace: _job_trace(tst, 'dead', total, exe, tests, reporting) finished += [tst] tst.reraise() del dead if len(tests) >= jobs or exe >= total: time.sleep(0.250) if len(finished): reporting = report_finished(reports, log_mode, reporting, finished, job_trace) finished_time = datetime.datetime.now() reporting = report_finished(reports, log_mode, reporting, finished, job_trace) if reporting < total: log.warning('finished jobs does match: %d' % (reporting)) report_finished(reports, log_mode, -1, finished, job_trace) reports.summary() end_time = datetime.datetime.now() average_time = 'Average test time: %s' % (str( (end_time - start_time) / total)) total_time = 'Testing time : %s' % (str(end_time - start_time)) log.notice(average_time) log.notice(total_time) for report_format in report_formats: report_formatters[report_format]( args, reports, start_time, end_time, total, '.'.join([report_location, report_format])) if mail is not None and output is not None: m_arch = opts.defaults.expand('%{arch}') m_bsp = opts.defaults.expand('%{bsp}') build = ' %s:' % (reports.get_config('build', not_found='')) subject = '[rtems-test] %s/%s:%s %s' % ( m_arch, m_bsp, build, reports.score_card('short')) np = 'Not present in test' ver = reports.get_config('version', not_found=np) build = reports.get_config('build', not_found=np) tools = reports.get_config('tools', not_found=np) body = [ total_time, average_time, '', 'Host', '====', host.label(mode='all'), '', 'Configuration', '=============', 'Version: %s' % (ver), 'Build : %s' % (build), 'Tools : %s' % (tools), '', 'Summary', '=======', '', reports.score_card(), '', reports.failures(), 'Log', '===', '' ] + output.get() mail.send(to_addr, subject, os.linesep.join(body)) if coverage_enabled: coverage_runner.run() except error.general as gerr: print(gerr) sys.exit(1) except error.internal as ierr: print(ierr) sys.exit(1) except error.exit: sys.exit(2) except KeyboardInterrupt: if opts is not None and opts.find_arg('--stacktrace'): print('}} dumping:', threading.active_count()) for t in threading.enumerate(): print('}} ', t.name) print(stacktraces.trace()) log.notice('abort: user terminated') killall(tests) sys.exit(1) finally: console.restore(stdtty) sys.exit(0)
def run(command_path = None): import sys tests = [] stdtty = console.save() opts = None default_exefilter = '*.exe' try: optargs = { '--rtems-tools': 'The path to the RTEMS tools', '--rtems-bsp': 'The RTEMS BSP to run the test on', '--report-mode': 'Reporting modes, failures (default),all,none', '--list-bsps': 'List the supported BSPs', '--debug-trace': 'Debug trace based on specific flags', '--filter': 'Glob that executables must match to run (default: ' + default_exefilter + ')', '--stacktrace': 'Dump a stack trace on a user termination (^C)' } opts = options.load(sys.argv, optargs = optargs, command_path = command_path) log.notice('RTEMS Testing - Tester, v%s' % (version.str())) if opts.find_arg('--list-bsps'): bsps.list(opts) exe_filter = opts.find_arg('--filter') if exe_filter: exe_filter = exe_filter[1] else: exe_filter = default_exefilter opts.log_info() debug_trace = opts.find_arg('--debug-trace') if debug_trace: debug_trace = debug_trace[1] else: debug_trace = '' opts.defaults['debug_trace'] = debug_trace job_trace = 'jobs' in debug_trace.split(',') rtems_tools = opts.find_arg('--rtems-tools') if rtems_tools: if len(rtems_tools) != 2: raise error.general('invalid RTEMS tools option') rtems_tools = rtems_tools[1] else: rtems_tools = '%{_prefix}' bsp = opts.find_arg('--rtems-bsp') if bsp is None or len(bsp) != 2: raise error.general('RTEMS BSP not provided or invalid option') opts.defaults.load('%%{_configdir}/bsps/%s.mc' % (bsp[1])) bsp = opts.defaults.get('%{bsp}') if not bsp: raise error.general('BSP definition (%{bsp}) not found in the global map') bsp = bsp[2] if not opts.defaults.set_read_map(bsp): raise error.general('no BSP map found') bsp_script = opts.defaults.get(bsp) if not bsp_script: raise error.general('BSP script not found: %s' % (bsp)) bsp_config = opts.defaults.expand(opts.defaults[bsp]) report_mode = opts.find_arg('--report-mode') if report_mode: if report_mode[1] != 'failures' and \ report_mode[1] != 'all' and \ report_mode[1] != 'none': raise error.general('invalid report mode') report_mode = report_mode[1] else: report_mode = 'failures' executables = find_executables(opts.params(), exe_filter) if len(executables) == 0: raise error.general('no executables supplied') start_time = datetime.datetime.now() total = len(executables) reports = report.report(total) invalid_tests = opts.defaults['invalid_tests'] if invalid_tests: reports.set_invalid_tests([l.strip() for l in invalid_tests.splitlines()]) reporting = 1 jobs = int(opts.jobs(opts.defaults['_ncpus'])) exe = 0 finished = [] if jobs > len(executables): jobs = len(executables) while exe < total or len(tests) > 0: if exe < total and len(tests) < jobs: tst = test_run(exe + 1, total, reports, executables[exe], rtems_tools, bsp, bsp_config, opts) exe += 1 tests += [tst] if job_trace: _job_trace(tst, 'create', total, exe, tests, reporting) tst.run() else: dead = [t for t in tests if not t.is_alive()] tests[:] = [t for t in tests if t not in dead] for tst in dead: if job_trace: _job_trace(tst, 'dead', total, exe, tests, reporting) finished += [tst] tst.reraise() del dead if len(tests) >= jobs or exe >= total: time.sleep(0.250) if len(finished): reporting = report_finished(reports, report_mode, reporting, finished, job_trace) finished_time = datetime.datetime.now() reporting = report_finished(reports, report_mode, reporting, finished, job_trace) if reporting < total: log.warning('finished jobs does match: %d' % (reporting)) report_finished(reports, report_mode, -1, finished, job_trace) reports.summary() end_time = datetime.datetime.now() log.notice('Average test time: %s' % (str((end_time - start_time) / total))) log.notice('Testing time : %s' % (str(end_time - start_time))) except error.general as gerr: print(gerr) sys.exit(1) except error.internal as ierr: print(ierr) sys.exit(1) except error.exit: sys.exit(2) except KeyboardInterrupt: if opts is not None and opts.find_arg('--stacktrace'): print('}} dumping:', threading.active_count()) for t in threading.enumerate(): print('}} ', t.name) print(stacktraces.trace()) log.notice('abort: user terminated') killall(tests) sys.exit(1) finally: console.restore(stdtty) sys.exit(0)
def run(command_path = None): import sys stdtty = console.save() opts = None try: optargs = { '--rtems-tools': 'The path to the RTEMS tools', '--rtems-bsp': 'The RTEMS BSP to run the test on', '--report-mode': 'Reporting modes, failures (default),all,none', '--list-bsps': 'List the supported BSPs', '--debug-trace': 'Debug trace based on specific flags', '--stacktrace': 'Dump a stack trace on a user termination (^C)' } opts = options.load(sys.argv, optargs = optargs, command_path = command_path) log.notice('RTEMS Testing - Tester, v%s' % (version.str())) if opts.find_arg('--list-bsps'): list_bsps(opts) opts.log_info() debug_trace = opts.find_arg('--debug-trace') if debug_trace: debug_trace = debug_trace[1] else: debug_trace = '' opts.defaults['debug_trace'] = debug_trace job_trace = 'jobs' in debug_trace.split(',') rtems_tools = opts.find_arg('--rtems-tools') if rtems_tools: rtems_tools = rtems_tools[1] bsp = opts.find_arg('--rtems-bsp') if bsp is None: raise error.general('no RTEMS BSP provided') opts.defaults.load('%%{_configdir}/bsps/%s.mc' % (bsp[1])) bsp = opts.defaults.get('%{bsp}') if not bsp: raise error.general('BSP definition (%{bsp}) not found in the global map') bsp = bsp[2] if not opts.defaults.set_read_map(bsp): raise error.general('no BSP map found') bsp_script = opts.defaults.get(bsp) if not bsp_script: raise error.general('BSP script not found: %s' % (bsp)) bsp_config = opts.defaults.expand(opts.defaults[bsp]) report_mode = opts.find_arg('--report-mode') if report_mode: if report_mode[1] != 'failures' and \ report_mode[1] != 'all' and \ report_mode[1] != 'none': raise error.general('invalid report mode') report_mode = report_mode[1] else: report_mode = 'failures' executables = find_executables(opts.params()) if len(executables) == 0: raise error.general('no executbles supplied') start_time = datetime.datetime.now() total = len(executables) reports = report.report(total) invalid_tests = opts.defaults['invalid_tests'] if invalid_tests: reports.set_invalid_tests([l.strip() for l in invalid_tests.splitlines()]) reporting = 1 jobs = int(opts.jobs(opts.defaults['_ncpus'])) exe = 0 tests = [] finished = [] if jobs > len(executables): jobs = len(executables) while exe < total or len(tests) > 0: if exe < total and len(tests) < jobs: tst = test_run(exe + 1, total, reports, executables[exe], rtems_tools, bsp, bsp_config, opts) exe += 1 tests += [tst] if job_trace: _job_trace(tst, 'create', total, exe, tests, reporting) tst.run() else: dead = [t for t in tests if not t.is_alive()] tests[:] = [t for t in tests if t not in dead] for tst in dead: if job_trace: _job_trace(tst, 'dead', total, exe, tests, reporting) finished += [tst] tst.reraise() del dead if len(tests) >= jobs or exe >= total: time.sleep(0.250) if len(finished): reporting = report_finished(reports, report_mode, reporting, finished, job_trace) finished_time = datetime.datetime.now() reporting = report_finished(reports, report_mode, reporting, finished, job_trace) if reporting < total: log.warning('finished jobs does match: %d' % (reporting)) report_finished(reports, report_mode, -1, finished, job_trace) reports.summary() end_time = datetime.datetime.now() log.notice('Testing time: %s' % (str(end_time - start_time))) except error.general, gerr: print gerr sys.exit(1)
def run(command_path=None): import sys tests = [] stdtty = console.save() opts = None default_exefilter = '*.exe' try: optargs = { '--rtems-tools': 'The path to the RTEMS tools', '--rtems-bsp': 'The RTEMS BSP to run the test on', '--report-mode': 'Reporting modes, failures (default),all,none', '--list-bsps': 'List the supported BSPs', '--debug-trace': 'Debug trace based on specific flags', '--filter': 'Glob that executables must match to run (default: ' + default_exefilter + ')', '--stacktrace': 'Dump a stack trace on a user termination (^C)', '--coverage': 'Perform coverage analysis of test exectuables.', '--rtems-builddir': 'The path to the build directory.' } opts = options.load(sys.argv, optargs=optargs, command_path=command_path) log.notice('RTEMS Testing - Tester, %s' % (version.str())) if opts.find_arg('--list-bsps'): bsps.list(opts) exe_filter = opts.find_arg('--filter') if exe_filter: exe_filter = exe_filter[1] else: exe_filter = default_exefilter opts.log_info() debug_trace = opts.find_arg('--debug-trace') if debug_trace: if len(debug_trace) != 1: debug_trace = debug_trace[1] else: raise error.general( 'no debug flags, can be: console,gdb,output') else: debug_trace = '' opts.defaults['debug_trace'] = debug_trace job_trace = 'jobs' in debug_trace.split(',') rtems_tools = opts.find_arg('--rtems-tools') if rtems_tools: if len(rtems_tools) != 2: raise error.general('invalid RTEMS tools option') rtems_tools = rtems_tools[1] else: rtems_tools = '%{_prefix}' bsp = opts.find_arg('--rtems-bsp') if bsp is None or len(bsp) != 2: raise error.general('RTEMS BSP not provided or invalid option') opts.defaults.load('%%{_configdir}/bsps/%s.mc' % (bsp[1])) bsp = opts.defaults.get('%{bsp}') if not bsp: raise error.general( 'BSP definition (%{bsp}) not found in the global map') bsp = bsp[2] if not opts.defaults.set_read_map(bsp): raise error.general('no BSP map found') bsp_script = opts.defaults.get(bsp) if not bsp_script: raise error.general('BSP script not found: %s' % (bsp)) bsp_config = opts.defaults.expand(opts.defaults[bsp]) path_to_builddir = opts.find_arg('--rtems-builddir') if not path_to_builddir: raise error.general('Path to build directory not provided') coverage_enabled = opts.find_arg('--coverage') if coverage_enabled: coverage = prepare_coverage(opts, path_to_builddir[1]) coverage.prepare_environment() report_mode = opts.find_arg('--report-mode') if report_mode: if report_mode[1] != 'failures' and \ report_mode[1] != 'all' and \ report_mode[1] != 'none': raise error.general('invalid report mode') report_mode = report_mode[1] else: report_mode = 'failures' executables = find_executables(opts.params(), exe_filter, path_to_builddir[1]) if len(executables) == 0: raise error.general('no executables supplied') start_time = datetime.datetime.now() total = len(executables) reports = report.report(total) reporting = 1 jobs = int(opts.jobs(opts.defaults['_ncpus'])) exe = 0 finished = [] if jobs > len(executables): jobs = len(executables) while exe < total or len(tests) > 0: if exe < total and len(tests) < jobs: tst = test_run(exe + 1, total, reports, executables[exe], rtems_tools, bsp, bsp_config, opts) exe += 1 tests += [tst] if job_trace: _job_trace(tst, 'create', total, exe, tests, reporting) tst.run() else: dead = [t for t in tests if not t.is_alive()] tests[:] = [t for t in tests if t not in dead] for tst in dead: if job_trace: _job_trace(tst, 'dead', total, exe, tests, reporting) finished += [tst] tst.reraise() del dead if len(tests) >= jobs or exe >= total: time.sleep(0.250) if len(finished): reporting = report_finished(reports, report_mode, reporting, finished, job_trace) finished_time = datetime.datetime.now() reporting = report_finished(reports, report_mode, reporting, finished, job_trace) if reporting < total: log.warning('finished jobs does match: %d' % (reporting)) report_finished(reports, report_mode, -1, finished, job_trace) reports.summary() end_time = datetime.datetime.now() log.notice('Average test time: %s' % (str( (end_time - start_time) / total))) log.notice('Testing time : %s' % (str(end_time - start_time))) if coverage_enabled: coverage_run(opts, coverage, executables) except error.general as gerr: print(gerr) sys.exit(1) except error.internal as ierr: print(ierr) sys.exit(1) except error.exit: sys.exit(2) except KeyboardInterrupt: if opts is not None and opts.find_arg('--stacktrace'): print('}} dumping:', threading.active_count()) for t in threading.enumerate(): print('}} ', t.name) print(stacktraces.trace()) log.notice('abort: user terminated') killall(tests) sys.exit(1) finally: console.restore(stdtty) sys.exit(0)
def run(command_path = None): import sys tests = [] stdtty = console.save() opts = None default_exefilter = '*.exe' try: optargs = { '--rtems-tools': 'The path to the RTEMS tools', '--rtems-bsp': 'The RTEMS BSP to run the test on', '--report-mode': 'Reporting modes, failures (default),all,none', '--list-bsps': 'List the supported BSPs', '--debug-trace': 'Debug trace based on specific flags', '--filter': 'Glob that executables must match to run (default: ' + default_exefilter + ')', '--stacktrace': 'Dump a stack trace on a user termination (^C)', '--rtems-builddir': 'The path to the build directory ( including e.g. /b-leon2/ )'} opts = options.load(sys.argv, optargs = optargs, command_path = command_path) log.notice('RTEMS Testing - Tester, v%s' % (version.str())) if opts.find_arg('--list-bsps'): bsps.list(opts) exe_filter = opts.find_arg('--filter') if exe_filter: exe_filter = exe_filter[1] else: exe_filter = default_exefilter opts.log_info() debug_trace = opts.find_arg('--debug-trace') if debug_trace: debug_trace = debug_trace[1] else: debug_trace = '' opts.defaults['debug_trace'] = debug_trace job_trace = 'jobs' in debug_trace.split(',') rtems_tools = opts.find_arg('--rtems-tools') if rtems_tools: bla = '%{_prefix}' print "prefixx: " + bla if len(rtems_tools) != 2: raise error.general('invalid RTEMS tools option') rtems_tools = rtems_tools[1] else: rtems_tools = '%{_prefix}' bsp = opts.find_arg('--rtems-bsp') if bsp is None or len(bsp) != 2: raise error.general('RTEMS BSP not provided or invalid option') opts.defaults.load('%%{_configdir}/bsps/%s.mc' % (bsp[1])) bsp = opts.defaults.get('%{bsp}') if not bsp: raise error.general('BSP definition (%{bsp}) not found in the global map') bsp = bsp[2] if not opts.defaults.set_read_map(bsp): raise error.general('no BSP map found') bsp_script = opts.defaults.get(bsp) if not bsp_script: raise error.general('BSP script not found: %s' % (bsp)) bsp_config = opts.defaults.expand(opts.defaults[bsp]) path_to_builddir= opts.find_arg('--rtems-builddir') if not path_to_builddir: raise error.general("Path to build directory not provided") coverage_enabled = opts.coverage() if coverage_enabled: import coverage from rtemstoolkit import check log.notice("Coverage analysis requested") opts.defaults.load('%%{_configdir}/coverage.mc') if not check.check_exe('__covoar', opts.defaults['__covoar']): raise error.general("Covoar not found!") coverage = coverage.coverage_run(opts.defaults, path_to_builddir[1]) coverage.prepareEnvironment(); report_mode = opts.find_arg('--report-mode') if report_mode: if report_mode[1] != 'failures' and \ report_mode[1] != 'all' and \ report_mode[1] != 'none': raise error.general('invalid report mode') report_mode = report_mode[1] else: report_mode = 'failures' executables = find_executables(opts.params(), exe_filter, path_to_builddir[1]) if len(executables) == 0: raise error.general('no executables supplied') start_time = datetime.datetime.now() total = len(executables) reports = report.report(total) invalid_tests = opts.defaults['invalid_tests'] if invalid_tests: reports.set_invalid_tests([l.strip() for l in invalid_tests.splitlines()]) reporting = 1 jobs = int(opts.jobs(opts.defaults['_ncpus'])) exe = 0 finished = [] if jobs > len(executables): jobs = len(executables) while exe < total or len(tests) > 0: if exe < total and len(tests) < jobs: tst = test_run(exe + 1, total, reports, executables[exe], rtems_tools, bsp, bsp_config, opts) exe += 1 tests += [tst] if job_trace: _job_trace(tst, 'create', total, exe, tests, reporting) tst.run() else: dead = [t for t in tests if not t.is_alive()] tests[:] = [t for t in tests if t not in dead] for tst in dead: if job_trace: _job_trace(tst, 'dead', total, exe, tests, reporting) finished += [tst] tst.reraise() del dead if len(tests) >= jobs or exe >= total: time.sleep(0.250) if len(finished): reporting = report_finished(reports, report_mode, reporting, finished, job_trace) finished_time = datetime.datetime.now() reporting = report_finished(reports, report_mode, reporting, finished, job_trace) if reporting < total: log.warning('finished jobs does match: %d' % (reporting)) report_finished(reports, report_mode, -1, finished, job_trace) reports.summary() end_time = datetime.datetime.now() log.notice('Average test time: %s' % (str((end_time - start_time) / total))) log.notice('Testing time : %s' % (str(end_time - start_time))) if coverage_enabled: coverage.config_map = opts.defaults.macros['coverage'] coverage.executables = executables print [c for c in coverage.config_map] print [e for e in executables]
def load(self, name): def common_end(left, right): end = '' while len(left) and len(right): if left[-1] != right[-1]: return end end = left[-1] + end left = left[:-1] right = right[:-1] return end if self.load_depth == 0: self.in_error = False self.lc = 0 self.name = name self.conditionals = {} self.load_depth += 1 save_name = self.name save_lc = self.lc self.name = name self.lc = 0 # # Locate the config file. Expand any macros then add the # extension. Check if the file exists, therefore directly # referenced. If not see if the file contains ':' or the path # separator. If it does split the path else use the standard config dir # path in the defaults. # exname = self.expand(name) # # Macro could add an extension. # if exname.endswith('.cfg'): configname = exname else: configname = '%s.cfg' % (exname) name = '%s.cfg' % (name) if ':' in configname: cfgname = path.basename(configname) else: cfgname = common_end(configname, name) if not path.exists(configname): if ':' in configname: configdirs = path.dirname(configname).split(':') else: configdirs = self.define('_configdir').split(':') for cp in configdirs: configname = path.join(path.abspath(cp), cfgname) if path.exists(configname): break configname = None if configname is None: raise error.general('no config file found: %s' % (cfgname)) try: log.trace('config: %s: _open: %s' % (self.init_name, path.host(configname))) config = open(path.host(configname), 'r') except IOError as err: raise error.general('error opening config file: %s' % (path.host(configname))) self.configpath += [configname] self._includes += [configname] try: dir = None info = None data = [] while True: r = self._parse(config, dir, info) if r[0] == 'control': if r[1] == '%end': break log.warning("unexpected '%s'" % (r[1])) elif r[0] == 'directive': if r[1] == '%include': self.load(r[2][0]) continue dir, info, data = self._process_directive(r, dir, info, data) elif r[0] == 'data': dir, info, data = self._process_data(r, dir, info, data) else: self._error("%d: invalid parse state: '%s" % (self.lc, r[0])) if dir is not None: self._directive_extend(dir, data) except: config.close() raise config.close() self.name = save_name self.lc = save_lc self.load_depth -= 1
def _parse(self, config, dir, info, roc = False, isvalid = True): # roc = return on control def _clean(line): line = line[0:-1] b = line.find('#') if b >= 0: line = line[1:b] return line.strip() # # Need to add code to count matching '{' and '}' and if they # do not match get the next line and add to the string until # they match. This closes an opening '{' that is on another # line. # for l in config: self.lc += 1 l = _clean(l) if len(l) == 0: continue log.trace('config: %s: %03d: %s %s' % \ (self.init_name, self.lc, str(isvalid), l)) lo = l if isvalid: l = self._expand(l) if len(l) == 0: continue if l[0] == '%': ls = self.wss.split(l, 2) los = self.wss.split(lo, 2) if ls[0] == '%disable': if isvalid: self._disable(config, ls) elif ls[0] == '%select': if isvalid: self._select(config, ls) elif ls[0] == '%error': if isvalid: return ('data', ['%%error %s' % (self._name_line_msg(l[7:]))]) elif ls[0] == '%warning': if isvalid: return ('data', ['%%warning %s' % (self._name_line_msg(l[9:]))]) elif ls[0] == '%define' or ls[0] == '%global': if isvalid: self._define(config, ls) elif ls[0] == '%undefine': if isvalid: self._undefine(config, ls) elif ls[0] == '%if': d = self._if(config, ls, isvalid, dir, info) if len(d): log.trace('config: %s: %%if: %s' % (self.init_name, d)) return ('data', d) elif ls[0] == '%ifn': d = self._if(config, ls, isvalid, dir, info, True) if len(d): log.trace('config: %s: %%ifn: %s' % (self.init_name, d)) return ('data', d) elif ls[0] == '%ifos': d = self._ifos(config, ls, isvalid, dir, info) if len(d): return ('data', d) elif ls[0] == '%ifarch': d = self._ifarch(config, True, ls, isvalid, dir, info) if len(d): return ('data', d) elif ls[0] == '%ifnarch': d = self._ifarch(config, False, ls, isvalid, dir, info) if len(d): return ('data', d) elif ls[0] == '%endif': if roc: return ('control', '%endif', '%endif') log.warning("unexpected '" + ls[0] + "'") elif ls[0] == '%else': if roc: return ('control', '%else', '%else') log.warning("unexpected '" + ls[0] + "'") elif ls[0].startswith('%defattr'): return ('data', [l]) elif ls[0] == '%bcond_with': if isvalid: # # Check if already defined. Would be by the command line or # even a host specific default. # if self._label('with_' + ls[1]) not in self.macros: self._define(config, (ls[0], 'without_' + ls[1])) elif ls[0] == '%bcond_without': if isvalid: if self._label('without_' + ls[1]) not in self.macros: self._define(config, (ls[0], 'with_' + ls[1])) else: pt = self._parse_token(lo, los, l, ls) if pt is not None: return pt if self.ignores is not None: for r in self.ignores: if r.match(ls[0]) is not None: return ('data', [l]) if isvalid: for d in self.directives: if ls[0].strip() == d: return ('directive', ls[0].strip(), ls[1:]) log.warning("unknown directive: '" + ls[0] + "'") return ('data', [lo]) else: return ('data', [lo]) return ('control', '%end', '%end')
def copy_tree(src, dst): trace = False hsrc = host(src) hdst = host(dst) if exists(hsrc): if isdir(hsrc): names = listdir(hsrc) else: names = [basename(hsrc)] hsrc = dirname(hsrc) else: names = [] if trace: print('path.copy_tree:') print(' src: "%s"' % (src)) print(' hsrc: "%s"' % (hsrc)) print(' dst: "%s"' % (dst)) print(' hdst: "%s"' % (hdst)) print(' names: %r' % (names)) if not os.path.isdir(hdst): if trace: print(' mkdir: %s' % (hdst)) try: os.makedirs(hdst) except OSError as why: raise error.general('copying tree: cannot create target directory %s: %s' % \ (hdst, str(why))) for name in names: srcname = host(os.path.join(hsrc, name)) dstname = host(os.path.join(hdst, name)) try: if os.path.islink(srcname): linkto = os.readlink(srcname) if exists(shell(dstname)): if os.path.islink(dstname): dstlinkto = os.readlink(dstname) if linkto != dstlinkto: log.warning('copying tree: link does not match: %s -> %s' % \ (dstname, dstlinkto)) os.remove(dstname) else: log.warning('copying tree: destination is not a link: %s' % \ (dstname)) os.remove(dstname) else: os.symlink(linkto, dstname) elif os.path.isdir(srcname): copy_tree(srcname, dstname) else: shutil.copyfile(host(srcname), host(dstname)) shutil.copystat(host(srcname), host(dstname)) except shutil.Error as err: raise error.general('copying tree (2): %s -> %s: %s' % \ (hsrc, hdst, str(err))) except EnvironmentError as why: raise error.general('copying tree (3): %s -> %s: %s' % \ (srcname, dstname, str(why))) try: shutil.copystat(hsrc, hdst) except OSError as why: if windows: if WindowsError is not None and isinstance(why, WindowsError): pass else: raise error.general('copying tree (4): %s -> %s: %s' % (hsrc, hdst, str(why)))
def _expand(self, s): expand_count = 0 expanded = True while expanded: expand_count += 1 if expand_count > 500: raise error.general('macro expand looping: %s' % (s)) expanded = False ms = self._macro_split(s) for m in ms: mn = m # # A macro can be '%{macro}' or '%macro'. Turn the later into # the former. # show_warning = True if mn[1] != '{': if self.ignores is not None: for r in self.ignores: if r.match(mn) is not None: mn = None break else: mn = self._label(mn[1:]) show_warning = False else: mn = self._label(mn[1:]) show_warning = False elif m.startswith('%{expand'): colon = m.find(':') if colon < 8: log.warning('malformed expand macro, no colon found') else: e = self._expand(m[colon + 1:-1].strip()) s = s.replace(m, e) expanded = True mn = None elif m.startswith('%{with '): # # Change the ' ' to '_' because the macros have no spaces. # n = self._label('with_' + m[7:-1].strip()) if n in self.macros: s = s.replace(m, '1') else: s = s.replace(m, '0') expanded = True mn = None elif m.startswith('%{echo'): if not m.endswith('}'): log.warning("malformed conditional macro '%s'" % (m)) mn = None else: e = self._expand(m[6:-1].strip()) log.output('%s' % (self._name_line_msg(e))) s = '' expanded = True mn = None elif m.startswith('%{defined'): n = self._label(m[9:-1].strip()) if n in self.macros: s = s.replace(m, '1') else: s = s.replace(m, '0') expanded = True mn = None elif m.startswith('%{?') or m.startswith('%{!?'): if m[2] == '!': start = 4 else: start = 3 colon = m[start:].find(':') if colon < 0: if not m.endswith('}'): log.warning("malformed conditional macro '%s'" % (m)) mn = None else: mn = self._label(m[start:-1]) else: mn = self._label(m[start:start + colon]) if mn: if m.startswith('%{?'): istrue = False if mn in self.macros: # If defined and 0 then it is false. istrue = _check_bool(self.macros[mn]) if istrue is None: istrue = True if colon >= 0 and istrue: s = s.replace(m, m[start + colon + 1:-1]) expanded = True mn = None elif not istrue: mn = '%{nil}' else: isfalse = True if mn in self.macros: istrue = _check_bool(self.macros[mn]) if istrue is None or istrue == True: isfalse = False if colon >= 0 and isfalse: s = s.replace(m, m[start + colon + 1:-1]) expanded = True mn = None else: mn = '%{nil}' if mn: if mn.lower() in self.macros: s = s.replace(m, self.macros[mn.lower()]) expanded = True elif show_warning: self._error("macro '%s' not found" % (mn)) return self._shell(s)