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
