def test_mac_version_by_name(self): map = VersionNameMap() self.assertEqual(('mac', Version(10, 12)), map.from_name('Sierra')) self.assertEqual(('mac', Version(10, 12)), map.from_name('sierra')) self.assertEqual(('mac', Version(10, 11)), map.from_name('El Capitan')) self.assertEqual(('mac', Version(10, 11)), map.from_name('elcapitan')) self.assertEqual(('mac', Version(10, 11)), map.from_name('el Capitan'))
def test_ios_version_by_name(self): map = VersionNameMap() self.assertEqual(('ios', Version(11)), map.from_name('iOS 11')) self.assertEqual(('ios', Version(11)), map.from_name('ios11')) self.assertEqual(('ios', Version(11)), map.from_name('iOS 11.2')) self.assertEqual(('ios', Version(11)), map.from_name('ios11.2')) self.assertEqual(('ios', Version(11)), map.from_name('iOS11.2'))
def ios_version(self): runtime_identifier = self.get_option('runtime') if self.get_option('version'): return Version(self.get_option('version')) if runtime_identifier: return Version(Runtime.from_identifier(runtime_identifier).version) return Version(self.host.platform.xcode_sdk_version('iphonesimulator'))
def test_ios_name_by_version(self): map = VersionNameMap() self.assertEqual('iOS 11', map.to_name(version=Version(11), platform='ios')) self.assertEqual('iOS 10', map.to_name(version=Version(10), platform='ios')) self.assertEqual('iOS 10', map.to_name(version=Version(10, 3), platform='ios'))
def default_baseline_search_path(self, device_type=None): wk_string = 'wk1' if self.get_option('webkit_test_runner'): wk_string = 'wk2' versions_to_fallback = [] if self.device_version().major == self.CURRENT_VERSION.major: versions_to_fallback = [self.CURRENT_VERSION] elif self.device_version(): temp_version = Version(self.device_version().major) while temp_version != self.CURRENT_VERSION: versions_to_fallback.append(Version.from_iterable(temp_version)) if temp_version < self.CURRENT_VERSION: temp_version.major += 1 else: temp_version.major -= 1 runtime_type = 'simulator' if 'simulator' in self.SDK else 'device' hardware_family = device_type.hardware_family.lower() if device_type and device_type.hardware_family else None hardware_type = device_type.hardware_type.lower() if device_type and device_type.hardware_type else None base_variants = [] if hardware_family and hardware_type: base_variants.append('{}-{}-{}'.format(hardware_family, hardware_type, runtime_type)) if hardware_family: base_variants.append('{}-{}'.format(hardware_family, runtime_type)) base_variants.append('{}-{}'.format(IOSPort.port_name, runtime_type)) if hardware_family and hardware_type: base_variants.append('{}-{}'.format(hardware_family, hardware_type)) if hardware_family: base_variants.append(hardware_family) base_variants.append(IOSPort.port_name) expectations = [] for variant in base_variants: for version in versions_to_fallback: apple_name = None if apple_additions(): apple_name = VersionNameMap.map(self.host.platform).to_name(version, platform=IOSPort.port_name, table=INTERNAL_TABLE) if apple_name: expectations.append(self._apple_baseline_path('{}-{}-{}'.format(variant, apple_name.lower().replace(' ', ''), wk_string))) expectations.append(self._webkit_baseline_path('{}-{}-{}'.format(variant, version.major, wk_string))) if apple_name: expectations.append(self._apple_baseline_path('{}-{}'.format(variant, apple_name.lower().replace(' ', '')))) expectations.append(self._webkit_baseline_path('{}-{}'.format(variant, version.major))) if apple_additions(): expectations.append(self._apple_baseline_path('{}-{}'.format(variant, wk_string))) expectations.append(self._webkit_baseline_path('{}-{}'.format(variant, wk_string))) if apple_additions(): expectations.append(self._apple_baseline_path(variant)) expectations.append(self._webkit_baseline_path(variant)) if self.get_option('webkit_test_runner'): expectations.append(self._webkit_baseline_path('wk2')) return expectations
def test_mac_name_by_version(self): map = VersionNameMap() self.assertEqual('Sierra', map.to_name(version=Version(10, 12), platform='mac')) self.assertEqual('El Capitan', map.to_name(version=Version(10, 11), platform='mac')) self.assertEqual( 'El Capitan', map.to_name(version=Version(10, 11, 3), platform='mac'))
def test_matching_up_success(self): SimulatedDeviceTest.reset_simulated_device_manager() host = SimulatedDeviceTest.mock_host_for_simctl() SimulatedDeviceManager.available_devices(host) runtime = SimulatedDeviceManager.get_runtime_for_device_type( DeviceType.from_string('iphone 5s', Version(9, 2))) self.assertEquals(runtime.os_variant, 'iOS') self.assertEquals(runtime.version, Version(9, 3))
def default_baseline_search_path(self, **kwargs): versions_to_fallback = [] if self.device_version() == self.CURRENT_VERSION: versions_to_fallback = [self.CURRENT_VERSION] elif self.device_version(): temp_version = Version(self.device_version().major) while temp_version.major != self.CURRENT_VERSION.major: versions_to_fallback.append( Version.from_iterable(temp_version)) if temp_version < self.CURRENT_VERSION: temp_version.major += 1 else: temp_version.major -= 1 expectations = [] for version in versions_to_fallback: if apple_additions(): apple_name = VersionNameMap.map(self.host.platform).to_name( version, platform=WatchPort.port_name, table=INTERNAL_TABLE) expectations.append( self._apple_baseline_path('{}-{}'.format( self.port_name, apple_name.lower().replace(' ', '')))) expectations.append( self._webkit_baseline_path('{}-{}'.format( self.port_name, version.major))) if apple_additions(): expectations.append(self._apple_baseline_path(self.port_name)) expectations.append(self._webkit_baseline_path(self.port_name)) for version in versions_to_fallback: apple_name = None if apple_additions(): apple_name = VersionNameMap.map(self.host.platform).to_name( version, platform=WatchPort.port_name, table=INTERNAL_TABLE) if apple_name: expectations.append( self._apple_baseline_path('{}-{}'.format( WatchPort.port_name, apple_name.lower().replace(' ', '')))) expectations.append( self._webkit_baseline_path('{}-{}'.format( WatchPort.port_name, version.major))) if apple_additions(): expectations.append(self._apple_baseline_path(WatchPort.port_name)) expectations.append(self._webkit_baseline_path(WatchPort.port_name)) expectations.append(self._webkit_baseline_path('wk2')) return expectations
def _automap_to_major_version(cls, prefix, minimum=Version(1), maximum=Version(1)): result = {} assert minimum <= maximum for i in xrange((maximum.major + 1) - minimum.major): result['{} {}'.format(prefix, str( Version(minimum.major + i)))] = Version(minimum.major + i) return result
def test_mac(self): self.assert_port(port_name='mac-lion', cls=mac.MacPort) self.assert_port(port_name='mac-lion-wk2', cls=mac.MacPort) self.assert_port(port_name='mac', os_name='mac', os_version=Version.from_name('Lion'), cls=mac.MacPort) self.assert_port(port_name=None, os_name='mac', os_version=Version.from_name('Lion'), cls=mac.MacPort)
def test_contained_in(self): self.assertTrue( DeviceType.from_string('iPhone 6s') in DeviceType.from_string( 'iPhone')) self.assertFalse( DeviceType.from_string('iPhone') in DeviceType.from_string( 'iPhone 6s')) self.assertTrue( DeviceType.from_string('iPhone', Version(11, 1)) in DeviceType.from_string('iPhone', Version(11))) self.assertFalse( DeviceType.from_string('iPhone', Version(11)) in DeviceType.from_string('iPhone', Version(11, 1)))
def test_iphone_initialization(self): type = DeviceType(hardware_family='iPhone') self.assertEquals('iPhone', type.hardware_family) self.assertEquals(None, type.hardware_type) self.assertEquals('iOS', type.software_variant) self.assertEquals(None, type.software_version) self.assertEqual('iPhone running iOS', str(type)) type = DeviceType('iPhone', '6s', Version(11)) self.assertEquals('iPhone', type.hardware_family) self.assertEquals('6s', type.hardware_type) self.assertEquals('iOS', type.software_variant) self.assertEquals(Version(11), type.software_version) self.assertEqual('iPhone 6s running iOS 11', str(type))
def test_ipad_initialization(self): type = DeviceType(hardware_family='iPad') self.assertEquals('iPad', type.hardware_family) self.assertEquals(None, type.hardware_type) self.assertEquals('iOS', type.software_variant) self.assertEquals(None, type.software_version) self.assertEqual('iPad running iOS', str(type)) type = DeviceType('iPad', 'Air 2', Version(11)) self.assertEquals('iPad', type.hardware_family) self.assertEquals('Air 2', type.hardware_type) self.assertEquals('iOS', type.software_variant) self.assertEquals(Version(11), type.software_version) self.assertEqual('iPad Air 2 running iOS 11', str(type))
def test_tv_initialization(self): type = DeviceType(hardware_family='TV') self.assertEquals('Apple TV', type.hardware_family) self.assertEquals(None, type.hardware_type) self.assertEquals('tvOS', type.software_variant) self.assertEquals(None, type.software_version) self.assertEqual('Apple TV running tvOS', str(type)) type = DeviceType('Apple TV', '4K', Version(11)) self.assertEquals('Apple TV', type.hardware_family) self.assertEquals('4K', type.hardware_type) self.assertEquals('tvOS', type.software_variant) self.assertEquals(Version(11), type.software_version) self.assertEqual('Apple TV 4K running tvOS 11', str(type))
def test_watch_initialization(self): type = DeviceType(hardware_family='Watch') self.assertEquals('Apple Watch', type.hardware_family) self.assertEquals(None, type.hardware_type) self.assertEquals('watchOS', type.software_variant) self.assertEquals(None, type.software_version) self.assertEqual('Apple Watch running watchOS', str(type)) type = DeviceType('Apple Watch', 'Series 2 - 42mm', Version(4)) self.assertEquals('Apple Watch', type.hardware_family) self.assertEquals('Series 2 - 42mm', type.hardware_type) self.assertEquals('watchOS', type.software_variant) self.assertEquals(Version(4), type.software_version) self.assertEqual('Apple Watch Series 2 - 42mm running watchOS 4', str(type))
def test_unavailable_devices(self): """ Tests that unavailable devices are ignored """ self._set_expected_xcrun_simctl_list('''== Device Types == iPhone 4s (com.apple.CoreSimulator.SimDeviceType.iPhone-4s) == Runtimes == iOS 8.0 (8.0 - 12A465) (com.apple.CoreSimulator.SimRuntime.iOS-8-0) iOS 8.0 Internal (8.0 - Unknown) (com.apple.CoreSimulator.SimRuntime.iOS-8-0-Internal) (unavailable, runtime path not found) == Devices == -- iOS 8.0 -- iPhone 4s (271BBEAC-1826-4CE1-B3AF-83F35CDD1D82) (Shutdown) -- iOS 8.0 Internal -- -- Unavailable: com.apple.CoreSimulator.SimRuntime.iOS-8-1 -- iPhone 4s (08C0542B-65F7-46E8-B203-CB4055207BC8) (Shutdown) (unavailable, runtime profile not found) -- Unavailable: com.apple.CoreSimulator.SimRuntime.iOS-8-2 -- iPhone 4s (A36F7432-0AF5-49C4-A261-C44383992597) (Shutdown) (unavailable, runtime profile not found) ''') simulator = Simulator(host=self._host) self.assertEqual(1, len(simulator.device_types)) device_type_iphone_4s = simulator.device_types[0] self.assertEqual('iPhone 4s', device_type_iphone_4s.name) self.assertEqual('com.apple.CoreSimulator.SimDeviceType.iPhone-4s', device_type_iphone_4s.identifier) self.assertEqual(2, len(simulator.runtimes)) runtime_ios_8 = simulator.runtimes[0] self.assertEqual('com.apple.CoreSimulator.SimRuntime.iOS-8-0', runtime_ios_8.identifier) self.assertEqual(True, runtime_ios_8.available) self.assertEqual(False, runtime_ios_8.is_internal_runtime) self.assertEqual(Version(8, 0), runtime_ios_8.version) self.assertEqual(1, len(runtime_ios_8.devices)) device_iphone_4s = runtime_ios_8.devices[0] self.assertEqual('iPhone 4s', device_iphone_4s.name) self.assertEqual('271BBEAC-1826-4CE1-B3AF-83F35CDD1D82', device_iphone_4s.udid) self.assertEqual(True, device_iphone_4s.available) self.assertEqual(runtime_ios_8, device_iphone_4s.runtime) runtime_ios_8_internal = simulator.runtimes[1] self.assertEqual('com.apple.CoreSimulator.SimRuntime.iOS-8-0-Internal', runtime_ios_8_internal.identifier) self.assertEqual(False, runtime_ios_8_internal.available) self.assertEqual(True, runtime_ios_8_internal.is_internal_runtime) self.assertEqual(Version(8, 0), runtime_ios_8_internal.version) self.assertEqual(0, len(runtime_ios_8_internal.devices))
def test_win(self): self.assert_port(port_name='win-xp', cls=win.WinPort) self.assert_port(port_name='win-xp-wk2', cls=win.WinPort) self.assert_port(port_name='win', os_name='win', os_version=Version.from_name('XP'), cls=win.WinPort) self.assert_port(port_name=None, os_name='win', os_version=Version.from_name('XP'), cls=win.WinPort) self.assert_port(port_name=None, os_name='win', os_version=Version.from_name('XP'), options=self.webkit_options, cls=win.WinPort)
def xcode_sdk_version(self, sdk_name): if self.is_mac(): # Assumes that xcrun does not write to standard output on failure (e.g. SDK does not exist). xcrun_output = self.executive.run_command(['xcrun', '--sdk', sdk_name, '--show-sdk-version'], return_stderr=False, ignore_errors=True).rstrip() if xcrun_output: return Version.from_string(xcrun_output) return None
def test_layout_searchpath_wih_device_type(self): search_path = self.make_port(port_name='ios-device-wk2', os_version=Version(12)).default_baseline_search_path(DeviceType.from_string('iPhone SE')) self.assertEqual(search_path, [ '/mock-checkout/LayoutTests/platform/iphone-se-device-12-wk2', '/mock-checkout/LayoutTests/platform/iphone-se-device-12', '/mock-checkout/LayoutTests/platform/iphone-se-device-wk2', '/mock-checkout/LayoutTests/platform/iphone-se-device', '/mock-checkout/LayoutTests/platform/iphone-device-12-wk2', '/mock-checkout/LayoutTests/platform/iphone-device-12', '/mock-checkout/LayoutTests/platform/iphone-device-wk2', '/mock-checkout/LayoutTests/platform/iphone-device', '/mock-checkout/LayoutTests/platform/ios-device-12-wk2', '/mock-checkout/LayoutTests/platform/ios-device-12', '/mock-checkout/LayoutTests/platform/ios-device-wk2', '/mock-checkout/LayoutTests/platform/ios-device', '/mock-checkout/LayoutTests/platform/iphone-se-12-wk2', '/mock-checkout/LayoutTests/platform/iphone-se-12', '/mock-checkout/LayoutTests/platform/iphone-se-wk2', '/mock-checkout/LayoutTests/platform/iphone-se', '/mock-checkout/LayoutTests/platform/iphone-12-wk2', '/mock-checkout/LayoutTests/platform/iphone-12', '/mock-checkout/LayoutTests/platform/iphone-wk2', '/mock-checkout/LayoutTests/platform/iphone', '/mock-checkout/LayoutTests/platform/ios-12-wk2', '/mock-checkout/LayoutTests/platform/ios-12', '/mock-checkout/LayoutTests/platform/ios-wk2', '/mock-checkout/LayoutTests/platform/ios', '/mock-checkout/LayoutTests/platform/wk2', ])
def device_version(self): if self.get_option('version'): return Version.from_string(self.get_option('version')) return IOSSimulatorPort._version_from_name( self._name) if IOSSimulatorPort._version_from_name( self._name) else self.host.platform.xcode_sdk_version( 'iphonesimulator')
def test_get_by_int(self): v = Version(1, 2, 3, 4, 5) self.assertEqual(v[0], v.major) self.assertEqual(v[1], v.minor) self.assertEqual(v[2], v.tiny) self.assertEqual(v[3], v.micro) self.assertEqual(v[4], v.nano)
def test_get_by_string(self): v = Version(1, 2, 3, 4, 5) self.assertEqual(v['major'], v.major) self.assertEqual(v['minor'], v.minor) self.assertEqual(v['tiny'], v.tiny) self.assertEqual(v['micro'], v.micro) self.assertEqual(v['nano'], v.nano)
def test_from_list(self): v = Version.from_iterable([1, 2, 3, 4, 5]) self.assertEqual(v.major, 1) self.assertEqual(v.minor, 2) self.assertEqual(v.tiny, 3) self.assertEqual(v.micro, 4) self.assertEqual(v.nano, 5)
def test_int_constructor(self): v = Version(1) self.assertEqual(v.major, 1) self.assertEqual(v.minor, 0) self.assertEqual(v.tiny, 0) self.assertEqual(v.micro, 0) self.assertEqual(v.nano, 0)
def test_string_constructor(self): v = Version.from_string('1.2.3.4.5') self.assertEqual(v.major, 1) self.assertEqual(v.minor, 2) self.assertEqual(v.tiny, 3) self.assertEqual(v.micro, 4) self.assertEqual(v.nano, 5)
def _parse_devices(self, lines): """ Continue to parse devices from ``simctl list``. :param lines: A generator for the output lines from ``simctl list``. :type lines: genexpr :return: None """ current_runtime = None for line in lines: version_match = self.version_re.match(line) if version_match: current_runtime = self.runtime(version=Version.from_string(version_match.group('version')), is_internal_runtime=bool(version_match.group('internal'))) assert current_runtime continue unavailable_version_match = self.unavailable_version_re.match(line) if unavailable_version_match: current_runtime = None continue device_match = self.devices_re.match(line) if not device_match: if line != '== Device Pairs ==': raise RuntimeError('Expected == Device Pairs == header but got: "{}"'.format(line)) break if current_runtime: device = Simulator.Device(name=device_match.group('name').rstrip(), udid=device_match.group('udid'), available=device_match.group('availability') is None, runtime=current_runtime, host=self._host) current_runtime.devices.append(device)
def __init__(self, os_name='mac', os_version=Version.from_name('Snow Leopard')): assert isinstance(os_version, Version) self.os_name = os_name self.os_version = os_version self.expected_xcode_simctl_list = None
def __init__(self, sys_module, platform_module, executive): self._executive = executive self._platform_module = platform_module self.os_name = self._determine_os_name(sys_module.platform) self.os_version = None self._is_cygwin = sys_module.platform == 'cygwin' if self.os_name.startswith('mac'): self.os_version = Version.from_string(platform_module.mac_ver()[0]) elif self.os_name.startswith('win'): self.os_version = self._win_version() elif self.os_name == 'linux' or self.os_name == 'freebsd' or self.os_name == 'openbsd' or self.os_name == 'netbsd': return else: # Most other platforms (namely iOS) return conforming version strings. self.os_version = Version.from_string(platform_module.release())
def test_matching_up_failure(self): SimulatedDeviceTest.reset_simulated_device_manager() host = SimulatedDeviceTest.mock_host_for_simctl() SimulatedDeviceManager.available_devices(host) runtime = SimulatedDeviceManager.get_runtime_for_device_type( DeviceType.from_string('iphone 5s', Version(9, 4))) self.assertEquals(runtime, None)
def default_baseline_search_path(self): versions_to_fallback = [] version_name_map = VersionNameMap.map(self.host.platform) if self._os_version == self.CURRENT_VERSION: versions_to_fallback = [self.CURRENT_VERSION] else: temp_version = Version(self._os_version.major, self._os_version.minor) while temp_version != self.CURRENT_VERSION: versions_to_fallback.append(Version.from_iterable(temp_version)) if temp_version < self.CURRENT_VERSION: temp_version.minor += 1 else: temp_version.minor -= 1 wk_string = 'wk1' if self.get_option('webkit_test_runner'): wk_string = 'wk2' expectations = [] for version in versions_to_fallback: version_name = version_name_map.to_name(version, platform=self.port_name) if version_name: standardized_version_name = version_name.lower().replace(' ', '') apple_name = None if apple_additions(): apple_name = version_name_map.to_name(version, platform=self.port_name, table=INTERNAL_TABLE) if apple_name: expectations.append(self._apple_baseline_path('mac-{}-{}'.format(apple_name.lower().replace(' ', ''), wk_string))) if version_name: expectations.append(self._webkit_baseline_path('mac-{}-{}'.format(standardized_version_name, wk_string))) if apple_name: expectations.append(self._apple_baseline_path('mac-{}'.format(apple_name.lower().replace(' ', '')))) if version_name: expectations.append(self._webkit_baseline_path('mac-{}'.format(standardized_version_name))) if apple_additions(): expectations.append(self._apple_baseline_path('{}-{}'.format(self.port_name, wk_string))) expectations.append(self._webkit_baseline_path('{}-{}'.format(self.port_name, wk_string))) if apple_additions(): expectations.append(self._apple_baseline_path('{}'.format(self.port_name))) expectations.append(self._webkit_baseline_path(self.port_name)) if self.get_option('webkit_test_runner'): expectations.append(self._webkit_baseline_path('wk2')) return expectations