← Back to branch summary

~ubuntu-branches/ubuntu/raring/qtwebkit-source/raring-proposed

« back to all changes in this revision

Viewing changes to Tools/Scripts/webkitpy/layout_tests/port/chromium_port_testcase.py

  • Committer: Package Import Robot
  • Author(s): Jonathan Riddell
  • Date: 2013-02-18 14:24:18 UTC
  • Revision ID: package-import@ubuntu.com-20130218142418-eon0jmjg3nj438uy
Tags: upstream-2.3
Import upstream version 2.3

Show diffs side-by-side

added added

removed removed

Lines of Context:
Tools/Scripts/webkitpy/layout_tests/port/chromium_port_testcase.py
 
1
# Copyright (C) 2010 Google Inc. All rights reserved.
 
2
#
 
3
# Redistribution and use in source and binary forms, with or without
 
4
# modification, are permitted provided that the following conditions are
 
5
# met:
 
6
#
 
7
#    * Redistributions of source code must retain the above copyright
 
8
# notice, this list of conditions and the following disclaimer.
 
9
#    * Redistributions in binary form must reproduce the above
 
10
# copyright notice, this list of conditions and the following disclaimer
 
11
# in the documentation and/or other materials provided with the
 
12
# distribution.
 
13
#    * Neither the name of Google Inc. nor the names of its
 
14
# contributors may be used to endorse or promote products derived from
 
15
# this software without specific prior written permission.
 
16
#
 
17
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 
18
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 
19
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 
20
# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 
21
# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 
22
# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 
23
# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 
24
# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 
25
# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 
26
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 
27
# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
28
 
 
29
import unittest
 
30
 
 
31
from webkitpy.common.system import logtesting
 
32
from webkitpy.common.system.executive_mock import MockExecutive2
 
33
from webkitpy.common.system.systemhost_mock import MockSystemHost
 
34
from webkitpy.tool.mocktool import MockOptions
 
35
 
 
36
import chromium_android
 
37
import chromium_linux
 
38
import chromium_mac
 
39
import chromium_win
 
40
 
 
41
from webkitpy.layout_tests.models.test_configuration import TestConfiguration
 
42
from webkitpy.layout_tests.port import port_testcase
 
43
 
 
44
 
 
45
class ChromiumPortTestCase(port_testcase.PortTestCase):
 
46
 
 
47
    def test_check_build(self):
 
48
        port = self.make_port()
 
49
        port.check_build(needs_http=True)
 
50
 
 
51
    def test_default_max_locked_shards(self):
 
52
        port = self.make_port()
 
53
        port.default_child_processes = lambda: 16
 
54
        self.assertEqual(port.default_max_locked_shards(), 4)
 
55
        port.default_child_processes = lambda: 2
 
56
        self.assertEqual(port.default_max_locked_shards(), 1)
 
57
 
 
58
    def test_default_timeout_ms(self):
 
59
        self.assertEqual(self.make_port(options=MockOptions(configuration='Release')).default_timeout_ms(), 6000)
 
60
        self.assertEqual(self.make_port(options=MockOptions(configuration='Debug')).default_timeout_ms(), 12000)
 
61
 
 
62
    def test_default_pixel_tests(self):
 
63
        self.assertEqual(self.make_port().default_pixel_tests(), True)
 
64
 
 
65
    def test_missing_symbol_to_skipped_tests(self):
 
66
        # Test that we get the chromium skips and not the webkit default skips
 
67
        port = self.make_port()
 
68
        skip_dict = port._missing_symbol_to_skipped_tests()
 
69
        self.assertTrue('ff_mp3_decoder' in skip_dict)
 
70
        self.assertFalse('WebGLShader' in skip_dict)
 
71
 
 
72
    def test_all_test_configurations(self):
 
73
        """Validate the complete set of configurations this port knows about."""
 
74
        port = self.make_port()
 
