def test_basic(self):
cmd = [
sys.executable, '-c',
'import sys; import time; time.sleep(0.02); print "stdout"; sys.stdout.flush(); print >>sys.stderr, "stderr"'
]
host = SystemHost()
factory = PortFactory(host)
port = factory.get()
now = time.time()
proc = server_process.ServerProcess(port, 'python', cmd)
proc.write('')
self.assertEquals(proc.poll(), None)
self.assertFalse(proc.has_crashed())
# check that doing a read after an expired deadline returns
# nothing immediately.
line = proc.read_stdout_line(now - 1)
self.assertEquals(line, None)
line = proc.read_stdout_line(now + 1.0)
self.assertEquals(line.strip(), "stdout")
line = proc.read_stderr_line(now + 1.0)
self.assertEquals(line.strip(), "stderr")
proc.stop()
def test_basic(self):
cmd = [
sys.executable, '-c',
'import sys; import time; time.sleep(0.02); print "stdout"; sys.stdout.flush(); print >>sys.stderr, "stderr"'
]
host = SystemHost()
factory = PortFactory(host)
port = factory.get()
now = time.time()
proc = server_process.ServerProcess(port, 'python', cmd)
proc.write('')
self.assertEquals(proc.poll(), None)
self.assertFalse(proc.has_crashed())
# check that doing a read after an expired deadline returns
# nothing immediately.
line = proc.read_stdout_line(now - 1)
self.assertEquals(line, None)
# FIXME: This part appears to be flaky. line should always be non-None.
# FIXME: https://bugs.webkit.org/show_bug.cgi?id=88280
line = proc.read_stdout_line(now + 1.0)
if line:
self.assertEquals(line.strip(), "stdout")
line = proc.read_stderr_line(now + 1.0)
if line:
self.assertEquals(line.strip(), "stderr")
proc.stop(0)
def start(self):
server_name = self._port.driver_name()
environment = self._port.setup_environ_for_server(server_name)
environment['DYLD_FRAMEWORK_PATH'] = self._port._build_path()
# FIXME: We're assuming that WebKitTestRunner checks this DumpRenderTree-named environment variable.
environment['DUMPRENDERTREE_TEMP'] = str(self._driver_tempdir)
self._server_process = server_process.ServerProcess(
self._port, server_name, self.cmd_line(), environment)
def _start_image_diff_process(self, expected_contents, actual_contents, tolerance=None):
command = self._image_diff_command(tolerance)
environment = self.setup_environ_for_server('ImageDiff')
process = server_process.ServerProcess(self, 'ImageDiff', command, environment)
process.write('Content-Length: %d\n%sContent-Length: %d\n%s' % (
len(actual_contents), actual_contents,
len(expected_contents), expected_contents))
return process
def _android_server_process_constructor(port, server_name, cmd_line, env=None, more_logging=False):
# We need universal_newlines=True, because 'adb shell' for some unknown reason
# does newline conversion of unix-style LF into win-style CRLF (and we need
# to convert that back). This can cause headaches elsewhere because
# server_process' stdout and stderr are now unicode file-like objects,
# not binary file-like objects like all of the other ports are.
# FIXME: crbug.com/496983.
return server_process.ServerProcess(port, server_name, cmd_line, env,
universal_newlines=True, treat_no_data_as_crash=True, more_logging=more_logging)
def _android_server_process_constructor(port,
server_name,
cmd_line,
env=None):
return server_process.ServerProcess(port,
server_name,
cmd_line,
env,
universal_newlines=True,
treat_no_data_as_crash=True)
def start(self):
command = []
# FIXME: We should not be grabbing at self._port._options.wrapper directly.
command += self._command_wrapper(self._port._options.wrapper)
command += [self._port._path_to_driver(), '-']
if self._image_path:
command.append('--pixel-tests')
environment = os.environ
environment['DYLD_FRAMEWORK_PATH'] = self._port._build_path()
self._server_process = server_process.ServerProcess(
self._port, "DumpRenderTree", command, environment)
def _android_server_process_constructor(port,
server_name,
cmd_line,
env=None,
more_logging=False):
return server_process.ServerProcess(port,
server_name,
cmd_line,
env,
treat_no_data_as_crash=True,
more_logging=more_logging)
def _start(self, pixel_tests, per_test_args):
server_name = self._port.driver_name()
environment = self._port.setup_environ_for_server(server_name)
environment['DYLD_LIBRARY_PATH'] = self._port._build_path()
environment['DYLD_FRAMEWORK_PATH'] = self._port._build_path()
# FIXME: We're assuming that WebKitTestRunner checks this DumpRenderTree-named environment variable.
environment['DUMPRENDERTREE_TEMP'] = str(self._driver_tempdir)
environment['LOCAL_RESOURCE_ROOT'] = self._port.layout_tests_dir()
self._crashed_process_name = None
self._crashed_pid = None
self._server_process = server_process.ServerProcess(
self._port, server_name, self.cmd_line(pixel_tests, per_test_args),
environment)
def _diff_image_request(self, expected_filename, actual_filename, tolerance):
command = [self._path_to_image_diff(), '--tolerance', str(tolerance)]
sp = server_process.ServerProcess(self, 'ImageDiff', command)
actual_length = os.stat(actual_filename).st_size
with open(actual_filename) as file:
actual_file = file.read()
expected_length = os.stat(expected_filename).st_size
with open(expected_filename) as file:
expected_file = file.read()
sp.write('Content-Length: %d\n%sContent-Length: %d\n%s' %
(actual_length, actual_file, expected_length, expected_file))
return sp
def _start_image_diff_process(self, expected_contents, actual_contents):
# FIXME: There needs to be a more sane way of handling default
# values for options so that you can distinguish between a default
# value of None and a default value that wasn't set.
if self.get_option('tolerance') is not None:
tolerance = self.get_option('tolerance')
else:
tolerance = 0.1
command = [self._path_to_image_diff(), '--tolerance', str(tolerance)]
process = server_process.ServerProcess(self, 'ImageDiff', command)
process.write('Content-Length: %d\n%sContent-Length: %d\n%s' %
(len(actual_contents), actual_contents,
len(expected_contents), expected_contents))
return process
def start(self):
display_id = self._worker_number + 1
run_xvfb = [
"Xvfb",
":%d" % (display_id), "-screen", "0", "800x600x24", "-nolisten",
"tcp"
]
devnull = open(os.devnull, 'w')
self._xvfb_process = subprocess.Popen(run_xvfb, stderr=devnull)
devnull.close()
server_name = self._port.driver_name()
environment = self._port.setup_environ_for_server(server_name)
# We must do this here because the DISPLAY number depends on _worker_number
environment['DISPLAY'] = ":%d" % (display_id)
self._server_process = server_process.ServerProcess(
self._port, server_name, self.cmd_line(), environment)
def _diff_image_request(self, expected_filename, actual_filename):
# FIXME: either expose the tolerance argument as a command-line
# parameter, or make it go away and aways use exact matches.
command = [self._path_to_image_diff(), '--tolerance', '0.1']
sp = server_process.ServerProcess(self, 'ImageDiff', command)
actual_length = os.stat(actual_filename).st_size
with open(actual_filename) as file:
actual_file = file.read()
expected_length = os.stat(expected_filename).st_size
with open(expected_filename) as file:
expected_file = file.read()
sp.write('Content-Length: %d\n%sContent-Length: %d\n%s' %
(actual_length, actual_file, expected_length, expected_file))
return sp
def start(self):
environment = self._port.setup_environ_for_server()
environment['DYLD_FRAMEWORK_PATH'] = self._port._build_path()
environment['DUMPRENDERTREE_TEMP'] = str(self._driver_tempdir)
self._server_process = server_process.ServerProcess(self._port,
"DumpRenderTree", self.cmd_line(), environment)
def _start_once(self, pixel_tests, per_test_args):
super(ChromiumAndroidDriver, self)._start(pixel_tests, per_test_args)
self._port._run_adb_command(['logcat', '-c'])
self._port._run_adb_command(
['shell', 'echo'] +
self._drt_cmd_line(pixel_tests, per_test_args) +
['>', COMMAND_LINE_FILE])
start_result = self._port._run_adb_command([
'shell', 'am', 'start', '-e', 'RunInSubThread', '-n',
DRT_ACTIVITY_FULL_NAME
])
if start_result.find('Exception') != -1:
_log.error(
'Failed to start DumpRenderTree application. Exception:\n' +
start_result)
return False
seconds = 0
while (not self._file_exists_on_device(self._in_fifo_path)
or not self._file_exists_on_device(self._out_fifo_path)
or not self._file_exists_on_device(self._err_fifo_path)):
time.sleep(1)
seconds += 1
if seconds >= DRT_START_STOP_TIMEOUT_SECS:
return False
# Read back the shell prompt to ensure adb shell ready.
deadline = time.time() + DRT_START_STOP_TIMEOUT_SECS
self._server_process.start()
self._read_prompt(deadline)
_log.debug('Interactive shell started')
# Start a process to read from the stdout fifo of the DumpRenderTree app and print to stdout.
_log.debug('Redirecting stdout to ' + self._out_fifo_path)
self._read_stdout_process = server_process.ServerProcess(
self._port,
'ReadStdout',
self._port._adb_command + ['shell', 'cat', self._out_fifo_path],
universal_newlines=True)
self._read_stdout_process.start()
# Start a process to read from the stderr fifo of the DumpRenderTree app and print to stdout.
_log.debug('Redirecting stderr to ' + self._err_fifo_path)
self._read_stderr_process = server_process.ServerProcess(
self._port,
'ReadStderr',
self._port._adb_command + ['shell', 'cat', self._err_fifo_path],
universal_newlines=True)
self._read_stderr_process.start()
_log.debug('Redirecting stdin to ' + self._in_fifo_path)
self._server_process.write('cat >%s\n' % self._in_fifo_path)
# Combine the stdout and stderr pipes into self._server_process.
self._server_process.replace_outputs(
self._read_stdout_process._proc.stdout,
self._read_stderr_process._proc.stdout)
# Start a thread to kill the pipe reading/writing processes on deadlock of the fifos during startup.
normal_startup_event = threading.Event()
threading.Thread(target=self._deadlock_detector,
args=([
self._server_process, self._read_stdout_process,
self._read_stderr_process
], normal_startup_event)).start()
output = ''
line = self._server_process.read_stdout_line(deadline)
while not self._server_process.timed_out and not self.has_crashed(
) and line.rstrip() != '#READY':
output += line
line = self._server_process.read_stdout_line(deadline)
if self._server_process.timed_out and not self.has_crashed():
# DumpRenderTree crashes during startup, or when the deadlock detector detected
# deadlock and killed the fifo reading/writing processes.
_log.error('Failed to start DumpRenderTree: \n%s' % output)
return False
else:
# Inform the deadlock detector that the startup is successful without deadlock.
normal_startup_event.set()
return True