| #!/usr/bin/env python |
| # Copyright (C) 2010 Google Inc. All rights reserved. |
| # |
| # Redistribution and use in source and binary forms, with or without |
| # modification, are permitted provided that the following conditions are |
| # met: |
| # |
| # * Redistributions of source code must retain the above copyright |
| # notice, this list of conditions and the following disclaimer. |
| # * Redistributions in binary form must reproduce the above |
| # copyright notice, this list of conditions and the following disclaimer |
| # in the documentation and/or other materials provided with the |
| # distribution. |
| # * Neither the Google name nor the names of its |
| # contributors may be used to endorse or promote products derived from |
| # this software without specific prior written permission. |
| # |
| # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
| # "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
| # LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
| # A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
| # OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| # SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
| # LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| |
| """WebKit Mac implementation of the Port interface.""" |
| |
| import fcntl |
| import os |
| import pdb |
| import platform |
| import select |
| import signal |
| import subprocess |
| import sys |
| import time |
| import webbrowser |
| |
| import base |
| |
| import webkitpy |
| from webkitpy import executive |
| |
| class MacPort(base.Port): |
| """WebKit Mac implementation of the Port class.""" |
| |
| def __init__(self, port_name=None, options=None): |
| if port_name is None: |
| port_name = 'mac' + self.version() |
| base.Port.__init__(self, port_name, options) |
| self._cached_build_root = None |
| |
| def baseline_search_path(self): |
| dirs = [] |
| if self._name == 'mac-tiger': |
| dirs.append(self._webkit_baseline_path(self._name)) |
| if self._name in ('mac-tiger', 'mac-leopard'): |
| dirs.append(self._webkit_baseline_path('mac-leopard')) |
| if self._name in ('mac-tiger', 'mac-leopard', 'mac-snowleopard'): |
| dirs.append(self._webkit_baseline_path('mac-snowleopard')) |
| dirs.append(self._webkit_baseline_path('mac')) |
| return dirs |
| |
| def check_sys_deps(self): |
| # FIXME: This should run build-dumprendertree. |
| # This should also validate that all of the tool paths are valid. |
| return True |
| |
| def num_cores(self): |
| return int(os.popen2("sysctl -n hw.ncpu")[1].read()) |
| |
| def results_directory(self): |
| return ('/tmp/run-chromium-webkit-tests-' + |
| self._options.results_directory) |
| |
| def setup_test_run(self): |
| # This port doesn't require any specific configuration. |
| pass |
| |
| def show_results_html_file(self, results_filename): |
| uri = self.filename_to_uri(results_filename) |
| webbrowser.open(uri, new=1) |
| |
| def start_driver(self, image_path, options): |
| """Starts a new Driver and returns a handle to it.""" |
| return MacDriver(self, image_path, options) |
| |
| def start_helper(self): |
| # This port doesn't use a helper process. |
| pass |
| |
| def stop_helper(self): |
| # This port doesn't use a helper process. |
| pass |
| |
| def test_base_platform_names(self): |
| # At the moment we don't use test platform names, but we have |
| # to return something. |
| return ('mac',) |
| |
| def test_expectations(self): |
| # |
| # The WebKit mac port uses 'Skipped' files at the moment. Each |
| # file contains a list of files or directories to be skipped during |
| # the test run. The total list of tests to skipped is given by the |
| # contents of the generic Skipped file found in platform/X plus |
| # a version-specific file found in platform/X-version. Duplicate |
| # entries are allowed. This routine reads those files and turns |
| # contents into the format expected by test_expectations. |
| expectations = [] |
| skipped_files = [] |
| if self._name in ('mac-tiger', 'mac-leopard', 'mac-snowleopard'): |
| skipped_files.append(os.path.join( |
| self._webkit_baseline_path(self._name), 'Skipped')) |
| skipped_files.append(os.path.join(self._webkit_baseline_path('mac'), |
| 'Skipped')) |
| for filename in skipped_files: |
| if os.path.exists(filename): |
| f = file(filename) |
| for l in f.readlines(): |
| l = l.strip() |
| if not l.startswith('#') and len(l): |
| l = 'BUG_SKIPPED SKIP : ' + l + ' = FAIL' |
| if l not in expectations: |
| expectations.append(l) |
| f.close() |
| |
| # TODO - figure out how to check for these dynamically |
| expectations.append('BUG_SKIPPED SKIP : fast/wcss = FAIL') |
| expectations.append('BUG_SKIPPED SKIP : fast/xhtmlmp = FAIL') |
| expectations.append('BUG_SKIPPED SKIP : http/tests/wml = FAIL') |
| expectations.append('BUG_SKIPPED SKIP : mathml = FAIL') |
| expectations.append('BUG_SKIPPED SKIP : platform/chromium = FAIL') |
| expectations.append('BUG_SKIPPED SKIP : platform/gtk = FAIL') |
| expectations.append('BUG_SKIPPED SKIP : platform/qt = FAIL') |
| expectations.append('BUG_SKIPPED SKIP : platform/win = FAIL') |
| expectations.append('BUG_SKIPPED SKIP : wml = FAIL') |
| |
| # TODO - figure out how to handle webarchive tests |
| expectations.append('BUG_SKIPPED SKIP : webarchive = PASS') |
| expectations.append('BUG_SKIPPED SKIP : svg/webarchive = PASS') |
| expectations.append('BUG_SKIPPED SKIP : http/tests/webarchive = PASS') |
| expectations.append('BUG_SKIPPED SKIP : svg/custom/' |
| 'image-with-prefix-in-webarchive.svg = PASS') |
| |
| expectations_str = '\n'.join(expectations) |
| return expectations_str |
| |
| def test_platform_name(self): |
| # At the moment we don't use test platform names, but we have |
| # to return something. |
| return 'mac' |
| |
| def test_platform_names(self): |
| # At the moment we don't use test platform names, but we have |
| # to return something. |
| return ('mac',) |
| |
| def version(self): |
| os_version_string = platform.mac_ver()[0] # e.g. "10.5.6" |
| if not os_version_string: |
| return '-leopard' |
| release_version = int(os_version_string.split('.')[1]) |
| if release_version == 4: |
| return '-tiger' |
| elif release_version == 5: |
| return '-leopard' |
| elif release_version == 6: |
| return '-snowleopard' |
| return '' |
| |
| # |
| # PROTECTED METHODS |
| # |
| |
| def _build_path(self, *comps): |
| if not self._cached_build_root: |
| self._cached_build_root = executive.run_command(["webkit-build-directory", "--base"]).rstrip() |
| return os.path.join(self._cached_build_root, self._options.target, *comps) |
| |
| def _kill_process(self, pid): |
| """Forcefully kill the process. |
| |
| Args: |
| pid: The id of the process to be killed. |
| """ |
| os.kill(pid, signal.SIGKILL) |
| |
| def _kill_all_process(self, process_name): |
| # On Mac OS X 10.6, killall has a new constraint: -SIGNALNAME or |
| # -SIGNALNUMBER must come first. Example problem: |
| # $ killall -u $USER -TERM lighttpd |
| # killall: illegal option -- T |
| # Use of the earlier -TERM placement is just fine on 10.5. |
| null = open(os.devnull) |
| subprocess.call(['killall', '-TERM', '-u', os.getenv('USER'), |
| process_name], stderr=null) |
| null.close() |
| |
| def _path_to_apache(self): |
| return '/usr/sbin/httpd' |
| |
| def _path_to_apache_config_file(self): |
| return os.path.join(self.layout_tests_dir(), 'http', 'conf', |
| 'apache2-httpd.conf') |
| |
| def _path_to_driver(self): |
| return self._build_path('DumpRenderTree') |
| |
| def _path_to_helper(self): |
| return None |
| |
| def _path_to_image_diff(self): |
| return self._build_path('image_diff') # FIXME: This is wrong and should be "ImageDiff", but having the correct path causes other parts of the script to hang. |
| |
| def _path_to_wdiff(self): |
| return 'wdiff' # FIXME: This does not exist on a default Mac OS X Leopard install. |
| |
| def _shut_down_http_server(self, server_pid): |
| """Shut down the lighttpd web server. Blocks until it's fully |
| shut down. |
| |
| Args: |
| server_pid: The process ID of the running server. |
| """ |
| # server_pid is not set when "http_server.py stop" is run manually. |
| if server_pid is None: |
| # TODO(mmoss) This isn't ideal, since it could conflict with |
| # lighttpd processes not started by http_server.py, |
| # but good enough for now. |
| self._kill_all_process('httpd') |
| else: |
| try: |
| os.kill(server_pid, signal.SIGTERM) |
| # TODO(mmoss) Maybe throw in a SIGKILL just to be sure? |
| except OSError: |
| # Sometimes we get a bad PID (e.g. from a stale httpd.pid |
| # file), so if kill fails on the given PID, just try to |
| # 'killall' web servers. |
| self._shut_down_http_server(None) |
| |
| |
| class MacDriver(base.Driver): |
| """implementation of the DumpRenderTree interface.""" |
| |
| def __init__(self, port, image_path, driver_options): |
| self._port = port |
| self._driver_options = driver_options |
| self._target = port._options.target |
| self._image_path = image_path |
| self._stdout_fd = None |
| self._cmd = None |
| self._env = None |
| self._proc = None |
| self._read_buffer = '' |
| |
| cmd = [] |
| # Hook for injecting valgrind or other runtime instrumentation, |
| # used by e.g. tools/valgrind/valgrind_tests.py. |
| wrapper = os.environ.get("BROWSER_WRAPPER", None) |
| if wrapper != None: |
| cmd += [wrapper] |
| if self._port._options.wrapper: |
| # This split() isn't really what we want -- it incorrectly will |
| # split quoted strings within the wrapper argument -- but in |
| # practice it shouldn't come up and the --help output warns |
| # about it anyway. |
| cmd += self._options.wrapper.split() |
| # FIXME: Using arch here masks any possible file-not-found errors from a non-existant driver executable. |
| cmd += ['arch', '-i386', port._path_to_driver(), '-'] |
| if not self._port._options.no_pixel_tests: |
| cmd.append('--pixel-tests') |
| |
| #if driver_options: |
| # cmd += driver_options |
| env = os.environ |
| env['DYLD_FRAMEWORK_PATH'] = self._port._build_path() |
| self._cmd = cmd |
| self._env = env |
| self.restart() |
| |
| def poll(self): |
| return self._proc.poll() |
| |
| def restart(self): |
| self.stop() |
| self._proc = subprocess.Popen(self._cmd, stdin=subprocess.PIPE, |
| stdout=subprocess.PIPE, |
| stderr=subprocess.PIPE, |
| env=self._env) |
| |
| def returncode(self): |
| return self._proc.returncode |
| |
| def run_test(self, uri, timeoutms, image_hash): |
| output = [] |
| error = [] |
| image = '' |
| crash = False |
| timeout = False |
| actual_uri = None |
| actual_image_hash = None |
| |
| if uri.startswith("file:///"): |
| cmd = uri[7:] |
| else: |
| cmd = uri |
| |
| if image_hash: |
| cmd += "'" + image_hash |
| cmd += "\n" |
| |
| self._proc.stdin.write(cmd) |
| self._stdout_fd = self._proc.stdout.fileno() |
| fl = fcntl.fcntl(self._stdout_fd, fcntl.F_GETFL) |
| fcntl.fcntl(self._stdout_fd, fcntl.F_SETFL, fl | os.O_NONBLOCK) |
| |
| stop_time = time.time() + (int(timeoutms) / 1000.0) |
| resp = '' |
| (timeout, line) = self._read_line(timeout, stop_time) |
| resp += line |
| have_seen_content_type = False |
| while not timeout and line.rstrip() != "#EOF": |
| # Make sure we haven't crashed. |
| if line == '' and self.poll() is not None: |
| # This is hex code 0xc000001d, which is used for abrupt |
| # termination. This happens if we hit ctrl+c from the prompt |
| # and we happen to be waiting on the test_shell. |
| # sdoyon: Not sure for which OS and in what circumstances the |
| # above code is valid. What works for me under Linux to detect |
| # ctrl+c is for the subprocess returncode to be negative |
| # SIGINT. And that agrees with the subprocess documentation. |
| if (-1073741510 == self.returncode() or |
| - signal.SIGINT == self.returncode()): |
| raise KeyboardInterrupt |
| crash = True |
| break |
| |
| elif (line.startswith('Content-Type:') and not |
| have_seen_content_type): |
| have_seen_content_type = True |
| pass |
| else: |
| output.append(line) |
| |
| (timeout, line) = self._read_line(timeout, stop_time) |
| resp += line |
| |
| # Now read a second block of text for the optional image data |
| image_length = 0 |
| (timeout, line) = self._read_line(timeout, stop_time) |
| resp += line |
| HASH_HEADER = 'ActualHash: ' |
| LENGTH_HEADER = 'Content-Length: ' |
| while not timeout and not crash and line.rstrip() != "#EOF": |
| if line == '' and self.poll() is not None: |
| if (-1073741510 == self.returncode() or |
| - signal.SIGINT == self.returncode()): |
| raise KeyboardInterrupt |
| crash = True |
| break |
| elif line.startswith(HASH_HEADER): |
| actual_image_hash = line[len(HASH_HEADER):].strip() |
| elif line.startswith('Content-Type:'): |
| pass |
| elif line.startswith(LENGTH_HEADER): |
| image_length = int(line[len(LENGTH_HEADER):]) |
| elif image_length: |
| image += line |
| |
| (timeout, line) = self._read_line(timeout, stop_time, image_length) |
| resp += line |
| |
| if timeout: |
| self.restart() |
| |
| if self._image_path and len(self._image_path): |
| image_file = file(self._image_path, "wb") |
| image_file.write(image) |
| image_file.close() |
| |
| return (crash, timeout, actual_image_hash, |
| ''.join(output), ''.join(error)) |
| pass |
| |
| def stop(self): |
| if self._proc: |
| self._proc.stdin.close() |
| self._proc.stdout.close() |
| if self._proc.stderr: |
| self._proc.stderr.close() |
| if (sys.platform not in ('win32', 'cygwin') and |
| not self._proc.poll()): |
| # Closing stdin/stdout/stderr hangs sometimes on OS X. |
| null = open(os.devnull, "w") |
| subprocess.Popen(["kill", "-9", |
| str(self._proc.pid)], stderr=null) |
| null.close() |
| |
| def _read_line(self, timeout, stop_time, image_length=0): |
| now = time.time() |
| read_fds = [] |
| |
| # first check to see if we have a line already read or if we've |
| # read the entire image |
| if image_length and len(self._read_buffer) >= image_length: |
| out = self._read_buffer[0:image_length] |
| self._read_buffer = self._read_buffer[image_length:] |
| return (timeout, out) |
| |
| idx = self._read_buffer.find('\n') |
| if not image_length and idx != -1: |
| out = self._read_buffer[0:idx + 1] |
| self._read_buffer = self._read_buffer[idx + 1:] |
| return (timeout, out) |
| |
| # If we've timed out, return just what we have, if anything |
| if timeout or now >= stop_time: |
| out = self._read_buffer |
| self._read_buffer = '' |
| return (True, out) |
| |
| (read_fds, write_fds, err_fds) = select.select( |
| [self._stdout_fd], [], [], stop_time - now) |
| try: |
| if timeout or len(read_fds) == 1: |
| self._read_buffer += self._proc.stdout.read() |
| except IOError, e: |
| read = [] |
| return self._read_line(timeout, stop_time) |
