Changeset 90077 in webkit


Ignore:
Timestamp:
Jun 29, 2011 6:36:03 PM (13 years ago)
Author:
eric@webkit.org
Message:

2011-06-29 Eric Seidel <​eric@webkit.org>

Reviewed by Adam Barth.

Simplify skipped file finding in preparation for adding wk2 skipped list fallback
​https://bugs.webkit.org/show_bug.cgi?id=63501

Re-landing after fixing a bug in WebKitPort.baseline_search_path which broke
the rebaselineserver unit tests. Also fixed nits brought up by Dirk after previous landing.

The goal was to add support for wk2 skipped lists.
However, I found that our skipped list computation was a
manual hack (which only worked for the mac port).

So I fixed a FIXME to move the skipped list finding
into WebKitPort instead of MacPort.
Doing so required the concept of a "port_name", since previously
the only name accessible from a port object was name()
which includes many things beyond "mac" or "chromium", etc.

Eventually I believe we'll want to re-think the way that we pass
in a port_name argument to Port subclasses and expect them to parse
it. But for now I just added a cls.port_name variable which contains
the static information needed to compute wk2 names as well as
compute Skipped list fallback which works for Mac/Win/Qt and Gtk.

In order to test my new _skipped_file_search_paths method, I
fixed another FIXME by making it return relative paths.

I also fixed the test_expectations_path code in WebKitPort to use port_name.
It was using name() which would return PORT-VERSION so MacPort was overriding
it to use just PORT. After fixing test_expectations_path to use port_name
(and making it aware of webkit2) I was able to remove the MacPort implementation.

  • Scripts/webkitpy/layout_tests/port/base.py:
    • Add port_name() to access "mac", since name() returns "mac-leopard" etc.
    • Document that real_name() seems to have no purpose.
  • Scripts/webkitpy/layout_tests/port/chromium_linux.py:
    • Add _parse_port_name(), eventually we might call this from WebKitPort directly.
  • Scripts/webkitpy/layout_tests/port/chromium_mac.py:
    • Add _parse_port_name.
  • Scripts/webkitpy/layout_tests/port/chromium_win.py:
    • Add _parse_port_name.
  • Scripts/webkitpy/layout_tests/port/gtk.py:
  • Scripts/webkitpy/layout_tests/port/mac.py:
    • Move Skipped-file finding code down to WebKitPort
  • 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:
Location:
trunk/Tools
Files:
15 edited

Legend:

