mirror of
https://github.com/flutter/flutter.git
synced 2026-02-20 02:29:02 +08:00
321 lines
15 KiB
Python
321 lines
15 KiB
Python
# Copyright (C) 2012 Google Inc. All rights reserved.
|
|
#
|
|
# Redistribution and use in source and binary forms, with or without
|
|
# modification, are permitted provided that the following conditions are
|
|
# met:
|
|
#
|
|
# * Redistributions of source code must retain the above copyright
|
|
# notice, this list of conditions and the following disclaimer.
|
|
# * Redistributions in binary form must reproduce the above
|
|
# copyright notice, this list of conditions and the following disclaimer
|
|
# in the documentation and/or other materials provided with the
|
|
# distribution.
|
|
# * Neither the name of Google Inc. nor the names of its
|
|
# contributors may be used to endorse or promote products derived from
|
|
# this software without specific prior written permission.
|
|
#
|
|
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
|
# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
|
# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
|
# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
|
|
import StringIO
|
|
import optparse
|
|
import sys
|
|
import time
|
|
import unittest
|
|
|
|
from webkitpy.common.system import executive_mock
|
|
from webkitpy.common.system.executive_mock import MockExecutive2
|
|
from webkitpy.common.system.systemhost_mock import MockSystemHost
|
|
|
|
from webkitpy.layout_tests.port import android
|
|
from webkitpy.layout_tests.port import port_testcase
|
|
from webkitpy.layout_tests.port import driver
|
|
from webkitpy.layout_tests.port import driver_unittest
|
|
from webkitpy.tool.mocktool import MockOptions
|
|
|
|
# Type of tombstone test which the mocked Android Debug Bridge should execute.
|
|
VALID_TOMBSTONE_TEST_TYPE = 0
|
|
NO_FILES_TOMBSTONE_TEST_TYPE = 1
|
|
NO_PERMISSION_TOMBSTONE_TEST_TYPE = 2
|
|
INVALID_ENTRY_TOMBSTONE_TEST_TYPE = 3
|
|
INVALID_ENTRIES_TOMBSTONE_TEST_TYPE = 4
|
|
|
|
# Any "adb" commands will be interpret by this class instead of executing actual
|
|
# commansd on the file system, which we don't want to do.
|
|
class MockAndroidDebugBridge:
|
|
def __init__(self, device_count):
|
|
self._device_count = device_count
|
|
self._last_command = None
|
|
self._tombstone_output = None
|
|
|
|
# Local public methods.
|
|
|
|
def run_command(self, args):
|
|
self._last_command = ' '.join(args)
|
|
if args[0].startswith('path'):
|
|
if args[0] == 'path1':
|
|
return ''
|
|
if args[0] == 'path2':
|
|
return 'version 1.1'
|
|
|
|
return 'version 1.0'
|
|
|
|
if args[0] == 'adb':
|
|
if len(args) > 1 and args[1] == 'version':
|
|
return 'version 1.0'
|
|
if len(args) > 1 and args[1] == 'devices':
|
|
return self._get_device_output()
|
|
if len(args) > 3 and args[3] == 'command':
|
|
return 'mockoutput'
|
|
if len(args) > 3 and args[3] == 'install':
|
|
return 'Success'
|
|
if len(args) > 3 and args[3] in ('push', 'wait-for-device'):
|
|
return 'mockoutput'
|
|
if len(args) > 5 and args[5] == 'battery':
|
|
return 'level: 99'
|
|
if len(args) > 5 and args[5] == 'force-stop':
|
|
return 'mockoutput'
|
|
if len(args) > 5 and args[5] == 'power':
|
|
return 'mScreenOn=true'
|
|
if len(args) > 5 and args[4] == 'cat' and args[5].find('tombstone') != -1:
|
|
return 'tombstone content'
|
|
if len(args) > 6 and args[4] == 'ls' and args[6].find('tombstone') != -1:
|
|
assert self._tombstone_output, 'Tombstone output needs to have been set by the test.'
|
|
return self._tombstone_output
|
|
|
|
return ''
|
|
|
|
def last_command(self):
|
|
return self._last_command
|
|
|
|
def set_tombstone_output(self, output):
|
|
self._tombstone_output = output
|
|
|
|
# Local private methods.
|
|
|
|
def _get_device_output(self):
|
|
serials = ['123456789ABCDEF0', '123456789ABCDEF1', '123456789ABCDEF2',
|
|
'123456789ABCDEF3', '123456789ABCDEF4', '123456789ABCDEF5']
|
|
output = 'List of devices attached\n'
|
|
for serial in serials[:self._device_count]:
|
|
output += '%s\tdevice\n' % serial
|
|
return output
|
|
|
|
|
|
class AndroidCommandsTest(unittest.TestCase):
|
|
def setUp(self):
|
|
android.AndroidCommands._adb_command_path = None
|
|
android.AndroidCommands._adb_command_path_options = ['adb']
|
|
|
|
def make_executive(self, device_count):
|
|
self._mock_executive = MockAndroidDebugBridge(device_count)
|
|
return MockExecutive2(run_command_fn=self._mock_executive.run_command)
|
|
|
|
def make_android_commands(self, device_count, serial):
|
|
return android.AndroidCommands(self.make_executive(device_count), serial, debug_logging=False)
|
|
|
|
# The used adb command should include the device's serial number, and get_serial() should reflect this.
|
|
def test_adb_command_and_get_serial(self):
|
|
android_commands = self.make_android_commands(1, '123456789ABCDEF0')
|
|
self.assertEquals(['adb', '-s', '123456789ABCDEF0'], android_commands.adb_command())
|
|
self.assertEquals('123456789ABCDEF0', android_commands.get_serial())
|
|
|
|
# Running an adb command should return the command's output.
|
|
def test_run_command(self):
|
|
android_commands = self.make_android_commands(1, '123456789ABCDEF0')
|
|
|
|
output = android_commands.run(['command'])
|
|
self.assertEquals('adb -s 123456789ABCDEF0 command', self._mock_executive.last_command())
|
|
self.assertEquals('mockoutput', output)
|
|
|
|
# Test that the convenience methods create the expected commands.
|
|
def test_convenience_methods(self):
|
|
android_commands = self.make_android_commands(1, '123456789ABCDEF0')
|
|
|
|
android_commands.file_exists('/some_directory')
|
|
self.assertEquals('adb -s 123456789ABCDEF0 shell ls -d /some_directory', self._mock_executive.last_command())
|
|
|
|
android_commands.push('foo', 'bar')
|
|
self.assertEquals('adb -s 123456789ABCDEF0 push foo bar', self._mock_executive.last_command())
|
|
|
|
android_commands.pull('bar', 'foo')
|
|
self.assertEquals('adb -s 123456789ABCDEF0 pull bar foo', self._mock_executive.last_command())
|
|
|
|
|
|
class AndroidPortTest(port_testcase.PortTestCase):
|
|
port_name = 'android'
|
|
port_maker = android.AndroidPort
|
|
|
|
def make_port(self, **kwargs):
|
|
port = super(AndroidPortTest, self).make_port(**kwargs)
|
|
port._mock_adb = MockAndroidDebugBridge(kwargs.get('device_count', 1))
|
|
port._executive = MockExecutive2(run_command_fn=port._mock_adb.run_command)
|
|
return port
|
|
|
|
def test_check_build(self):
|
|
host = MockSystemHost()
|
|
host.filesystem.exists = lambda p: True
|
|
port = self.make_port(host=host, options=MockOptions(child_processes=1))
|
|
port.check_build(needs_http=True, printer=port_testcase.FakePrinter())
|
|
|
|
def test_check_sys_deps(self):
|
|
# FIXME: Do something useful here, but testing the full logic would be hard.
|
|
pass
|
|
|
|
def make_wdiff_available(self, port):
|
|
port._wdiff_available = True
|
|
port._host_port._wdiff_available = True
|
|
|
|
# Test that content_shell currently is the only supported driver.
|
|
def test_non_content_shell_driver(self):
|
|
self.assertRaises(self.make_port, options=optparse.Values({'driver_name': 'foobar'}))
|
|
|
|
# Test that the number of child processes to create depends on the devices.
|
|
def test_default_child_processes(self):
|
|
port_default = self.make_port(device_count=5)
|
|
port_fixed_device = self.make_port(device_count=5, options=optparse.Values({'adb_device': '123456789ABCDEF9'}))
|
|
|
|
self.assertEquals(5, port_default.default_child_processes())
|
|
self.assertEquals(1, port_fixed_device.default_child_processes())
|
|
|
|
# Test that an HTTP server indeed is required by Android (as we serve all tests over them)
|
|
def test_requires_http_server(self):
|
|
self.assertTrue(self.make_port(device_count=1).requires_http_server())
|
|
|
|
# Tests the default timeouts for Android, which are different than the rest of Chromium.
|
|
def test_default_timeout_ms(self):
|
|
self.assertEqual(self.make_port(options=optparse.Values({'configuration': 'Release'})).default_timeout_ms(), 10000)
|
|
self.assertEqual(self.make_port(options=optparse.Values({'configuration': 'Debug'})).default_timeout_ms(), 10000)
|
|
|
|
|
|
class ChromiumAndroidDriverTest(unittest.TestCase):
|
|
def setUp(self):
|
|
self._mock_adb = MockAndroidDebugBridge(1)
|
|
self._mock_executive = MockExecutive2(run_command_fn=self._mock_adb.run_command)
|
|
|
|
android_commands = android.AndroidCommands(self._mock_executive, '123456789ABCDEF0', debug_logging=False)
|
|
self._port = android.AndroidPort(MockSystemHost(executive=self._mock_executive), 'android')
|
|
self._driver = android.ChromiumAndroidDriver(self._port, worker_number=0,
|
|
pixel_tests=True, driver_details=android.ContentShellDriverDetails(), android_devices=self._port._devices)
|
|
|
|
# The cmd_line() method in the Android port is used for starting a shell, not the test runner.
|
|
def test_cmd_line(self):
|
|
self.assertEquals(['adb', '-s', '123456789ABCDEF0', 'shell'], self._driver.cmd_line(False, []))
|
|
|
|
# Test that the Chromium Android port can interpret Android's shell output.
|
|
def test_read_prompt(self):
|
|
self._driver._server_process = driver_unittest.MockServerProcess(lines=['root@android:/ # '])
|
|
self.assertIsNone(self._driver._read_prompt(time.time() + 1))
|
|
self._driver._server_process = driver_unittest.MockServerProcess(lines=['$ '])
|
|
self.assertIsNone(self._driver._read_prompt(time.time() + 1))
|
|
|
|
|
|
class ChromiumAndroidDriverTwoDriversTest(unittest.TestCase):
|
|
# Test two drivers getting the right serial numbers, and that we disregard per-test arguments.
|
|
def test_two_drivers(self):
|
|
mock_adb = MockAndroidDebugBridge(2)
|
|
mock_executive = MockExecutive2(run_command_fn=mock_adb.run_command)
|
|
|
|
port = android.AndroidPort(MockSystemHost(executive=mock_executive), 'android')
|
|
driver0 = android.ChromiumAndroidDriver(port, worker_number=0, pixel_tests=True,
|
|
driver_details=android.ContentShellDriverDetails(), android_devices=port._devices)
|
|
driver1 = android.ChromiumAndroidDriver(port, worker_number=1, pixel_tests=True,
|
|
driver_details=android.ContentShellDriverDetails(), android_devices=port._devices)
|
|
|
|
self.assertEqual(['adb', '-s', '123456789ABCDEF0', 'shell'], driver0.cmd_line(True, []))
|
|
self.assertEqual(['adb', '-s', '123456789ABCDEF1', 'shell'], driver1.cmd_line(True, ['anything']))
|
|
|
|
|
|
class ChromiumAndroidTwoPortsTest(unittest.TestCase):
|
|
# Test that the driver's command line indeed goes through to the driver.
|
|
def test_options_with_two_ports(self):
|
|
mock_adb = MockAndroidDebugBridge(2)
|
|
mock_executive = MockExecutive2(run_command_fn=mock_adb.run_command)
|
|
|
|
port0 = android.AndroidPort(MockSystemHost(executive=mock_executive),
|
|
'android', options=MockOptions(additional_drt_flag=['--foo=bar']))
|
|
port1 = android.AndroidPort(MockSystemHost(executive=mock_executive),
|
|
'android', options=MockOptions(driver_name='content_shell'))
|
|
|
|
self.assertEqual(1, port0.driver_cmd_line().count('--foo=bar'))
|
|
self.assertEqual(0, port1.driver_cmd_line().count('--create-stdin-fifo'))
|
|
|
|
|
|
class ChromiumAndroidDriverTombstoneTest(unittest.TestCase):
|
|
EXPECTED_STACKTRACE = '-rw------- 1000 1000 3604 2013-11-19 16:16 tombstone_10\ntombstone content'
|
|
|
|
def setUp(self):
|
|
self._mock_adb = MockAndroidDebugBridge(1)
|
|
self._mock_executive = MockExecutive2(run_command_fn=self._mock_adb.run_command)
|
|
|
|
self._port = android.AndroidPort(MockSystemHost(executive=self._mock_executive), 'android')
|
|
self._driver = android.ChromiumAndroidDriver(self._port, worker_number=0,
|
|
pixel_tests=True, driver_details=android.ContentShellDriverDetails(), android_devices=self._port._devices)
|
|
|
|
self._errors = []
|
|
self._driver._log_error = lambda msg: self._errors.append(msg)
|
|
|
|
self._warnings = []
|
|
self._driver._log_warning = lambda msg: self._warnings.append(msg)
|
|
|
|
# Tests that we return an empty string and log an error when no tombstones could be found.
|
|
def test_no_tombstones_found(self):
|
|
self._mock_adb.set_tombstone_output('/data/tombstones/tombstone_*: No such file or directory')
|
|
stacktrace = self._driver._get_last_stacktrace()
|
|
|
|
self.assertEqual(1, len(self._errors))
|
|
self.assertEqual('The driver crashed, but no tombstone found!', self._errors[0])
|
|
self.assertEqual('', stacktrace)
|
|
|
|
# Tests that an empty string will be returned if we cannot read the tombstone files.
|
|
def test_insufficient_tombstone_permission(self):
|
|
self._mock_adb.set_tombstone_output('/data/tombstones/tombstone_*: Permission denied')
|
|
stacktrace = self._driver._get_last_stacktrace()
|
|
|
|
self.assertEqual(1, len(self._errors))
|
|
self.assertEqual('The driver crashed, but we could not read the tombstones!', self._errors[0])
|
|
self.assertEqual('', stacktrace)
|
|
|
|
# Tests that invalid "ls" output will throw a warning when listing the tombstone files.
|
|
def test_invalid_tombstone_list_entry_format(self):
|
|
self._mock_adb.set_tombstone_output('-rw------- 1000 1000 3604 2013-11-19 16:15 tombstone_00\n' +
|
|
'-- invalid entry --\n' +
|
|
'-rw------- 1000 1000 3604 2013-11-19 16:16 tombstone_10')
|
|
stacktrace = self._driver._get_last_stacktrace()
|
|
|
|
self.assertEqual(1, len(self._warnings))
|
|
self.assertEqual(ChromiumAndroidDriverTombstoneTest.EXPECTED_STACKTRACE, stacktrace)
|
|
|
|
# Tests the case in which we can't find any valid tombstone entries at all. The tombstone
|
|
# output used for the mock misses the permission part.
|
|
def test_invalid_tombstone_list(self):
|
|
self._mock_adb.set_tombstone_output('1000 1000 3604 2013-11-19 16:15 tombstone_00\n' +
|
|
'1000 1000 3604 2013-11-19 16:15 tombstone_01\n' +
|
|
'1000 1000 3604 2013-11-19 16:15 tombstone_02')
|
|
stacktrace = self._driver._get_last_stacktrace()
|
|
|
|
self.assertEqual(3, len(self._warnings))
|
|
self.assertEqual(1, len(self._errors))
|
|
self.assertEqual('The driver crashed, but we could not find any valid tombstone!', self._errors[0])
|
|
self.assertEqual('', stacktrace)
|
|
|
|
# Tests that valid tombstone listings will return the contents of the most recent file.
|
|
def test_read_valid_tombstone_file(self):
|
|
self._mock_adb.set_tombstone_output('-rw------- 1000 1000 3604 2013-11-19 16:15 tombstone_00\n' +
|
|
'-rw------- 1000 1000 3604 2013-11-19 16:16 tombstone_10\n' +
|
|
'-rw------- 1000 1000 3604 2013-11-19 16:15 tombstone_02')
|
|
stacktrace = self._driver._get_last_stacktrace()
|
|
|
|
self.assertEqual(0, len(self._warnings))
|
|
self.assertEqual(0, len(self._errors))
|
|
self.assertEqual(ChromiumAndroidDriverTombstoneTest.EXPECTED_STACKTRACE, stacktrace)
|