def open(self, command, executable,
output, gdb_console, script = None, tty = None,
timeout = 300):
self._lock('_open')
try:
cmds = execute.arg_list(command) + ['-i=mi',
'--nx',
'--quiet']
if tty:
cmds += ['--tty=%s' % tty]
if executable:
cmds += [executable]
self.output = output
self.gdb_console = gdb_console
self.script = script
self.running = False
self.process = execute.execute(output = self._reader,
input = self._writer,
cleanup = self._cleanup)
finally:
self._unlock('_open')
try:
self.gdb_console('gdb: %s' % (' '.join(cmds)))
ec, proc = self.process.open(cmds, timeout = (timeout, self._timeout))
if self.trace:
print 'gdb done', ec
if ec > 0:
raise error.general('gdb exec: %s' % (os.strerror(ec)))
except:
raise
self._lock('_open')
try:
self.process = None
finally:
self._unlock('_open')
def open(self, command, executable,
output, gdb_console, script = None, tty = None,
timeout = 300):
self._lock('_open')
try:
cmds = execute.arg_list(command) + ['-i=mi',
'--nx',
'--quiet']
if tty:
cmds += ['--tty=%s' % tty]
if executable:
cmds += [executable]
self.output = output
self.gdb_console = gdb_console
self.script = script
self.running = False
self.process = execute.execute(output = self._reader,
input = self._writer,
cleanup = self._cleanup)
finally:
self._unlock('_open')
try:
self.gdb_console('gdb: %s' % (' '.join(cmds)))
ec, proc = self.process.open(cmds, timeout = (timeout, self._timeout))
if self.trace:
print('gdb done', ec)
if ec > 0:
raise error.general('gdb exec: %s: %s' % (cmds[0], os.strerror(ec)))
except:
raise
self._lock('_open')
try:
self.process = None
finally:
self._unlock('_open')
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 run(self, set_name, covoar_config_file, symbol_file, gcnos_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)):
log.stderr("Symbol set file: " + symbol_file +
" doesn't exists! Covoar can not be run!")
log.stderr("Skipping " + set_name)
return
command = "covoar -v -C" + covoar_config_file + " -S " + symbol_file + " -O " + covoar_result_dir + " " + path.join(
self.traces_dir, "*.exe")
if (path.exists(gcnos_file)):
command = command + " -g " + gcnos_file
log.notice("Running covoar for " + set_name, stdout_only=True)
log.notice(command, stdout_only=True)
executor = execute.execute(verbose=True, output=output_handler)
exit_code = executor.shell(command, cwd=os.getcwd())
shutil.copy2(path.join(self.covoar_src_dir, 'table.js'),
path.join(covoar_result_dir, 'table.js'))
shutil.copy2(path.join(self.covoar_src_dir, 'covoar.css'),
path.join(covoar_result_dir, 'covoar.css'))
log.notice("Coverage run for " + set_name + " finished ")
status = "success"
if (exit_code[0] != 0):
status = "failure. Error code: " + str(exit_code[0])
log.notice("Coverage run for " + set_name + " finished " + status)
log.notice("-----------------------------------------------")
def run(self, setName, covoarConfigFile, symbolFile):
covoarResultDir = path.join(self.baseResultDir, setName)
if (not path.exists(covoarResultDir)):
path.mkdir(covoarResultDir)
if (not path.exists(symbolFile)):
log.stderr("Symbol set file: " + symbolFile + " doesn't exists! Covoar can not be run!")
log.stderr("Skipping " + setName)
return
command = "covoar -C" + covoarConfigFile + " -S " + symbolFile + " -O " + covoarResultDir + " " + path.join(self.tracesDir, "*.exe")
log.notice("Running covoar for " + setName, stdout_only=True)
log.notice(command, stdout_only=True)
executor = execute.execute(verbose=True, output=output_handler)
exit_code = executor.shell(command, cwd=os.getcwd())
shutil.copy2(path.join(self.covoarSrcDir, 'table.js'), path.join(covoarResultDir, 'table.js'))
shutil.copy2(path.join(self.covoarSrcDir, 'covoar.css'), path.join(covoarResultDir, 'covoar.css'))
log.notice("Coverage run for " + setName + " finished ")
status = "success"
if (exit_code[0] != 0):
status = "failure. Error code: " + str(exit_code[0])
log.notice("Coverage run for " + setName + " finished " + status)
log.notice("-----------------------------------------------")
def open(self,
command,
executable,
output,
gdb_console,
timeout,
script=None,
tty=None):
self._lock('_open')
self.timeout = timeout[2]
self.test_too_long = timeout[3]
try:
cmds = execute.arg_list(command) + ['-i=mi', '--nx', '--quiet']
if tty:
cmds += ['--tty=%s' % tty]
if executable:
cmds += [executable]
self.output = output
self.gdb_console = gdb_console
self.script = script
self.process = execute.execute(output=self._reader,
input=self._writer,
cleanup=self._cleanup)
exec_thread = threading.Thread(target=self._execute_gdb,
args=[cmds])
exec_thread.start()
self._monitor(timeout)
if self.ecode is not None and self.ecode > 0:
raise error.general('gdb exec: %s: %s' %
(cmds[0], os.strerror(self.ecode)))
finally:
self._unlock('_open')
def _dir_execute(self, data, total, index, exe, bsp_arch, bsp):
self.process = execute.execute(output = self.capture)
if not self.in_error:
if self.console:
self.console.open()
self.capture_console('run: %s' % (' '.join(data)))
ec, proc = self.process.open(data,
timeout = (int(self.expand('%{timeout}')),
self._timeout))
if ec > 0:
self._lock()
self._error('execute failed: %s: exit-code:%d' % (' '.join(data), ec))
self._unlock()
if self.console:
self.console.close()
def _dir_execute(self, data, total, index, exe, bsp_arch, bsp):
self.process = execute.execute(output = self.capture)
if not self.in_error:
if self.console:
self.console.open()
self.capture_console('run: %s' % (' '.join(data)))
ec, proc = self.process.open(data,
timeout = (int(self.expand('%{timeout}')),
self._timeout))
self._lock()
if ec > 0:
self._error('execute failed: %s: exit-code:%d' % (' '.join(data), ec))
elif self.timedout:
self.process.kill()
self._unlock()
if self.console:
self.console.close()
def run(self, symbol_file):
if not path.exists(symbol_file):
raise error.general('coverage: no symbol set file: %s'% (symbol_file))
exe = self._find_covoar()
# The order of these arguments matters. Command line options must come
# before the executable path arguments because covoar uses getopt() to
# process the command line options.
command = exe + ' -O ' + self.base_result_dir + \
' -p ' + self.project_name + \
' ' + self.covoar_cmd + ' '
command += self.executables
log.notice()
log.notice('Running coverage analysis (%s)' % (self.base_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 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(
'symbol set file: coverage/%s.symcfg was not created for covoar, skipping %s'
% (symbol_file, set_name))
command = ('covoar -S ' + symbol_file + ' -O ' + covoar_result_dir +
' -f' + self.simulator_format + ' -T' + self.target_arch +
' -E' + self.explanations_txt + ' -c' +
self.coverage_extension + ' -e' +
self.executable_extension + ' -p' + self.project_name +
' ' + self.executables)
log.notice('Running covoar for %s' % (set_name))
executor = execute.execute(verbose=True, output=self.output_handler)
exit_code = executor.shell(command, cwd=os.getcwd())
if (exit_code[0] != 0):
raise error.general('covoar failure exit code: %d' %
(exit_code[0]))
log.notice('Coverage run for %s finished successfully.' % (set_name))
log.notice('-----------------------------------------------')
