Changeset 239989 in webkit


Ignore:
Timestamp:
Jan 15, 2019 9:46:31 AM (5 years ago)
Author:
Jonathan Bedard
Message:

webkitpy: Implement device type specific expected results (Part 1)
​https://bugs.webkit.org/show_bug.cgi?id=192162

Reviewed by Lucas Forschler.

Device type specific expected results covers two related ideas. The first (covered by this change)
is where to search for -expected.* files. The second is which tests to run based on the
TestExpectations.txt file.

After this change, the baseline search path will be determined by the type of device running a
test. Device type will be passed into any function which picks a file based on the baseline search
path.

  • Scripts/webkitpy/layout_tests/controllers/layout_test_runner.py:

(Worker._update_test_input): Pass device_type to self._port.reference_files(...).

  • Scripts/webkitpy/layout_tests/controllers/manager.py:

(Manager.run): Print baseline search path for each round of devices.

  • Scripts/webkitpy/layout_tests/controllers/single_test_runner.py:

(SingleTestRunner.init): Pass device_type into expected_*(...).
(SingleTestRunner._expected_driver_output): Ditto.
(SingleTestRunner._driver_input): Ditto.

  • Scripts/webkitpy/layout_tests/views/printing.py:

(Printer.print_config): Move printing of baseline search path to a separate function.
(Printer.print_baseline_search_path): Moved from Printer.print_config.

  • Scripts/webkitpy/layout_tests/views/printing_unittest.py:

(Testprinter.test_print_config):
(Testprinter.test_print_baseline_search_path):

  • Scripts/webkitpy/port/base.py:

(Port.baseline_search_path): Pass device_type through.
(Port._expected_baselines_for_suffixes): Ditto.
(Port.expected_baselines): Ditto.
(Port.expected_filename): Ditto.
(Port.expected_checksum): Ditto.
(Port.expected_image): Ditto.
(Port.expected_audio): Ditto.
(Port.expected_text): Ditto.
(Port.reference_files): Ditto.
(Port.tests): Ditto.
(Port._expanded_paths): Ditto.
(Port.skipped_layout_tests): Ditto.
(Port.expectations_dict): Ditto.
(Port._port_specific_expectations_files): Ditto.
(Port.expectations_files): Ditto.
(Port.test_search_path): Ditto.
(Port._tests_for_other_platforms): Ditto.

  • Scripts/webkitpy/port/base_unittest.py:

(PortTest.test_additional_platform_directory): Accept, but do not use, device_type.
(PortTest.test_nonexistant_expectations): Ditto.
(test_ref_tests_platform_directory): Ditto.

  • Scripts/webkitpy/port/darwin.py:

(DarwinPort._port_specific_expectations_files): Accept device_type.

  • Scripts/webkitpy/port/driver.py:

(DriverProxy):
(DriverProxy.host): Expose _target_host for device_type information.

  • Scripts/webkitpy/port/gtk.py:

(GtkPort._port_specific_expectations_files): Accept, but do not use, device_type.

  • Scripts/webkitpy/port/ios.py:

(IOSPort. default_baseline_search_path): Remove memoized, since it does not accept kwargs.

  • Scripts/webkitpy/port/mac.py:

(MacPort. default_baseline_search_path): Ditto.

  • Scripts/webkitpy/port/port_testcase.py:

(TestWebKitPort._tests_for_other_platforms): Accept, but do not use, device_type.

  • Scripts/webkitpy/port/test.py:
  • Scripts/webkitpy/port/watch.py:

(WatchPort. default_baseline_search_path): Remove memoized, since it does not accept kwargs.

  • Scripts/webkitpy/port/win.py:

(WinPort.test_search_path): Accept, but do not use, device_type.

  • Scripts/webkitpy/port/wpe.py:

(WPEPort._port_specific_expectations_files): Ditto.

  • Scripts/webkitpy/tool/servers/rebaselineserver.py:

(get_test_baselines.AllPlatformsPort.baseline_search_path): Ditto.

Location:
trunk/Tools
Files:
19 edited

Legend:

