def __init__(self, host, port_name=None, **kwargs): Port.__init__(self, host, port_name or TestPort.default_port_name, **kwargs) self._tests = unit_test_list() self._flakes = set() self._expectations_path = LAYOUT_TEST_DIR + '/platform/test/TestExpectations' self._results_directory = None self._operating_system = self._name.split('-')[1] if self._operating_system == 'linux': self._os_version = None else: self._os_version = VersionNameMap.map(self.host.platform).from_name(self._name.split('-')[2])[1]
def __init__(self, host, port_name, **kwargs): DarwinPort.__init__(self, host, port_name, **kwargs) version_name_map = VersionNameMap.map(host.platform) self._os_version = None split_port_name = port_name.split('-') if len(split_port_name) > 1 and split_port_name[1] != 'wk2': self._os_version = version_name_map.from_name( split_port_name[1])[1] elif self.host.platform.is_mac() and apple_additions(): self._os_version = self.host.platform.os_version if not self._os_version: self._os_version = MacPort.CURRENT_VERSION
def default_baseline_search_path(self): version_name_map = VersionNameMap.map(self.host.platform) if self._os_version < self.VERSION_MIN or self._os_version >= self.VERSION_MAX: version_fallback = [self._os_version] else: sorted_versions = sorted( version_name_map.mapping_for_platform( platform=self.port_name).values()) version_fallback = sorted_versions[sorted_versions. index(self._os_version):-1] wk_string = 'wk1' if self.get_option('webkit_test_runner'): wk_string = 'wk2' expectations = [] for version in version_fallback: version_name = version_name_map.to_name( version, platform=self.port_name).lower().replace(' ', '') if apple_additions(): apple_name = version_name_map.to_name(version, platform=self.port_name, table='internal') else: apple_name = None if apple_name: expectations.append( self._apple_baseline_path('mac-{}-{}'.format( apple_name.lower().replace(' ', ''), wk_string))) expectations.append( self._webkit_baseline_path('mac-{}-{}'.format( version_name, wk_string))) if apple_name: expectations.append( self._apple_baseline_path('mac-{}'.format( apple_name.lower().replace(' ', '')))) expectations.append( self._webkit_baseline_path('mac-{}'.format(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
def default_baseline_search_path(self): 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 __init__(self, host, port_name, **kwargs): DarwinPort.__init__(self, host, port_name, **kwargs) version_name_map = VersionNameMap.map(host.platform) if port_name.split('-') > 1: self._os_version = version_name_map.from_name( port_name.split('-')[1])[1] elif self.host.platform.is_mac(): self._os_version = self.host.platform.os_version else: sorted_versions = sorted( version_name_map.mapping_for_platform( platform=self.port_name).values()) self._os_version = sorted_versions[ sorted_versions.index(self.VERSION_MAX) - 1]
def configuration_specifier_macros(self): config_map = {} version_name_map = VersionNameMap.map(self.host.platform) for version in self._allowed_versions(): version_names = [] for newer in self._allowed_versions()[self._allowed_versions().index(version):]: version_name = version_name_map.to_name(newer, platform=self.port_name) if not version_name: version_name = version_name_map.to_name(newer, platform=self.port_name, table=INTERNAL_TABLE) version_names.append(version_name.lower().replace(' ', '')) for table in [PUBLIC_TABLE, INTERNAL_TABLE]: version_name = version_name_map.to_name(version, platform=self.port_name, table=table) if not version_name: continue config_map[version_name.lower().replace(' ', '') + '+'] = version_names return config_map
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
def _generate_all_test_configurations(self): configurations = [] for version in self._allowed_versions(): for build_type in self.ALL_BUILD_TYPES: for architecture in self.ARCHITECTURES: for table in [PUBLIC_TABLE, INTERNAL_TABLE]: version_name = VersionNameMap.map( self.host.platform).to_name( version, platform=self.port_name.split('-')[0], table=table) if version_name: configurations.append( TestConfiguration(version=version_name, architecture=architecture, build_type=build_type)) return configurations
def default_baseline_search_path(self, **kwargs): version_name_map = VersionNameMap.map(self.host.platform) if self._os_version < self.VERSION_MIN or self._os_version > self.VERSION_MAX: fallback_versions = [self._os_version] else: sorted_versions = sorted( version_name_map.mapping_for_platform( platform=self.port_name).values()) fallback_versions = sorted_versions[sorted_versions. index(self._os_version):] fallback_names = [ 'wincairo-' + version_name_map.to_name( version, platform=self.port_name).lower().replace(' ', '') for version in fallback_versions ] fallback_names.append('wincairo') return map(self._webkit_baseline_path, fallback_names)
def configuration_specifier_macros(self): map = {} version_name_map = VersionNameMap.map(self.host.platform) sorted_versions = sorted( version_name_map.mapping_for_platform( platform=self.port_name).values()) for version in sorted_versions: list = [] for newer in sorted_versions[sorted_versions.index(version):]: list.append( version_name_map.to_name( newer, platform=self.port_name).lower().replace(' ', '')) map[version_name_map.to_name( version, platform=self.port_name).lower().replace(' ', '') + '+'] = list return map
def ios_version(self): if self.get_option('version'): return Version.from_string(self.get_option('version')) if not apple_additions(): raise RuntimeError(self.NO_ON_DEVICE_TESTING) if not self._device_for_worker_number_map(): raise RuntimeError('No devices are available') version = None for device in self._device_for_worker_number_map(): if not version: version = device.platform.os_version else: if device.platform.os_version != version: raise RuntimeError('Multiple connected devices have different iOS versions') if version: return VersionNameMap.map(self.host.platform).from_name(version)[1] return None
def default_baseline_search_path(self, **kwargs): version_name_map = VersionNameMap.map(self.host.platform) if self._os_version < self.VERSION_MIN or self._os_version > self.VERSION_MAX: fallback_versions = [self._os_version] else: sorted_versions = sorted(version_name_map.mapping_for_platform(platform=self.port_name).values()) fallback_versions = sorted_versions[sorted_versions.index(self._os_version):] fallback_names = ['win-' + version_name_map.to_name(version, platform=self.port_name).lower().replace(' ', '') for version in fallback_versions] fallback_names.append('win') # FIXME: The AppleWin port falls back to AppleMac for some results. Eventually we'll have a shared 'apple' port. if self.get_option('webkit_test_runner'): fallback_names.insert(0, 'win-wk2') fallback_names.append('mac-wk2') # Note we do not add 'wk2' here, even though it's included in _skipped_search_paths(). # FIXME: Perhaps we should get this list from MacPort? fallback_names.append('mac') result = map(self._webkit_baseline_path, fallback_names) if apple_additions() and getattr(apple_additions(), "layout_tests_path", None): result.insert(0, self._filesystem.join(apple_additions().layout_tests_path(), self.port_name)) return result
class WinCairoPort(WinPort): port_name = "wincairo" TEST_PATH_SEPARATOR = os.sep VERSION_FALLBACK_ORDER = [ "wincairo-" + os_name.lower() for os_name in VersionNameMap.map().names() ] def default_baseline_search_path(self): name = self._name.replace('-wk2', '') if name.endswith(self.FUTURE_VERSION): fallback_names = [] else: assert name in self.VERSION_FALLBACK_ORDER fallback_names = self.VERSION_FALLBACK_ORDER[ self.VERSION_FALLBACK_ORDER.index(name):] fallback_names.append(self.port_name) return map(self._webkit_baseline_path, fallback_names) def _future_port_name(self): return self.port_name + "-" + self.FUTURE_VERSION
def version_name(self): if self._os_version is None: return None return VersionNameMap.map(self.host.platform).to_name( self._os_version, platform=IOSPort.port_name)
def _assert_version(self, port_name, expected_version): host = MockSystemHost(os_name='win', os_version=expected_version) port = WinPort(host, port_name=port_name) self.assertEqual(port.version_name(), VersionNameMap.map().to_name(expected_version, platform='win', table=PUBLIC_TABLE))
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(u'{}-{}-{}'.format(hardware_family, hardware_type, runtime_type)) if hardware_family: base_variants.append(u'{}-{}'.format(hardware_family, runtime_type)) base_variants.append(u'{}-{}'.format(IOSPort.port_name, runtime_type)) if hardware_family and hardware_type: base_variants.append(u'{}-{}'.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(u'{}-{}-{}'.format( variant, apple_name.lower().replace(' ', ''), wk_string))) expectations.append( self._webkit_baseline_path(u'{}-{}-{}'.format( variant, version.major, wk_string))) if apple_name: expectations.append( self._apple_baseline_path(u'{}-{}'.format( variant, apple_name.lower().replace(' ', '')))) expectations.append( self._webkit_baseline_path(u'{}-{}'.format( variant, version.major))) if apple_additions(): expectations.append( self._apple_baseline_path(u'{}-{}'.format( variant, wk_string))) expectations.append( self._webkit_baseline_path(u'{}-{}'.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 default_baseline_search_path(self): wk_string = 'wk1' if self.get_option('webkit_test_runner'): wk_string = 'wk2' # If we don't have a specified version, that means we using the port without an SDK. # This usually means we're doing some type of testing.In this case, don't add version fallbacks expectations = [] if apple_additions() and self.ios_version(): apple_name = VersionNameMap.map(self.host.platform).to_name( self.ios_version(), platform=IOSPort.port_name, table='internal').lower().replace(' ', '') else: apple_name = None if self.ios_version(): if apple_name: expectations.append( self._apple_baseline_path('{}-{}-{}'.format( self.port_name, apple_name, wk_string))) expectations.append( self._webkit_baseline_path('{}-{}-{}'.format( self.port_name, self.ios_version().major, wk_string))) if apple_name: expectations.append( self._apple_baseline_path('{}-{}'.format( self.port_name, apple_name))) expectations.append( self._webkit_baseline_path('{}-{}'.format( self.port_name, self.ios_version().major))) 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(self.port_name)) expectations.append(self._webkit_baseline_path(self.port_name)) if self.ios_version(): if apple_name: expectations.append( self._apple_baseline_path('{}-{}'.format( IOSPort.port_name, apple_name))) expectations.append( self._webkit_baseline_path('{}-{}'.format( IOSPort.port_name, self.ios_version().major))) if apple_additions(): expectations.append( self._apple_baseline_path('{}-{}'.format( IOSPort.port_name, wk_string))) expectations.append( self._webkit_baseline_path('{}-{}'.format(IOSPort.port_name, wk_string))) if apple_additions(): expectations.append(self._apple_baseline_path(IOSPort.port_name)) expectations.append(self._webkit_baseline_path(IOSPort.port_name)) if self.get_option('webkit_test_runner'): expectations.append(self._webkit_baseline_path('wk2')) return expectations
def assert_name(self, port_name, os_version_string, expected): host = MockSystemHost(os_name=self.os_name, os_version=VersionNameMap.map().from_name(os_version_string)[1]) port = self.make_port(host=host, port_name=port_name) self.assertEqual(expected, port.name())
def os_version_name(self, table=PUBLIC_TABLE): if not self.os_version: return None return VersionNameMap.map(self).to_name(self.os_version, table=table)
def version_name(self): if self._os_version is None: return None return VersionNameMap.map(self.host.platform).to_name(self._os_version, platform=self._operating_system, table=PUBLIC_TABLE)
def _allowed_versions(self): if self.VERSION_MIN is None or self.VERSION_MAX is None: return [] sorted_versions = sorted(VersionNameMap.map(self.host.platform).mapping_for_platform(platform=self.port_name.split('-')[0]).values()) return sorted_versions[sorted_versions.index(self.VERSION_MIN):sorted_versions.index(self.VERSION_MAX) + 1]
def from_name(name): from webkitpy.common.version_name_map import VersionNameMap return VersionNameMap.map().from_name(name)[1]
def __init__(self, host, port_name, **kwargs): ApplePort.__init__(self, host, port_name, **kwargs) if port_name.split('-') > 1: self._os_version = VersionNameMap.map(host.platform).from_name(port_name.split('-')[1])[1] else: self._os_version = self.host.platform.os_version
def _allowed_versions(self): versions = set() for table in [PUBLIC_TABLE, INTERNAL_TABLE]: versions.update(VersionNameMap.map(self.host.platform).mapping_for_platform(platform=self.port_name.split('-')[0], table=table).values()) return sorted(versions)