def main(host=None, args=None):
options = parse_args(args)
if options.no_autopep8:
options.style = None
if options.leave_strings_alone:
options.quoting = None
autopep8_options = _autopep8_options_for_style(options.style)
fixers = ['webkitpy.formatter.fix_docstrings']
fixers.extend(_fixers_for_quoting(options.quoting))
if options.files == ['-']:
host = host or SystemHost()
host.print_(reformat_source(host.stdin.read(), autopep8_options,
fixers, '<stdin>'),
end='')
return
# We create the arglist before checking if we need to create a Host, because a
# real host is non-picklable and can't be passed to host.executive.map().
arglist = [(host, name, autopep8_options, fixers, options.backup)
for name in options.files]
host = host or SystemHost()
host.executive.map(_reformat_thunk, arglist, processes=options.jobs)
def create_crash_logs_darwin(self):
if not SystemHost().platform.is_mac():
return
self.older_mock_crash_report = make_mock_crash_report_darwin(
'DumpRenderTree', 28528)
self.mock_crash_report = make_mock_crash_report_darwin(
'DumpRenderTree', 28530)
self.newer_mock_crash_report = make_mock_crash_report_darwin(
'DumpRenderTree', 28529)
self.other_process_mock_crash_report = make_mock_crash_report_darwin(
'FooProcess', 28527)
self.misformatted_mock_crash_report = 'Junk that should not appear in a crash report' + make_mock_crash_report_darwin(
'DumpRenderTree', 28526)[200:]
self.files = {}
self.files[
'/Users/mock/Library/Logs/DiagnosticReports/DumpRenderTree_2011-06-13-150718_quadzen.crash'] = self.older_mock_crash_report
self.files[
'/Users/mock/Library/Logs/DiagnosticReports/DumpRenderTree_2011-06-13-150719_quadzen.crash'] = self.mock_crash_report
self.files[
'/Users/mock/Library/Logs/DiagnosticReports/DumpRenderTree_2011-06-13-150720_quadzen.crash'] = self.newer_mock_crash_report
self.files[
'/Users/mock/Library/Logs/DiagnosticReports/DumpRenderTree_2011-06-13-150721_quadzen.crash'] = None
self.files[
'/Users/mock/Library/Logs/DiagnosticReports/DumpRenderTree_2011-06-13-150722_quadzen.crash'] = self.other_process_mock_crash_report
self.files[
'/Users/mock/Library/Logs/DiagnosticReports/DumpRenderTree_2011-06-13-150723_quadzen.crash'] = self.misformatted_mock_crash_report
self.filesystem = MockFileSystem(self.files)
crash_logs = CrashLogs(MockSystemHost(filesystem=self.filesystem),
CrashLogsTest.DARWIN_MOCK_CRASH_DIRECTORY)
logs = self.filesystem.files_under(
'/Users/mock/Library/Logs/DiagnosticReports/')
for path in reversed(sorted(logs)):
self.assertTrue(path in self.files.keys())
return crash_logs
def _boot_device(device, host=None):
host = host or SystemHost()
_log.debug(u"Booting device '{}'".format(device.udid))
device.platform_device.booted_by_script = True
host.executive.run_command(
[SimulatedDeviceManager.xcrun, 'simctl', 'boot', device.udid])
SimulatedDeviceManager.INITIALIZED_DEVICES.append(device)
def serial_test_process_crashing(self):
# Give -u switch to force stdout to be unbuffered for Windows
cmd = [
sys.executable, '-uc',
'import sys; print("stdout 1"); print("stdout 2"); print("stdout 3"); sys.stdin.readline(); sys.exit(1);'
]
host = SystemHost()
factory = PortFactory(host)
port = factory.get()
now = time.time()
proc = server_process.ServerProcess(port, 'python', cmd)
proc.write(b'')
line = proc.read_stdout_line(now + 1.0)
self.assertEqual(line.strip(), b'stdout 1')
proc.write(b'End\n')
time.sleep(0.1) # Give process a moment to close.
line = proc.read_stdout_line(now + 1.0)
self.assertEqual(line.strip(), b'stdout 2')
self.assertEqual(True, proc.has_crashed())
line = proc.read_stdout_line(now + 1.0)
self.assertEqual(line, None)
proc.stop(0)
def test_find_log_darwin(self):
if not SystemHost().platform.is_mac():
return
crash_logs = self.create_crash_logs_darwin()
log = crash_logs.find_newest_log("DumpRenderTree")
self.assertMultiLineEqual(log, self.newer_mock_crash_report)
log = crash_logs.find_newest_log("DumpRenderTree", 28529)
self.assertMultiLineEqual(log, self.newer_mock_crash_report)
log = crash_logs.find_newest_log("DumpRenderTree", 28530)
self.assertMultiLineEqual(log, self.mock_crash_report)
log = crash_logs.find_newest_log("DumpRenderTree", 28531)
self.assertIsNone(log)
log = crash_logs.find_newest_log("DumpRenderTree", newer_than=1.0)
self.assertIsNone(log)
def bad_read(path):
raise IOError('IOError: No such file or directory')
def bad_mtime(path):
raise OSError('OSError: No such file or directory')
self.filesystem.read_text_file = bad_read
log = crash_logs.find_newest_log("DumpRenderTree", 28531, include_errors=True)
self.assertIn('IOError: No such file or directory', log)
self.filesystem = MockFileSystem(self.files)
crash_logs = CrashLogs(MockSystemHost(filesystem=self.filesystem))
self.filesystem.mtime = bad_mtime
log = crash_logs.find_newest_log("DumpRenderTree", newer_than=1.0, include_errors=True)
self.assertIn('OSError: No such file or directory', log)
def _create_or_find_device_for_request(request, host=SystemHost(), name_base='Managed'):
assert isinstance(request, DeviceRequest)
device = SimulatedDeviceManager._find_exisiting_device_for_request(request)
if device:
return device
name = SimulatedDeviceManager._find_available_name(name_base)
device_type = SimulatedDeviceManager._disambiguate_device_type(request.device_type)
runtime = SimulatedDeviceManager.get_runtime_for_device_type(device_type)
device_identifier = SimulatedDeviceManager._get_device_identifier_for_type(device_type)
assert runtime is not None
assert device_identifier is not None
for device in SimulatedDeviceManager.available_devices(host):
if device.platform_device.name == name:
device.platform_device._delete()
break
_log.debug(u"Creating device '{}', of type {}".format(name, device_type))
host.executive.run_command([SimulatedDeviceManager.xcrun, 'simctl', 'create', name, device_identifier, runtime.identifier])
# We just added a device, so our list of _available_devices needs to be re-synced.
SimulatedDeviceManager.populate_available_devices(host)
for device in SimulatedDeviceManager.available_devices(host):
if device.platform_device.name == name:
device.platform_device.managed_by_script = True
return device
return None
def test_find_log_darwin(self):
if not SystemHost().platform.is_mac():
return
older_mock_crash_report = make_mock_crash_report_darwin(
'DumpRenderTree', 28528)
mock_crash_report = make_mock_crash_report_darwin(
'DumpRenderTree', 28530)
newer_mock_crash_report = make_mock_crash_report_darwin(
'DumpRenderTree', 28529)
other_process_mock_crash_report = make_mock_crash_report_darwin(
'FooProcess', 28527)
misformatted_mock_crash_report = 'Junk that should not appear in a crash report' + \
make_mock_crash_report_darwin('DumpRenderTree', 28526)[200:]
files = {
'/Users/mock/Library/Logs/DiagnosticReports/DumpRenderTree_2011-06-13-150718_quadzen.crash':
older_mock_crash_report,
'/Users/mock/Library/Logs/DiagnosticReports/DumpRenderTree_2011-06-13-150719_quadzen.crash':
mock_crash_report,
'/Users/mock/Library/Logs/DiagnosticReports/DumpRenderTree_2011-06-13-150720_quadzen.crash':
newer_mock_crash_report,
'/Users/mock/Library/Logs/DiagnosticReports/DumpRenderTree_2011-06-13-150721_quadzen.crash':
None,
'/Users/mock/Library/Logs/DiagnosticReports/DumpRenderTree_2011-06-13-150722_quadzen.crash':
other_process_mock_crash_report,
'/Users/mock/Library/Logs/DiagnosticReports/DumpRenderTree_2011-06-13-150723_quadzen.crash':
misformatted_mock_crash_report,
}
filesystem = MockFileSystem(files)
crash_logs = CrashLogs(MockSystemHost(filesystem=filesystem))
log = crash_logs.find_newest_log("DumpRenderTree")
self.assertMultiLineEqual(log, newer_mock_crash_report)
log = crash_logs.find_newest_log("DumpRenderTree", 28529)
self.assertMultiLineEqual(log, newer_mock_crash_report)
log = crash_logs.find_newest_log("DumpRenderTree", 28530)
self.assertMultiLineEqual(log, mock_crash_report)
log = crash_logs.find_newest_log("DumpRenderTree", 28531)
self.assertIsNone(log)
log = crash_logs.find_newest_log("DumpRenderTree", newer_than=1.0)
self.assertIsNone(log)
def bad_read(path):
raise IOError('IOError: No such file or directory')
def bad_mtime(path):
raise OSError('OSError: No such file or directory')
filesystem.read_text_file = bad_read
log = crash_logs.find_newest_log("DumpRenderTree",
28531,
include_errors=True)
self.assertIn('IOError: No such file or directory', log)
filesystem = MockFileSystem(files)
crash_logs = CrashLogs(MockSystemHost(filesystem=filesystem))
filesystem.mtime = bad_mtime
log = crash_logs.find_newest_log("DumpRenderTree",
newer_than=1.0,
include_errors=True)
self.assertIn('OSError: No such file or directory', log)
def tear_down(host=None, timeout=SIMULATOR_BOOT_TIMEOUT):
host = host or SystemHost()
if SimulatedDeviceManager._managing_simulator_app:
host.executive.run_command(['killall', '-9', 'Simulator'], return_exit_code=True)
SimulatedDeviceManager._managing_simulator_app = False
if SimulatedDeviceManager.INITIALIZED_DEVICES is None:
return
deadline = time.time() + timeout
while SimulatedDeviceManager.INITIALIZED_DEVICES:
device = SimulatedDeviceManager.INITIALIZED_DEVICES[0]
if device is None:
SimulatedDeviceManager.INITIALIZED_DEVICES.remove(None)
continue
device.platform_device._tear_down(deadline - time.time())
SimulatedDeviceManager.INITIALIZED_DEVICES = None
if SimulatedDeviceManager._managing_simulator_app:
for pid in host.executive.running_pids(lambda name: 'CoreSimulator.framework' in name):
host.executive.kill_process(pid)
# If we were managing the simulator, there are some cache files we need to remove
for directory in host.filesystem.glob('/tmp/com.apple.CoreSimulator.SimDevice.*'):
host.filesystem.rmtree(directory)
core_simulator_directory = host.filesystem.expanduser(host.filesystem.join('~', 'Library', 'Developer', 'CoreSimulator'))
host.filesystem.rmtree(host.filesystem.join(core_simulator_directory, 'Caches'))
host.filesystem.rmtree(host.filesystem.join(core_simulator_directory, 'Temp'))
def swap(device,
request,
host=SystemHost(),
name_base='Managed',
timeout=SIMULATOR_BOOT_TIMEOUT):
if SimulatedDeviceManager.INITIALIZED_DEVICES is None:
raise RuntimeError(
'Cannot swap when there are no initialized devices')
if device not in SimulatedDeviceManager.INITIALIZED_DEVICES:
raise RuntimeError(
'{} is not initialized, cannot swap it'.format(device))
index = SimulatedDeviceManager.INITIALIZED_DEVICES.index(device)
SimulatedDeviceManager.INITIALIZED_DEVICES[index] = None
device.platform_device._tear_down()
device = SimulatedDeviceManager._create_or_find_device_for_request(
request, host, name_base)
assert device
if not device.platform_device.is_booted_or_booting(force_update=True):
device.platform_device.booted_by_script = True
_log.debug("Booting device '{}'".format(device.udid))
host.executive.run_command(
[SimulatedDeviceManager.xcrun, 'simctl', 'boot', device.udid])
SimulatedDeviceManager.INITIALIZED_DEVICES[index] = device
deadline = time.time() + timeout
SimulatedDeviceManager._wait_until_device_is_usable(
device, max(0, deadline - time.time()))
def test_basic(self):
cmd = [
sys.executable, '-c',
'import sys; print "stdout"; sys.stdout.flush(); print >>sys.stderr, "stderr"; sys.stdin.readline();'
]
host = SystemHost()
factory = PortFactory(host)
port = factory.get()
now = time.time()
proc = server_process.ServerProcess(port, 'python', cmd)
proc.write('')
if sys.platform.startswith('win'):
self.assertEqual(proc.poll(), 0)
else:
self.assertEqual(proc.poll(), None)
self.assertFalse(proc.has_crashed())
# check that doing a read after an expired deadline returns
# nothing immediately.
line = proc.read_stdout_line(now - 1)
self.assertEqual(line, None)
line = proc.read_stdout_line(now + 1.0)
self.assertEqual(line.strip(), "stdout")
line = proc.read_stderr_line(now + 1.0)
self.assertEqual(line.strip(), "stderr")
proc.write('End\n')
proc.stop(0)
def max_supported_simulators(host=SystemHost()):
if not host.platform.is_mac():
return 0
try:
system_process_count_limit = int(host.executive.run_command(['/usr/bin/ulimit', '-u']).strip())
current_process_count = len(host.executive.run_command(['/bin/ps', 'aux']).strip().split('\n'))
_log.debug(u'Process limit: {}, current #processes: {}'.format(system_process_count_limit, current_process_count))
except (ValueError, ScriptError):
return 0
max_supported_simulators_for_hardware = min(
host.executive.cpu_count() // 2,
host.platform.total_bytes_memory() // SimulatedDeviceManager.MEMORY_ESTIMATE_PER_SIMULATOR_INSTANCE,
SimulatedDeviceManager.MAX_NUMBER_OF_SIMULATORS,
)
max_supported_simulators_locally = (system_process_count_limit - current_process_count) // SimulatedDeviceManager.PROCESS_COUNT_ESTIMATE_PER_SIMULATOR_INSTANCE
if (max_supported_simulators_locally < max_supported_simulators_for_hardware):
_log.warn(u'This machine could support {} simulators, but is only configured for {}.'.format(max_supported_simulators_for_hardware, max_supported_simulators_locally))
_log.warn('Please see <https://trac.webkit.org/wiki/IncreasingKernelLimits>.')
if max_supported_simulators_locally == 0:
max_supported_simulators_locally = 1
return min(max_supported_simulators_locally, max_supported_simulators_for_hardware)
def device_by_filter(filter, host=None):
host = host or SystemHost()
result = []
for device in SimulatedDeviceManager.available_devices(host):
if filter(device):
result.append(device)
return result
def setup(cls):
LLDB_WEBKIT_TESTER_NAME = 'lldbWebKitTester'
BREAK_FOR_TESTING_FUNCTION_NAME = 'breakForTestingSummaryProviders'
cls.sbDebugger = lldb.SBDebugger.Create()
cls.sbDebugger.SetAsync(False)
host = SystemHost()
config = Config(host.executive, host.filesystem)
cls.lldbWebKitTesterExecutable = os.path.join(config.build_directory(config.default_configuration()), LLDB_WEBKIT_TESTER_NAME)
cls.sbTarget = cls.sbDebugger.CreateTarget(str(cls.lldbWebKitTesterExecutable))
assert cls.sbTarget
cls.sbTarget.BreakpointCreateByName(BREAK_FOR_TESTING_FUNCTION_NAME, cls.sbTarget.GetExecutable().GetFilename())
argv = None
envp = None
cls.sbProcess = cls.sbTarget.LaunchSimple(argv, envp, os.getcwd())
assert cls.sbProcess
assert cls.sbProcess.GetState() == lldb.eStateStopped
cls.sbThread = cls.sbProcess.GetThreadAtIndex(0)
assert cls.sbThread
# Frame 0 is the function with name BREAK_FOR_TESTING_FUNCTION_NAME. We want the frame of the caller of
# BREAK_FOR_TESTING_FUNCTION_NAME because it has all the interesting local variables we want to test.
cls.sbFrame = cls.sbThread.GetFrameAtIndex(1)
assert cls.sbFrame
def populate_available_devices(host=SystemHost()):
if not host.platform.is_mac():
return
try:
simctl_json = json.loads(host.executive.run_command([SimulatedDeviceManager.xcrun, 'simctl', 'list', '--json'], decode_output=False))
except (ValueError, ScriptError):
return
SimulatedDeviceManager._device_identifier_to_name = {device['identifier']: device['name'] for device in simctl_json['devicetypes']}
SimulatedDeviceManager.AVAILABLE_RUNTIMES = SimulatedDeviceManager._create_runtimes(simctl_json['runtimes'])
for runtime in SimulatedDeviceManager.AVAILABLE_RUNTIMES:
# Needed for <rdar://problem/47122965>
devices = []
if isinstance(simctl_json['devices'], list):
for devices_for_runtime in simctl_json['devices']:
if devices_for_runtime['name'] == runtime.name:
devices = devices_for_runtime['devices']
break
else:
devices = simctl_json['devices'].get(runtime.name, None) or simctl_json['devices'].get(runtime.identifier, [])
for device_json in devices:
device = SimulatedDeviceManager._create_device_with_runtime(host, runtime, device_json)
if not device:
continue
# Update device state from simctl output.
device.platform_device._state = SimulatedDevice.NAME_FOR_STATE.index(device_json['state'].upper())
device.platform_device._last_updated_state = time.time()
return
def populate_available_devices(host=SystemHost()):
if not host.platform.is_mac():
return
try:
simctl_json = json.loads(
host.executive.run_command(
[SimulatedDeviceManager.xcrun, 'simctl', 'list',
'--json']))
except (ValueError, ScriptError):
return
SimulatedDeviceManager._device_identifier_to_name = {
device['identifier']: device['name']
for device in simctl_json['devicetypes']
}
SimulatedDeviceManager.AVAILABLE_RUNTIMES = SimulatedDeviceManager._create_runtimes(
simctl_json['runtimes'])
for runtime in SimulatedDeviceManager.AVAILABLE_RUNTIMES:
for device_json in simctl_json['devices'][runtime.name]:
device = SimulatedDeviceManager._create_device_with_runtime(
host, runtime, device_json)
if not device:
continue
# Update device state from simctl output.
device.platform_device._state = SimulatedDevice.NAME_FOR_STATE.index(
device_json['state'].upper())
device.platform_device._last_updated_state = time.time()
return
def test_virtual_test_suites(self):
# We test that we can load the real LayoutTests/VirtualTestSuites file properly, so we
# use a real SystemHost(). We don't care what virtual_test_suites() returns as long
# as it is iterable.
port = self.make_port(host=SystemHost(), port_name=self.full_port_name)
self.assertTrue(
isinstance(port.virtual_test_suites(), collections.Iterable))
def serial_test_basic(self):
# Give -u switch to force stdout and stderr to be unbuffered for Windows
cmd = [
sys.executable, '-uc',
'import sys; print "stdout"; print >>sys.stderr, "stderr"; sys.stdin.readline();'
]
host = SystemHost()
factory = PortFactory(host)
port = factory.get()
now = time.time()
proc = server_process.ServerProcess(port, 'python', cmd)
proc.write('')
self.assertEqual(proc.poll(), None)
self.assertFalse(proc.has_crashed())
# check that doing a read after an expired deadline returns
# nothing immediately.
line = proc.read_stdout_line(now - 1)
self.assertEqual(line, None)
line = proc.read_stdout_line(now + 1.0)
self.assertEqual(line.strip(), "stdout")
line = proc.read_stderr_line(now + 1.0)
self.assertEqual(line.strip(), "stderr")
proc.write('End\n')
time.sleep(0.1) # Give process a moment to close.
self.assertEqual(proc.poll(), 0)
proc.stop(0)
def test_process_crashing(self):
cmd = [
sys.executable, '-c',
'import sys; print "stdout 1"; print "stdout 2"; print "stdout 3"; sys.stdout.flush(); sys.stdin.readline(); sys.exit(1);'
]
host = SystemHost()
factory = PortFactory(host)
port = factory.get()
now = time.time()
proc = server_process.ServerProcess(port, 'python', cmd)
proc.write('')
line = proc.read_stdout_line(now + 1.0)
self.assertEqual(line.strip(), 'stdout 1')
proc.write('End\n')
time.sleep(0.1) # Give process a moment to close.
line = proc.read_stdout_line(now + 1.0)
self.assertEqual(line.strip(), 'stdout 2')
self.assertEqual(True, proc.has_crashed())
line = proc.read_stdout_line(now + 1.0)
self.assertEqual(line, None)
proc.stop(0)
def test_basic(self):
cmd = [sys.executable, '-c', 'import sys; import time; time.sleep(0.02); print "stdout"; sys.stdout.flush(); print >>sys.stderr, "stderr"']
host = SystemHost()
factory = PortFactory(host)
port = factory.get()
now = time.time()
proc = server_process.ServerProcess(port, 'python', cmd)
proc.write('')
self.assertEqual(proc.poll(), None)
self.assertFalse(proc.has_crashed())
# check that doing a read after an expired deadline returns
# nothing immediately.
line = proc.read_stdout_line(now - 1)
self.assertEqual(line, None)
# FIXME: This part appears to be flaky. line should always be non-None.
# FIXME: https://bugs.webkit.org/show_bug.cgi?id=88280
line = proc.read_stdout_line(now + 1.0)
if line:
self.assertEqual(line.strip(), "stdout")
line = proc.read_stderr_line(now + 1.0)
if line:
self.assertEqual(line.strip(), "stderr")
proc.stop(0)
def configure(self, options):
self.options = options
if options.timing:
# --timing implies --verbose
options.verbose = max(options.verbose, 1)
log_level = logging.INFO
if options.quiet:
log_level = logging.WARNING
elif options.verbose == 2:
log_level = logging.DEBUG
self.meter = MeteredStream(
self.stream, (options.verbose == 2),
number_of_columns=SystemHost().platform.terminal_width())
handler = logging.StreamHandler(self.stream)
# We constrain the level on the handler rather than on the root
# logger itself. This is probably better because the handler is
# configured and known only to this module, whereas the root logger
# is an object shared (and potentially modified) by many modules.
# Modifying the handler, then, is less intrusive and less likely to
# interfere with modifications made by other modules (e.g. in unit
# tests).
handler.name = __name__
handler.setLevel(log_level)
formatter = logging.Formatter("%(message)s")
handler.setFormatter(formatter)
logger = logging.getLogger()
logger.addHandler(handler)
logger.setLevel(logging.NOTSET)
# Filter out most webkitpy messages.
#
# Messages can be selectively re-enabled for this script by updating
# this method accordingly.
def filter_records(record):
"""Filter out autoinstall and non-third-party webkitpy messages."""
# FIXME: Figure out a way not to use strings here, for example by
# using syntax like webkitpy.test.__name__. We want to be
# sure not to import any non-Python 2.4 code, though, until
# after the version-checking code has executed.
if (record.name.startswith("webkitpy.common.system.autoinstall")
or record.name.startswith("webkitpy.test")):
return True
if record.name.startswith("webkitpy"):
return False
return True
testing_filter = logging.Filter()
testing_filter.filter = filter_records
# Display a message so developers are not mystified as to why
# logging does not work in the unit tests.
_log.info(
"Suppressing most webkitpy logging while running unit tests.")
handler.addFilter(testing_filter)
def reformat_file(host, name, autopep8_options, fixers, should_backup_file):
host = host or SystemHost()
source = host.filesystem.read_text_file(name)
dest = reformat_source(source, autopep8_options, fixers, name)
if dest != source:
if should_backup_file:
host.filesystem.write_text_file(name + '.bak', source)
host.filesystem.write_text_file(name, dest)
def __init__(self, file_path, handle_style_error, scm=None, host=None):
self._file_path = file_path
self._handle_style_error = handle_style_error
self._host = host or SystemHost()
self._fs = self._host.filesystem
self._detector = scm or SCMDetector(
self._fs, self._host.executive).detect_scm_system(
self._fs.getcwd())
def __init__(self, tool, options, host=None, scm=None):
self._tool = tool
self._options = options
self._host = host or SystemHost()
self._fs = self._host.filesystem
self._detector = scm or SCMDetector(
self._fs, self._host.executive).detect_scm_system(
self._fs.getcwd())
def main(host=None, args=None):
options = parse_args(args)
if options.files == ['-']:
host = host or SystemHost()
host.print_(reformat_source(host.stdin.read(), options.style,
'<stdin>'),
end='')
return
# We create the arglist before checking if we need to create a Host, because a
# real host is non-picklable and can't be passed to host.executive.map().
arglist = [(host, name, options.style, options.backup)
for name in options.files]
host = host or SystemHost()
host.executive.map(_reformat_thunk, arglist, processes=options.jobs)
def _boot_device(device, host=None):
host = host or SystemHost()
_log.debug(u"Booting device '{}'".format(device.udid))
device.platform_device.booted_by_script = True
host.executive.run_command([SimulatedDeviceManager.xcrun, 'simctl', 'boot', device.udid])
SimulatedDeviceManager.INITIALIZED_DEVICES.append(device)
# FIXME: Remove this delay once rdar://77234240 is resolved.
time.sleep(10)
def setUp(self):
# A real PlatformInfo object is used here instead of a
# MockPlatformInfo because we need to actually check for
# Windows and Mac to skip some tests.
self._platform = SystemHost().platform
# FIXME: Remove this when we fix test-webkitpy to work
# properly on cygwin (bug 63846).
self.should_test_processes = not self._platform.is_win()
def __init__(self, platform=None):
if platform is None:
from webkitpy.common.system.systemhost import SystemHost
platform = SystemHost().platform
self.mapping = {}
self.default_system_platform = platform.os_name
self.mapping[PUBLIC_TABLE] = {
'mac': {
'Leopard': Version(10, 5),
'Snow Leopard': Version(10, 6),
'Lion': Version(10, 7),
'Mountain Lion': Version(10, 8),
'Mavericks': Version(10, 9),
'Yosemite': Version(10, 10),
'El Capitan': Version(10, 11),
'Sierra': Version(10, 12),
'High Sierra': Version(10, 13),
'Mojave': Version(10, 14),
'Catalina': Version(10, 15),
'Big Sur': Version(11, 0),
},
'ios':
self._automap_to_major_version('iOS',
minimum=Version(10),
maximum=Version(14)),
'tvos':
self._automap_to_major_version('tvOS',
minimum=Version(10),
maximum=Version(14)),
'watchos':
self._automap_to_major_version('watchOS',
minimum=Version(1),
maximum=Version(7)),
'win': {
'Win10': Version(10),
'8.1': Version(6, 3),
'8': Version(6, 2),
'7sp0': Version(6, 1, 7600),
'Vista': Version(6),
'XP': Version(5, 1),
},
# This entry avoids hitting the assert in mapping_for_platform() on Linux,
# but otherwise shouldn't contain any useful key-value pairs.
'linux': {},
}
# wincairo uses the same versions as Windows
self.mapping[PUBLIC_TABLE]['wincairo'] = self.mapping[PUBLIC_TABLE][
'win']
# FTW uses the same versions as Windows
self.mapping[PUBLIC_TABLE]['ftw'] = self.mapping[PUBLIC_TABLE]['win']
def test_find_all_log_darwin(self):
if not SystemHost().platform.is_mac():
return
crash_logs = self.create_crash_logs_darwin()
all_logs = crash_logs.find_all_logs()
self.assertEqual(len(all_logs), 5)
for test, crash_log in all_logs.iteritems():
self.assertTrue(crash_log in self.files.values())
self.assertTrue(test == "Unknown" or int(test.split("-")[1]) in range(28527, 28531))
def initialize_devices(requests, host=None, name_base='Managed', simulator_ui=True, timeout=SIMULATOR_BOOT_TIMEOUT, **kwargs):
host = host or SystemHost()
if SimulatedDeviceManager.INITIALIZED_DEVICES is not None:
return SimulatedDeviceManager.INITIALIZED_DEVICES
if not host.platform.is_mac():
return None
SimulatedDeviceManager.INITIALIZED_DEVICES = []
atexit.register(SimulatedDeviceManager.tear_down)
# Convert to iterable type
if not hasattr(requests, '__iter__'):
requests = [requests]
# Check running sims
for device in SimulatedDeviceManager.available_devices(host):
matched_request = SimulatedDeviceManager._does_fulfill_request(device, requests)
if matched_request is None:
continue
requests.remove(matched_request)
_log.debug(u'Attached to running simulator {}'.format(device))
SimulatedDeviceManager.INITIALIZED_DEVICES.append(device)
# DeviceRequests are compared by reference
requests_copy = [request for request in requests]
# Merging requests means that if 4 devices are requested, but only one is running, these
# 4 requests will be fulfilled by the 1 running device.
for request in requests_copy:
if not request.merge_requests:
continue
if not request.use_booted_simulator:
continue
if request.device_type != device.device_type and not request.allow_incomplete_match:
continue
if request.device_type.software_variant != device.device_type.software_variant:
continue
requests.remove(request)
for request in requests:
device = SimulatedDeviceManager._create_or_find_device_for_request(request, host, name_base)
assert device is not None
SimulatedDeviceManager._boot_device(device, host)
if simulator_ui and host.executive.run_command(['killall', '-0', 'Simulator'], return_exit_code=True) != 0:
SimulatedDeviceManager._managing_simulator_app = not host.executive.run_command(['open', '-g', '-b', SimulatedDeviceManager.simulator_bundle_id, '--args', '-PasteboardAutomaticSync', '0'], return_exit_code=True)
deadline = time.time() + timeout
for device in SimulatedDeviceManager.INITIALIZED_DEVICES:
SimulatedDeviceManager._wait_until_device_is_usable(device, deadline)
return SimulatedDeviceManager.INITIALIZED_DEVICES
def device_count_for_type(device_type, host=SystemHost(), use_booted_simulator=True, **kwargs):
if not host.platform.is_mac():
return 0
if SimulatedDeviceManager.device_by_filter(lambda device: device.platform_device.is_booted_or_booting(), host=host) and use_booted_simulator:
filter = lambda device: device.platform_device.is_booted_or_booting() and device.device_type in device_type
return len(SimulatedDeviceManager.device_by_filter(filter, host=host))
for name in SimulatedDeviceManager._device_identifier_to_name.itervalues():
if DeviceType.from_string(name) in device_type:
return SimulatedDeviceManager.max_supported_simulators(host)
return 0
