def _run_single_test(self, binary_name, test):
server_process = ServerProcess(
self._port,
binary_name,
Runner.command_for_port(self._port, [
self._port._build_path(binary_name),
'--gtest_filter={}'.format(test)
]),
env=self._port.environment_for_api_tests())
status = Runner.STATUS_RUNNING
if test.split('.')[1].startswith(
'DISABLED_') and not self._port.get_option('force'):
status = Runner.STATUS_DISABLED
try:
deadline = time.time() + self._timeout
if status != Runner.STATUS_DISABLED:
server_process.start()
stdout_buffer = ''
stderr_buffer = ''
while status == Runner.STATUS_RUNNING:
stdout_line, stderr_line = server_process.read_either_stdout_or_stderr_line(
deadline)
if not stderr_line and not stdout_line:
break
if stderr_line:
stderr_buffer += stderr_line
self.post('log', output=stderr_line[:-1])
if stdout_line:
if '**PASS**' in stdout_line:
status = Runner.STATUS_PASSED
elif '**FAIL**' in stdout_line:
status = Runner.STATUS_FAILED
else:
stdout_buffer += stdout_line
self.post('log', output=stdout_line[:-1])
if status == Runner.STATUS_DISABLED:
pass
elif server_process.timed_out:
status = Runner.STATUS_TIMEOUT
elif server_process.has_crashed():
status = Runner.STATUS_CRASHED
elif status == Runner.STATUS_RUNNING:
status = Runner.STATUS_FAILED
finally:
remaining_stderr = server_process.pop_all_buffered_stderr()
remaining_stdout = server_process.pop_all_buffered_stdout()
self.post('log', output=remaining_stderr + remaining_stdout)
output_buffer = stderr_buffer + stdout_buffer + remaining_stderr + remaining_stdout
server_process.stop()
self.post('ended_test', '{}.{}'.format(binary_name, test), status,
self._filter_noisy_output(output_buffer))
def _run_single_test(self, binary_name, test):
server_process = ServerProcess(
self._port,
binary_name,
Runner.command_for_port(self._port, [
self._port._build_path(binary_name),
'--gtest_filter={}'.format(test)
]),
env=self._port.environment_for_api_tests())
try:
deadline = time.time() + self._timeout
server_process.start()
if not test.split('.')[1].startswith('DISABLED_'):
stdout_line = server_process.read_stdout_line(deadline)
else:
stdout_line = None
if not stdout_line and server_process.timed_out:
status = Runner.STATUS_TIMEOUT
elif not stdout_line and server_process.has_crashed():
status = Runner.STATUS_CRASHED
elif not stdout_line:
status = Runner.STATUS_DISABLED
elif '**PASS**' in stdout_line:
status = Runner.STATUS_PASSED
else:
status = Runner.STATUS_FAILED
finally:
output_buffer = server_process.pop_all_buffered_stdout(
) + server_process.pop_all_buffered_stderr()
server_process.stop()
self._caller.post('ended_test', '{}.{}'.format(binary_name, test),
status, self._filter_noisy_output(output_buffer))
def _run_shard_with_binary(self, binary_name, tests):
remaining_tests = list(tests)
# Try to run the shard in a single process.
while remaining_tests and not self._port.get_option('run_singly'):
starting_length = len(remaining_tests)
server_process = ServerProcess(
self._port,
binary_name,
Runner.command_for_port(self._port, [
self._port._build_path(binary_name),
'--gtest_filter={}'.format(':'.join(remaining_tests))
]),
env=self._port.environment_for_api_tests())
try:
deadline = time.time() + self._timeout
last_test = None
last_status = None
stdout_buffer = ''
server_process.start()
while remaining_tests:
stdout = server_process.read_stdout_line(deadline)
# If we've triggered a timeout, we don't know which test caused it. Break out and run singly.
if stdout is None and server_process.timed_out:
break
if stdout is None and server_process.has_crashed():
# It's possible we crashed before printing anything.
if last_status == Runner.STATUS_PASSED:
last_test = None
else:
last_status = Runner.STATUS_CRASHED
break
assert stdout is not None
stdout_split = stdout.rstrip().split(' ')
if len(stdout_split) != 2 or not (
stdout_split[0].startswith('**')
and stdout_split[0].endswith('**')):
stdout_buffer += stdout
continue
if last_test is not None:
remaining_tests.remove(last_test)
self.post('ended_test',
'{}.{}'.format(binary_name, last_test),
last_status, stdout_buffer)
deadline = time.time() + self._timeout
stdout_buffer = ''
if '**PASS**' == stdout_split[0]:
last_status = Runner.STATUS_PASSED
else:
last_status = Runner.STATUS_FAILED
last_test = stdout_split[1]
# We assume that stderr is only relevant if there is a crash (meaning we triggered an assert)
if last_test:
remaining_tests.remove(last_test)
stdout_buffer += server_process.pop_all_buffered_stdout()
stderr_buffer = server_process.pop_all_buffered_stderr(
) if last_status == Runner.STATUS_CRASHED else ''
self.post('log', output=stdout_buffer + stderr_buffer)
self.post(
'ended_test', '{}.{}'.format(binary_name, last_test),
last_status,
self._filter_noisy_output(stdout_buffer +
stderr_buffer))
if server_process.timed_out:
break
# If we weren't able to determine the results for any tests, we need to run what remains singly.
if starting_length == len(remaining_tests):
break
finally:
server_process.stop()
# Now, just try and run the rest of the tests singly.
for test in remaining_tests:
self._run_single_test(binary_name, test)
def __init__(self, sock, type):
self.socket = sock
self._file = os.fdopen(sock.fileno(), type, 0)
ServerProcess._set_file_nonblocking(self._file)
def _run_single_test(self, binary_name, test):
server_process = ServerProcess(
self._port,
binary_name,
Runner.command_for_port(self._port, [
self._port._build_path(binary_name),
'--gtest_filter={}'.format(test)
]),
env=self._port.environment_for_api_tests())
status = Runner.STATUS_RUNNING
if test.split('.')[1].startswith(
'DISABLED_') and not self._port.get_option('force'):
status = Runner.STATUS_DISABLED
stdout_buffer = ''
stderr_buffer = ''
try:
deadline = time.time() + self._timeout
if status != Runner.STATUS_DISABLED:
server_process.start()
while status == Runner.STATUS_RUNNING:
stdout_line, stderr_line = server_process.read_either_stdout_or_stderr_line(
deadline)
if not stderr_line and not stdout_line:
break
if stderr_line:
stderr_line = string_utils.decode(stderr_line,
target_type=str)
stderr_buffer += stderr_line
_log.error(stderr_line[:-1])
if stdout_line:
stdout_line = string_utils.decode(stdout_line,
target_type=str)
if '**PASS**' in stdout_line:
status = Runner.STATUS_PASSED
elif '**FAIL**' in stdout_line:
status = Runner.STATUS_FAILED
else:
stdout_buffer += stdout_line
_log.error(stdout_line[:-1])
if status == Runner.STATUS_DISABLED:
pass
elif server_process.timed_out:
status = Runner.STATUS_TIMEOUT
elif server_process.has_crashed():
status = Runner.STATUS_CRASHED
elif status == Runner.STATUS_RUNNING:
status = Runner.STATUS_FAILED
finally:
remaining_stderr = string_utils.decode(
server_process.pop_all_buffered_stderr(), target_type=str)
remaining_stdout = string_utils.decode(
server_process.pop_all_buffered_stdout(), target_type=str)
for line in (remaining_stdout +
remaining_stderr).splitlines(False):
_log.error(line)
output_buffer = stderr_buffer + stdout_buffer + remaining_stderr + remaining_stdout
server_process.stop()
TaskPool.Process.queue.send(
TaskPool.Task(
report_result,
None,
TaskPool.Process.name,
'{}.{}'.format(binary_name, test),
status,
self._filter_noisy_output(output_buffer),
))