def test_default_configuration(self):
mock_options = mocktool.MockOptions()
port = ChromiumPortTest.TestLinuxPort(options=mock_options)
self.assertEquals(mock_options.configuration, 'default')
self.assertTrue(port.default_configuration_called)
mock_options = mocktool.MockOptions(configuration=None)
port = ChromiumPortTest.TestLinuxPort(mock_options)
self.assertEquals(mock_options.configuration, 'default')
self.assertTrue(port.default_configuration_called)
def test_diff_image(self):
class TestPort(ChromiumPortTest.TestLinuxPort):
def _path_to_image_diff(self):
return "/path/to/image_diff"
mock_options = mocktool.MockOptions()
port = ChromiumPortTest.TestLinuxPort(mock_options)
mock_image_diff = "MOCK Image Diff"
def mock_run_command(args):
port._filesystem.write_binary_file(args[4], mock_image_diff)
return 1
# Images are different.
port._executive = executive_mock.MockExecutive2(run_command_fn=mock_run_command)
self.assertEquals(mock_image_diff, port.diff_image("EXPECTED", "ACTUAL")[0])
# Images are the same.
port._executive = executive_mock.MockExecutive2(exit_code=0)
self.assertEquals(None, port.diff_image("EXPECTED", "ACTUAL")[0])
# There was some error running image_diff.
port._executive = executive_mock.MockExecutive2(exit_code=2)
exception_raised = False
try:
port.diff_image("EXPECTED", "ACTUAL")
except ValueError, e:
exception_raised = True
def test_options():
return mocktool.MockOptions(configuration=None,
backup=False,
html_directory='/tmp',
archive_url=ARCHIVE_URL,
force_archive_url=None,
verbose=False,
quiet=False,
platforms=None)
def test_path_to_image_diff(self):
mock_options = mocktool.MockOptions()
port = ChromiumPortTest.TestLinuxPort(options=mock_options)
self.assertTrue(port._path_to_image_diff().endswith(
'/out/default/ImageDiff'))
port = ChromiumPortTest.TestMacPort(options=mock_options)
self.assertTrue(port._path_to_image_diff().endswith(
'/xcodebuild/default/ImageDiff'))
port = ChromiumPortTest.TestWinPort(options=mock_options)
self.assertTrue(port._path_to_image_diff().endswith(
'/default/ImageDiff.exe'))
def test_driver_cmd_line(self):
port = self.make_port()
if not port:
return
self.assertTrue(len(port.driver_cmd_line()))
options = mocktool.MockOptions(
additional_drt_flag=['--foo=bar', '--foo=baz'])
port = self.make_port(options=options)
cmd_line = port.driver_cmd_line()
self.assertTrue('--foo=bar' in cmd_line)
self.assertTrue('--foo=baz' in cmd_line)
def assert_result(self, release_present, debug_present, valid_port_obj):
# Tests whether we get a valid port object returned when we claim
# that Image diff is (or isn't) present in the two configs.
port.get = get_mock_get({'Release': release_present,
'Debug': debug_present})
options = mocktool.MockOptions(configuration=None,
html_directory='/tmp')
port_obj = rebaseline_chromium_webkit_tests.get_host_port_object(options)
if valid_port_obj:
self.assertNotEqual(port_obj, None)
else:
self.assertEqual(port_obj, None)
def make_generator(self, files, tests):
options = mocktool.MockOptions(configuration=None,
html_directory='/tmp')
host_port = port.get('test',
options,
filesystem=port.unit_test_filesystem(files))
generator = rebaseline_chromium_webkit_tests.HtmlGenerator(
host_port,
target_port=None,
options=options,
platforms=['test-mac-leopard'],
rebaselining_tests=tests)
return generator, host_port
def test_skipped_layout_tests(self):
mock_options = mocktool.MockOptions()
port = ChromiumPortTest.TestLinuxPort(options=mock_options)
fake_test = port._filesystem.join(port.layout_tests_dir(), "fast/js/not-good.js")
port.test_expectations = lambda: """BUG_TEST SKIP : fast/js/not-good.js = TEXT
LINUX WIN : fast/js/very-good.js = TIMEOUT PASS"""
port.test_expectations_overrides = lambda: ''
port.tests = lambda paths: set()
port.path_exists = lambda test: True
skipped_tests = port.skipped_layout_tests(extra_test_files=[fake_test, ])
self.assertTrue("fast/js/not-good.js" in skipped_tests)
def assertOverridesWorked(self, port_name, input_name=None, platform=None):
# test that we got the right port
mock_options = mocktool.MockOptions(accelerated_compositing=None,
accelerated_2d_canvas=None,
builder_name='foo',
child_processes=None)
if input_name and platform:
port = chromium_gpu.get(platform=platform,
port_name=input_name,
options=mock_options)
else:
port = chromium_gpu.get(port_name=port_name, options=mock_options)
self.assertTrue(port._options.accelerated_compositing)
self.assertTrue(port._options.accelerated_2d_canvas)
self.assertEqual(port.default_child_processes(), 1)
self.assertEqual(port._options.builder_name, 'foo - GPU')
self.assertTrue(port.name().startswith(port_name))
# test that it has the right directories in front of the search path.
paths = port.baseline_search_path()
self.assertEqual(port._webkit_baseline_path(port_name), paths[0])
if port_name == 'chromium-gpu-linux':
self.assertEqual(port._webkit_baseline_path('chromium-gpu-win'),
paths[1])
self.assertEqual(port._webkit_baseline_path('chromium-gpu'),
paths[2])
else:
self.assertEqual(port._webkit_baseline_path('chromium-gpu'),
paths[1])
# Test that we're limiting to the correct directories.
# These two tests are picked mostly at random, but we make sure they
# exist separately from being filtered out by the port.
files = port.tests(None)
path = port.abspath_for_test('compositing/checkerboard.html')
self.assertTrue(port._filesystem.exists(path))
self.assertTrue(path in files)
path = port.abspath_for_test('fast/html/keygen.html')
self.assertTrue(port._filesystem.exists(path))
self.assertFalse(path in files)
if port_name.startswith('chromium-gpu-mac'):
path = port.abspath_for_test('fast/canvas/set-colors.html')
self.assertTrue(port._filesystem.exists(path))
self.assertFalse(path in files)
def test_check_sys_deps(self):
mock_options = mocktool.MockOptions()
port = ChromiumPortTest.TestLinuxPort(options=mock_options)
# Success
port._executive = executive_mock.MockExecutive2(exit_code=0)
self.assertTrue(port.check_sys_deps(needs_http=False))
# Failure
port._executive = executive_mock.MockExecutive2(exit_code=1,
output='testing output failure')
self.assertFalse(port.check_sys_deps(needs_http=False))
self.assertLog([
'ERROR: System dependencies check failed.\n',
'ERROR: To override, invoke with --nocheck-sys-deps\n',
'ERROR: \n',
'ERROR: testing output failure\n'])
def run_one_thread(self, msg):
runner = self.MockTestRunner()
port = None
options = mocktool.MockOptions(child_processes='1')
starting_queue = Queue.Queue()
stopping_queue = Queue.Queue()
broker = message_broker.MultiThreadedBroker(port, options)
broker._test_runner = runner
child_thread = TestThread(starting_queue, stopping_queue)
broker._workers['worker-0'] = message_broker._WorkerState('worker-0')
broker._workers['worker-0'].thread = child_thread
child_thread.start()
started_msg = starting_queue.get()
stopping_queue.put(msg)
res = broker.run_message_loop()
if msg == 'Timeout':
child_thread._timeout_queue.put('done')
child_thread.join(1.0)
self.assertFalse(child_thread.isAlive())
return res
def test_diff_image(self):
class TestPort(ChromiumPortTest.TestLinuxPort):
def _path_to_image_diff(self):
return "/path/to/image_diff"
mock_options = mocktool.MockOptions()
port = ChromiumPortTest.TestLinuxPort(mock_options)
# Images are different.
port._executive = executive_mock.MockExecutive2(exit_code=0)
self.assertEquals(False, port.diff_image("EXPECTED", "ACTUAL"))
# Images are the same.
port._executive = executive_mock.MockExecutive2(exit_code=1)
self.assertEquals(True, port.diff_image("EXPECTED", "ACTUAL"))
# There was some error running image_diff.
port._executive = executive_mock.MockExecutive2(exit_code=2)
exception_raised = False
try:
port.diff_image("EXPECTED", "ACTUAL")
except ValueError, e:
exception_raised = True
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
"""Unit tests for MockDRT."""
import sys
import unittest2 as unittest
from webkitpy.common import newstringio
from webkitpy.common.system.systemhost_mock import MockSystemHost
from webkitpy.layout_tests.port import mock_drt
from webkitpy.layout_tests.port import port_testcase
from webkitpy.layout_tests.port import test
from webkitpy.layout_tests.port.factory import PortFactory
from webkitpy.tool import mocktool
mock_options = mocktool.MockOptions(configuration='Release')
class MockDRTPortTest(port_testcase.PortTestCase):
def make_port(self, options=mock_options):
host = MockSystemHost()
test.add_unit_tests_to_mock_filesystem(host.filesystem)
return mock_drt.MockDRTPort(host,
port_name='mock-chromium-mac',
options=options)
def test_port_name_in_constructor(self):
self.assertTrue(
mock_drt.MockDRTPort(MockSystemHost(), port_name='mock-test'))
def test_check_sys_deps(self):
def setUp(self):
self.real_sys_platform = sys.platform
self.webkit_options = mocktool.MockOptions(pixel_tests=False)
self.chromium_options = mocktool.MockOptions(pixel_tests=False,
chromium=True)
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
"""Unit tests for MockDRT."""
import sys
import unittest
from webkitpy.common import newstringio
from webkitpy.layout_tests.port import mock_drt
from webkitpy.layout_tests.port import factory
from webkitpy.layout_tests.port import port_testcase
from webkitpy.layout_tests.port import test
from webkitpy.tool import mocktool
mock_options = mocktool.MockOptions(use_apache=True, configuration='Release')
class MockDRTPortTest(port_testcase.PortTestCase):
def make_port(self, options=mock_options):
if sys.platform == 'win32':
# We use this because the 'win' port doesn't work yet.
return mock_drt.MockDRTPort(port_name='mock-chromium-win',
options=options)
return mock_drt.MockDRTPort(options=options)
def test_default_worker_model(self):
# only overridding the default test; we don't care about this one.
pass
def test_port_name_in_constructor(self):
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
"""Unit testing base class for Port implementations."""
import sys
import unittest
# Handle Python < 2.6 where multiprocessing isn't available.
try:
import multiprocessing
except ImportError:
multiprocessing = None
from webkitpy.tool import mocktool
mock_options = mocktool.MockOptions(results_directory='layout-test-results',
use_apache=True,
configuration='Release')
# FIXME: This should be used for all ports, not just WebKit Mac. See
# https://bugs.webkit.org/show_bug.cgi?id=50043 .
class PortTestCase(unittest.TestCase):
"""Tests the WebKit port implementation."""
def port_maker(self, platform):
"""Override to return the class object of the port to be tested,
or None if a valid port object cannot be constructed on the specified
platform."""
raise NotImplementedError()
def make_port(self, options=mock_options):