75
        self.assertEqual(set(port.all_test_configurations()), set([
 
76
            TestConfiguration('icecreamsandwich', 'x86', 'debug'),
 
77
            TestConfiguration('icecreamsandwich', 'x86', 'release'),
 
78
            TestConfiguration('snowleopard', 'x86', 'debug'),
 
79
            TestConfiguration('snowleopard', 'x86', 'release'),
 
80
            TestConfiguration('lion', 'x86', 'debug'),
 
81
            TestConfiguration('lion', 'x86', 'release'),
 
82
            TestConfiguration('mountainlion', 'x86', 'debug'),
 
83
            TestConfiguration('mountainlion', 'x86', 'release'),
 
84
            TestConfiguration('xp', 'x86', 'debug'),
 
85
            TestConfiguration('xp', 'x86', 'release'),
 
86
            TestConfiguration('win7', 'x86', 'debug'),
 
87
            TestConfiguration('win7', 'x86', 'release'),
 
88
            TestConfiguration('lucid', 'x86', 'debug'),
 
89
            TestConfiguration('lucid', 'x86', 'release'),
 
90
            TestConfiguration('lucid', 'x86_64', 'debug'),
 
91
            TestConfiguration('lucid', 'x86_64', 'release'),
 
92
        ]))
 
93
 
 
94
    class TestMacPort(chromium_mac.ChromiumMacPort):
 
95
        def __init__(self, options=None):
 
96
            options = options or MockOptions()
 
97
            chromium_mac.ChromiumMacPort.__init__(self, MockSystemHost(os_name='mac', os_version='leopard'), 'chromium-mac-leopard', options=options)
 
98
 
 
99
        def default_configuration(self):
 
100
            self.default_configuration_called = True
 
101
            return 'default'
 
102
 
 
103
    class TestAndroidPort(chromium_android.ChromiumAndroidPort):
 
104
        def __init__(self, options=None):
 
105
            options = options or MockOptions()
 
106
            chromium_android.ChromiumAndroidPort.__init__(self, MockSystemHost(os_name='android', os_version='icecreamsandwich'), 'chromium-android', options=options)
 
107
 
 
108
        def default_configuration(self):
 
109
            self.default_configuration_called = True
 
110
            return 'default'
 
111
 
 
112
    class TestLinuxPort(chromium_linux.ChromiumLinuxPort):
 
113
        def __init__(self, options=None):
 
114
            options = options or MockOptions()
 
115
            chromium_linux.ChromiumLinuxPort.__init__(self, MockSystemHost(os_name='linux', os_version='lucid'), 'chromium-linux-x86', options=options)
 
116
 
 
117
        def default_configuration(self):
 
118
            self.default_configuration_called = True
 
119
            return 'default'
 
120
 
 
121
    class TestWinPort(chromium_win.ChromiumWinPort):
 
122
        def __init__(self, options=None):
 
123
            options = options or MockOptions()
 
124
            chromium_win.ChromiumWinPort.__init__(self, MockSystemHost(os_name='win', os_version='xp'), 'chromium-win-xp', options=options)
 
125
 
 
126
        def default_configuration(self):
 
127
            self.default_configuration_called = True
 
128
            return 'default'
 
129
 
 
130
    def test_default_configuration(self):
 
131
        mock_options = MockOptions()
 
132
        port = ChromiumPortTestCase.TestLinuxPort(options=mock_options)
 
133
        self.assertEqual(mock_options.configuration, 'default')  # pylint: disable-msg=E1101
 
134
        self.assertTrue(port.default_configuration_called)
 
135
 
 
136
        mock_options = MockOptions(configuration=None)
 
137
        port = ChromiumPortTestCase.TestLinuxPort(mock_options)
 
138
        self.assertEqual(mock_options.configuration, 'default')  # pylint: disable-msg=E1101
 
139
        self.assertTrue(port.default_configuration_called)
 
140
 
 
141
    def test_diff_image(self):
 
142
        class TestPort(ChromiumPortTestCase.TestLinuxPort):
 
143
            def _path_to_image_diff(self):
 
144
                return "/path/to/image_diff"
 
