Changeset 104725 in webkit


Ignore:
Timestamp:
Jan 11, 2012 11:26:25 AM (12 years ago)
Author:
dpranke@chromium.org
Message:

webkitpy: clean up version detection in webkitpy.layout_tests.port
​https://bugs.webkit.org/show_bug.cgi?id=76016

Reviewed by Adam Barth.

This change updates the code in webkitpy.layout_tests.port to
use the new os_name and os_version fields on host.platform. This
gets layout_tests.port out of the version parsing business. Most
of the diffs are just cleaning up test code to accomodate the
changes.

  • Scripts/webkitpy/common/system/executive_mock.py:

(MockExecutive):
(MockExecutive.ignore_error):
(MockExecutive2):
(MockExecutive2.ignore_error):

  • Scripts/webkitpy/common/system/platforminfo_mock.py:

(MockPlatformInfo.is_mac):
(MockPlatformInfo.is_linux):
(MockPlatformInfo.is_win):

  • Scripts/webkitpy/common/system/systemhost_mock.py:

(MockSystemHost.init):

  • Scripts/webkitpy/layout_tests/port/apple.py:

(ApplePort.init):

  • Scripts/webkitpy/layout_tests/port/chromium_mac.py:

(ChromiumMacPort.init):
(ChromiumMacPort.check_wdiff):

  • Scripts/webkitpy/layout_tests/port/chromium_mac_unittest.py:

(ChromiumMacPortTest):
(ChromiumMacPortTest.assert_name):
(ChromiumMacPortTest.test_versions):

  • Scripts/webkitpy/layout_tests/port/chromium_unittest.py:

(ChromiumPortTest.test_all_test_configurations):
(ChromiumPortTest.TestMacPort.init):
(ChromiumPortTest.TestLinuxPort.init):
(ChromiumPortTest.TestWinPort.init):

  • Scripts/webkitpy/layout_tests/port/chromium_win.py:

(ChromiumWinPort.init):

  • Scripts/webkitpy/layout_tests/port/chromium_win_unittest.py:

(ChromiumWinTest):
(ChromiumWinTest.assert_name):
(ChromiumWinTest.test_versions):
(ChromiumWinTest.test_baseline_path):
(ChromiumWinTest.test_build_path):

  • Scripts/webkitpy/layout_tests/port/factory.py:

(PortFactory._port_name_from_arguments_and_options):
(PortFactory.get):

  • Scripts/webkitpy/layout_tests/port/factory_unittest.py:

(FactoryTest):
(FactoryTest.setUp):
(FactoryTest.assert_port):
(FactoryTest.test_mac):
(FactoryTest.test_win):
(FactoryTest.test_google_chrome):
(FactoryTest.test_gtk):
(FactoryTest.test_qt):
(FactoryTest.test_chromium_gpu):
(FactoryTest.test_chromium_gpu_linux):
(FactoryTest.test_chromium_gpu_mac):
(FactoryTest.test_chromium_gpu_win):
(FactoryTest.test_chromium_mac):
(FactoryTest.test_chromium_linux):
(FactoryTest.test_chromium_win):
(FactoryTest.test_unknown_specified):
(FactoryTest.test_unknown_default):

  • Scripts/webkitpy/layout_tests/port/google_chrome_unittest.py:

(TestGoogleChromePort):
(TestGoogleChromePort._verify_baseline_path):
(TestGoogleChromePort._verify_expectations_overrides):
(TestGoogleChromePort.test_get_google_chrome_port):

  • Scripts/webkitpy/layout_tests/port/mac.py:

(MacPort):

  • Scripts/webkitpy/layout_tests/port/mac_unittest.py:

(MacTest):
(assert_name):
(test_tests_for_other_platforms):
(test_version):
(test_versions):
(test_is_version_methods):
(test_setup_environ_for_server):
(_assert_search_path):
(test_show_results_html_file):

  • Scripts/webkitpy/layout_tests/port/port_testcase.py:

(PortTestCase):
(PortTestCase.make_port):

  • Scripts/webkitpy/layout_tests/port/win.py:

(WinPort):

  • Scripts/webkitpy/layout_tests/port/win_unittest.py:

(WinPortTest):
(WinPortTest.test_show_results_html_file):
(WinPortTest._assert_search_path):
(WinPortTest._assert_version):

Location:
trunk/Tools
Files:
18 edited

Legend:

