')\
+len('
') \
: file_data.find('' + symbol_set)
with open(html_file, 'w') as f:
f.write(file_data)
class build_path_generator(object):
'''
Generates the build path from the path to executables
'''
def __init__(self, executables, target):
self.executables = executables
self.target = target
def run(self):
build_path = '/'
path_ = self.executables[0].split('/')
for p in path_:
if p == self.target:
break
else:
build_path = path.join(build_path, p)
return build_path
class symbol_parser(object):
'''
Parse the symbol sets ini and create custom ini file for covoar
'''
def __init__(self,
symbol_config_path,
symbol_select_path,
symbol_set,
build_dir,
bsp_name,
target):
self.symbol_select_file = symbol_select_path
self.symbol_file = symbol_config_path
self.build_dir = build_dir
self.symbol_sets = {}
self.symbol_set = symbol_set
self.ssets = []
self.bsp_name = bsp_name
self.target = target
def parse(self):
config = configparser.ConfigParser()
try:
config.read(self.symbol_file)
if self.symbol_set is not None:
self.ssets = self.symbol_set.split(',')
else:
self.ssets = config.get('symbol-sets', 'sets').split(',')
for sset in self.ssets:
lib = path.join(self.build_dir, config.get('libraries', sset))
self.symbol_sets[sset] = lib
ss = self.symbol_sets[sset]
ss = ss.replace('@BSP@', self.bsp_name)
ss = ss.replace('@BUILD-TARGET@', self.target)
self.symbol_sets[sset] = ss
return self.ssets
except:
raise error.general('Symbol set parsing failed for %s' % (sset))
def write_ini(self, symbol_set):
config = configparser.ConfigParser()
try:
sset = symbol_set
config.add_section('symbol-sets')
config.set('symbol-sets', 'sets', sset)
config.add_section(sset)
object_files = [o for o in path.listdir(self.symbol_sets[sset]) if o[-1] == 'o']
object_paths = []
for o in object_files:
object_paths.append(path.join(self.symbol_sets[sset], o))
config.set(sset, 'libraries', ','.join(object_paths))
with open(self.symbol_select_file, 'w') as conf:
config.write(conf)
except:
raise error.general('symbol parser write failed for %s' % (sset))
class covoar(object):
'''
Covoar runner
'''
def __init__(self,
base_result_dir,
config_dir,
executables,
trace,
prefix,
covoar_cmd):
self.base_result_dir = base_result_dir
self.config_dir = config_dir
self.executables = ' '.join(executables)
self.project_name = 'RTEMS-' + str(version.version())
self.trace = trace
self.prefix = prefix
self.covoar_cmd = covoar_cmd
def _find_covoar(self):
covoar_exe = 'covoar'
tester_dir = path.dirname(path.abspath(sys.argv[0]))
base = path.dirname(tester_dir)
exe = path.join(self.prefix, 'share', 'rtems', 'tester', 'bin', covoar_exe)
if path.isfile(exe):
return exe
exe = path.join(base, 'build', 'tester', 'covoar', covoar_exe)
if path.isfile(exe):
return exe
raise error.general('coverage: %s not found'% (covoar_exe))
def run(self, set_name, symbol_file):
covoar_result_dir = path.join(self.base_result_dir, set_name)
if not path.exists(covoar_result_dir):
path.mkdir(covoar_result_dir)
if not path.exists(symbol_file):
raise error.general('coverage: no symbol set file: %s'% (symbol_file))
exe = self._find_covoar()
command = exe + ' -O ' + covoar_result_dir + \
' -p ' + self.project_name + \
' ' + self.executables + ' '
command += self.covoar_cmd
log.notice()
log.notice('Running coverage analysis: %s (%s)' % (set_name, covoar_result_dir))
start_time = datetime.datetime.now()
executor = execute.execute(verbose = self.trace, output = self.output_handler)
exit_code = executor.shell(command, cwd=os.getcwd())
if exit_code[0] != 0:
raise error.general('coverage: covoar failure:: %d' % (exit_code[0]))
end_time = datetime.datetime.now()
log.notice('Coverage time: %s' % (str(end_time - start_time)))
def output_handler(self, text):
log.output('%s' % (text))
class coverage_run(object):
'''
Coverage analysis support for rtems-test
'''
def __init__(self, macros_, executables, prefix, symbol_set = None, trace = False):
'''
Constructor
'''
self.trace = trace
self.macros = macros_
self.build_dir = self.macros['_cwd']
self.test_dir = path.join(self.build_dir, self.macros['bsp'] + '-coverage')
if not path.exists(self.test_dir):
path.mkdir(self.test_dir)
self.rtdir = path.abspath(self.macros['_rtdir'])
self.rtscripts = self.macros.expand(self.macros['_rtscripts'])
self.coverage_config_path = path.join(self.rtscripts, 'coverage')
self.symbol_config_path = path.join(self.coverage_config_path,
'symbol-sets.ini')
self.symbol_select_path = self.macros.expand(self.macros['bsp_symbol_path'])
self.executables = executables
self.symbol_sets = []
self.no_clean = int(self.macros['_no_clean'])
self.report_format = self.macros['cov_report_format']
self.symbol_set = symbol_set
self.target = self.macros['target']
self.bsp_name = self.macros['bsp'].split('-')[0]
self.prefix = prefix
self.macros.define('coverage')
self.covoar_cmd = self.macros.expand(self.macros['bsp_covoar_cmd'])
def run(self):
try:
if self.executables is None:
raise error.general('no test executables provided.')
build_dir = build_path_generator(self.executables, self.target).run()
parser = symbol_parser(self.symbol_config_path,
self.symbol_select_path,
self.symbol_set,
build_dir,
self.bsp_name,
self.target)
symbol_sets = parser.parse()
for sset in symbol_sets:
parser.write_ini(sset)
covoar_runner = covoar(self.test_dir,
self.symbol_select_path,
self.executables,
self.trace,
self.prefix,
self.covoar_cmd)
covoar_runner.run(sset, self.symbol_select_path)
self._generate_reports(symbol_sets);
self._summarize();
finally:
self._cleanup();
def _generate_reports(self, symbol_sets):
log.notice('Coverage generating reports')
if self.report_format == 'html':
report = report_gen_html(symbol_sets,
self.build_dir,
self.rtdir,
self.macros['bsp'])
report.generate()
report.add_covoar_css()
report.add_dir_name()
def _cleanup(self):
if not self.no_clean:
if self.trace:
log.output('Coverage cleaning tempfiles')
for exe in self.executables:
trace_file = exe + '.cov'
if path.exists(trace_file):
os.remove(trace_file)
os.remove(self.symbol_select_path)
def _summarize(self):
log.notice('Coverage analysis finished: %s' % (self.build_dir))