⚠ Archived content — this site is no longer maintained.   Current WebKit documentation is at docs.webkit.org.

Changeset 99781 in webkit


Ignore:
Timestamp:
Nov 9, 2011, 4:24:08 PM (15 years ago)
Author:
eric@webkit.org
Message:

Remove the concept of platform-dependent unittests
https://bugs.webkit.org/show_bug.cgi?id=71963

Reviewed by Adam Barth.

These have been the source of never-ending sadness.
We'd change behavior and forget to update results in
some unittests because they were only run on certain platforms.
This change removes a large source of these platform-dependent
unittests, which was caused by the port_maker stuff.

It's possible that this change will break test-webkitpy
on some platforms, but that will be a one-time cost.
I will fix the breakage by removing the platform-dependantness
of any such broken tests.

  • Scripts/webkitpy/layout_tests/port/base_unittest.py:
  • Scripts/webkitpy/layout_tests/port/chromium_linux_unittest.py:
  • Scripts/webkitpy/layout_tests/port/chromium_mac_unittest.py:
  • Scripts/webkitpy/layout_tests/port/chromium_unittest.py:
  • Scripts/webkitpy/layout_tests/port/chromium_win.py:
  • Scripts/webkitpy/layout_tests/port/chromium_win_unittest.py:
  • Scripts/webkitpy/layout_tests/port/efl_unittest.py:
  • Scripts/webkitpy/layout_tests/port/gtk_unittest.py:
  • Scripts/webkitpy/layout_tests/port/mac_unittest.py:
  • Scripts/webkitpy/layout_tests/port/port_testcase.py:
  • Scripts/webkitpy/layout_tests/port/qt_unittest.py:
  • Scripts/webkitpy/layout_tests/port/webkit_unittest.py:
  • Scripts/webkitpy/layout_tests/port/win_unittest.py:
Location:
trunk/Tools
Files:
14 edited

Legend:

Unmodified
Added
Removed
  • trunk/Tools/ChangeLog

    r99773 r99781  
     12011-11-09  Eric Seidel  <eric@webkit.org>
     2
     3        Remove the concept of platform-dependent unittests
     4        https://bugs.webkit.org/show_bug.cgi?id=71963
     5
     6        Reviewed by Adam Barth.
     7
     8        These have been the source of never-ending sadness.
     9        We'd change behavior and forget to update results in
     10        some unittests because they were only run on certain platforms.
     11        This change removes a large source of these platform-dependent
     12        unittests, which was caused by the port_maker stuff.
     13
     14        It's possible that this change will break test-webkitpy
     15        on some platforms, but that will be a one-time cost.
     16        I will fix the breakage by removing the platform-dependantness
     17        of any such broken tests.
     18
     19        * Scripts/webkitpy/layout_tests/port/base_unittest.py:
     20        * Scripts/webkitpy/layout_tests/port/chromium_linux_unittest.py:
     21        * Scripts/webkitpy/layout_tests/port/chromium_mac_unittest.py:
     22        * Scripts/webkitpy/layout_tests/port/chromium_unittest.py:
     23        * Scripts/webkitpy/layout_tests/port/chromium_win.py:
     24        * Scripts/webkitpy/layout_tests/port/chromium_win_unittest.py:
     25        * Scripts/webkitpy/layout_tests/port/efl_unittest.py:
     26        * Scripts/webkitpy/layout_tests/port/gtk_unittest.py:
     27        * Scripts/webkitpy/layout_tests/port/mac_unittest.py:
     28        * Scripts/webkitpy/layout_tests/port/port_testcase.py:
     29        * Scripts/webkitpy/layout_tests/port/qt_unittest.py:
     30        * Scripts/webkitpy/layout_tests/port/webkit_unittest.py:
     31        * Scripts/webkitpy/layout_tests/port/win_unittest.py:
     32
    1332011-11-09  Eric Seidel  <eric@webkit.org>
    234
  • trunk/Tools/Scripts/webkitpy/layout_tests/port/base_unittest.py

    r99773 r99781  
    4949
    5050class PortTest(unittest.TestCase):
    51     def make_port(self, *args, **kwargs):
    52         kwargs.setdefault('host', MockHost())
    53         return Port(*args, **kwargs)
     51    def make_port(self, host=None, **kwargs):
     52        host = host or MockHost()
     53        return Port(host, **kwargs)
    5454
    5555    def test_format_wdiff_output_as_html(self):
  • trunk/Tools/Scripts/webkitpy/layout_tests/port/chromium_linux_unittest.py

    r99773 r99781  
    3737
    3838class ChromiumLinuxPortTest(port_testcase.PortTestCase):
    39     def port_maker(self, platform):
    40         if not platform.startswith('linux'):
    41             return None
    42         return chromium_linux.ChromiumLinuxPort
     39    port_maker = chromium_linux.ChromiumLinuxPort
    4340
    44     def assert_architecture(self, port_name=None, file_output=None,
    45                             expected_architecture=None):
     41    def assert_architecture(self, port_name=None, file_output=None, expected_architecture=None):
    4642        host = MockHost()
    4743        host.filesystem.exists = lambda x: 'DumpRenderTree' in x
  • trunk/Tools/Scripts/webkitpy/layout_tests/port/chromium_mac_unittest.py

    r99773 r99781  
    3737
    3838class ChromiumMacPortTest(port_testcase.PortTestCase):
    39     def port_maker(self, platform):
    40         # FIXME: This platform check should be removed!
    41         if platform != 'darwin':
    42             return None
    43         return chromium_mac.ChromiumMacPort
     39    port_maker = chromium_mac.ChromiumMacPort
    4440
    4541    def test_check_wdiff(self):
    46         port = chromium_mac.ChromiumMacPort(MockHost())
    47         self.assertTrue(port.check_wdiff())
     42        self.assertTrue(self.make_port().check_wdiff())
    4843
    4944    def assert_name(self, port_name, os_version_string, expected):
    50         port = chromium_mac.ChromiumMacPort(MockHost(), port_name=port_name, os_version_string=os_version_string)
     45        port = self.make_port(port_name=port_name, os_version_string=os_version_string)
    5146        self.assertEquals(expected, port.name())
    5247
    5348    def test_versions(self):
    54         port = chromium_mac.ChromiumMacPort(MockHost())
    55         self.assertTrue(port.name() in ('chromium-cg-mac-leopard', 'chromium-cg-mac-snowleopard', 'chromium-cg-mac-lion', 'chromium-cg-mac-future'))
     49        self.assertTrue(self.make_port().name() in ('chromium-cg-mac-leopard', 'chromium-cg-mac-snowleopard', 'chromium-cg-mac-lion', 'chromium-cg-mac-future'))
    5650
    5751        self.assert_name(None, '10.5.3', 'chromium-cg-mac-leopard')
     
    7771
    7872    def test_baseline_path(self):
    79         port = chromium_mac.ChromiumMacPort(MockHost(), port_name='chromium-mac-leopard')
     73        port = self.make_port(port_name='chromium-mac-leopard')
    8074        self.assertEquals(port.baseline_path(), port._webkit_baseline_path('chromium-mac-leopard'))
    8175
    82         port = chromium_mac.ChromiumMacPort(MockHost(), port_name='chromium-mac-snowleopard')
     76        port = self.make_port(port_name='chromium-mac-snowleopard')
    8377        self.assertEquals(port.baseline_path(), port._webkit_baseline_path('chromium-mac-snowleopard'))
    8478
    85         port = chromium_mac.ChromiumMacPort(MockHost(), port_name='chromium-mac-lion')
     79        port = self.make_port(port_name='chromium-mac-lion')
    8680        self.assertEquals(port.baseline_path(), port._webkit_baseline_path('chromium-mac'))
    8781
    8882    def test_graphics_type(self):
    89         port = chromium_mac.ChromiumMacPort(MockHost(), port_name='chromium-cg-mac')
    90         self.assertEquals('cpu-cg', port.graphics_type())
    91         port = chromium_mac.ChromiumMacPort(MockHost(), port_name='chromium-mac')
    92         self.assertEquals('cpu', port.graphics_type())
     83        self.assertEquals('cpu-cg', self.make_port(port_name='chromium-cg-mac').graphics_type())
     84        self.assertEquals('cpu', self.make_port(port_name='chromium-mac').graphics_type())
    9385        # For now, Mac defaults to cpu-cg graphics type.
    94         port = chromium_mac.ChromiumMacPort(MockHost())
    95         self.assertEquals('cpu-cg', port.graphics_type())
     86        self.assertEquals('cpu-cg', self.make_port().graphics_type())
    9687
    9788
  • trunk/Tools/Scripts/webkitpy/layout_tests/port/chromium_unittest.py

    r99773 r99781  
    118118
    119119class ChromiumPortTest(port_testcase.PortTestCase):
    120     def port_maker(self, platform):
    121         return chromium.ChromiumPort
     120    port_maker = chromium.ChromiumPort
    122121
    123122    def test_all_test_configurations(self):
     
    277276    def test_overrides_and_builder_names(self):
    278277        port = self.make_port()
    279         if not port:
    280             return
    281278
    282279        filesystem = MockFileSystem()
  • trunk/Tools/Scripts/webkitpy/layout_tests/port/chromium_win.py

    r99773 r99781  
    5656
    5757class ChromiumWinPort(chromium.ChromiumPort):
    58     """Chromium Win implementation of the Port class."""
    59 
    6058    # FIXME: Figure out how to unify this with base.TestConfiguration.all_systems()?
    6159    SUPPORTED_VERSIONS = ('xp', 'vista', 'win7')
  • trunk/Tools/Scripts/webkitpy/layout_tests/port/chromium_win_unittest.py

    r99773 r99781  
    3333from webkitpy.common.system import outputcapture
    3434from webkitpy.common.host_mock import MockHost
     35from webkitpy.common.system.executive_mock import MockExecutive
    3536from webkitpy.common.system.filesystem_mock import MockFileSystem
    3637
     
    5253        self._port = None
    5354
    54     def port_maker(self, platform):
    55         if platform not in ('cygwin', 'win32'):
    56             return None
    57         return chromium_win.ChromiumWinPort
     55    port_maker = chromium_win.ChromiumWinPort
    5856
    5957    def _mock_path_from_chromium_base(self, *comps):
     
    6159
    6260    def test_uses_apache(self):
    63         port = self.make_port()
    64         if not port:
    65             return
    66 
    67         self.assertFalse(port._uses_apache())
     61        self.assertFalse(self.make_port()._uses_apache())
    6862
    6963    def test_setup_environ_for_server(self):
    7064        port = self.make_port()
    71         if not port:
    72             return
    7365
    7466        port._executive = MockExecutive(should_log=True)
     
    8375    def test_setup_environ_for_server_register_cygwin(self):
    8476        port = self.make_port(options=ChromiumWinTest.RegisterCygwinOption())
    85         if not port:
    86             return
    8777
    8878        port._executive = MockExecutive(should_log=True)
     
    9080        self._port = port
    9181        setup_mount = self._mock_path_from_chromium_base("third_party", "cygwin", "setup_mount.bat")
    92         expected_stderr = "MOCK run_command: %s, cwd=None\n" % [setup_mount]
     82        # FIXME: This is kinda lame, we only run setup_mount on win32 platforms, so we only expect the run_command output there.
     83        if sys.platform != "win32":
     84            expected_stderr = ""
     85        else:
     86            expected_stderr = "MOCK run_command: %s, cwd=None\n" % [setup_mount]
    9387        output = outputcapture.OutputCapture()
    9488        output.assert_outputs(self, port.setup_environ_for_server, expected_stderr=expected_stderr)
  • trunk/Tools/Scripts/webkitpy/layout_tests/port/efl_unittest.py

    r99140 r99781  
    3434
    3535class EflPortTest(port_testcase.PortTestCase):
    36     def port_maker(self, platform):
    37         return EflPort
     36    port_maker = EflPort
    3837
    3938    def test_show_results_html_file(self):
  • trunk/Tools/Scripts/webkitpy/layout_tests/port/gtk_unittest.py

    r99140 r99781  
    3636
    3737class GtkPortTest(port_testcase.PortTestCase):
    38     def port_maker(self, platform):
    39         return GtkPort
     38    port_maker = GtkPort
    4039
    4140    def test_show_results_html_file(self):
  • trunk/Tools/Scripts/webkitpy/layout_tests/port/mac_unittest.py

    r99773 r99781  
    3737
    3838class MacTest(port_testcase.PortTestCase):
    39     def port_maker(self, platform):
    40         # FIXME: This platform check should no longer be necessary and should be removed as soon as possible.
    41         if platform != 'darwin':
    42             return None
    43         return MacPort
     39    port_maker = MacPort
    4440
    4541    def assert_skipped_file_search_paths(self, port_name, expected_paths):
    46         port = MacPort(MockHost(), port_name=port_name)
     42        port = self.make_port(port_name=port_name)
    4743        self.assertEqual(port._skipped_file_search_paths(), expected_paths)
    4844
     
    7571
    7672    def test_tests_from_skipped_file_contents(self):
    77         port = MacPort(MockHost())
     73        port = self.make_port()
    7874        self.assertEqual(port._tests_from_skipped_file_contents(self.example_skipped_file), self.example_skipped_tests)
    7975
    8076    def assert_name(self, port_name, os_version_string, expected):
    81         port = MacPort(MockHost(), port_name=port_name, os_version_string=os_version_string)
     77        port = self.make_port(port_name=port_name, os_version_string=os_version_string)
    8278        self.assertEquals(expected, port.name())
    8379
  • trunk/Tools/Scripts/webkitpy/layout_tests/port/port_testcase.py

    r99773 r99781  
    4848from webkitpy.common.system.executive_mock import MockExecutive
    4949from webkitpy.common.host_mock import MockHost
    50 mock_options = MockOptions(configuration='Release')
    5150
    5251
     
    5655    WEBSOCKET_PORTS = (8880,)
    5756
    58     def port_maker(self, platform):
    59         """Override to return the class object of the port to be tested,
    60         or None if a valid port object cannot be constructed on the specified
    61         platform."""
    62         raise NotImplementedError()
    63 
    64     def make_port(self, options=mock_options):
    65         """This routine should be used for tests that should only be run
    66         when we can create a full, valid port object."""
    67         maker = self.port_maker(sys.platform)
    68         if not maker:
    69             return None
    70 
    71         return maker(options=options, host=MockHost())
     57    # Subclasses override this to point to their Port subclass.
     58    port_maker = None
     59
     60    def make_port(self, host=None, options=None, **kwargs):
     61        host = host or MockHost()
     62        options = options or MockOptions(configuration='Release')
     63        return self.port_maker(host, options=options, **kwargs)
    7264
    7365    def test_default_worker_model(self):
    7466        port = self.make_port()
    75         if not port:
    76             return
    77 
    7867        if multiprocessing:
    7968            self.assertEqual(port.default_worker_model(), 'processes')
     
    8372    def test_driver_cmd_line(self):
    8473        port = self.make_port()
    85         if not port:
    86             return
    8774        self.assertTrue(len(port.driver_cmd_line()))
    8875
     
    9481
    9582    def test_uses_apache(self):
    96         port = self.make_port()
    97         if not port:
    98             return
    99 
    100         self.assertTrue(port._uses_apache())
     83        self.assertTrue(self.make_port()._uses_apache())
    10184
    10285    def assert_servers_are_down(self, host, ports):
     
    123106    def integration_test_http_lock(self):
    124107        port = self.make_port()
    125         if not port:
    126             return
    127108        # Only checking that no exception is raised.
    128109        port.acquire_http_lock()
     
    131112    def integration_test_check_sys_deps(self):
    132113        port = self.make_port()
    133         if not port:
    134             return
    135114        # Only checking that no exception is raised.
    136115        port.check_sys_deps(True)
     
    138117    def integration_test_helper(self):
    139118        port = self.make_port()
    140         if not port:
    141             return
    142119        # Only checking that no exception is raised.
    143120        port.start_helper()
     
    146123    def integration_test_http_server__normal(self):
    147124        port = self.make_port()
    148         if not port:
    149             return
    150125        self.assert_servers_are_down('localhost', self.HTTP_PORTS)
    151126        port.start_http_server()
     
    156131    def integration_test_http_server__fails(self):
    157132        port = self.make_port()
    158         if not port:
    159             return
    160133        # Test that if a port isn't available, the call fails.
    161134        for port_number in self.HTTP_PORTS:
     
    188161        # first port to be treated as stale and killed.
    189162        port = self.make_port()
    190         if not port:
    191             return
    192163        # Test that if a port isn't available, the call fails.
    193164        port.start_http_server()
     
    213184    def integration_test_image_diff(self):
    214185        port = self.make_port()
    215         if not port:
    216             return
    217 
     186        # FIXME: This test will never run since we are using a MockFilesystem for these tests!?!?
    218187        if not port.check_image_diff():
    219188            # The port hasn't been built - don't run the tests.
     
    238207    def test_diff_image__missing_both(self):
    239208        port = self.make_port()
    240         if not port:
    241             return
    242209        self.assertFalse(port.diff_image(None, None)[0])
    243210        self.assertFalse(port.diff_image(None, '')[0])
     
    247214    def test_diff_image__missing_actual(self):
    248215        port = self.make_port()
    249         if not port:
    250             return
    251216        self.assertTrue(port.diff_image(None, 'foo')[0])
    252217        self.assertTrue(port.diff_image('', 'foo')[0])
     
    254219    def test_diff_image__missing_expected(self):
    255220        port = self.make_port()
    256         if not port:
    257             return
    258221        self.assertTrue(port.diff_image('foo', None)[0])
    259222        self.assertTrue(port.diff_image('foo', '')[0])
     
    261224    def test_check_build(self):
    262225        port = self.make_port()
    263         if not port:
    264             return
    265226        port.check_build(needs_http=True)
    266227
    267228    def test_check_wdiff(self):
    268229        port = self.make_port()
    269         if not port:
    270             return
    271230        port.check_wdiff()
    272231
    273232    def integration_test_websocket_server__normal(self):
    274233        port = self.make_port()
    275         if not port:
    276             return
    277 
    278234        self.assert_servers_are_down('localhost', self.WEBSOCKET_PORTS)
    279235        port.start_websocket_server()
     
    284240    def integration_test_websocket_server__fails(self):
    285241        port = self.make_port()
    286         if not port:
    287             return
    288242
    289243        # Test that start() fails if a port isn't available.
     
    310264    def integration_test_websocket_server__two_servers(self):
    311265        port = self.make_port()
    312         if not port:
    313             return
    314266
    315267        # Test that calling start() on two different ports causes the
     
    337289    def test_test_configuration(self):
    338290        port = self.make_port()
    339         if not port:
    340             return
    341291        self.assertTrue(port.test_configuration())
    342292
    343293    def test_all_test_configurations(self):
    344294        port = self.make_port()
    345         if not port:
    346             return
    347295        self.assertTrue(len(port.all_test_configurations()) > 0)
    348296        self.assertTrue(port.test_configuration() in port.all_test_configurations(), "%s not in %s" % (port.test_configuration(), port.all_test_configurations()))
     
    350298    def integration_test_http_server__loop(self):
    351299        port = self.make_port()
    352         if not port:
    353             return
    354300
    355301        i = 0
  • trunk/Tools/Scripts/webkitpy/layout_tests/port/qt_unittest.py

    r99773 r99781  
    4040
    4141class QtPortTest(port_testcase.PortTestCase):
    42     def port_maker(self, platform):
    43         return QtPort
     42    port_maker = QtPort
    4443
    4544    def _assert_search_path(self, search_paths, sys_platform, use_webkit2=False, qt_version='4.7'):
  • trunk/Tools/Scripts/webkitpy/layout_tests/port/webkit_unittest.py

    r99773 r99781  
    8181
    8282class WebKitPortTest(port_testcase.PortTestCase):
    83     def port_maker(self, platform):
    84         return TestWebKitPort
     83    port_maker = TestWebKitPort
    8584
    8685    def test_check_build(self):
  • trunk/Tools/Scripts/webkitpy/layout_tests/port/win_unittest.py

    r99773 r99781  
    4242
    4343class WinPortTest(port_testcase.PortTestCase):
    44     def port_maker(self, platform):
    45         return WinPort
     44    port_maker = WinPort
    4645
    4746    def test_show_results_html_file(self):
Note: See TracChangeset for help on using the changeset viewer.