Unmodified
Added
Removed

  • trunk/Tools/ChangeLog

    r104718 r104725  
     12012-01-11  Dirk Pranke  <dpranke@chromium.org>
     2
     3        webkitpy: clean up version detection in webkitpy.layout_tests.port
     4        https://bugs.webkit.org/show_bug.cgi?id=76016
     5
     6        Reviewed by Adam Barth.
     7
     8        This change updates the code in webkitpy.layout_tests.port to
     9        use the new os_name and os_version fields on host.platform. This
     10        gets layout_tests.port out of the version parsing business. Most
     11        of the diffs are just cleaning up test code to accomodate the
     12        changes.
     13
     14        * Scripts/webkitpy/common/system/executive_mock.py:
     15        (MockExecutive):
     16        (MockExecutive.ignore_error):
     17        (MockExecutive2):
     18        (MockExecutive2.ignore_error):
     19        * Scripts/webkitpy/common/system/platforminfo_mock.py:
     20        (MockPlatformInfo.is_mac):
     21        (MockPlatformInfo.is_linux):
     22        (MockPlatformInfo.is_win):
     23        * Scripts/webkitpy/common/system/systemhost_mock.py:
     24        (MockSystemHost.__init__):
     25        * Scripts/webkitpy/layout_tests/port/apple.py:
     26        (ApplePort.__init__):
     27        * Scripts/webkitpy/layout_tests/port/chromium_mac.py:
     28        (ChromiumMacPort.__init__):
     29        (ChromiumMacPort.check_wdiff):
     30        * Scripts/webkitpy/layout_tests/port/chromium_mac_unittest.py:
     31        (ChromiumMacPortTest):
     32        (ChromiumMacPortTest.assert_name):
     33        (ChromiumMacPortTest.test_versions):
     34        * Scripts/webkitpy/layout_tests/port/chromium_unittest.py:
     35        (ChromiumPortTest.test_all_test_configurations):
     36        (ChromiumPortTest.TestMacPort.__init__):
     37        (ChromiumPortTest.TestLinuxPort.__init__):
     38        (ChromiumPortTest.TestWinPort.__init__):
     39        * Scripts/webkitpy/layout_tests/port/chromium_win.py:
     40        (ChromiumWinPort.__init__):
     41        * Scripts/webkitpy/layout_tests/port/chromium_win_unittest.py:
     42        (ChromiumWinTest):
     43        (ChromiumWinTest.assert_name):
     44        (ChromiumWinTest.test_versions):
     45        (ChromiumWinTest.test_baseline_path):
     46        (ChromiumWinTest.test_build_path):
     47        * Scripts/webkitpy/layout_tests/port/factory.py:
     48        (PortFactory._port_name_from_arguments_and_options):
     49        (PortFactory.get):
     50        * Scripts/webkitpy/layout_tests/port/factory_unittest.py:
     51        (FactoryTest):
     52        (FactoryTest.setUp):
     53        (FactoryTest.assert_port):
     54        (FactoryTest.test_mac):
     55        (FactoryTest.test_win):
     56        (FactoryTest.test_google_chrome):
     57        (FactoryTest.test_gtk):
     58        (FactoryTest.test_qt):
     59        (FactoryTest.test_chromium_gpu):
     60        (FactoryTest.test_chromium_gpu_linux):
     61        (FactoryTest.test_chromium_gpu_mac):
     62        (FactoryTest.test_chromium_gpu_win):
     63        (FactoryTest.test_chromium_mac):
     64        (FactoryTest.test_chromium_linux):
     65        (FactoryTest.test_chromium_win):
     66        (FactoryTest.test_unknown_specified):
     67        (FactoryTest.test_unknown_default):
     68        * Scripts/webkitpy/layout_tests/port/google_chrome_unittest.py:
     69        (TestGoogleChromePort):
     70        (TestGoogleChromePort._verify_baseline_path):
     71        (TestGoogleChromePort._verify_expectations_overrides):
     72        (TestGoogleChromePort.test_get_google_chrome_port):
     73        * Scripts/webkitpy/layout_tests/port/mac.py:
     74        (MacPort):
     75        * Scripts/webkitpy/layout_tests/port/mac_unittest.py:
     76        (MacTest):
     77        (assert_name):
     78        (test_tests_for_other_platforms):
     79        (test_version):
     80        (test_versions):
     81        (test_is_version_methods):
     82        (test_setup_environ_for_server):
     83        (_assert_search_path):
     84        (test_show_results_html_file):
     85        * Scripts/webkitpy/layout_tests/port/port_testcase.py:
     86        (PortTestCase):
     87        (PortTestCase.make_port):
     88        * Scripts/webkitpy/layout_tests/port/win.py:
     89        (WinPort):
     90        * Scripts/webkitpy/layout_tests/port/win_unittest.py:
     91        (WinPortTest):
     92        (WinPortTest.test_show_results_html_file):
     93        (WinPortTest._assert_search_path):
     94        (WinPortTest._assert_version):
     95
    1962012-01-11  Hugo Parente Lima  <hugo.lima@openbossa.org>
    297

  • trunk/Tools/Scripts/webkitpy/common/system/executive_mock.py

    r102056 r104725  
    3535# FIXME: This should be unified with MockExecutive2
    3636class MockExecutive(object):
     37    @staticmethod
     38    def ignore_error(error):
     39        pass
     40
    3741    def __init__(self, should_log=False, should_throw=False, should_throw_when_run=None):
    3842        self._should_log = should_log
    … …  
    8084
    8185class MockExecutive2(object):
     86    @staticmethod
     87    def ignore_error(error):
     88        pass
     89
    8290    def __init__(self, output='', exit_code=0, exception=None,
    8391                 run_command_fn=None, stderr=''):

  • trunk/Tools/Scripts/webkitpy/common/system/platforminfo_mock.py

    r104637 r104725  
    3333
    3434    def is_mac(self):
    35         return True
     35        return self.os_name == 'mac'
    3636
    3737    def is_linux(self):
    38         return False
     38        return self.os_name == 'linux'
    3939
    40     def is_windows(self):
    41         return False
     40    def is_win(self):
     41        return self.os_name == 'win'
    4242
    4343    def display_name(self):

  • trunk/Tools/Scripts/webkitpy/common/system/systemhost_mock.py

    r102393 r104725  
    3636
    3737class MockSystemHost(object):
    38     def __init__(self, log_executive=False, executive_throws_when_run=None):
     38    def __init__(self, log_executive=False, executive_throws_when_run=None, os_name=None, os_version=None):
    3939        self.executive = MockExecutive(should_log=log_executive, should_throw_when_run=executive_throws_when_run)
    4040        self.filesystem = MockFileSystem()
    4141        self.user = MockUser()
    4242        self.platform = MockPlatformInfo()
     43        if os_name:
     44            self.platform.os_name = os_name
     45        if os_version:
     46            self.platform.os_version = os_version
    4347
    4448        # FIXME: Should this take pointers to the filesystem and the executive?

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

    r104637 r104725  
    5757        return port_name[len(self.port_name + '-'):]
    5858
    59     def __init__(self, host, port_name=None, os_version_string=None, **kwargs):
     59    def __init__(self, host, port_name=None, **kwargs):
    6060        port_name = port_name or self.port_name
    6161        WebKitPort.__init__(self, host, port_name=port_name, **kwargs)
    … …  
    6868
    6969        if port_name == self.port_name:
    70             # FIXME: Use host.platforminfo.os_version instead.
    71             self._version = self._detect_version(os_version_string) or self.FUTURE_VERSION
     70            self._version = host.platform.os_version
    7271            self._name = self.port_name + '-' + self._version
    7372        else:

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

    r104637 r104725  
    3131
    3232import logging
    33 import os
    3433import signal
    3534
    36 from webkitpy.layout_tests.port import mac
    3735from webkitpy.layout_tests.port import chromium
    38 
    39 from webkitpy.common.system.executive import Executive
    4036
    4137
    … …  
    8480        chromium.ChromiumPort.__init__(self, host, port_name=port_name, **kwargs)
    8581        if port_name.endswith('-mac'):
    86             # FIXME: Use host.platforminfo.os_version instead.
    87             self._version = mac.os_version(os_version_string, self.SUPPORTED_OS_VERSIONS)
     82            assert host.platform.is_mac()
     83            self._version = host.platform.os_version
    8884            self._name = port_name + '-' + self._version
    8985        else:
    … …  
    142138        try:
    143139            # We're ignoring the return and always returning True
    144             self._executive.run_command([self._path_to_wdiff()], error_handler=Executive.ignore_error)
     140            self._executive.run_command([self._path_to_wdiff()], error_handler=self._executive.ignore_error)
    145141        except OSError:
    146142            if logging:

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

    r104416 r104725  
    2929import unittest
    3030
    31 from webkitpy.thirdparty.mock import Mock
    32 from webkitpy.common.host_mock import MockHost
    33 
    3431from webkitpy.layout_tests.port import chromium_mac
    3532from webkitpy.layout_tests.port import port_testcase
    … …  
    3734
    3835class ChromiumMacPortTest(port_testcase.PortTestCase):
     36    os_name = 'mac'
     37    os_version = 'leopard'
    3938    port_maker = chromium_mac.ChromiumMacPort
    4039
    … …  
    4342
    4443    def assert_name(self, port_name, os_version_string, expected):
    45         port = self.make_port(port_name=port_name, os_version_string=os_version_string)
     44        port = self.make_port(os_version=os_version_string, port_name=port_name)
    4645        self.assertEquals(expected, port.name())
    4746
    … …  
    4948        self.assertTrue(self.make_port().name() in ('chromium-mac-leopard', 'chromium-mac-snowleopard', 'chromium-mac-lion', 'chromium-mac-future'))
    5049
    51         self.assert_name(None, '10.5.3', 'chromium-mac-leopard')
    52         self.assert_name('chromium-mac', '10.5.3', 'chromium-mac-leopard')
    53         self.assert_name('chromium-mac-leopard', '10.5.3', 'chromium-mac-leopard')
    54         self.assert_name('chromium-mac-leopard', '10.6.3', 'chromium-mac-leopard')
     50        self.assert_name(None, 'leopard', 'chromium-mac-leopard')
     51        self.assert_name('chromium-mac', 'leopard', 'chromium-mac-leopard')
     52        self.assert_name('chromium-mac-leopard', 'leopard', 'chromium-mac-leopard')
     53        self.assert_name('chromium-mac-leopard', 'snowleopard', 'chromium-mac-leopard')
    5554
    56         self.assert_name(None, '10.6.3', 'chromium-mac-snowleopard')
    57         self.assert_name('chromium-mac', '10.6.3', 'chromium-mac-snowleopard')
    58         self.assert_name('chromium-mac-snowleopard', '10.5.3', 'chromium-mac-snowleopard')
    59         self.assert_name('chromium-mac-snowleopard', '10.6.3', 'chromium-mac-snowleopard')
     55        self.assert_name(None, 'snowleopard', 'chromium-mac-snowleopard')
     56        self.assert_name('chromium-mac', 'snowleopard', 'chromium-mac-snowleopard')
     57        self.assert_name('chromium-mac-snowleopard', 'leopard', 'chromium-mac-snowleopard')
     58        self.assert_name('chromium-mac-snowleopard', 'snowleopard', 'chromium-mac-snowleopard')
    6059
    61         self.assert_name(None, '10.7', 'chromium-mac-lion')
    62         self.assert_name(None, '10.7.3', 'chromium-mac-lion')
    63         self.assert_name(None, '10.8', 'chromium-mac-future')
    64         self.assert_name('chromium-mac', '10.7.3', 'chromium-mac-lion')
    65         self.assert_name('chromium-mac-future', '10.4.3', 'chromium-mac-future')
    66         self.assert_name('chromium-mac-future', '10.5.3', 'chromium-mac-future')
    67         self.assert_name('chromium-mac-future', '10.6.3', 'chromium-mac-future')
    68         self.assert_name('chromium-mac-future', '10.7.3', 'chromium-mac-future')
     60        self.assert_name(None, 'lion', 'chromium-mac-lion')
     61        self.assert_name(None, 'future', 'chromium-mac-future')
     62        self.assert_name('chromium-mac', 'lion', 'chromium-mac-lion')
     63        self.assert_name('chromium-mac-future', 'tiger', 'chromium-mac-future')
     64        self.assert_name('chromium-mac-future', 'leopard', 'chromium-mac-future')
     65        self.assert_name('chromium-mac-future', 'snowleopard', 'chromium-mac-future')
     66        self.assert_name('chromium-mac-future', 'lion', 'chromium-mac-future')
    6967
    70         self.assertRaises(AssertionError, self.assert_name, None, '10.4.1', 'should-raise-assertion-so-this-value-does-not-matter')
     68        self.assertRaises(AssertionError, self.assert_name, None, 'tiger', 'should-raise-assertion-so-this-value-does-not-matter')
    7169
    7270    def test_baseline_path(self):

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

    r104416 r104725  
    3535from webkitpy.common.system.executive_mock import MockExecutive, MockExecutive2
    3636from webkitpy.common.system.filesystem_mock import MockFileSystem
    37 from webkitpy.common.host_mock import MockHost
     37from webkitpy.common.system.systemhost_mock import MockSystemHost
    3838from webkitpy.thirdparty.mock import Mock
    3939from webkitpy.tool.mocktool import MockOptions
    … …  
    159159    def test_all_test_configurations(self):
    160160        """Validate the complete set of configurations this port knows about."""
    161         port = chromium.ChromiumPort(MockHost())
     161        port = chromium.ChromiumPort(MockSystemHost())
    162162        self.assertEquals(set(port.all_test_configurations()), set([
    163163            TestConfiguration('leopard', 'x86', 'debug', 'cpu'),
    … …  
    210210        def __init__(self, options=None):
    211211            options = options or MockOptions()
    212             chromium_mac.ChromiumMacPort.__init__(self, MockHost(), options=options)
     212            chromium_mac.ChromiumMacPort.__init__(self, MockSystemHost(os_name='mac', os_version='leopard'), options=options)
    213213
    214214        def default_configuration(self):
    … …  
    219219        def __init__(self, options=None):
    220220            options = options or MockOptions()
    221             chromium_linux.ChromiumLinuxPort.__init__(self, MockHost(), options=options)
     221            chromium_linux.ChromiumLinuxPort.__init__(self, MockSystemHost(os_name='linux', os_version='lucid'), options=options)
    222222
    223223        def default_configuration(self):
    … …  
    228228        def __init__(self, options=None):
    229229            options = options or MockOptions()
    230             chromium_win.ChromiumWinPort.__init__(self, MockHost(), options=options)
     230            chromium_win.ChromiumWinPort.__init__(self, MockSystemHost(os_name='win', os_version='xp'), options=options)
    231231
    232232        def default_configuration(self):

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

    r103952 r104725  
    3232import os
    3333import logging
    34 import sys
    3534
    3635import chromium
    … …  
    3837
    3938_log = logging.getLogger(__name__)
    40 
    41 
    42 def os_version(windows_version=None):
    43     if not windows_version:
    44         if hasattr(sys, 'getwindowsversion'):
    45             windows_version = tuple(sys.getwindowsversion()[:2])
    46         else:
    47             # Make up something for testing.
    48             windows_version = (5, 1)
    49 
    50     version_strings = {
    51         (6, 1): 'win7',
    52         (6, 0): 'vista',
    53         (5, 1): 'xp',
    54     }
    55     return version_strings[windows_version]
    5639
    5740
    … …  
    9174        chromium.ChromiumPort.__init__(self, host, port_name=port_name, **kwargs)
    9275        if port_name.endswith('-win'):
    93             self._version = os_version(windows_version)
     76            assert host.platform.is_win()
     77            if host.platform.os_version == '7sp0':
     78                self._version = 'win7'
     79            else:
     80                self._version = host.platform.os_version
    9481            self._name = port_name + '-' + self._version
    9582        else:
    9683            self._version = port_name[port_name.index('-win-') + len('-win-'):]
    97             assert self._version in self.SUPPORTED_VERSIONS, "%s is not in %s" % (self._version, self.SUPPORTED_VERSIONS)
     84        assert self._version in self.SUPPORTED_VERSIONS, "%s is not in %s" % (self._version, self.SUPPORTED_VERSIONS)
    9885
    9986

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

    r103952 r104725  
    2828
    2929import os
    30 import sys
    3130import unittest
    3231
    3332from webkitpy.common.system import outputcapture
    34 from webkitpy.common.host_mock import MockHost
    3533from webkitpy.common.system.executive_mock import MockExecutive
    3634from webkitpy.common.system.filesystem_mock import MockFileSystem
    37 
    3835from webkitpy.layout_tests.port import chromium_win
    3936from webkitpy.layout_tests.port import port_testcase
    … …  
    4744
    4845    port_maker = chromium_win.ChromiumWinPort
     46    os_name = 'win'
     47    os_version = 'xp'
    4948
    5049    def test_uses_apache(self):
    … …  
    7372        output.assert_outputs(self, port.setup_environ_for_server, expected_stderr=expected_stderr)
    7473
    75     def assert_name(self, port_name, windows_version, expected):
    76         port = chromium_win.ChromiumWinPort(MockHost(), port_name=port_name, windows_version=windows_version)
     74    def assert_name(self, port_name, os_version_string, expected):
     75        port = self.make_port(port_name=port_name, os_version=os_version_string)
    7776        self.assertEquals(expected, port.name())
    7877
    7978    def test_versions(self):
    80         port = chromium_win.ChromiumWinPort(MockHost())
     79        port = self.make_port()
    8180        self.assertTrue(port.name() in ('chromium-win-xp', 'chromium-win-vista', 'chromium-win-win7'))
    8281
    83         self.assert_name(None, (5, 1), 'chromium-win-xp')
    84         self.assert_name('chromium-win', (5, 1), 'chromium-win-xp')
    85         self.assert_name('chromium-win-xp', (5, 1), 'chromium-win-xp')
    86         self.assert_name('chromium-win-xp', (6, 0), 'chromium-win-xp')
    87         self.assert_name('chromium-win-xp', (6, 1), 'chromium-win-xp')
     82        self.assert_name(None, 'xp', 'chromium-win-xp')
     83        self.assert_name('chromium-win', 'xp', 'chromium-win-xp')
     84        self.assert_name('chromium-win-xp', 'xp', 'chromium-win-xp')
     85        self.assert_name('chromium-win-xp', 'vista', 'chromium-win-xp')
     86        self.assert_name('chromium-win-xp', '7sp0', 'chromium-win-xp')
    8887
    89         self.assert_name(None, (6, 0), 'chromium-win-vista')
    90         self.assert_name('chromium-win', (6, 0), 'chromium-win-vista')
    91         self.assert_name('chromium-win-vista', (5, 1), 'chromium-win-vista')
    92         self.assert_name('chromium-win-vista', (6, 0), 'chromium-win-vista')
    93         self.assert_name('chromium-win-vista', (6, 1), 'chromium-win-vista')
     88        self.assert_name(None, 'vista', 'chromium-win-vista')
     89        self.assert_name('chromium-win', 'vista', 'chromium-win-vista')
     90        self.assert_name('chromium-win-vista', 'xp', 'chromium-win-vista')
     91        self.assert_name('chromium-win-vista', 'vista', 'chromium-win-vista')
     92        self.assert_name('chromium-win-vista', '7sp0', 'chromium-win-vista')
    9493
    95         self.assert_name(None, (6, 1), 'chromium-win-win7')
    96         self.assert_name('chromium-win', (6, 1), 'chromium-win-win7')
    97         self.assert_name('chromium-win-win7', (5, 1), 'chromium-win-win7')
    98         self.assert_name('chromium-win-win7', (6, 0), 'chromium-win-win7')
    99         self.assert_name('chromium-win-win7', (6, 1), 'chromium-win-win7')
     94        self.assert_name(None, '7sp0', 'chromium-win-win7')
     95        self.assert_name('chromium-win', '7sp0', 'chromium-win-win7')
     96        self.assert_name('chromium-win-win7', 'xp', 'chromium-win-win7')
     97        self.assert_name('chromium-win-win7', 'vista', 'chromium-win-win7')
     98        self.assert_name('chromium-win-win7', '7sp0', 'chromium-win-win7')
    10099
    101         self.assertRaises(KeyError, self.assert_name, None, (4, 0), 'chromium-win-xp')
    102         self.assertRaises(KeyError, self.assert_name, None, (5, 0), 'chromium-win-xp')
    103         self.assertRaises(KeyError, self.assert_name, None, (5, 2), 'chromium-win-xp')
    104         self.assertRaises(KeyError, self.assert_name, None, (7, 1), 'chromium-win-xp')
     100        self.assertRaises(AssertionError, self.assert_name, None, 'w2k', 'chromium-win-xp')
    105101
    106102    def test_baseline_path(self):
    107         port = chromium_win.ChromiumWinPort(MockHost(), port_name='chromium-win-xp')
     103        port = self.make_port(port_name='chromium-win-xp')
    108104        self.assertEquals(port.baseline_path(), port._webkit_baseline_path('chromium-win-xp'))
    109105
    110         port = chromium_win.ChromiumWinPort(MockHost(), port_name='chromium-win-vista')
     106        port = self.make_port(port_name='chromium-win-vista')
    111107        self.assertEquals(port.baseline_path(), port._webkit_baseline_path('chromium-win-vista'))
    112108
    113         port = chromium_win.ChromiumWinPort(MockHost(), port_name='chromium-win-win7')
     109        port = self.make_port(port_name='chromium-win-win7')
    114110        self.assertEquals(port.baseline_path(), port._webkit_baseline_path('chromium-win'))
    115111
    116112    def test_build_path(self):
    117         host = MockHost()
    118         host.filesystem = MockFileSystem(files={
     113        port = self.make_port()
     114        port._filesystem.files = {
    119115            '/mock-checkout/Source/WebKit/chromium/build/Release/DumpRenderTree.exe': 'exe',
    120         })
    121 
    122         port = chromium_win.ChromiumWinPort(host)
     116        }
    123117        self.assertEquals(
    124118            '/mock-checkout/Source/WebKit/chromium/build/Release/DumpRenderTree.exe',

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

    r104416 r104725  
    3131
    3232import re
    33 import sys
    3433
    3534from webkitpy.layout_tests.port import builders
    … …  
    4847    def _port_name_from_arguments_and_options(self, port_name, options, platform):
    4948        if port_name == 'chromium-gpu':
    50             if platform in ('cygwin', 'win32'):
     49            if platform.is_win():
    5150                return 'chromium-gpu-win'
    52             if platform.startswith('linux'):
     51            if platform.is_linux():
    5352                return 'chromium-gpu-linux'
    54             if platform == 'darwin':
     53            if platform.is_mac():
    5554                return 'chromium-gpu-mac'
    5655
    … …  
    5857            return port_name
    5958
    60         if platform in ('win32', 'cygwin'):
     59        if platform.is_win():
    6160            if options and hasattr(options, 'chromium') and options.chromium:
    6261                return 'chromium-win'
    6362            return 'win'
    64         if platform.startswith('linux'):
     63        if platform.is_linux():
    6564            return 'chromium-linux'
    66         if platform == 'darwin':
     65        if platform.is_mac():
    6766            if options and hasattr(options, 'chromium') and options.chromium:
    6867                return 'chromium-mac'
    6968            return 'mac'
    7069
    71         raise NotImplementedError('unknown port; platform = "%s"' % platform)
     70        raise NotImplementedError('unknown port; os_name = "%s"' % platform.os_name)
    7271
    73     def get(self, port_name=None, options=None, platform=None, **kwargs):
     72    def get(self, port_name=None, options=None, **kwargs):
    7473        """Returns an object implementing the Port interface. If
    7574        port_name is None, this routine attempts to guess at the most
    7675        appropriate port on this platform."""
    77         platform = platform or sys.platform
    78         port_to_use = self._port_name_from_arguments_and_options(port_name, options, platform)
     76        port_to_use = self._port_name_from_arguments_and_options(port_name, options, self._host.platform)
    7977        if port_to_use.startswith('test'):
    8078            import test

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

    r104416 r104725  
    2727# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    2828
    29 import sys
    3029import unittest
    3130
    3231from webkitpy.tool.mocktool import MockOptions
    3332from webkitpy.common.system.systemhost_mock import MockSystemHost
     33from webkitpy.layout_tests.port.factory import PortFactory
    3434
    3535import chromium_gpu
    … …  
    3838import chromium_win
    3939import dryrun
    40 import factory
    4140import google_chrome
    4241import gtk
    … …  
    4847
    4948class FactoryTest(unittest.TestCase):
    50     """Test factory creates proper port object for the target.
    51 
    52     Target is specified by port_name, sys.platform and options.
    53 
    54     """
     49    """Test that the factory creates the proper port object for given combination of port_name, host.platform, and options."""
    5550    # FIXME: The ports themselves should expose what options they require,
    5651    # instead of passing generic "options".
    5752
    5853    def setUp(self):
    59         self.real_sys_platform = sys.platform
    6054        self.webkit_options = MockOptions(pixel_tests=False)
    6155        self.chromium_options = MockOptions(pixel_tests=False, chromium=True)
    62         self.factory = factory.PortFactory(MockSystemHost())
    6356
    64     def tearDown(self):
    65         sys.platform = self.real_sys_platform
    66 
    67     def assert_port(self, port_name, expected_port, port_obj=None, platform=None):
    68         """Helper assert for port_name.
    69 
    70         Args:
    71           port_name: port name to get port object.
    72           expected_port: class of expected port object.
    73           port_obj: optional port object
    74         """
    75         port_obj = port_obj or self.factory.get(port_name=port_name, platform=platform)
    76         self.assertTrue(isinstance(port_obj, expected_port))
    77 
    78     def assert_platform_port(self, platform, options, expected_port):
    79         """Helper assert for platform and options.
    80 
    81         Args:
    82           platform: sys.platform.
    83           options: options to get port object.
    84           expected_port: class of expected port object.
    85 
    86         """
    87         # FIXME: Hacking sys.platform like this is WRONG.
    88         orig_platform = sys.platform
    89         sys.platform = platform
    90         # FIXME: We need a better way to mock this.
    91         self.assertTrue(isinstance(self.factory.get(options=options), expected_port))
    92         sys.platform = orig_platform
     57    def assert_port(self, port_name=None, os_name=None, os_version=None, options=None, cls=None):
     58        host = MockSystemHost(os_name=os_name, os_version=os_version)
     59        port = PortFactory(host).get(port_name, options=options)
     60        self.assertTrue(isinstance(port, cls))
    9361
    9462    def test_mac(self):
    95         self.assert_port("mac", mac.MacPort)
    96         self.assert_platform_port("darwin", None, mac.MacPort)
    97         self.assert_platform_port("darwin", self.webkit_options, mac.MacPort)
     63        self.assert_port(port_name='mac', cls=mac.MacPort)
     64        self.assert_port(port_name=None,  os_name='mac', os_version='leopard', cls=mac.MacPort)
    9865
    9966    def test_win(self):
    100         self.assert_port("win", win.WinPort)
    101         self.assert_platform_port("win32", None, win.WinPort)
    102         self.assert_platform_port("win32", self.webkit_options, win.WinPort)
    103         self.assert_platform_port("cygwin", None, win.WinPort)
    104         self.assert_platform_port("cygwin", self.webkit_options, win.WinPort)
     67        self.assert_port(port_name='win', cls=win.WinPort)
     68        self.assert_port(port_name=None, os_name='win', os_version='xp', cls=win.WinPort)
     69        self.assert_port(port_name=None, os_name='win', os_version='xp', options=self.webkit_options, cls=win.WinPort)
    10570
    10671    def test_google_chrome(self):
    107         self.assert_port("google-chrome-linux32", google_chrome.GoogleChromeLinux32Port)
    108         self.assert_port("google-chrome-linux64", google_chrome.GoogleChromeLinux64Port)
    109         self.assert_port("google-chrome-win", google_chrome.GoogleChromeWinPort)
    110         self.assert_port("google-chrome-mac", google_chrome.GoogleChromeMacPort)
     72        self.assert_port(port_name='google-chrome-linux32',
     73                         cls=google_chrome.GoogleChromeLinux32Port)
     74        self.assert_port(port_name='google-chrome-linux64', os_name='linux', os_version='lucid',
     75                         cls=google_chrome.GoogleChromeLinux64Port)
     76        self.assert_port(port_name='google-chrome-linux64',
     77                         cls=google_chrome.GoogleChromeLinux64Port)
     78        self.assert_port(port_name='google-chrome-win-xp',
     79                         cls=google_chrome.GoogleChromeWinPort)
     80        self.assert_port(port_name='google-chrome-win', os_name='win', os_version='xp',
     81                         cls=google_chrome.GoogleChromeWinPort)
     82        self.assert_port(port_name='google-chrome-win-xp', os_name='win', os_version='xp',
     83                         cls=google_chrome.GoogleChromeWinPort)
     84        self.assert_port(port_name='google-chrome-mac', os_name='mac', os_version='leopard',
     85                         cls=google_chrome.GoogleChromeMacPort)
     86        self.assert_port(port_name='google-chrome-mac-leopard', os_name='mac', os_version='leopard',
     87                         cls=google_chrome.GoogleChromeMacPort)
     88        self.assert_port(port_name='google-chrome-mac-leopard',
     89                         cls=google_chrome.GoogleChromeMacPort)
    11190
    11291    def test_gtk(self):
    113         self.assert_port("gtk", gtk.GtkPort)
     92        self.assert_port(port_name='gtk', cls=gtk.GtkPort)
    11493
    11594    def test_qt(self):
    116         self.assert_port("qt", qt.QtPort)
     95        self.assert_port(port_name='qt', cls=qt.QtPort)
    11796
    11897    def test_chromium_gpu(self):
    119         self.assert_port('chromium-gpu', chromium_gpu.ChromiumGpuMacPort, platform='darwin')
    120         self.assert_port('chromium-gpu', chromium_gpu.ChromiumGpuWinPort, platform='win32')
    121         self.assert_port('chromium-gpu', chromium_gpu.ChromiumGpuWinPort, platform='cygwin')
    122         self.assert_port('chromium-gpu', chromium_gpu.ChromiumGpuLinuxPort, platform='linux2')
    123         self.assert_port('chromium-gpu', chromium_gpu.ChromiumGpuLinuxPort, platform='linux3')
     98        self.assert_port(port_name='chromium-gpu', os_name='mac', os_version='leopard',
     99                         cls=chromium_gpu.ChromiumGpuMacPort)
     100        self.assert_port(port_name='chromium-gpu', os_name='win', os_version='xp',
     101                         cls=chromium_gpu.ChromiumGpuWinPort)
     102        self.assert_port(port_name='chromium-gpu', os_name='linux', os_version='lucid',
     103                         cls=chromium_gpu.ChromiumGpuLinuxPort)
    124104
    125105    def test_chromium_gpu_linux(self):
    126         self.assert_port("chromium-gpu-linux", chromium_gpu.ChromiumGpuLinuxPort)
     106        self.assert_port(port_name='chromium-gpu-linux', cls=chromium_gpu.ChromiumGpuLinuxPort)
    127107
    128108    def test_chromium_gpu_mac(self):
    129         self.assert_port("chromium-gpu-mac", chromium_gpu.ChromiumGpuMacPort)
     109        self.assert_port(port_name='chromium-gpu-mac-leopard', cls=chromium_gpu.ChromiumGpuMacPort)
    130110
    131111    def test_chromium_gpu_win(self):
    132         self.assert_port("chromium-gpu-win", chromium_gpu.ChromiumGpuWinPort)
     112        self.assert_port(port_name='chromium-gpu-win-xp', cls=chromium_gpu.ChromiumGpuWinPort)
    133113
    134114    def test_chromium_mac(self):
    135         self.assert_port("chromium-mac", chromium_mac.ChromiumMacPort)
    136         self.assert_platform_port("darwin", self.chromium_options,
    137                                   chromium_mac.ChromiumMacPort)
     115        self.assert_port(port_name='chromium-mac-leopard', cls=chromium_mac.ChromiumMacPort)
     116        self.assert_port(port_name='chromium-mac', os_name='mac', os_version='leopard',
     117                         cls=chromium_mac.ChromiumMacPort)
     118        self.assert_port(port_name=None, os_name='mac', os_version='leopard', options=self.chromium_options,
     119                         cls=chromium_mac.ChromiumMacPort)
    138120
    139121    def test_chromium_linux(self):
    140         self.assert_port("chromium-linux", chromium_linux.ChromiumLinuxPort)
    141         self.assert_platform_port("linux2", self.chromium_options,
    142                                   chromium_linux.ChromiumLinuxPort)
    143         self.assert_platform_port("linux3", self.chromium_options,
    144                                   chromium_linux.ChromiumLinuxPort)
     122        self.assert_port(port_name='chromium-linux', cls=chromium_linux.ChromiumLinuxPort)
     123        self.assert_port(port_name=None, os_name='linux', os_version='lucid', options=self.chromium_options,
     124                         cls=chromium_linux.ChromiumLinuxPort)
    145125
    146126    def test_chromium_win(self):
    147         self.assert_port("chromium-win", chromium_win.ChromiumWinPort)
    148         self.assert_platform_port("win32", self.chromium_options,
    149                                   chromium_win.ChromiumWinPort)
    150         self.assert_platform_port("cygwin", self.chromium_options,
    151                                   chromium_win.ChromiumWinPort)
     127        self.assert_port(port_name='chromium-win-xp', cls=chromium_win.ChromiumWinPort)
     128        self.assert_port(port_name='chromium-win', os_name='win', os_version='xp',
     129                         cls=chromium_win.ChromiumWinPort)
     130        self.assert_port(port_name=None, os_name='win', os_version='xp', options=self.chromium_options,
     131                         cls=chromium_win.ChromiumWinPort)
    152132
    153133    def test_unknown_specified(self):
    154         # Test what happens when you specify an unknown port.
    155         self.assertRaises(NotImplementedError, self.factory.get, port_name='unknown')
     134        self.assertRaises(NotImplementedError, PortFactory(MockSystemHost()).get, port_name='unknown')
    156135
    157136    def test_unknown_default(self):
    158         # Test what happens when you're running on an unknown platform.
    159         orig_platform = sys.platform
    160         sys.platform = 'unknown'
    161         self.assertRaises(NotImplementedError, self.factory.get)
    162         sys.platform = orig_platform
     137        self.assertRaises(NotImplementedError, PortFactory(MockSystemHost(os_name='vms')).get)
    163138
    164139

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

    r104416 r104725  
    2727import unittest
    2828
    29 from webkitpy.common.host_mock import MockHost
     29from webkitpy.common.system.systemhost_mock import MockSystemHost
     30from webkitpy.layout_tests.port.factory import PortFactory
    3031
    3132
    32 class GetGoogleChromePortTest(unittest.TestCase):
    33     def test_get_google_chrome_port(self):
    34         test_ports = ('google-chrome-linux32', 'google-chrome-linux64', 'google-chrome-mac', 'google-chrome-win')
    35         for port in test_ports:
    36             self._verify_baseline_path(port, port)
    37             self._verify_expectations_overrides(port)
    38 
    39         self._verify_baseline_path('google-chrome-mac', 'google-chrome-mac-leopard')
    40         self._verify_baseline_path('google-chrome-win', 'google-chrome-win-xp')
    41         self._verify_baseline_path('google-chrome-win', 'google-chrome-win-vista')
    42 
     33class TestGoogleChromePort(unittest.TestCase):
    4334    def _verify_baseline_path(self, expected_path, port_name):
    44         port = MockHost().port_factory.get(port_name=port_name)
     35        port = PortFactory(MockSystemHost()).get(port_name=port_name)
    4536        path = port.baseline_search_path()[0]
    4637        self.assertEqual(expected_path, port._filesystem.basename(path))
    4738
    4839    def _verify_expectations_overrides(self, port_name):
    49         # FIXME: Make this more robust when we have the Tree() abstraction.
    50         # we should be able to test for the files existing or not, and
    51         # be able to control the contents better.
    52         # FIXME: What is the Tree() abstraction?
    53 
    54         host = MockHost()
    55         chromium_port = host.port_factory.get("chromium-mac")
     40        host = MockSystemHost()
     41        chromium_port = PortFactory(host).get("chromium-mac-leopard")
    5642        chromium_base = chromium_port.path_from_chromium_base()
    57         port = host.port_factory.get(port_name=port_name, options=None)
     43        port = PortFactory(host).get(port_name=port_name, options=None)
    5844
    5945        expected_chromium_overrides = '// chromium overrides\n'
    … …  
    7157        self.assertEqual(actual_chrome_overrides, expected_chromium_overrides + expected_chrome_overrides)
    7258
     59    def test_get_google_chrome_port(self):
     60        self._verify_baseline_path('google-chrome-linux32', 'google-chrome-linux32')
     61        self._verify_baseline_path('google-chrome-linux64', 'google-chrome-linux64')
     62        self._verify_baseline_path('google-chrome-mac', 'google-chrome-mac-leopard')
     63        self._verify_baseline_path('google-chrome-win', 'google-chrome-win-xp')
     64
     65        self._verify_expectations_overrides('google-chrome-mac-leopard')
     66        self._verify_expectations_overrides('google-chrome-win-xp')
     67        self._verify_expectations_overrides('google-chrome-linux32')
     68        self._verify_expectations_overrides('google-chrome-linux64')
     69
    7370
    7471if __name__ == '__main__':

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

    r104637 r104725  
    2828
    2929import logging
    30 import platform
    3130import re
    3231
    … …  
    3736_log = logging.getLogger(__name__)
    3837
    39 # FIXME: Delete this when we switch to using host.platforminfo.os_version instead.
    40 def os_version(os_version_string=None, supported_versions=None):
    41     if not os_version_string:
    42         if hasattr(platform, 'mac_ver') and platform.mac_ver()[0]:
    43             os_version_string = platform.mac_ver()[0]
    44         else:
    45             # Make up something for testing.
    46             os_version_string = "10.5.6"
    47     release_version = int(os_version_string.split('.')[1])
    48     version_strings = {
    49         5: 'leopard',
    50         6: 'snowleopard',
    51         7: 'lion',
    52     }
    53     assert release_version >= min(version_strings.keys())
    54     version_string = version_strings.get(release_version, 'future')
    55     if supported_versions:
    56         assert version_string in supported_versions
    57     return version_string
    58 
    59 
    6038class MacPort(ApplePort):
    6139    port_name = "mac"
    … …  
    6442    # and the order of fallback between them.  Matches ORWT.
    6543    VERSION_FALLBACK_ORDER = ["mac-leopard", "mac-snowleopard", "mac-lion", "mac"]
    66 
    67     # FIXME: Delete this when we switch to using host.platforminfo.os_version instead.
    68     def _detect_version(self, os_version_string):
    69         # FIXME: MacPort and WinPort implement _detect_version differently.
    70         # WinPort uses os_version_string as a replacement for self.version.
    71         # Thus just returns os_version_string from this function if not None.
    72         # Mac (incorrectly) uses os_version_string as a way to unit-test
    73         # the os_version parsing logic.  We should split the os_version parsing tests
    74         # into separate unittests so that they do not need to construct
    75         # MacPort objects just to test our version parsing.
    76         return os_version(os_version_string)
    7744
    7845    def __init__(self, host, **kwargs):

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

    r103952 r104725  
    3333from webkitpy.tool.mocktool import MockOptions
    3434from webkitpy.common.system.executive_mock import MockExecutive
    35 from webkitpy.common.host_mock import MockHost
     35from webkitpy.common.system.systemhost_mock import MockSystemHost
    3636
    3737
    3838class MacTest(port_testcase.PortTestCase):
     39    os_name = 'mac'
     40    os_version = 'leopard'
    3941    port_maker = MacPort
    4042
    … …  
    7577
    7678    def assert_name(self, port_name, os_version_string, expected):
    77         port = self.make_port(port_name=port_name, os_version_string=os_version_string)
     79        host = MockSystemHost(os_name='mac', os_version=os_version_string)
     80        port = self.make_port(host=host, port_name=port_name)
    7881        self.assertEquals(expected, port.name())
    7982
    8083    def test_tests_for_other_platforms(self):
    8184        platforms = ['mac', 'chromium-linux', 'mac-snowleopard']
    82         port = MacPort(MockHost(), port_name='mac-snowleopard')
     85        port = self.make_port(port_name='mac-snowleopard')
    8386        platform_dir_paths = map(port._webkit_baseline_path, platforms)
    8487        # Replace our empty mock file system with one which has our expected platform directories.
    … …  
    9194
    9295    def test_version(self):
    93         port = MacPort(MockHost())
     96        port = self.make_port()
    9497        self.assertTrue(port.version())
    9598
    9699    def test_versions(self):
    97         self.assert_name(None, '10.5.3', 'mac-leopard')
    98         self.assert_name('mac', '10.5.3', 'mac-leopard')
    99         self.assert_name('mac-leopard', '10.4.8', 'mac-leopard')
    100         self.assert_name('mac-leopard', '10.5.3', 'mac-leopard')
    101         self.assert_name('mac-leopard', '10.6.3', 'mac-leopard')
     100        self.assert_name(None, 'leopard', 'mac-leopard')
     101        self.assert_name('mac', 'leopard', 'mac-leopard')
     102        self.assert_name('mac-leopard', 'tiger', 'mac-leopard')
     103        self.assert_name('mac-leopard', 'leopard', 'mac-leopard')
     104        self.assert_name('mac-leopard', 'snowleopard', 'mac-leopard')
    102105
    103         self.assert_name(None, '10.6.3', 'mac-snowleopard')
    104         self.assert_name('mac', '10.6.3', 'mac-snowleopard')
    105         self.assert_name('mac-snowleopard', '10.4.3', 'mac-snowleopard')
    106         self.assert_name('mac-snowleopard', '10.5.3', 'mac-snowleopard')
    107         self.assert_name('mac-snowleopard', '10.6.3', 'mac-snowleopard')
     106        self.assert_name(None, 'snowleopard', 'mac-snowleopard')
     107        self.assert_name('mac', 'snowleopard', 'mac-snowleopard')
     108        self.assert_name('mac-snowleopard', 'tiger', 'mac-snowleopard')
     109        self.assert_name('mac-snowleopard', 'leopard', 'mac-snowleopard')
     110        self.assert_name('mac-snowleopard', 'snowleopard', 'mac-snowleopard')
    108111
    109         self.assert_name(None, '10.7', 'mac-lion')
    110         self.assert_name(None, '10.7.3', 'mac-lion')
    111         self.assert_name('mac', '10.7.3', 'mac-lion')
     112        self.assert_name(None, 'lion', 'mac-lion')
     113        self.assert_name('mac', 'lion', 'mac-lion')
     114        self.assert_name('mac-lion', 'lion', 'mac-lion')
    112115
    113         self.assert_name(None, '10.9', 'mac-future')
    114         self.assert_name('mac', '10.9', 'mac-future')
    115         self.assert_name('mac-future', '10.9', 'mac-future')
     116        self.assert_name(None, 'future', 'mac-future')
     117        self.assert_name('mac', 'future', 'mac-future')
     118        self.assert_name('mac-future', 'future', 'mac-future')
    116119
    117         self.assertRaises(AssertionError, self.assert_name, None, '10.3.1', 'should-raise-assertion-so-this-value-does-not-matter')
    118120
    119121    def test_is_version_methods(self):
    120         leopard_port = self.make_port(port_name='mac-leopard', os_version_string='10.5.3')
     122        leopard_port = self.make_port(port_name='mac-leopard')
    121123        self.assertTrue(leopard_port.is_leopard())
    122124        self.assertFalse(leopard_port.is_snowleopard())
    123125        self.assertFalse(leopard_port.is_lion())
    124126
    125         snowleopard_port = self.make_port(port_name='mac-snowleopard', os_version_string='10.6.3')
     127        snowleopard_port = self.make_port(port_name='mac-snowleopard')
    126128        self.assertFalse(snowleopard_port.is_leopard())
    127129        self.assertTrue(snowleopard_port.is_snowleopard())
    128130        self.assertFalse(snowleopard_port.is_lion())
    129131
    130         lion_port = self.make_port(port_name='mac-lion', os_version_string='10.7.2')
     132        lion_port = self.make_port(port_name='mac-lion')
    131133        self.assertFalse(lion_port.is_leopard())
    132134        self.assertFalse(lion_port.is_snowleopard())
    … …  
    134136
    135137    def test_setup_environ_for_server(self):
    136         port = MacPort(MockHost(), options=MockOptions(leaks=True, guard_malloc=True))
     138        port = self.make_port(options=MockOptions(leaks=True, guard_malloc=True))
    137139        env = port.setup_environ_for_server(port.driver_name())
    138140        self.assertEquals(env['MallocStackLogging'], '1')
    … …  
    143145        # rather be passed components (directly or via setters).  Once
    144146        # we fix that, this method will need a re-write.
    145         port = MacPort(MockHost(), port_name='mac-%s' % version, options=MockOptions(webkit_test_runner=use_webkit2))
     147        port = self.make_port(port_name='mac-%s' % version, options=MockOptions(webkit_test_runner=use_webkit2))
    146148        absolute_search_paths = map(port._webkit_baseline_path, search_paths)
    147149        self.assertEquals(port.baseline_search_path(), absolute_search_paths)
    … …  
    158160
    159161    def test_show_results_html_file(self):
    160         port = MacPort(MockHost())
     162        port = self.make_port()
    161163        # Delay setting a should_log executive to avoid logging from MacPort.__init__.
    162164        port._executive = MockExecutive(should_log=True)

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

    r99781 r104725  
    4747from webkitpy.tool.mocktool import MockOptions
    4848from webkitpy.common.system.executive_mock import MockExecutive
    49 from webkitpy.common.host_mock import MockHost
     49from webkitpy.common.system.systemhost_mock import MockSystemHost
    5050
    5151
    … …  
    5656
    5757    # Subclasses override this to point to their Port subclass.
     58    os_name = None
     59    os_version = None
    5860    port_maker = None
    5961
    60     def make_port(self, host=None, options=None, **kwargs):
    61         host = host or MockHost()
     62    def make_port(self, host=None, options=None, os_name=None, os_version=None, **kwargs):
     63        host = host or MockSystemHost(os_name=(os_name or self.os_name), os_version=(os_version or self.os_version))
    6264        options = options or MockOptions(configuration='Release')
    6365        return self.port_maker(host, options=options, **kwargs)

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

    r104637 r104725  
    4646    VERSION_FALLBACK_ORDER = ["win-xp", "win-vista", "win-7sp0", "win"]
    4747
    48     # FIXME: Use host.platforminfo.os_version instead.
    49     def _version_string_from_windows_version_tuple(self, windows_version_tuple):
    50         if windows_version_tuple[:3] == (6, 1, 7600):
    51             return '7sp0'
    52         if windows_version_tuple[:2] == (6, 0):
    53             return 'vista'
    54         if windows_version_tuple[:2] == (5, 1):
    55             return 'xp'
    56         return None
    57 
    58     def _detect_version(self, os_version_string=None, run_on_non_windows_platforms=None):
    59         # FIXME: os_version_string is for unit testing, but may eventually be provided by factory.py instead.
    60         if os_version_string is not None:
    61             return os_version_string
    62 
    63         # No sense in trying to detect our windows version on non-windows platforms, unless we're unittesting.
    64         if sys.platform != 'cygwin' and not run_on_non_windows_platforms:
    65             return None
    66 
    67         # Note, this intentionally returns None to mean that it can't detect what the current version is.
    68         # Callers can then decide what version they want to pretend to be.
    69         try:
    70             ver_output = self._executive.run_command(['cmd', '/c', 'ver'])
    71         except (ScriptError, OSError), e:
    72             ver_output = ""
    73             _log.error("Failed to detect Windows version, assuming latest.\n%s" % e)
    74         match_object = re.search(r'(?P<major>\d)\.(?P<minor>\d)\.(?P<build>\d+)', ver_output)
    75         if match_object:
    76             version_tuple = tuple(map(int, match_object.groups()))
    77             return self._version_string_from_windows_version_tuple(version_tuple)
    78 
    7948    def compare_text(self, expected_text, actual_text):
    8049        # Sanity was restored in WK2, so we don't need this hack there.

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

    r104191 r104725  
    2828
    2929import StringIO
    30 import sys
    3130import unittest
    3231
    … …  
    3433from webkitpy.common.system.executive_mock import MockExecutive, MockExecutive2
    3534from webkitpy.common.system.filesystem_mock import MockFileSystem
    36 from webkitpy.common.host_mock import MockHost
    3735from webkitpy.common.system.outputcapture import OutputCapture
     36from webkitpy.common.system.systemhost_mock import MockSystemHost
    3837from webkitpy.layout_tests.port import port_testcase
    3938from webkitpy.layout_tests.port.win import WinPort
    … …  
    4241
    4342class WinPortTest(port_testcase.PortTestCase):
     43    os_name = 'win'
     44    os_version = 'xp'
    4445    port_maker = WinPort
    4546
    … …  
    5657        self.assertTrue(stderr.endswith("test.html'], cwd=/mock-checkout\n"))
    5758
    58     def test_detect_version(self):
    59         port = self.make_port()
    60 
    61         def mock_run_command(cmd):
    62             self.assertEquals(cmd, ['cmd', '/c', 'ver'])
    63             return "6.1.7600"
    64 
    65         port._executive = MockExecutive2(run_command_fn=mock_run_command)
    66         self.assertEquals(port._detect_version(run_on_non_windows_platforms=True), '7sp0')
    67 
    68         def mock_run_command(cmd):
    69             raise ScriptError('Failure')
    70 
    71         port._executive = MockExecutive2(run_command_fn=mock_run_command)
    72         # Failures log to the python error log, but we have no easy way to capture/test that.
    73         self.assertEquals(port._detect_version(run_on_non_windows_platforms=True), None)
    74 
    7559    def _assert_search_path(self, expected_search_paths, version, use_webkit2=False):
    76         port = WinPort(os_version_string=version,
    77             options=MockOptions(webkit_test_runner=use_webkit2),
    78             host=MockHost())
     60        host = MockSystemHost(os_name='win', os_version=version)
     61        port = WinPort(host, options=MockOptions(webkit_test_runner=use_webkit2))
    7962        absolute_search_paths = map(port._webkit_baseline_path, expected_search_paths)
    8063        self.assertEquals(port.baseline_search_path(), absolute_search_paths)
    … …  
    9275
    9376    def _assert_version(self, port_name, expected_version):
    94         port = WinPort(port_name=port_name, host=MockHost())
     77        host = MockSystemHost(os_name='win', os_version=expected_version)
     78        port = WinPort(host, port_name=port_name)
    9579        self.assertEquals(port.version(), expected_version)
    9680
Note: See TracChangeset for help on using the changeset viewer.