def test_no_warnings_on_known_names(self): for name in known_os_names(): with self.warnings() as warning_list: normalize_os_name(name) self.assertEqual( 0, len(warning_list), 'Recieved unexpected warnings: {}'.format(warning_list))
def test_no_warnings_on_known_names(self) -> None: for name in known_os_names(): with self.captured_logging(logging.WARNING) as captured: normalize_os_name(name) self.assertEqual( 0, len(captured.warnings()), f'Recieved unexpected warnings: {captured.warnings()}')
def test_no_warnings_on_known_names(self): for name in known_os_names(): with self.captured_logging() as captured: normalize_os_name(name) self.assertEqual( 0, len(captured.warnings()), 'Recieved unexpected warnings: {}'.format( captured.warnings()))
def test_warnings_on_unknown_names(self): name = 'I really hope no one ever names an operating system with this string.' with self.captured_logging(logging.WARNING) as captured: normalize_os_name(name) self.assertEqual( 1, len(captured.warnings()), 'Expected exactly one warning, but got: {}'.format( captured.warnings()))
def test_warnings_on_unknown_names(self): name = 'I really hope no one ever names an operating system with this string.' with self.warnings() as warning_list: normalize_os_name(name) self.assertEqual( 1, len(warning_list), 'Expected exactly one warning, but got: {}'.format( warning_list))
def _handle_system_specific_libraries(self, libraries): general_confs = {'default', 'sources', 'javadoc'} specific_confs = set(libraries) - general_confs os_name = normalize_os_name(get_os_name()) for conf in specific_confs: for name in known_os_names(): if name in conf.lower() and normalize_os_name(name) == os_name: # Assume this conf actually represents libraries that should be mapped to 'default' on # this system. libraries['default'].update(libraries[conf])
def test_preferred_jvm_distributions(self): with self.fake_distribution(version="9999") as strict_home: with self.fake_distribution(version="10000") as non_strict_home: options = { JvmPlatform.options_scope: { "default_platform": "java9999", "platforms": { "java9999": {"target": "9999"}, "java10000": {"target": "10000"}, }, }, DistributionLocator.options_scope: { "paths": {normalize_os_name(get_os_name()): [strict_home, non_strict_home]} }, } export_json = self.execute_export_json(**options) self.assertEqual( strict_home, export_json["preferred_jvm_distributions"]["java9999"]["strict"], "strict home does not match", ) # Since it is non-strict, it can be either. self.assertIn( export_json["preferred_jvm_distributions"]["java9999"]["non_strict"], [non_strict_home, strict_home], "non-strict home does not match", )
def test_preferred_jvm_distributions(self): with self.fake_distribution(version='9999') as strict_home: with self.fake_distribution(version='10000') as non_strict_home: options = { JvmPlatform.options_scope: { 'default_platform': 'java9999', 'platforms': { 'java9999': {'target': '9999'}, 'java10000': {'target': '10000'} } }, DistributionLocator.options_scope: { 'paths': { normalize_os_name(get_os_name()): [ strict_home, non_strict_home ] } } } export_json = self.execute_export_json(**options) self.assertEqual(strict_home, export_json['preferred_jvm_distributions']['java9999']['strict'], "strict home does not match") # Since it is non-strict, it can be either. self.assertIn(export_json['preferred_jvm_distributions']['java9999']['non_strict'], [non_strict_home, strict_home], "non-strict home does not match")
def test_preferred_jvm_distributions(self): with self.fake_distribution(version='9999') as strict_home: with self.fake_distribution(version='10000') as non_strict_home: options = { JvmPlatform.options_scope: { 'default_platform': 'java9999', 'platforms': { 'java9999': { 'target': '9999' }, 'java10000': { 'target': '10000' } } }, DistributionLocator.options_scope: { 'paths': { normalize_os_name(get_os_name()): [strict_home, non_strict_home] } } } export_json = self.execute_export_json(**options) self.assertEqual( { 'strict': strict_home, 'non_strict': non_strict_home }, export_json['preferred_jvm_distributions']['java9999'])
def test_preferred_jvm_distributions(self): self.set_options_for_scope('jvm-platform', default_platform='java9999', platforms={ 'java9999': { 'target': '9999' }, 'java10000': { 'target': '10000' } }) with self.fake_distribution(version='9999') as strict_home: with self.fake_distribution(version='10000') as non_strict_home: self.set_options_for_scope( 'jvm-distributions', paths={ normalize_os_name(get_os_name()): [strict_home, non_strict_home] }) with subsystem_instance(DistributionLocator) as locator: locator._reset( ) # Make sure we get a fresh read from the options set just above. self.addCleanup( locator._reset ) # And make sure we we clean up the values we cache. export_json = self.execute_export_json() self.assertEqual( { 'strict': strict_home, 'non_strict': non_strict_home }, export_json['preferred_jvm_distributions']['java9999'])
def _get_explicit_jdk_paths(self): if not self._normalized_jdk_paths: return () os_name = normalize_os_name(os.uname()[0].lower()) if os_name not in self._normalized_jdk_paths: logger.warning('--jvm-distributions-paths was specified, but has no entry for "{}".' .format(os_name)) return self._normalized_jdk_paths.get(os_name, ())
def get_jdk_paths(self, os_name=None): jdk_paths = self._normalized_jdk_paths if not jdk_paths: return () if os_name is None: os_name = os.uname()[0].lower() os_name = normalize_os_name(os_name) if os_name not in jdk_paths: logger.warning('--jvm-jdk-paths was specified, but has no entry for "{}".'.format(os_name)) return jdk_paths.get(os_name, ())
def _normalized_jdk_paths(self): jdk_paths = self.get_options().paths or {} normalized = {} for name, paths in sorted(jdk_paths.items()): rename = normalize_os_name(name) if rename in normalized: logger.warning('Multiple OS names alias to "{}"; combining results.'.format(rename)) normalized[rename].extend(paths) else: normalized[rename] = paths return normalized
def get_jdk_paths(self, os_name=None): """Get the list of explicitly configured JDK paths for this os. :param os_name: Os name to lookup. If None, use the currently detected os name. :return: Paths of explicitly configured JDK's from the --jvm-distribution-paths option :rtype: list of strings """ jdk_paths = self._normalized_jdk_paths if not jdk_paths: return () if os_name is None: os_name = os.uname()[0].lower() os_name = normalize_os_name(os_name) if os_name not in jdk_paths: logger.warning('--jvm-distributions-paths was specified, but has no entry for "{}".' .format(os_name)) return jdk_paths.get(os_name, ())
def _get_platform_specific_subsystems(cls): """Return the subsystems used by the native toolchain for this platform.""" os_name = get_os_name() normed_os_name = normalize_os_name(os_name) subsystems_for_host = cls._PLATFORM_SPECIFIC_SUBSYSTEMS.get(normed_os_name, None) if subsystems_for_host is None: raise cls.UnsupportedPlatformError( "Pants doesn't support building native code on this platform " "(uname: '{}').".format(os_name)) # NB: path entries for cross-platform subsystems currently take precedence # over platform-specific ones -- this could be made configurable. all_subsystems_for_toolchain = cls._CROSS_PLATFORM_SUBSYSTEMS + subsystems_for_host return all_subsystems_for_toolchain
def test_preferred_jvm_distributions(self): with self.fake_distribution(version="9999") as strict_home: with self.fake_distribution(version="10000") as non_strict_home: options = { JvmPlatform.options_scope: { "default_platform": "java9999", "platforms": {"java9999": {"target": "9999"}, "java10000": {"target": "10000"}}, }, DistributionLocator.options_scope: { "paths": {normalize_os_name(get_os_name()): [strict_home, non_strict_home]} }, } export_json = self.execute_export_json(**options) self.assertEqual( {"strict": strict_home, "non_strict": non_strict_home}, export_json["preferred_jvm_distributions"]["java9999"], )
def _get_platform_specific_subsystems(cls): """Return the subsystems used by the native toolchain for this platform.""" os_name = get_os_name() normed_os_name = normalize_os_name(os_name) subsystems_for_host = cls._PLATFORM_SPECIFIC_SUBSYSTEMS.get( normed_os_name, None) if subsystems_for_host is None: raise cls.UnsupportedPlatformError( "Pants doesn't support building native code on this platform " "(uname: '{}').".format(os_name)) # NB: path entries for cross-platform subsystems currently take precedence # over platform-specific ones -- this could be made configurable. all_subsystems_for_toolchain = cls._CROSS_PLATFORM_SUBSYSTEMS + subsystems_for_host return all_subsystems_for_toolchain
def test_preferred_jvm_distributions(self): self.set_options_for_scope( "jvm-platform", default_platform="java9999", platforms={"java9999": {"target": "9999"}, "java10000": {"target": "10000"}}, ) with self.fake_distribution(version="9999") as strict_home: with self.fake_distribution(version="10000") as non_strict_home: self.set_options_for_scope( "jvm-distributions", paths={normalize_os_name(get_os_name()): [strict_home, non_strict_home]} ) with subsystem_instance(DistributionLocator) as locator: locator._reset() # Make sure we get a fresh read from the options set just above. self.addCleanup(locator._reset) # And make sure we we clean up the values we cache. export_json = self.execute_export_json() self.assertEqual( {"strict": strict_home, "non_strict": non_strict_home}, export_json["preferred_jvm_distributions"]["java9999"], )
def test_preferred_jvm_distributions(self): self.set_options_for_scope('jvm-platform', default_platform='java9999', platforms={ 'java9999': {'target': '9999'}, 'java10000': {'target': '10000'} }) with self.fake_distribution(version='9999') as strict_home: with self.fake_distribution(version='10000') as non_strict_home: self.set_options_for_scope('jvm-distributions', paths={ normalize_os_name(get_os_name()): [ strict_home, non_strict_home ] }) with subsystem_instance(DistributionLocator) as locator: locator._reset() # Make sure we get a fresh read from the options set just above. export_json = self.execute_export_json() self.assertEqual({'strict': strict_home, 'non_strict': non_strict_home}, export_json['preferred_jvm_distributions']['java9999'])
def test_preferred_jvm_distributions(self): with self.fake_distribution(version='9999') as strict_home: with self.fake_distribution(version='10000') as non_strict_home: options = { JvmPlatform.options_scope: { 'default_platform': 'java9999', 'platforms': { 'java9999': {'target': '9999'}, 'java10000': {'target': '10000'} } }, DistributionLocator.options_scope: { 'paths': { normalize_os_name(get_os_name()): [ strict_home, non_strict_home ] } } } export_json = self.execute_export_json(**options) self.assertEqual({'strict': strict_home, 'non_strict': non_strict_home}, export_json['preferred_jvm_distributions']['java9999'])
def test_alias_normalization() -> None: for normal_os, aliases in OS_ALIASES.items(): for alias in aliases: assert normal_os == normalize_os_name(alias)
def arch(self): name = normalize_os_name(get_os_name()) return self.__architectures.get(name, 'unknown')
def test_alias_normalization(self): for normal_os, aliases in OS_ALIASES.items(): for alias in aliases: self.assertEqual(normal_os, normalize_os_name(alias))
def test_no_warnings_on_known_names(self): for name in known_os_names(): with self.warnings() as warning_list: normalize_os_name(name) self.assertEqual(0, len(warning_list), 'Recieved unexpected warnings: {}'.format(warning_list))
def test_warnings_on_unknown_names(self): name = 'I really hope no one ever names an operating system with this string.' with self.warnings() as warning_list: normalize_os_name(name) self.assertEqual(1, len(warning_list), 'Expected exactly one warning, but got: {}'.format(warning_list))
def test_warnings_on_unknown_names(self): name = 'I really hope no one ever names an operating system with this string.' with self.captured_logging(logging.WARNING) as captured: normalize_os_name(name) self.assertEqual(1, len(captured.warnings()), 'Expected exactly one warning, but got: {}'.format(captured.warnings()))
def test_no_warnings_on_known_names(self): for name in known_os_names(): with self.captured_logging(logging.WARNING) as captured: normalize_os_name(name) self.assertEqual(0, len(captured.warnings()), 'Recieved unexpected warnings: {}'.format(captured.warnings()))
def test_no_warnings_on_known_names(caplog) -> None: for name in _values(OS_ALIASES): normalize_os_name(name) assert len(caplog.records) == 0
def test_warnings_on_unknown_names(caplog) -> None: name = "I really hope no one ever names an operating system with this string." normalize_os_name(name) assert len(caplog.records) == 1 assert "Unknown operating system name" in caplog.text
def test_no_warnings_on_known_names(caplog) -> None: for name in known_os_names(): normalize_os_name(name) assert len(caplog.records) == 0
def test_java_home_extraction_missing_distributions(self): # This will need to be bumped if java ever gets to major version one million. far_future_version = "999999.1" farther_future_version = "999999.2" os_name = normalize_os_name(get_os_name()) @contextmanager def fake_distributions(versions): """Create a fake JDK for each java version in the input, and yield the list of java_homes. :param list versions: List of java version strings. """ fakes = [] for version in versions: fakes.append( distribution(executables=[ EXE("bin/java", version), EXE("bin/javac", version) ], )) yield [d.__enter__() for d in fakes] for d in fakes: d.__exit__(None, None, None) @contextmanager def fake_distribution_locator(*versions): """Sets up a fake distribution locator with fake distributions. Creates one distribution for each java version passed as an argument, and yields a list of paths to the java homes for each distribution. """ with fake_distributions(versions) as paths: path_options = { DistributionLocator.options_scope: { "paths": { os_name: paths } } } Subsystem.reset() init_subsystem(DistributionLocator, options=path_options) yield paths # Completely missing a usable distribution. with fake_distribution_locator(far_future_version): with self.assertRaises(DistributionLocator.Error): self._get_zinc_arguments( JvmPlatformSettings( source_level=farther_future_version, target_level=farther_future_version, args=["$JAVA_HOME/foo"], jvm_options=[], )) # Missing a strict distribution. with fake_distribution_locator(farther_future_version) as paths: results = self._get_zinc_arguments( JvmPlatformSettings( source_level=far_future_version, target_level=far_future_version, args=["$JAVA_HOME/foo", "$JAVA_HOME"], jvm_options=[], )) self.assertEqual(paths[0], results[-1]) self.assertEqual(f"{paths[0]}/foo", results[-2]) # Make sure we pick up the strictest possible distribution. with fake_distribution_locator(farther_future_version, far_future_version) as paths: farer_path, far_path = paths results = self._get_zinc_arguments( JvmPlatformSettings( source_level=far_future_version, target_level=far_future_version, args=["$JAVA_HOME/foo", "$JAVA_HOME"], jvm_options=[], )) self.assertEqual(far_path, results[-1]) self.assertEqual(f"{far_path}/foo", results[-2]) # Make sure we pick the higher distribution when the lower one doesn't work. with fake_distribution_locator(farther_future_version, far_future_version) as paths: farer_path, far_path = paths results = self._get_zinc_arguments( JvmPlatformSettings( source_level=farther_future_version, target_level=farther_future_version, args=["$JAVA_HOME/foo", "$JAVA_HOME"], jvm_options=[], )) self.assertEqual(farer_path, results[-1]) self.assertEqual(f"{farer_path}/foo", results[-2])
def test_java_home_extraction_missing_distributions(self): # This will need to be bumped if java ever gets to major version one million. far_future_version = '999999.1' farer_future_version = '999999.2' os_name = normalize_os_name(get_os_name()) @contextmanager def fake_distributions(versions): """Create a fake JDK for each java version in the input, and yield the list of java_homes. :param list versions: List of java version strings. """ fakes = [] for version in versions: fakes.append(distribution( executables=[EXE('bin/java', version), EXE('bin/javac', version)], )) yield [d.__enter__() for d in fakes] for d in fakes: d.__exit__(None, None, None) @contextmanager def fake_distribution_locator(*versions): """Sets up a fake distribution locator with fake distributions. Creates one distribution for each java version passed as an argument, and yields a list of paths to the java homes for each distribution. """ with fake_distributions(versions) as paths: path_options = { DistributionLocator.options_scope: { 'paths': { os_name: paths, } } } Subsystem.reset() init_subsystem(DistributionLocator, options=path_options) yield paths # Completely missing a usable distribution. with fake_distribution_locator(far_future_version): with self.assertRaises(DistributionLocator.Error): ZincCompile._get_zinc_arguments(JvmPlatformSettings( source_level=farer_future_version, target_level=farer_future_version, args=['$JAVA_HOME/foo'], )) # Missing a strict distribution. with fake_distribution_locator(farer_future_version) as paths: results = ZincCompile._get_zinc_arguments(JvmPlatformSettings( source_level=far_future_version, target_level=far_future_version, args=['$JAVA_HOME/foo', '$JAVA_HOME'], )) self.assertEquals(paths[0], results[-1]) self.assertEquals('{}/foo'.format(paths[0]), results[-2]) # Make sure we pick up the strictest possible distribution. with fake_distribution_locator(farer_future_version, far_future_version) as paths: farer_path, far_path = paths results = ZincCompile._get_zinc_arguments(JvmPlatformSettings( source_level=far_future_version, target_level=far_future_version, args=['$JAVA_HOME/foo', '$JAVA_HOME'], )) self.assertEquals(far_path, results[-1]) self.assertEquals('{}/foo'.format(far_path), results[-2]) # Make sure we pick the higher distribution when the lower one doesn't work. with fake_distribution_locator(farer_future_version, far_future_version) as paths: farer_path, far_path = paths results = ZincCompile._get_zinc_arguments(JvmPlatformSettings( source_level=farer_future_version, target_level=farer_future_version, args=['$JAVA_HOME/foo', '$JAVA_HOME'], )) self.assertEquals(farer_path, results[-1]) self.assertEquals('{}/foo'.format(farer_path), results[-2])
def test_java_home_extraction_missing_distributions(self): # This will need to be bumped if java ever gets to major version one million. far_future_version = '999999.1' farer_future_version = '999999.2' os_name = normalize_os_name(get_os_name()) @contextmanager def fake_distributions(versions): """Create a fake JDK for each java version in the input, and yield the list of java_homes. :param list versions: List of java version strings. """ fakes = [] for version in versions: fakes.append(distribution( executables=[EXE('bin/java', version), EXE('bin/javac', version)], )) yield [d.__enter__() for d in fakes] for d in fakes: d.__exit__(None, None, None) @contextmanager def fake_distribution_locator(*versions): """Sets up a fake distribution locator with fake distributions. Creates one distribution for each java version passed as an argument, and yields a list of paths to the java homes for each distribution. """ with fake_distributions(versions) as paths: path_options = { 'jvm-distributions': { 'paths': { os_name: paths, } } } with subsystem_instance(DistributionLocator, **path_options) as locator: yield paths locator._reset() # Completely missing a usable distribution. with fake_distribution_locator(far_future_version): with self.assertRaises(DistributionLocator.Error): ZincCompile._get_zinc_arguments(JvmPlatformSettings( source_level=farer_future_version, target_level=farer_future_version, args=['$JAVA_HOME/foo'], )) # Missing a strict distribution. with fake_distribution_locator(farer_future_version) as paths: results = ZincCompile._get_zinc_arguments(JvmPlatformSettings( source_level=far_future_version, target_level=far_future_version, args=['$JAVA_HOME/foo', '$JAVA_HOME'], )) self.assertEquals(paths[0], results[-1]) self.assertEquals('{}/foo'.format(paths[0]), results[-2]) # Make sure we pick up the strictest possible distribution. with fake_distribution_locator(farer_future_version, far_future_version) as paths: farer_path, far_path = paths results = ZincCompile._get_zinc_arguments(JvmPlatformSettings( source_level=far_future_version, target_level=far_future_version, args=['$JAVA_HOME/foo', '$JAVA_HOME'], )) self.assertEquals(far_path, results[-1]) self.assertEquals('{}/foo'.format(far_path), results[-2]) # Make sure we pick the higher distribution when the lower one doesn't work. with fake_distribution_locator(farer_future_version, far_future_version) as paths: farer_path, far_path = paths results = ZincCompile._get_zinc_arguments(JvmPlatformSettings( source_level=farer_future_version, target_level=farer_future_version, args=['$JAVA_HOME/foo', '$JAVA_HOME'], )) self.assertEquals(farer_path, results[-1]) self.assertEquals('{}/foo'.format(farer_path), results[-2])