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)