Unmodified
Added
Removed

  • trunk/Tools/ChangeLog

    r239983 r239989  
     12019-01-15  Jonathan Bedard  <jbedard@apple.com>
     2
     3        webkitpy: Implement device type specific expected results (Part 1)
     4        https://bugs.webkit.org/show_bug.cgi?id=192162
     5
     6        Reviewed by Lucas Forschler.
     7
     8        Device type specific expected results covers two related ideas. The first (covered by this change)
     9        is where to search for -expected.* files. The second is which tests to run based on the
     10        TestExpectations.txt file.
     11
     12        After this change, the baseline search path will be determined by the type of device running a
     13        test. Device type will be passed into any function which picks a file based on the baseline search
     14        path.
     15
     16        * Scripts/webkitpy/layout_tests/controllers/layout_test_runner.py:
     17        (Worker._update_test_input): Pass device_type to self._port.reference_files(...).
     18        * Scripts/webkitpy/layout_tests/controllers/manager.py:
     19        (Manager.run): Print baseline search path for each round of devices.
     20        * Scripts/webkitpy/layout_tests/controllers/single_test_runner.py:
     21        (SingleTestRunner.__init__): Pass device_type into expected_*(...).
     22        (SingleTestRunner._expected_driver_output): Ditto.
     23        (SingleTestRunner._driver_input): Ditto.
     24        * Scripts/webkitpy/layout_tests/views/printing.py:
     25        (Printer.print_config): Move printing of baseline search path to a separate function.
     26        (Printer.print_baseline_search_path): Moved from Printer.print_config.
     27        * Scripts/webkitpy/layout_tests/views/printing_unittest.py:
     28        (Testprinter.test_print_config):
     29        (Testprinter.test_print_baseline_search_path):
     30        * Scripts/webkitpy/port/base.py:
     31        (Port.baseline_search_path): Pass device_type through.
     32        (Port._expected_baselines_for_suffixes): Ditto.
     33        (Port.expected_baselines): Ditto.
     34        (Port.expected_filename): Ditto.
     35        (Port.expected_checksum): Ditto.
     36        (Port.expected_image): Ditto.
     37        (Port.expected_audio): Ditto.
     38        (Port.expected_text): Ditto.
     39        (Port.reference_files): Ditto.
     40        (Port.tests): Ditto.
     41        (Port._expanded_paths): Ditto.
     42        (Port.skipped_layout_tests): Ditto.
     43        (Port.expectations_dict): Ditto.
     44        (Port._port_specific_expectations_files): Ditto.
     45        (Port.expectations_files): Ditto.
     46        (Port.test_search_path): Ditto.
     47        (Port._tests_for_other_platforms): Ditto.
     48        * Scripts/webkitpy/port/base_unittest.py:
     49        (PortTest.test_additional_platform_directory): Accept, but do not use, device_type.
     50        (PortTest.test_nonexistant_expectations): Ditto.
     51        (test_ref_tests_platform_directory): Ditto.
     52        * Scripts/webkitpy/port/darwin.py:
     53        (DarwinPort._port_specific_expectations_files): Accept device_type.
     54        * Scripts/webkitpy/port/driver.py:
     55        (DriverProxy):
     56        (DriverProxy.host): Expose _target_host for device_type information.
     57        * Scripts/webkitpy/port/gtk.py:
     58        (GtkPort._port_specific_expectations_files): Accept, but do not use, device_type.
     59        * Scripts/webkitpy/port/ios.py:
     60        (IOSPort. default_baseline_search_path): Remove memoized, since it does not accept **kwargs.
     61        * Scripts/webkitpy/port/mac.py:
     62        (MacPort. default_baseline_search_path): Ditto.
     63        * Scripts/webkitpy/port/port_testcase.py:
     64        (TestWebKitPort._tests_for_other_platforms): Accept, but do not use, device_type.
     65        * Scripts/webkitpy/port/test.py:
     66        * Scripts/webkitpy/port/watch.py:
     67        (WatchPort. default_baseline_search_path): Remove memoized, since it does not accept **kwargs.
     68        * Scripts/webkitpy/port/win.py:
     69        (WinPort.test_search_path): Accept, but do not use, device_type.
     70        * Scripts/webkitpy/port/wpe.py:
     71        (WPEPort._port_specific_expectations_files): Ditto.
     72        * Scripts/webkitpy/tool/servers/rebaselineserver.py:
     73        (get_test_baselines.AllPlatformsPort.baseline_search_path): Ditto.
     74
    1752019-01-15  Zalan Bujtas  <zalan@apple.com>
    276

  • trunk/Tools/Scripts/webkitpy/layout_tests/controllers/layout_test_runner.py

    r235771 r239989  
    295295        if test_input.reference_files is None:
    296296            # Lazy initialization.
    297             test_input.reference_files = self._port.reference_files(test_input.test_name)
     297            test_input.reference_files = self._port.reference_files(test_input.test_name, device_type=self._port.target_host(self._worker_number).device_type)
    298298        if test_input.reference_files:
    299299            test_input.should_run_pixel_test = True

  • trunk/Tools/Scripts/webkitpy/layout_tests/controllers/manager.py

    r239739 r239989  
    275275                    index += 1
    276276
     277            self._printer.print_baseline_search_path(device_type=device_type)
     278
    277279            _log.info('Running {}{}'.format(pluralize(len(tests), 'test'), ' for {}'.format(str(device_type)) if device_type else ''))
    278280            _log.info('')

  • trunk/Tools/Scripts/webkitpy/layout_tests/controllers/single_test_runner.py

    r217130 r239989  
    7070            # in either layout tests or reftests, but not in both.
    7171            for suffix in ('.txt', '.png', '.wav'):
    72                 expected_filename = self._port.expected_filename(self._test_name, suffix)
     72                expected_filename = self._port.expected_filename(self._test_name, suffix, device_type=self._driver.host.device_type)
    7373                if self._filesystem.exists(expected_filename):
    7474                    _log.error('%s is a reftest, but has an unused expectation file. Please remove %s.', self._test_name, expected_filename)
    7575
    7676    def _expected_driver_output(self):
    77         return DriverOutput(self._port.expected_text(self._test_name),
    78                                  self._port.expected_image(self._test_name),
    79                                  self._port.expected_checksum(self._test_name),
    80                                  self._port.expected_audio(self._test_name))
     77        return DriverOutput(self._port.expected_text(self._test_name, device_type=self._driver.host.device_type),
     78                                 self._port.expected_image(self._test_name, device_type=self._driver.host.device_type),
     79                                 self._port.expected_checksum(self._test_name, device_type=self._driver.host.device_type),
     80                                 self._port.expected_audio(self._test_name, device_type=self._driver.host.device_type))
    8181
    8282    def _should_fetch_expected_checksum(self):
    … …  
    9090        image_hash = None
    9191        if self._should_fetch_expected_checksum():
    92             image_hash = self._port.expected_checksum(self._test_name)
     92            image_hash = self._port.expected_checksum(self._test_name, device_type=self._driver.host.device_type)
    9393        return DriverInput(self._test_name, self._timeout, image_hash, self._should_run_pixel_test, self._should_dump_jsconsolelog_in_stderr)
    9494

  • trunk/Tools/Scripts/webkitpy/layout_tests/views/printing.py

    r239874 r239989  
    8282            self._print_default("Placing new baselines in %s" % self._port.baseline_path())
    8383
    84         fs = self._port.host.filesystem
    85         full_baseline_search_path = self._port.baseline_search_path()
    86         normalize_baseline = lambda baseline_search_path: [fs.relpath(x, self._port.layout_tests_dir()).replace("../", "") for x in baseline_search_path]
    87 
    88         self._print_default('Verbose baseline search path: {} -> generic'.format(' -> '.join(normalize_baseline(full_baseline_search_path))))
    89 
    90         self._print_default('')
    91         self._print_default('Baseline search path: {} -> generic'.format(' -> '.join(normalize_baseline([path for path in full_baseline_search_path if fs.exists(path)]))))
    92         self._print_default('')
    93 
    9484        self._print_default("Using %s build" % self._options.configuration)
    9585        if self._options.pixel_tests:
    … …  
    10292
    10393        self._print_default('Command line: ' + ' '.join(self._port.driver_cmd_line_for_logging()))
     94        self._print_default('')
     95
     96    def print_baseline_search_path(self, device_type=None):
     97        fs = self._port.host.filesystem
     98        full_baseline_search_path = self._port.baseline_search_path(device_type=device_type)
     99        normalize_baseline = lambda baseline_search_path: [
     100            fs.relpath(x, self._port.layout_tests_dir()).replace("../", "") for x in baseline_search_path]
     101
     102        self._print_default('Verbose baseline search path: {} -> generic'.format(
     103            ' -> '.join(normalize_baseline(full_baseline_search_path))))
     104
     105        self._print_default('')
     106        self._print_default('Baseline search path: {} -> generic'.format(
     107            ' -> '.join(normalize_baseline([path for path in full_baseline_search_path if fs.exists(path)]))))
    104108        self._print_default('')
    105109

  • trunk/Tools/Scripts/webkitpy/layout_tests/views/printing_unittest.py

    r239874 r239989  
    112112        self.assertIn('Test configuration: <leopard, x86, release>', err.getvalue())
    113113        self.assertIn('Placing test results in /tmp', err.getvalue())
    114         self.assertIn('Verbose baseline search path: platform/test-mac-leopard -> platform/test-mac-snowleopard -> generic', err.getvalue())
    115         self.assertIn('Baseline search path: platform/test-mac-leopard -> generic', err.getvalue())
    116114        self.assertIn('Using Release build', err.getvalue())
    117115        self.assertIn('Pixel tests enabled', err.getvalue())
    … …  
    119117        self.assertIn('Regular timeout: ', err.getvalue())
    120118
     119    def test_print_baseline_search_path(self):
     120        printer, err = self.get_printer()
     121        printer.print_baseline_search_path()
     122
     123        self.assertIn('Verbose baseline search path: platform/test-mac-leopard -> platform/test-mac-snowleopard -> generic', err.getvalue())
     124        self.assertIn('Baseline search path: platform/test-mac-leopard -> generic', err.getvalue())
     125
    121126        self.reset(err)
    122127        printer._options.quiet = True
    123         printer.print_config('/tmp')
     128        printer.print_baseline_search_path()
    124129        self.assertNotIn('Baseline search path: platform/test-mac-leopard -> platform/test-mac-snowleopard -> generic', err.getvalue())
    125130

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

    r239875 r239989  
    209209        return baseline_search_paths[0]
    210210
    211     def baseline_search_path(self):
    212         return self.get_option('additional_platform_directory', []) + self._compare_baseline() + self.default_baseline_search_path()
     211    def baseline_search_path(self, device_type=None):
     212        return self.get_option('additional_platform_directory', []) + self._compare_baseline() + self.default_baseline_search_path(device_type=device_type)
    213213
    214214    def default_baseline_search_path(self, device_type=None):
    … …  
    409409        return ('.wav', '.webarchive', '.txt', '.png')
    410410
    411     def _expected_baselines_for_suffixes(self, test_name, suffixes, all_baselines=False):
    412         baseline_search_path = self.baseline_search_path() + [self.layout_tests_dir()]
     411    def _expected_baselines_for_suffixes(self, test_name, suffixes, all_baselines=False, device_type=None):
     412        baseline_search_path = self.baseline_search_path(device_type=device_type) + [self.layout_tests_dir()]
    413413
    414414        baselines = []
    … …  
    429429        return baselines
    430430
    431     def expected_baselines(self, test_name, suffix, all_baselines=False):
     431    def expected_baselines(self, test_name, suffix, all_baselines=False, device_type=None):
    432432        """Given a test name, finds where the baseline results are located.
    433433
    … …  
    456456        platform specific.
    457457        """
    458         return self._expected_baselines_for_suffixes(test_name, [suffix], all_baselines=all_baselines)
    459 
    460     def expected_filename(self, test_name, suffix, return_default=True):
     458        return self._expected_baselines_for_suffixes(test_name, [suffix], all_baselines=all_baselines, device_type=device_type)
     459
     460    def expected_filename(self, test_name, suffix, return_default=True, device_type=None):
    461461        """Given a test name, returns an absolute path to its expected results.
    462462
    … …  
    478478        the other baseline and filename manipulation routines.
    479479        """
    480         platform_dir, baseline_filename = self.expected_baselines(test_name, suffix)[0]
     480        platform_dir, baseline_filename = self.expected_baselines(test_name, suffix, device_type=device_type)[0]
    481481        if platform_dir or return_default:
    482482            return self._filesystem.join(platform_dir or self.layout_tests_dir(), baseline_filename)
    483483        return None
    484484
    485     def expected_checksum(self, test_name):
     485    def expected_checksum(self, test_name, device_type=None):
    486486        """Returns the checksum of the image we expect the test to produce, or None if it is a text-only test."""
    487         png_path = self.expected_filename(test_name, '.png')
     487        png_path = self.expected_filename(test_name, '.png', device_type=device_type)
    488488
    489489        if self._filesystem.exists(png_path):
    … …  
    493493        return None
    494494
    495     def expected_image(self, test_name):
     495    def expected_image(self, test_name, device_type=None):
    496496        """Returns the image we expect the test to produce."""
    497         baseline_path = self.expected_filename(test_name, '.png')
     497        baseline_path = self.expected_filename(test_name, '.png', device_type=device_type)
    498498        if not self._filesystem.exists(baseline_path):
    499499            return None
    500500        return self._filesystem.read_binary_file(baseline_path)
    501501
    502     def expected_audio(self, test_name):
    503         baseline_path = self.expected_filename(test_name, '.wav')
     502    def expected_audio(self, test_name, device_type=None):
     503        baseline_path = self.expected_filename(test_name, '.wav', device_type=device_type)
    504504        if not self._filesystem.exists(baseline_path):
    505505            return None
    506506        return self._filesystem.read_binary_file(baseline_path)
    507507
    508     def expected_text(self, test_name):
     508    def expected_text(self, test_name, device_type=None):
    509509        """Returns the text output we expect the test to produce, or None
    510510        if we don't expect there to be any text output.
    … …  
    513513        # output from DRT (instead treating it as a binary string), we read the
    514514        # baselines as a binary string, too.
    515         baseline_path = self.expected_filename(test_name, '.txt')
     515        baseline_path = self.expected_filename(test_name, '.txt', device_type=device_type)
    516516        if not self._filesystem.exists(baseline_path):
    517             baseline_path = self.expected_filename(test_name, '.webarchive')
     517            baseline_path = self.expected_filename(test_name, '.webarchive', device_type=device_type)
    518518            if not self._filesystem.exists(baseline_path):
    519519                return None
    … …  
    544544        return parsed_list
    545545
    546     def reference_files(self, test_name):
     546    def reference_files(self, test_name, device_type=None):
    547547        """Return a list of expectation (== or !=) and filename pairs"""
    548548
    … …  
    559559            for part2 in self._supported_reference_extensions:
    560560                suffixes.append(part1 + part2)
    561         for platform_dir, baseline_filename in self._expected_baselines_for_suffixes(test_name, suffixes):
     561        for platform_dir, baseline_filename in self._expected_baselines_for_suffixes(test_name, suffixes, device_type=device_type):
    562562            if not platform_dir:
    563563                continue
    … …  
    580580        return [self.host.filesystem.relpath(test, self.layout_tests_dir()) for test in self._filesystem.glob(re.sub('-expected.*', '.*', self._filesystem.join(self.layout_tests_dir(), path))) if self._filesystem.isfile(test)]
    581581
    582     def tests(self, paths):
     582    def tests(self, paths, device_type=None):
    583583        """Return the list of tests found. Both generic and platform-specific tests matching paths should be returned."""
    584         expanded_paths = self._expanded_paths(paths)
     584        expanded_paths = self._expanded_paths(paths, device_type=device_type)
    585585        return self._real_tests(expanded_paths)
    586586
    587     def _expanded_paths(self, paths):
     587    def _expanded_paths(self, paths, device_type=None):
    588588        expanded_paths = []
    589589        fs = self._filesystem
    … …  
    593593            if self.test_isdir(path) and not path.startswith('platform') and not fs.isabs(path):
    594594                for platform_dir in all_platform_dirs:
    595                     if fs.isdir(fs.join(platform_dir, path)) and platform_dir in self.baseline_search_path():
     595                    if fs.isdir(fs.join(platform_dir, path)) and platform_dir in self.baseline_search_path(device_type=device_type):
    596596                        expanded_paths.append(self.relative_test_filename(fs.join(platform_dir, path)))
    597597
    … …  
    754754        return self._webkit_finder.perf_tests_dir()
    755755
    756     def skipped_layout_tests(self, test_list):
     756    def skipped_layout_tests(self, test_list, device_type=None):
    757757        """Returns tests skipped outside of the TestExpectations files."""
    758         return set(self._tests_for_other_platforms()).union(self._skipped_tests_for_unsupported_features(test_list))
     758        return set(self._tests_for_other_platforms(device_type=device_type)).union(self._skipped_tests_for_unsupported_features(test_list))
    759759
    760760    @memoized
    … …  
    11601160        return False
    11611161
    1162     def expectations_dict(self):
     1162    def expectations_dict(self, device_type=None):
    11631163        """Returns an OrderedDict of name -> expectations strings.
    11641164        The names are expected to be (but not required to be) paths in the filesystem.
    … …  
    11711171        expectations = OrderedDict()
    11721172
    1173         for path in self.expectations_files():
     1173        for path in self.expectations_files(device_type=device_type):
    11741174            if self._filesystem.exists(path):
    11751175                expectations[path] = self._filesystem.read_text_file(path)
    … …  
    11841184        return expectations
    11851185
    1186     def _port_specific_expectations_files(self):
     1186    def _port_specific_expectations_files(self, **kwargs):
    11871187        # Unlike baseline_search_path, we only want to search [WK2-PORT, PORT-VERSION, PORT] and any directories
    11881188        # included via --additional-platform-directory, not the full casade.
    … …  
    12021202        return [self._filesystem.join(self._webkit_baseline_path(d), 'TestExpectations') for d in search_paths]
    12031203
    1204     def expectations_files(self):
    1205         return [self.path_to_generic_test_expectations_file()] + self._port_specific_expectations_files()
     1204    def expectations_files(self, device_type=None):
     1205        return [self.path_to_generic_test_expectations_file()] + self._port_specific_expectations_files(device_type=device_type)
    12061206
    12071207    def repository_paths(self):
    … …  
    15351535        return []
    15361536
    1537     def test_search_path(self):
    1538         return self.baseline_search_path()
    1539 
    1540     def _tests_for_other_platforms(self):
     1537    def test_search_path(self, device_type=None):
     1538        return self.baseline_search_path(device_type=device_type)
     1539
     1540    def _tests_for_other_platforms(self, device_type=None):
    15411541        # By default we will skip any directory under LayoutTests/platform
    15421542        # that isn't in our baseline search path (this mirrors what
    … …  
    15461546        dirs_to_skip = []
    15471547        for entry in entries:
    1548             if self._filesystem.isdir(entry) and entry not in self.test_search_path():
     1548            if self._filesystem.isdir(entry) and entry not in self.test_search_path(device_type=device_type):
    15491549                basename = self._filesystem.basename(entry)
    15501550                dirs_to_skip.append('platform/%s' % basename)

  • trunk/Tools/Scripts/webkitpy/port/base_unittest.py

    r239048 r239989  
    162162    def test_additional_platform_directory(self):
    163163        port = self.make_port(port_name='foo')
    164         port.default_baseline_search_path = lambda: ['LayoutTests/platform/foo']
     164        port.default_baseline_search_path = lambda **kwargs: ['LayoutTests/platform/foo']
    165165        test_file = 'fast/test.html'
    166166
    … …  
    188188    def test_nonexistant_expectations(self):
    189189        port = self.make_port(port_name='foo')
    190         port.expectations_files = lambda: ['/mock-checkout/LayoutTests/platform/exists/TestExpectations', '/mock-checkout/LayoutTests/platform/nonexistant/TestExpectations']
     190        port.expectations_files = lambda **kwargs: ['/mock-checkout/LayoutTests/platform/exists/TestExpectations', '/mock-checkout/LayoutTests/platform/nonexistant/TestExpectations']
    191191        port._filesystem.write_text_file('/mock-checkout/LayoutTests/platform/exists/TestExpectations', '')
    192192        self.assertEqual('\n'.join(port.expectations_dict().keys()), '/mock-checkout/LayoutTests/platform/exists/TestExpectations')
    … …  
    414414    def test_ref_tests_platform_directory(self):
    415415        port = self.make_port(port_name='foo')
    416         port.default_baseline_search_path = lambda: ['/mock-checkout/LayoutTests/platform/foo']
     416        port.default_baseline_search_path = lambda **kwargs: ['/mock-checkout/LayoutTests/platform/foo']
    417417        port._filesystem.write_text_file('/mock-checkout/LayoutTests/fast/ref-expected.html', 'foo')
    418418

  • trunk/Tools/Scripts/webkitpy/port/darwin.py

    r229085 r239989  
    5454        return super(DarwinPort, self).default_timeout_ms()
    5555
    56     def _port_specific_expectations_files(self):
    57         return list(reversed([self._filesystem.join(self._webkit_baseline_path(p), 'TestExpectations') for p in self.baseline_search_path()]))
     56    def _port_specific_expectations_files(self, device_type=None):
     57        return list(reversed([self._filesystem.join(self._webkit_baseline_path(p), 'TestExpectations') for p in self.baseline_search_path(device_type=device_type)]))
    5858
    5959    def check_for_leaks(self, process_name, process_pid):

  • trunk/Tools/Scripts/webkitpy/port/driver.py

    r235467 r239989  
    720720        return self._driver_instance_constructor(self._port, self._worker_number, pixel_tests, self._no_timeout)
    721721
     722    @property
     723    def host(self):
     724        return self._driver._target_host
     725
    722726    # FIXME: this should be a @classmethod (or implemented on Port instead).
    723727    def is_http_test(self, test_name):

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

    r239875 r239989  
    214214        return map(self._webkit_baseline_path, self._search_paths())
    215215
    216     def _port_specific_expectations_files(self):
     216    def _port_specific_expectations_files(self, **kwargs):
    217217        return [self._filesystem.join(self._webkit_baseline_path(p), 'TestExpectations') for p in reversed(self._search_paths())]
    218218

  • trunk/Tools/Scripts/webkitpy/port/ios.py

    r239875 r239989  
    5353        return VersionNameMap.map(self.host.platform).to_name(self._os_version, platform=IOSPort.port_name)
    5454
    55     @memoized
    5655    def default_baseline_search_path(self, device_type=None):
    5756        wk_string = 'wk1'

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

    r239875 r239989  
    7070        return ['ARCHS=i386'] if self.architecture() == 'x86' else []
    7171
    72     @memoized
    7372    def default_baseline_search_path(self, **kwargs):
    7473        versions_to_fallback = []

  • trunk/Tools/Scripts/webkitpy/port/port_testcase.py

    r238944 r239989  
    7171        return self.symbols_string
    7272
    73     def _tests_for_other_platforms(self):
     73    def _tests_for_other_platforms(self, **kwargs):
    7474        return ["media", ]
    7575

  • trunk/Tools/Scripts/webkitpy/port/test.py

    r238903 r239989  
    408408        return 'MOCK _path_to_driver'
    409409
    410     def baseline_search_path(self):
     410    def baseline_search_path(self, **kwargs):
    411411        search_paths = {
    412412            'test-mac-snowleopard': ['test-mac-snowleopard'],

  • trunk/Tools/Scripts/webkitpy/port/watch.py

    r239875 r239989  
    5959        return 4
    6060
    61     @memoized
    6261    def default_baseline_search_path(self, **kwargs):
    6362        versions_to_fallback = []

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

    r239875 r239989  
    218218        return {binary.split('.')[0]: self._build_path(binary) for binary in self.API_TEST_BINARY_NAMES}
    219219
    220     def test_search_path(self):
     220    def test_search_path(self, **kwargs):
    221221        test_fallback_names = [path for path in self.baseline_search_path() if not path.startswith(self._webkit_baseline_path('mac'))]
    222222        return map(self._webkit_baseline_path, test_fallback_names)

  • trunk/Tools/Scripts/webkitpy/port/wpe.py

    r239875 r239989  
    106106        return map(self._webkit_baseline_path, self._search_paths())
    107107
    108     def _port_specific_expectations_files(self):
     108    def _port_specific_expectations_files(self, **kwargs):
    109109        return map(lambda x: self._filesystem.join(self._webkit_baseline_path(x), 'TestExpectations'), reversed(self._search_paths()))
    110110

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

    r225733 r239989  
    169169            self._platforms_by_directory = dict([(self._webkit_baseline_path(p), p) for p in test_config.platforms])
    170170
    171         def baseline_search_path(self):
     171        def baseline_search_path(self, **kwargs):
    172172            return self._platforms_by_directory.keys()
    173173
Note: See TracChangeset for help on using the changeset viewer.