Unmodified
Added
Removed

  • trunk/Tools/ChangeLog

    r90076 r90077  
     12011-06-29  Eric Seidel  <eric@webkit.org>
     2
     3        Reviewed by Adam Barth.
     4
     5        Simplify skipped file finding in preparation for adding wk2 skipped list fallback
     6        https://bugs.webkit.org/show_bug.cgi?id=63501
     7
     8        Re-landing after fixing a bug in WebKitPort.baseline_search_path which broke
     9        the rebaselineserver unit tests.  Also fixed nits brought up by Dirk after previous landing.
     10
     11        The goal was to add support for wk2 skipped lists.
     12        However, I found that our skipped list computation was a
     13        manual hack (which only worked for the mac port).
     14
     15        So I fixed a FIXME to move the skipped list finding
     16        into WebKitPort instead of MacPort.
     17        Doing so required the concept of a "port_name", since previously
     18        the only name accessible from a port object was name()
     19        which includes many things beyond "mac" or "chromium", etc.
     20
     21        Eventually I believe we'll want to re-think the way that we pass
     22        in a port_name argument to Port subclasses and expect them to parse
     23        it.  But for now I just added a cls.port_name variable which contains
     24        the static information needed to compute wk2 names as well as
     25        compute Skipped list fallback which works for Mac/Win/Qt and Gtk.
     26
     27        In order to test my new _skipped_file_search_paths method, I
     28        fixed another FIXME by making it return relative paths.
     29
     30        I also fixed the test_expectations_path code in WebKitPort to use port_name.
     31        It was using name() which would return PORT-VERSION so MacPort was overriding
     32        it to use just PORT.  After fixing test_expectations_path to use port_name
     33        (and making it aware of webkit2) I was able to remove the MacPort implementation.
     34
     35        * Scripts/webkitpy/layout_tests/port/base.py:
     36         - Add port_name() to access "mac", since name() returns "mac-leopard" etc.
     37         - Document that real_name() seems to have no purpose.
     38        * Scripts/webkitpy/layout_tests/port/chromium_linux.py:
     39         - Add _parse_port_name(), eventually we might call this from WebKitPort directly.
     40        * Scripts/webkitpy/layout_tests/port/chromium_mac.py:
     41         - Add _parse_port_name.
     42        * Scripts/webkitpy/layout_tests/port/chromium_win.py:
     43         - Add _parse_port_name.
     44        * Scripts/webkitpy/layout_tests/port/gtk.py:
     45        * Scripts/webkitpy/layout_tests/port/mac.py:
     46         - Move Skipped-file finding code down to WebKitPort
     47        * Scripts/webkitpy/layout_tests/port/mac_unittest.py:
     48        * Scripts/webkitpy/layout_tests/port/qt.py:
     49        * Scripts/webkitpy/layout_tests/port/webkit.py:
     50        * Scripts/webkitpy/layout_tests/port/webkit_unittest.py:
     51
    1522011-06-29  Sheriff Bot  <webkit.review.bot@gmail.com>
    253

  • trunk/Tools/Scripts/webkitpy/layout_tests/port/base.py

    r90076 r90077  
    6767
    6868class DummyOptions(object):
    69     """Fake implementation of optparse.Values. Cloned from
    70     webkitpy.tool.mocktool.MockOptions.
    71 
    72     """
     69    """Fake implementation of optparse.Values. Cloned from webkitpy.tool.mocktool.MockOptions."""
    7370
    7471    def __init__(self, **kwargs):
    … …  
    8279
    8380
    84 # FIXME: This class should merge with webkitpy.webkit_port at some point.
     81# FIXME: This class should merge with webkitpy.common.config.ports.
    8582class Port(object):
    8683    """Abstract class for Port-specific hooks for the layout_test package."""
     84
     85    port_name = None  # Subclasses override this
    8786
    8887    def __init__(self, port_name=None, options=None,
    … …  
    9291                 config=None,
    9392                 **kwargs):
    94         self._name = port_name
    9593
    9694        # These are default values that should be overridden in a subclasses.
    97         # FIXME: These should really be passed in.
     95        self._name = port_name or self.port_name  # Subclasses may append a -VERSION (like mac-leopard) or other qualifiers.
    9896        self._operating_system = 'mac'
    9997        self._version = ''
    … …  
    113111        self._helper = None
    114112        self._http_server = None
    115         self._webkit_base_dir = None
    116113        self._websocket_server = None
    117         self._http_lock = None
     114        self._http_lock = None  # FIXME: Why does this live on the port object?
    118115
    119116        # Python's Popen has a bug that causes any pipes opened to a
    … …  
    133130
    134131        # FIXME: prettypatch.py knows this path, why is it copied here?
    135         self._pretty_patch_path = self.path_from_webkit_base("Websites",
    136             "bugs.webkit.org", "PrettyPatch", "prettify.rb")
     132        self._pretty_patch_path = self.path_from_webkit_base("Websites", "bugs.webkit.org", "PrettyPatch", "prettify.rb")
    137133        self._pretty_patch_available = None
    138134
    … …  
    154150
    155151    def default_child_processes(self):
    156         """Return the number of DumpRenderTree instances to use for this
    157         port."""
     152        """Return the number of DumpRenderTree instances to use for this port."""
    158153        return self._executive.cpu_count()
    159154
    … …  
    164159
    165160    def baseline_path(self):
    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()
     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()
    170163        return baseline_search_paths[0]
    171164
    … …  
    248241
    249242    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()).
    250244        """Return whether the two audio files are *not* equal."""
    251245        return expected_audio != actual_audio
    252246
    253     def diff_image(self, expected_contents, actual_contents,
    254                    diff_filename=None, tolerance=0):
     247    def diff_image(self, expected_contents, actual_contents, diff_filename=None, tolerance=0):
    255248        """Compare two images and produce a delta image file.
    256249
    … …  
    334327        baselines = []
    335328        for platform_dir in baseline_search_path:
    336             if self.path_exists(self._filesystem.join(platform_dir,
    337                                                       baseline_filename)):
     329            if self.path_exists(self._filesystem.join(platform_dir, baseline_filename)):
    338330                baselines.append((platform_dir, baseline_filename))
    339331
    … …  
    344336        # result in the test directory, even if no such file actually exists.
    345337        platform_dir = self.layout_tests_dir()
    346         if self.path_exists(self._filesystem.join(platform_dir,
    347                                                   baseline_filename)):
     338        if self.path_exists(self._filesystem.join(platform_dir, baseline_filename)):
    348339            baselines.append((platform_dir, baseline_filename))
    349340
    … …  
    372363        the other baseline and filename manipulation routines.
    373364        """
    374         platform_dir, baseline_filename = self.expected_baselines(
    375             filename, suffix)[0]
     365        # FIXME: The [0] here is very mysterious, as is the destructured return.
     366        platform_dir, baseline_filename = self.expected_baselines(filename, suffix)[0]
    376367        if platform_dir:
    377368            return self._filesystem.join(platform_dir, baseline_filename)
    … …  
    457448
    458449    def test_dirs(self):
    459         """Returns the list of top-level test directories.
    460 
    461         Used by --clobber-old-results."""
     450        """Returns the list of top-level test directories."""
    462451        layout_tests_dir = self.layout_tests_dir()
    463452        return filter(lambda x: self._filesystem.isdir(self._filesystem.join(layout_tests_dir, x)),
    … …  
    540529
    541530    def name(self):
    542         """Return the name of the port (e.g., 'mac', 'chromium-win-xp')."""
     531        """Returns a name that uniquely identifies this particular type of port
     532        (e.g., "mac-snowleopard" or "chromium-gpu-linux-x86_x64" and can be passed
     533        to factory.get() to instantiate the port."""
    543534        return self._name
     535
     536    def real_name(self):
     537        # FIXME: Seems this is only used for MockDRT and should be removed.
     538        """Returns the name of the port as passed to the --platform command line argument."""
     539        return self.name()
    544540
    545541    def operating_system(self):
    … …  
    568564    def architecture(self):
    569565        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()
    574566
    575567    def get_option(self, name, default_value=None):
    … …  
    642634
    643635    def create_driver(self, worker_number):
    644         """Return a newly created base.Driver subclass for starting/stopping
    645         the test driver."""
     636        """Return a newly created base.Driver subclass for starting/stopping the test driver."""
    646637        raise NotImplementedError('Port.create_driver')
    647638
    … …  
    877868
    878869    def _path_to_image_diff(self):
    879         """Returns the full path to the image_diff binary, or None if it
    880         is not available.
     870        """Returns the full path to the image_diff binary, or None if it is not available.
    881871
    882872        This is likely used only by diff_image()"""

  • trunk/Tools/Scripts/webkitpy/layout_tests/port/chromium.py

    r90076 r90077  
    5454
    5555
    56 # FIXME: This function doesn't belong in this package.
    5756class ChromiumPort(base.Port):
    5857    """Abstract base class for Chromium implementations of the Port class."""
     58
     59    port_name = "chromium"
     60
    5961    ALL_BASELINE_VARIANTS = [
    6062        'chromium-mac-snowleopard', 'chromium-mac-leopard',
    … …  
    347349
    348350class 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

    r90076 r90077  
    4949        port_name = port_name or 'chromium-linux'
    5050        chromium.ChromiumPort.__init__(self, port_name=port_name, **kwargs)
    51 
    5251        # We re-set the port name once the base object is fully initialized
    5352        # in order to be able to find the DRT binary properly.

  • trunk/Tools/Scripts/webkitpy/layout_tests/port/chromium_mac.py

    r90076 r90077  
    7777            self._name = port_name + '-' + self._version
    7878        else:
    79             self._version = port_name[port_name.index('-mac-') + 5:]
     79            self._version = port_name[port_name.index('-mac-') + len('-mac-'):]
    8080            assert self._version in self.SUPPORTED_OS_VERSIONS
    8181        self._operating_system = 'mac'

  • trunk/Tools/Scripts/webkitpy/layout_tests/port/chromium_win.py

    r90076 r90077  
    7575            self._name = port_name + '-' + self._version
    7676        else:
    77             self._version = port_name[port_name.index('-win-') + 5:]
    78             assert self._version in self.SUPPORTED_VERSIONS
    79 
     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)
    8079        self._operating_system = 'win'
    8180

  • trunk/Tools/Scripts/webkitpy/layout_tests/port/gtk.py

    r90076 r90077  
    4040
    4141class GtkDriver(webkit.WebKitDriver):
    42     """WebKit Gtk implementation of the Driver class."""
    43 
    4442    def start(self):
    4543        display_id = self._worker_number + 1
    … …  
    5856
    5957class GtkPort(webkit.WebKitPort):
    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)
     58    port_name = "gtk"
    6559
    6660    def create_driver(self, worker_number):
    … …  
    6963    def _path_to_apache_config_file(self):
    7064        # FIXME: This needs to detect the distribution and change config files.
    71         return self._filesystem.join(self.layout_tests_dir(), 'http', 'conf',
    72                                      'apache2-debian-httpd.conf')
     65        return self._filesystem.join(self.layout_tests_dir(), 'http', 'conf', 'apache2-debian-httpd.conf')
    7366
    7467    def _path_to_driver(self):
    … …  
    7669
    7770    def check_build(self, needs_http):
    78         if not self._check_driver():
    79             return False
    80         return True
     71        return self._check_driver()
    8172
    8273    def _path_to_apache(self):
    … …  
    9283            config_name = 'apache2-debian-httpd.conf'
    9384
    94         return self._filesystem.join(self.layout_tests_dir(), 'http', 'conf',
    95                             config_name)
     85        return self._filesystem.join(self.layout_tests_dir(), 'http', 'conf', config_name)
    9686
    9787    def _path_to_wdiff(self):
    … …  
    115105            if os.path.isfile(full_library):
    116106                return full_library
    117 
    118107        return None
    119108

  • trunk/Tools/Scripts/webkitpy/layout_tests/port/mac.py

    r90076 r90077  
    4949        5: 'leopard',
    5050        6: 'snowleopard',
     51        # Add 7: 'lion' here?
    5152    }
    5253    assert release_version >= min(version_strings.keys())
    … …  
    5859
    5960class MacPort(WebKitPort):
    60     """WebKit Mac implementation of the Port class."""
     61    port_name = "mac"
     62
    6163    # FIXME: 'wk2' probably shouldn't be a version, it should probably be
    6264    # a modifier, like 'chromium-gpu' is to 'chromium'.
    … …  
    6769        'snowleopard': ['mac-snowleopard', 'mac'],
    6870        'future': ['mac'],
     71        # FIXME: This isn't quite right for wk2, it should include mac-VERSION as well.
    6972        'wk2': ['mac-wk2', 'mac'],
    7073    }
    … …  
    7780            self._name = port_name + '-' + self._version
    7881        else:
    79             self._version = port_name[4:]
    80             assert self._version in self.SUPPORTED_VERSIONS
     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)
    8185        self._operating_system = 'mac'
    8286        if not hasattr(self._options, 'time-out-ms') or self._options.time_out_ms is None:
    … …  
    9599        return map(self._webkit_baseline_path, self.FALLBACK_PATHS[self._version])
    96100
    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
    114103
    115104    def _build_java_test_support(self):
    … …  
    125114
    126115    def _path_to_apache_config_file(self):
    127         return self._filesystem.join(self.layout_tests_dir(), 'http', 'conf',
    128                                      'apache2-httpd.conf')
     116        return self._filesystem.join(self.layout_tests_dir(), 'http', 'conf', 'apache2-httpd.conf')
    129117
    130118    def _path_to_webcore_library(self):

  • trunk/Tools/Scripts/webkitpy/layout_tests/port/mac_unittest.py

    r90076 r90077  
    4141        return mac.MacPort
    4242
    43     def assert_skipped_files_for_version(self, port_name, expected_paths):
     43    def assert_skipped_file_search_paths(self, port_name, expected_paths):
    4444        port = mac.MacPort(port_name=port_name)
    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)
     45        self.assertEqual(port._skipped_file_search_paths(), expected_paths)
    5046
    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.
     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.
    5449        if sys.platform == 'win32':
    5550            return None
    5651
    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'])
     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
    6157
    6258    example_skipped_file = u"""

  • trunk/Tools/Scripts/webkitpy/layout_tests/port/qt.py

    r90076 r90077  
    4040
    4141class QtPort(WebKitPort):
    42     """QtWebKit implementation of the Port class."""
    43 
    44     def __init__(self, **kwargs):
    45         kwargs.setdefault('port_name', 'qt')
    46         WebKitPort.__init__(self, **kwargs)
     42    port_name = "qt"
    4743
    4844    def baseline_search_path(self):
    … …  
    5955    def _path_to_apache_config_file(self):
    6056        # FIXME: This needs to detect the distribution and change config files.
    61         return self._filesystem.join(self.layout_tests_dir(), 'http', 'conf',
    62                                      'apache2-debian-httpd.conf')
     57        return self._filesystem.join(self.layout_tests_dir(), 'http', 'conf', 'apache2-debian-httpd.conf')
    6358
    6459    def _build_driver(self):

  • trunk/Tools/Scripts/webkitpy/layout_tests/port/webkit.py

    r90076 r90077  
    3737import os
    3838import re
    39 import signal
    40 import sys
    4139import time
    42 import webbrowser
    43 
    4440
    4541from webkitpy.common.net.buildbot import BuildBot
    46 from webkitpy.common.system import ospath
    4742from webkitpy.common.system.executive import ScriptError
    4843from webkitpy.layout_tests.port import base, builders, server_process
    4944
    50 _log = logging.getLogger("webkitpy.layout_tests.port.webkit")
     45
     46_log = logging.getLogger(__file__)
    5147
    5248
    5349class WebKitPort(base.Port):
    54     """WebKit implementation of the Port class."""
    55 
    5650    def __init__(self, **kwargs):
    5751        base.Port.__init__(self, **kwargs)
    58         self._cached_apache_path = None
     52        self._cached_apache_path = None  # FIXME: This class should use @memoized instead.
    5953
    6054        # FIXME: disable pixel tests until they are run by default on the build machines.
    … …  
    6660        return "DumpRenderTree"
    6761
     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.
    6865    def baseline_search_path(self):
    69         return [self._webkit_baseline_path(self._name)]
     66        search_paths = [self.name()]
     67        if self.get_option('webkit_test_runner'):
     68            search_paths.insert(0, self._wk2_port_name())
     69        return map(self._webkit_baseline_path, search_paths)
    7070
    7171    def path_to_test_expectations_file(self):
    72         return self._filesystem.join(self._webkit_baseline_path(self._name),
    73                                      'test_expectations.txt')
     72        # test_expectations are always in mac/ not mac-leopard/ by convention, hence we use port_name instead of name().
     73        expectations_directory = self._wk2_port_name() if self.get_option('webkit_test_runner') else self.port_name
     74        return self._filesystem.join(self._webkit_baseline_path(expectations_directory), 'test_expectations.txt')
    7475
    7576    def _results_for_platform(self, platform):
    … …  
    285286        return tests_to_skip
    286287
    287     def _skipped_file_paths(self):
    288         return [self._filesystem.join(self._webkit_baseline_path(self._name), 'Skipped')]
     288    def _wk2_port_name(self):
     289        # By current convention, the WebKit2 name is always mac-wk2, win-wk2, not mac-leopard-wk2, etc.
     290        return "%s-wk2" % self.port_name
     291
     292    def _skipped_file_search_paths(self):
     293        # Unlike baseline_search_path, we only want to search [WK2-PORT, PORT-VERSION, PORT] not the full casade.
     294        # Note order doesn't matter since the Skipped file contents are all combined.
     295        search_paths = set([self.port_name, self.name()])
     296        if self.get_option('webkit_test_runner'):
     297            # Quoting old-run-webkit-tests:
     298            # Because nearly all of the skipped tests for WebKit 2 on Mac are due to
     299            # cross-platform issues, the Windows and Qt ports use the Mac skipped list
     300            # additionally to their own to avoid maintaining separate lists.
     301            search_paths.update([self._wk2_port_name(), "mac-wk2"])
     302        return search_paths
    289303
    290304    def _expectations_from_skipped_files(self):
    291305        tests_to_skip = []
    292         for filename in self._skipped_file_paths():
     306        for search_path in self._skipped_file_search_paths():
     307            filename = self._filesystem.join(self._webkit_baseline_path(search_path), "Skipped")
    293308            if not self._filesystem.exists(filename):
    294309                _log.warn("Failed to open Skipped file: %s" % filename)
    … …  
    299314
    300315    def test_expectations(self):
    301         # The WebKit mac port uses a combination of a test_expectations file
    302         # and 'Skipped' files.
     316        # This allows ports to use a combination of test_expectations.txt files and Skipped lists.
     317        expectations = self._skipped_list_as_expectations()
    303318        expectations_path = self.path_to_test_expectations_file()
    304         return self._filesystem.read_text_file(expectations_path) + self._skips()
    305 
    306     def _skips(self):
     319        if self._filesystem.exists(expectations_path):
     320            expectations = self._filesystem.read_text_file(expectations_path) + expectations
     321        return expectations
     322
     323    def _skipped_list_as_expectations(self):
    307324        # Each Skipped file contains a list of files
    308325        # or directories to be skipped during the test run. The total list
    … …  
    314331
    315332        tests_to_skip = self.skipped_layout_tests()
    316         skip_lines = map(lambda test_path: "BUG_SKIPPED SKIP : %s = FAIL" %
    317                                 test_path, tests_to_skip)
     333        skip_lines = map(lambda test_path: "BUG_SKIPPED SKIP : %s = FAIL" % test_path, tests_to_skip)
    318334        return "\n".join(skip_lines)
    319335

  • trunk/Tools/Scripts/webkitpy/layout_tests/port/webkit_unittest.py

    r90076 r90077  
    3838
    3939class TestWebKitPort(WebKitPort):
     40    port_name = "testwebkitport"
     41
    4042    def __init__(self, symbol_list=None, feature_list=None,
    4143                 expectations_file=None, skips_file=None,
    … …  
    4749        filesystem = filesystem or MockFileSystem()
    4850        user = user or MockUser()
    49         WebKitPort.__init__(self, port_name="testwebkitport", executive=executive, filesystem=filesystem, user=MockUser(), **kwargs)
     51        WebKitPort.__init__(self, executive=executive, filesystem=filesystem, user=MockUser(), **kwargs)
    5052
    5153    def _runtime_feature_list(self):
    … …  
    9092        self.assertEqual(TestWebKitPort(None, None).skipped_layout_tests(), set(["media"]))
    9193
     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
    92102    def test_test_expectations(self):
    93103        # Check that we read both the expectations file and anything in a

  • trunk/Tools/Scripts/webkitpy/layout_tests/port/win.py

    r90076 r90077  
    3333from webkitpy.layout_tests.port.webkit import WebKitPort
    3434
    35 _log = logging.getLogger("webkitpy.layout_tests.port.win")
     35_log = logging.getLogger(__file__)
    3636
    3737
    3838class WinPort(WebKitPort):
    39     """WebKit Win implementation of the Port class."""
     39    port_name = "win"
    4040
    41     def __init__(self, port_name=None, **kwargs):
    42         port_name = port_name or 'win'
    43         WebKitPort.__init__(self, port_name=port_name, **kwargs)
     41    def __init__(self, **kwargs):
     42        WebKitPort.__init__(self, **kwargs)
    4443        self._version = 'win7'
    4544        self._operating_system = 'win'
    … …  
    5150
    5251    def _path_to_apache_config_file(self):
    53         return self._filesystem.join(self.layout_tests_dir(), 'http', 'conf',
    54                                      'cygwin-httpd.conf')
     52        return self._filesystem.join(self.layout_tests_dir(), 'http', 'conf', 'cygwin-httpd.conf')

  • trunk/Tools/Scripts/webkitpy/tool/commands/rebaselineserver.py

    r85254 r90077  
    349349
    350350def _get_test_baselines(test_file, test_config):
     351    # FIXME: This seems like a hack. This only seems used to access the Port.expected_baselines logic.
    351352    class AllPlatformsPort(WebKitPort):
    352353        def __init__(self):
    353354            WebKitPort.__init__(self, filesystem=test_config.filesystem)
    354             self._platforms_by_directory = dict(
    355                 [(self._webkit_baseline_path(p), p) for p in test_config.platforms])
     355            self._platforms_by_directory = dict([(self._webkit_baseline_path(p), p) for p in test_config.platforms])
    356356
    357357        def baseline_search_path(self):
    … …  
    361361            return self._platforms_by_directory[directory]
    362362
    363     test_path = test_config.filesystem.join(
    364         test_config.layout_tests_directory, test_file)
     363    test_path = test_config.filesystem.join(test_config.layout_tests_directory, test_file)
    365364
    366365    all_platforms_port = AllPlatformsPort()
    … …  
    368367    all_test_baselines = {}
    369368    for baseline_extension in ('.txt', '.checksum', '.png'):
    370         test_baselines = test_config.test_port.expected_baselines(
    371             test_path, baseline_extension)
    372         baselines = all_platforms_port.expected_baselines(
    373             test_path, baseline_extension, all_baselines=True)
     369        test_baselines = test_config.test_port.expected_baselines(test_path, baseline_extension)
     370        baselines = all_platforms_port.expected_baselines(test_path, baseline_extension, all_baselines=True)
    374371        for platform_directory, expected_filename in baselines:
    375372            if not platform_directory:
    … …  
    378375                platform = 'base'
    379376            else:
    380                 platform = all_platforms_port.platform_from_directory(
    381                     platform_directory)
     377                platform = all_platforms_port.platform_from_directory(platform_directory)
    382378            platform_baselines = all_test_baselines.setdefault(platform, {})
    383             was_used_for_test = (
    384                 platform_directory, expected_filename) in test_baselines
     379            was_used_for_test = (platform_directory, expected_filename) in test_baselines
    385380            platform_baselines[baseline_extension] = was_used_for_test
    386381

  • trunk/Tools/Scripts/webkitpy/tool/commands/rebaselineserver_unittest.py

    r90076 r90077  
    292292
    293293    class TestMacPort(WebKitPort):
     294        port_name = "mac"
    294295        def __init__(self):
    295296            # FIXME: This should use MockExecutive and MockUser as well.
    296297            WebKitPort.__init__(self, filesystem=mock_filesystem)
    297             self._name = 'mac'
    298298
    299299    return rebaselineserver.TestConfig(
Note: See TracChangeset for help on using the changeset viewer.