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