Changeset 90076 in webkit


Ignore:
Timestamp:
Jun 29, 2011 6:11:42 PM (13 years ago)
Author:
commit-queue@webkit.org
Message:

2011-06-29 Sheriff Bot <webkit.review.bot@gmail.com>

Unreviewed, rolling out r90070.
http://trac.webkit.org/changeset/90070
https://bugs.webkit.org/show_bug.cgi?id=63676

Broke test-webkitpy rebaseline tests (Requested by eseidel2 on
#webkit).

  • Scripts/webkitpy/layout_tests/port/base.py:
  • Scripts/webkitpy/layout_tests/port/chromium.py:
  • Scripts/webkitpy/layout_tests/port/chromium_linux.py:
  • Scripts/webkitpy/layout_tests/port/chromium_mac.py:
  • Scripts/webkitpy/layout_tests/port/chromium_win.py:
  • Scripts/webkitpy/layout_tests/port/gtk.py:
  • Scripts/webkitpy/layout_tests/port/mac.py:
  • Scripts/webkitpy/layout_tests/port/mac_unittest.py:
  • Scripts/webkitpy/layout_tests/port/qt.py:
  • Scripts/webkitpy/layout_tests/port/webkit.py:
  • Scripts/webkitpy/layout_tests/port/webkit_unittest.py:
  • Scripts/webkitpy/layout_tests/port/win.py:
  • Scripts/webkitpy/tool/commands/rebaselineserver_unittest.py:
Location:
trunk/Tools
Files:
14 edited

Legend:

Unmodified
Added
Removed
  • trunk/Tools/ChangeLog

    r90074 r90076  
     12011-06-29  Sheriff Bot  <webkit.review.bot@gmail.com>
     2
     3        Unreviewed, rolling out r90070.
     4        http://trac.webkit.org/changeset/90070
     5        https://bugs.webkit.org/show_bug.cgi?id=63676
     6
     7        Broke test-webkitpy rebaseline tests (Requested by eseidel2 on
     8        #webkit).
     9
     10        * Scripts/webkitpy/layout_tests/port/base.py:
     11        * Scripts/webkitpy/layout_tests/port/chromium.py:
     12        * Scripts/webkitpy/layout_tests/port/chromium_linux.py:
     13        * Scripts/webkitpy/layout_tests/port/chromium_mac.py:
     14        * Scripts/webkitpy/layout_tests/port/chromium_win.py:
     15        * Scripts/webkitpy/layout_tests/port/gtk.py:
     16        * Scripts/webkitpy/layout_tests/port/mac.py:
     17        * Scripts/webkitpy/layout_tests/port/mac_unittest.py:
     18        * Scripts/webkitpy/layout_tests/port/qt.py:
     19        * Scripts/webkitpy/layout_tests/port/webkit.py:
     20        * Scripts/webkitpy/layout_tests/port/webkit_unittest.py:
     21        * Scripts/webkitpy/layout_tests/port/win.py:
     22        * Scripts/webkitpy/tool/commands/rebaselineserver_unittest.py:
     23
    1242011-06-29  Adam Barth  <abarth@webkit.org>
    225
  • trunk/Tools/Scripts/webkitpy/layout_tests/port/base.py

    r90070 r90076  
    6767
    6868class DummyOptions(object):
    69     """Fake implementation of optparse.Values. Cloned from webkitpy.tool.mocktool.MockOptions."""
     69    """Fake implementation of optparse.Values. Cloned from
     70    webkitpy.tool.mocktool.MockOptions.
     71
     72    """
    7073
    7174    def __init__(self, **kwargs):
     
    7982
    8083
    81 # FIXME: This class should merge with webkitpy.common.config.ports.
     84# FIXME: This class should merge with webkitpy.webkit_port at some point.
    8285class Port(object):
    8386    """Abstract class for Port-specific hooks for the layout_test package."""
    84 
    85     port_name = None  # Subclasses override this
    8687
    8788    def __init__(self, port_name=None, options=None,
     
    9192                 config=None,
    9293                 **kwargs):
     94        self._name = port_name
    9395
    9496        # These are default values that should be overridden in a subclasses.
    95         self._name = port_name or self.port_name  # Subclasses may append a -VERSION (like mac-leopard) or other qualifiers.
     97        # FIXME: These should really be passed in.
    9698        self._operating_system = 'mac'
    9799        self._version = ''
     
    111113        self._helper = None
    112114        self._http_server = None
     115        self._webkit_base_dir = None
    113116        self._websocket_server = None
    114         self._http_lock = None  # FIXME: Why does this live on the port object?
     117        self._http_lock = None
    115118
    116119        # Python's Popen has a bug that causes any pipes opened to a
     
    130133
    131134        # FIXME: prettypatch.py knows this path, why is it copied here?
    132         self._pretty_patch_path = self.path_from_webkit_base("Websites", "bugs.webkit.org", "PrettyPatch", "prettify.rb")
     135        self._pretty_patch_path = self.path_from_webkit_base("Websites",
     136            "bugs.webkit.org", "PrettyPatch", "prettify.rb")
    133137        self._pretty_patch_available = None
    134138
    135139        self.set_option_default('configuration', self.default_configuration())
    136         self._test_configuration = None  # FIXME: This does not belong on the real object.
     140        self._test_configuration = None
    137141        self._multiprocessing_is_available = (multiprocessing is not None)
    138142        self._results_directory = None
     
    150154
    151155    def default_child_processes(self):
    152         """Return the number of DumpRenderTree instances to use for this port."""
     156        """Return the number of DumpRenderTree instances to use for this
     157        port."""
    153158        return self._executive.cpu_count()
    154159
     
    159164
    160165    def baseline_path(self):
    161         """Return the absolute path to the directory to store new baselines in for this port."""
    162         baseline_search_paths = self.get_option('additional_platform_directory', []) + self.baseline_search_path()
     166        """Return the absolute path to the directory to store new baselines
     167        in for this port."""
     168        baseline_search_paths = \
     169            self.get_option('additional_platform_directory', []) + self.baseline_search_path()
    163170        return baseline_search_paths[0]
    164171
     
    241248
    242249    def compare_audio(self, expected_audio, actual_audio):
    243         # FIXME: If we give this method a better name it won't need this docstring (e.g. are_audio_results_equal()).
    244250        """Return whether the two audio files are *not* equal."""
    245251        return expected_audio != actual_audio
    246252
    247     def diff_image(self, expected_contents, actual_contents, diff_filename=None, tolerance=0):
     253    def diff_image(self, expected_contents, actual_contents,
     254                   diff_filename=None, tolerance=0):
    248255        """Compare two images and produce a delta image file.
    249256
     
    327334        baselines = []
    328335        for platform_dir in baseline_search_path:
    329             if self.path_exists(self._filesystem.join(platform_dir, baseline_filename)):
     336            if self.path_exists(self._filesystem.join(platform_dir,
     337                                                      baseline_filename)):
    330338                baselines.append((platform_dir, baseline_filename))
    331339
     
    364372        the other baseline and filename manipulation routines.
    365373        """
    366         # FIXME: The [0] here is very mysterious, as is the destructured return.
    367         platform_dir, baseline_filename = self.expected_baselines(filename, suffix)[0]
     374        platform_dir, baseline_filename = self.expected_baselines(
     375            filename, suffix)[0]
    368376        if platform_dir:
    369377            return self._filesystem.join(platform_dir, baseline_filename)
     
    449457
    450458    def test_dirs(self):
    451         """Returns the list of top-level test directories."""
     459        """Returns the list of top-level test directories.
     460
     461        Used by --clobber-old-results."""
    452462        layout_tests_dir = self.layout_tests_dir()
    453463        return filter(lambda x: self._filesystem.isdir(self._filesystem.join(layout_tests_dir, x)),
     
    530540
    531541    def name(self):
    532         """Returns a name that uniquely identifies this particular type of port
    533         (e.g., "mac-snowleopard" or "chromium-gpu-linux-x86_x64" and can be passed
    534         to factory.get() to instantiate the port."""
     542        """Return the name of the port (e.g., 'mac', 'chromium-win-xp')."""
    535543        return self._name
    536 
    537     def real_name(self):
    538         # FIXME: Seems this is only used for MockDRT and should be removed.
    539         """Returns the name of the port as passed to the --platform command line argument."""
    540         return self.name()
    541544
    542545    def operating_system(self):
     
    565568    def architecture(self):
    566569        return self._architecture
     570
     571    def real_name(self):
     572        """Returns the actual name of the port, not the delegate's."""
     573        return self.name()
    567574
    568575    def get_option(self, name, default_value=None):
     
    635642
    636643    def create_driver(self, worker_number):
    637         """Return a newly created base.Driver subclass for starting/stopping the test driver."""
     644        """Return a newly created base.Driver subclass for starting/stopping
     645        the test driver."""
    638646        raise NotImplementedError('Port.create_driver')
    639647
     
    869877
    870878    def _path_to_image_diff(self):
    871         """Returns the full path to the image_diff binary, or None if it is not available.
     879        """Returns the full path to the image_diff binary, or None if it
     880        is not available.
    872881
    873882        This is likely used only by diff_image()"""
  • trunk/Tools/Scripts/webkitpy/layout_tests/port/chromium.py

    r90070 r90076  
    5454
    5555
     56# FIXME: This function doesn't belong in this package.
    5657class ChromiumPort(base.Port):
    5758    """Abstract base class for Chromium implementations of the Port class."""
    58 
    59     port_name = "chromium"
    60 
    6159    ALL_BASELINE_VARIANTS = [
    6260        'chromium-mac-snowleopard', 'chromium-mac-leopard',
     
    349347
    350348class ChromiumDriver(base.Driver):
     349    """Abstract interface for DRT."""
     350
    351351    def __init__(self, port, worker_number):
    352352        self._port = port
  • trunk/Tools/Scripts/webkitpy/layout_tests/port/chromium_linux.py

    r90070 r90076  
    4949        port_name = port_name or 'chromium-linux'
    5050        chromium.ChromiumPort.__init__(self, port_name=port_name, **kwargs)
     51
    5152        # We re-set the port name once the base object is fully initialized
    5253        # in order to be able to find the DRT binary properly.
  • trunk/Tools/Scripts/webkitpy/layout_tests/port/chromium_mac.py

    r90070 r90076  
    7777            self._name = port_name + '-' + self._version
    7878        else:
    79             self._version = port_name[port_name.index('-mac-') + len('-mac-'):]
     79            self._version = port_name[port_name.index('-mac-') + 5:]
    8080            assert self._version in self.SUPPORTED_OS_VERSIONS
    8181        self._operating_system = 'mac'
  • trunk/Tools/Scripts/webkitpy/layout_tests/port/chromium_win.py

    r90070 r90076  
    7575            self._name = port_name + '-' + self._version
    7676        else:
    77             self._version = port_name[port_name.index('-win-') + len('-win-'):]
    78             assert self._version in self.SUPPORTED_VERSIONS, "%s is not in %s" % (self._version, self.SUPPORTED_VERSIONS)
     77            self._version = port_name[port_name.index('-win-') + 5:]
     78            assert self._version in self.SUPPORTED_VERSIONS
     79
    7980        self._operating_system = 'win'
    8081
  • trunk/Tools/Scripts/webkitpy/layout_tests/port/gtk.py

    r90070 r90076  
    4040
    4141class GtkDriver(webkit.WebKitDriver):
     42    """WebKit Gtk implementation of the Driver class."""
     43
    4244    def start(self):
    4345        display_id = self._worker_number + 1
     
    5658
    5759class GtkPort(webkit.WebKitPort):
    58     port_name = "gtk"
     60    """WebKit Gtk implementation of the Port class."""
     61
     62    def __init__(self, **kwargs):
     63        kwargs.setdefault('port_name', 'gtk')
     64        webkit.WebKitPort.__init__(self, **kwargs)
    5965
    6066    def create_driver(self, worker_number):
     
    6369    def _path_to_apache_config_file(self):
    6470        # FIXME: This needs to detect the distribution and change config files.
    65         return self._filesystem.join(self.layout_tests_dir(), 'http', 'conf', 'apache2-debian-httpd.conf')
     71        return self._filesystem.join(self.layout_tests_dir(), 'http', 'conf',
     72                                     'apache2-debian-httpd.conf')
    6673
    6774    def _path_to_driver(self):
     
    6976
    7077    def check_build(self, needs_http):
    71         return self._check_driver()
     78        if not self._check_driver():
     79            return False
     80        return True
    7281
    7382    def _path_to_apache(self):
     
    8392            config_name = 'apache2-debian-httpd.conf'
    8493
    85         return self._filesystem.join(self.layout_tests_dir(), 'http', 'conf', config_name)
     94        return self._filesystem.join(self.layout_tests_dir(), 'http', 'conf',
     95                            config_name)
    8696
    8797    def _path_to_wdiff(self):
     
    106116                return full_library
    107117
     118        return None
     119
    108120    def _runtime_feature_list(self):
    109121        return None
  • trunk/Tools/Scripts/webkitpy/layout_tests/port/mac.py

    r90070 r90076  
    4949        5: 'leopard',
    5050        6: 'snowleopard',
    51         # Add 7: 'lion' here?
    5251    }
    5352    assert release_version >= min(version_strings.keys())
     
    5958
    6059class MacPort(WebKitPort):
    61     port_name = "mac"
    62 
     60    """WebKit Mac implementation of the Port class."""
    6361    # FIXME: 'wk2' probably shouldn't be a version, it should probably be
    6462    # a modifier, like 'chromium-gpu' is to 'chromium'.
     
    6967        'snowleopard': ['mac-snowleopard', 'mac'],
    7068        'future': ['mac'],
    71         # FIXME: This isn't quite right for wk2, it should include mac-VERSION as well.
    7269        'wk2': ['mac-wk2', 'mac'],
    7370    }
     
    8077            self._name = port_name + '-' + self._version
    8178        else:
    82             assert port_name.startswith('mac')
    83             self._version = port_name[len('mac-'):]
    84             assert self._version in self.SUPPORTED_VERSIONS, "%s is not in %s" % (self._version, self.SUPPORTED_VERSIONS)
     79            self._version = port_name[4:]
     80            assert self._version in self.SUPPORTED_VERSIONS
    8581        self._operating_system = 'mac'
    8682        if not hasattr(self._options, 'time-out-ms') or self._options.time_out_ms is None:
     
    9995        return map(self._webkit_baseline_path, self.FALLBACK_PATHS[self._version])
    10096
     97    def path_to_test_expectations_file(self):
     98        return self.path_from_webkit_base('LayoutTests', 'platform',
     99           'mac', 'test_expectations.txt')
     100
    101101    def is_crash_reporter(self, process_name):
    102102        return re.search(r'ReportCrash', process_name)
     103
     104    def _skipped_file_paths(self):
     105        # FIXME: This method will need to be made work for non-mac
     106        # platforms and moved into base.Port.
     107        skipped_files = []
     108        if self._name in ('mac-leopard', 'mac-snowleopard'):
     109            skipped_files.append(self._filesystem.join(
     110                self._webkit_baseline_path(self._name), 'Skipped'))
     111        skipped_files.append(self._filesystem.join(self._webkit_baseline_path('mac'),
     112                                          'Skipped'))
     113        return skipped_files
    103114
    104115    def _build_java_test_support(self):
     
    114125
    115126    def _path_to_apache_config_file(self):
    116         return self._filesystem.join(self.layout_tests_dir(), 'http', 'conf', 'apache2-httpd.conf')
     127        return self._filesystem.join(self.layout_tests_dir(), 'http', 'conf',
     128                                     'apache2-httpd.conf')
    117129
    118130    def _path_to_webcore_library(self):
  • trunk/Tools/Scripts/webkitpy/layout_tests/port/mac_unittest.py

    r90070 r90076  
    4141        return mac.MacPort
    4242
    43     def assert_skipped_file_search_paths(self, port_name, expected_paths):
     43    def assert_skipped_files_for_version(self, port_name, expected_paths):
    4444        port = mac.MacPort(port_name=port_name)
    45         self.assertEqual(port._skipped_file_search_paths(), expected_paths)
     45        skipped_paths = port._skipped_file_paths()
     46        # FIXME: _skipped_file_paths should return WebKit-relative paths.
     47        # So to make it unit testable, we strip the WebKit directory from the path.
     48        relative_paths = [path[len(port.path_from_webkit_base()):] for path in skipped_paths]
     49        self.assertEqual(relative_paths, expected_paths)
    4650
    47     def test_skipped_file_search_paths(self):
    48         # FIXME: This should no longer be necessary, but I'm not brave enough to remove it.
     51    def test_skipped_file_paths(self):
     52        # We skip this on win32 because we use '/' as the dir separator and it's
     53        # not worth making platform-independent.
    4954        if sys.platform == 'win32':
    5055            return None
    5156
    52         self.assert_skipped_file_search_paths('mac-snowleopard', set(['mac-snowleopard', 'mac']))
    53         self.assert_skipped_file_search_paths('mac-leopard', set(['mac-leopard', 'mac']))
    54         # We cannot test just "mac" here as the MacPort constructor automatically fills in the version from the running OS.
    55         # self.assert_skipped_file_search_paths('mac', ['mac'])
    56 
     57        self.assert_skipped_files_for_version('mac-snowleopard',
     58            ['/LayoutTests/platform/mac-snowleopard/Skipped', '/LayoutTests/platform/mac/Skipped'])
     59        self.assert_skipped_files_for_version('mac-leopard',
     60            ['/LayoutTests/platform/mac-leopard/Skipped', '/LayoutTests/platform/mac/Skipped'])
    5761
    5862    example_skipped_file = u"""
  • trunk/Tools/Scripts/webkitpy/layout_tests/port/qt.py

    r90070 r90076  
    4040
    4141class QtPort(WebKitPort):
    42     port_name = "qt"
     42    """QtWebKit implementation of the Port class."""
     43
     44    def __init__(self, **kwargs):
     45        kwargs.setdefault('port_name', 'qt')
     46        WebKitPort.__init__(self, **kwargs)
    4347
    4448    def baseline_search_path(self):
     
    5559    def _path_to_apache_config_file(self):
    5660        # FIXME: This needs to detect the distribution and change config files.
    57         return self._filesystem.join(self.layout_tests_dir(), 'http', 'conf', 'apache2-debian-httpd.conf')
     61        return self._filesystem.join(self.layout_tests_dir(), 'http', 'conf',
     62                                     'apache2-debian-httpd.conf')
    5863
    5964    def _build_driver(self):
  • trunk/Tools/Scripts/webkitpy/layout_tests/port/webkit.py

    r90070 r90076  
    3737import os
    3838import re
     39import signal
     40import sys
    3941import time
     42import webbrowser
     43
    4044
    4145from webkitpy.common.net.buildbot import BuildBot
     46from webkitpy.common.system import ospath
    4247from webkitpy.common.system.executive import ScriptError
    4348from webkitpy.layout_tests.port import base, builders, server_process
    4449
    45 
    46 _log = logging.getLogger(__file__)
     50_log = logging.getLogger("webkitpy.layout_tests.port.webkit")
    4751
    4852
    4953class WebKitPort(base.Port):
     54    """WebKit implementation of the Port class."""
     55
    5056    def __init__(self, **kwargs):
    5157        base.Port.__init__(self, **kwargs)
    52         self._cached_apache_path = None  # FIXME: This class should use @memoized instead.
     58        self._cached_apache_path = None
    5359
    5460        # FIXME: disable pixel tests until they are run by default on the build machines.
     
    6066        return "DumpRenderTree"
    6167
    62     # FIXME: This is not a very useful default implementation, as its wrong for any
    63     # port which uses version-specific fallback (e.g. ['mac-leapard', 'mac']).
    64     # We should replace this with a smarter implementation shared by all ports.
    6568    def baseline_search_path(self):
    66         search_paths = [self.name()]
    67         if self.get_option('webkit_test_runner'):
    68             search_paths.insert(0, self._wk2_port_name())
    69         return search_paths
    70 
    71     def _expectations_search_path(self):
    72         # test_expectations are always in mac/ not mac-leopard/ by convention, hence we use port_name instead of name().
    73         return self._wk2_port_name() if self.get_option('webkit_test_runner') else self.port_name
     69        return [self._webkit_baseline_path(self._name)]
    7470
    7571    def path_to_test_expectations_file(self):
    76         return self._filesystem.join(self._webkit_baseline_path(self._expectations_search_path()), 'test_expectations.txt')
     72        return self._filesystem.join(self._webkit_baseline_path(self._name),
     73                                     'test_expectations.txt')
    7774
    7875    def _results_for_platform(self, platform):
     
    288285        return tests_to_skip
    289286
    290     def _wk2_port_name(self):
    291         # By current convention, the WebKit2 name is always mac-wk2, win-wk2, not mac-leopard-wk2, etc.
    292         return "%s-wk2" % self.port_name
    293 
    294     def _skipped_file_search_paths(self):
    295         # Unlike baseline_search_path, we only want to search [WK2-PORT, PORT-VERSION, PORT] not the full casade.
    296         # Note order doesn't matter since the Skipped file contents are all combined.
    297         search_paths = set([self.port_name, self.name()])
    298         if self.get_option('webkit_test_runner'):
    299             # Quoting old-run-webkit-tests:
    300             # Because nearly all of the skipped tests for WebKit 2 on Mac are due to
    301             # cross-platform issues, the Windows and Qt ports use the Mac skipped list
    302             # additionally to their own to avoid maintaining separate lists.
    303             search_paths.update([self._wk2_port_name(), "mac-wk2"])
    304         return search_paths
     287    def _skipped_file_paths(self):
     288        return [self._filesystem.join(self._webkit_baseline_path(self._name), 'Skipped')]
    305289
    306290    def _expectations_from_skipped_files(self):
    307291        tests_to_skip = []
    308         for search_path in self._skipped_file_search_paths():
    309             filename = self._filesystem.join(self._webkit_baseline_path(search_path), "Skipped")
     292        for filename in self._skipped_file_paths():
    310293            if not self._filesystem.exists(filename):
    311294                _log.warn("Failed to open Skipped file: %s" % filename)
     
    316299
    317300    def test_expectations(self):
    318         # This allows ports to use a combination of test_expectations.txt files and Skipped lists.
    319         expectations = self._skipped_list_as_expectations()
     301        # The WebKit mac port uses a combination of a test_expectations file
     302        # and 'Skipped' files.
    320303        expectations_path = self.path_to_test_expectations_file()
    321         if self._filesystem.exists(expectations_path):
    322             expectations = self._filesystem.read_text_file(expectations_path) + expectations
    323         return expectations
    324 
    325     def _skipped_list_as_expectations(self):
     304        return self._filesystem.read_text_file(expectations_path) + self._skips()
     305
     306    def _skips(self):
    326307        # Each Skipped file contains a list of files
    327308        # or directories to be skipped during the test run. The total list
     
    333314
    334315        tests_to_skip = self.skipped_layout_tests()
    335         skip_lines = map(lambda test_path: "BUG_SKIPPED SKIP : %s = FAIL" % test_path, tests_to_skip)
     316        skip_lines = map(lambda test_path: "BUG_SKIPPED SKIP : %s = FAIL" %
     317                                test_path, tests_to_skip)
    336318        return "\n".join(skip_lines)
    337319
  • trunk/Tools/Scripts/webkitpy/layout_tests/port/webkit_unittest.py

    r90070 r90076  
    3838
    3939class TestWebKitPort(WebKitPort):
    40     port_name = "testwebkitport"
    41 
    4240    def __init__(self, symbol_list=None, feature_list=None,
    4341                 expectations_file=None, skips_file=None,
     
    4947        filesystem = filesystem or MockFileSystem()
    5048        user = user or MockUser()
    51         WebKitPort.__init__(self, executive=executive, filesystem=filesystem, user=MockUser(), **kwargs)
     49        WebKitPort.__init__(self, port_name="testwebkitport", executive=executive, filesystem=filesystem, user=MockUser(), **kwargs)
    5250
    5351    def _runtime_feature_list(self):
     
    9290        self.assertEqual(TestWebKitPort(None, None).skipped_layout_tests(), set(["media"]))
    9391
    94     def test_skipped_file_search_paths(self):
    95         port = TestWebKitPort()
    96         self.assertEqual(port._skipped_file_search_paths(), set(['testwebkitport']))
    97         port._name = "testwebkitport-version"
    98         self.assertEqual(port._skipped_file_search_paths(), set(['testwebkitport', 'testwebkitport-version']))
    99         port._options = MockOptions(webkit_test_runner=True)
    100         self.assertEqual(port._skipped_file_search_paths(), set(['testwebkitport', 'testwebkitport-version', 'testwebkitport-wk2', 'mac-wk2']))
    101 
    10292    def test_test_expectations(self):
    10393        # Check that we read both the expectations file and anything in a
  • trunk/Tools/Scripts/webkitpy/layout_tests/port/win.py

    r90070 r90076  
    3333from webkitpy.layout_tests.port.webkit import WebKitPort
    3434
    35 _log = logging.getLogger(__file__)
     35_log = logging.getLogger("webkitpy.layout_tests.port.win")
    3636
    3737
    3838class WinPort(WebKitPort):
    39     port_name = "win"
     39    """WebKit Win implementation of the Port class."""
    4040
    41     def __init__(self, **kwargs):
    42         WebKitPort.__init__(self, **kwargs)
     41    def __init__(self, port_name=None, **kwargs):
     42        port_name = port_name or 'win'
     43        WebKitPort.__init__(self, port_name=port_name, **kwargs)
    4344        self._version = 'win7'
    4445        self._operating_system = 'win'
     
    4647    def baseline_search_path(self):
    4748        # Based on code from old-run-webkit-tests expectedDirectoryForTest()
    48         search_paths = ["win", "mac-snowleopard", "mac"]
    49         return map(self._webkit_baseline_path, search_paths)
     49        port_names = ["win", "mac-snowleopard", "mac"]
     50        return map(self._webkit_baseline_path, port_names)
    5051
    5152    def _path_to_apache_config_file(self):
    52         return self._filesystem.join(self.layout_tests_dir(), 'http', 'conf', 'cygwin-httpd.conf')
     53        return self._filesystem.join(self.layout_tests_dir(), 'http', 'conf',
     54                                     'cygwin-httpd.conf')
  • trunk/Tools/Scripts/webkitpy/tool/commands/rebaselineserver_unittest.py

    r90070 r90076  
    292292
    293293    class TestMacPort(WebKitPort):
    294         port_name = 'testmacport'
    295294        def __init__(self):
    296295            # FIXME: This should use MockExecutive and MockUser as well.
Note: See TracChangeset for help on using the changeset viewer.