145
 
 
146
        port = ChromiumPortTestCase.TestLinuxPort()
 
147
        mock_image_diff = "MOCK Image Diff"
 
148
 
 
149
        def mock_run_command(args):
 
150
            port._filesystem.write_binary_file(args[4], mock_image_diff)
 
151
            return 1
 
152
 
 
153
        # Images are different.
 
154
        port._executive = MockExecutive2(run_command_fn=mock_run_command)
 
155
        self.assertEqual(mock_image_diff, port.diff_image("EXPECTED", "ACTUAL")[0])
 
156
 
 
157
        # Images are the same.
 
158
        port._executive = MockExecutive2(exit_code=0)
 
159
        self.assertEqual(None, port.diff_image("EXPECTED", "ACTUAL")[0])
 
160
 
 
161
        # There was some error running image_diff.
 
162
        port._executive = MockExecutive2(exit_code=2)
 
163
        exception_raised = False
 
164
        try:
 
165
            port.diff_image("EXPECTED", "ACTUAL")
 
166
        except ValueError, e:
 
167
            exception_raised = True
 
168
        self.assertFalse(exception_raised)
 
169
 
 
170
    def test_diff_image_crashed(self):
 
171
        port = ChromiumPortTestCase.TestLinuxPort()
 
172
        port._executive = MockExecutive2(exit_code=2)
 
173
        self.assertEqual(port.diff_image("EXPECTED", "ACTUAL"), (None, 0, 'image diff returned an exit code of 2'))
 
174
 
 
175
    def test_expectations_files(self):
 
176
        port = self.make_port()
 
177
        port.port_name = 'chromium'
 
178
 
 
179
        expectations_path = port.path_to_test_expectations_file()
 
180
        chromium_overrides_path = port.path_from_chromium_base(
 
181
            'webkit', 'tools', 'layout_tests', 'test_expectations.txt')
 
182
        skia_overrides_path = port.path_from_chromium_base(
 
183
            'skia', 'skia_test_expectations.txt')
 
184
 
 
185
        port._filesystem.write_text_file(skia_overrides_path, 'dummay text')
 
186
 
 
187
        port._options.builder_name = 'DUMMY_BUILDER_NAME'
 
188
        self.assertEqual(port.expectations_files(), [expectations_path, skia_overrides_path, chromium_overrides_path])
 
189
 
 
190
        port._options.builder_name = 'builder (deps)'
 
191
        self.assertEqual(port.expectations_files(), [expectations_path, skia_overrides_path, chromium_overrides_path])
 
192
 
 
193
        # A builder which does NOT observe the Chromium test_expectations,
 
194
        # but still observes the Skia test_expectations...
 
195
        port._options.builder_name = 'builder'
 
196
        self.assertEqual(port.expectations_files(), [expectations_path, skia_overrides_path])
 
197
 
 
198
    def test_expectations_ordering(self):
 
199
        # since we don't implement self.port_name in ChromiumPort.
 
200
        pass
 
201
 
 
202
 
 
203
class ChromiumPortLoggingTest(logtesting.LoggingTestCase):
 
204
    def test_check_sys_deps(self):
 
205
        port = ChromiumPortTestCase.TestLinuxPort()
 
206
 
 
207
        # Success
 
208
        port._executive = MockExecutive2(exit_code=0)
 
209
        self.assertTrue(port.check_sys_deps(needs_http=False))
 
210
 
 
211
        # Failure
 
212
        port._executive = MockExecutive2(exit_code=1,
 
213
            output='testing output failure')
 
214
        self.assertFalse(port.check_sys_deps(needs_http=False))
 
215
        self.assertLog([
 
216
            'ERROR: System dependencies check failed.\n',
 
217
            'ERROR: To override, invoke with --nocheck-sys-deps\n',
 
218
            'ERROR: \n',
 
219
            'ERROR: testing output failure\n'])
 
220
 
 
221
 
 
222
if __name__ == '__main__':
 
223
    unittest.main()