def test_compile_setting_equivalence(self): assert JvmPlatformSettings( source_level="11", target_level="11", args=["-Xfoo:bar"], jvm_options=[] ) == JvmPlatformSettings( source_level="11", target_level="11", args=["-Xfoo:bar"], jvm_options=[] ) assert JvmPlatformSettings( source_level="11", target_level="11", args=[], jvm_options=["-Xfoo:bar"] ) == JvmPlatformSettings( source_level="11", target_level="11", args=[], jvm_options=["-Xfoo:bar"] )
def test_compile_setting_inequivalence(self): assert JvmPlatformSettings( source_level="11", target_level="11", args=[], jvm_options=[]) != JvmPlatformSettings( source_level="11", target_level="12", args=[], jvm_options=[]) assert JvmPlatformSettings(source_level="11", target_level="11", args=["-Xfoo:bar"], jvm_options=[]) != JvmPlatformSettings( source_level="11", target_level="11", args=["-XSomethingElse"], jvm_options=[]) assert JvmPlatformSettings( source_level="9", target_level="11", args=[], jvm_options=[]) != JvmPlatformSettings( source_level="11", target_level="11", args=[], jvm_options=[]) assert JvmPlatformSettings( source_level="11", target_level="11", args=[], jvm_options=["-Xvmsomething"]) != JvmPlatformSettings( source_level="11", target_level="11", args=[], jvm_options=[])
def test_incompatible_source_target_level_raises_error(self): with self.assertRaises( JvmPlatformSettings.IllegalSourceTargetCombination): JvmPlatformSettings(source_level="11", target_level="9", args=[], jvm_options=[])
def test_java_home_extraction_empty(self): init_subsystem(DistributionLocator) result = tuple(self._get_zinc_arguments( JvmPlatformSettings('1.7', '1.7', []) )) self.assertEqual(4, len(result), msg='_get_zinc_arguments did not correctly handle empty args.')
def test_java_home_extraction_empty(self): result = tuple( ZincCompile._get_zinc_arguments( JvmPlatformSettings('1.7', '1.7', []))) self.assertEquals( 4, len(result), msg='_get_zinc_arguments did not correctly handle empty args.')
def test_distribution_from_jvm_platform_passed_through(self): fake_dist = "a dist" platforms = [JvmPlatformSettings('8', '8', [])] with unittest.mock.patch.object( JvmPlatform, 'preferred_jvm_distribution') as plat_mock: plat_mock.return_value = fake_dist dist = self.task.preferred_jvm_distribution(platforms) plat_mock.assert_called_once() self.assertEqual(fake_dist, dist)
def test_java_home_extraction_empty(self): init_subsystem(DistributionLocator) platform_settings = JvmPlatformSettings(source_level="1.8", target_level="1.8", args=[], jvm_options=[]) result = tuple(self._get_zinc_arguments(platform_settings)) self.assertEqual( 4, len(result), msg="_get_zinc_arguments did not correctly handle empty args.")
def test_java_home_extraction(self): _, source, _, target, foo, bar, composite, single = tuple(ZincCompile._get_zinc_arguments( JvmPlatformSettings('1.7', '1.7', [ 'foo', 'bar', 'foo:$JAVA_HOME/bar:$JAVA_HOME/foobar', '$JAVA_HOME', ]) )) self.assertEquals('-C1.7', source) self.assertEquals('-C1.7', target) self.assertEquals('foo', foo) self.assertEquals('bar', bar) self.assertNotEqual('$JAVA_HOME', single) self.assertNotIn('$JAVA_HOME', composite) self.assertEquals('foo:{0}/bar:{0}/foobar'.format(single), composite)
def test_compile_setting_inequivalence(self): self.assertNotEqual(JvmPlatformSettings('1.6', '1.6', ['-Xfoo:bar']), JvmPlatformSettings('1.6', '1.7', ['-Xfoo:bar'])) self.assertNotEqual(JvmPlatformSettings('1.6', '1.6', ['-Xfoo:bar']), JvmPlatformSettings('1.6', '1.6', ['-Xbar:foo'])) self.assertNotEqual(JvmPlatformSettings('1.4', '1.6', ['-Xfoo:bar']), JvmPlatformSettings('1.6', '1.6', ['-Xfoo:bar']))
def test_java_home_extraction(self): init_subsystem(DistributionLocator) _, source, _, target, foo, bar, composite, single = tuple( self._get_zinc_arguments( JvmPlatformSettings('1.8', '1.8', [ 'foo', 'bar', 'foo:$JAVA_HOME/bar:$JAVA_HOME/foobar', '$JAVA_HOME', ]))) self.assertEqual('-C1.8', source) self.assertEqual('-C1.8', target) self.assertEqual('foo', foo) self.assertEqual('bar', bar) self.assertNotEqual('$JAVA_HOME', single) self.assertNotIn('$JAVA_HOME', composite) self.assertEqual(f'foo:{single}/bar:{single}/foobar', composite)
def test_distribution_from_targets_passes_through_platforms(self): fake_dist = "a dist" java8_platform = JvmPlatformSettings('8', '8', []) targets = [ self.make_target('platformed_target', JvmTarget, platform='java8') ] with unittest.mock.patch.object( JvmPlatform, 'preferred_jvm_distribution') as plat_mock: with unittest.mock.patch.object(JvmPlatform.global_instance(), 'get_platform_for_target') as \ target_plat_mock: target_plat_mock.return_value = java8_platform plat_mock.return_value = fake_dist dist = self.task.preferred_jvm_distribution_for_targets( targets) plat_mock.assert_called_once_with([java8_platform], strict=False, jdk=False) self.assertEqual(fake_dist, dist)
def test_java_home_extraction(self): init_subsystem(DistributionLocator) _, source, _, target, foo, bar, composite, single = tuple( self._get_zinc_arguments( JvmPlatformSettings( source_level="1.8", target_level="1.8", args=[ "foo", "bar", "foo:$JAVA_HOME/bar:$JAVA_HOME/foobar", "$JAVA_HOME" ], jvm_options=[], ))) self.assertEqual("-C1.8", source) self.assertEqual("-C1.8", target) self.assertEqual("foo", foo) self.assertEqual("bar", bar) self.assertNotEqual("$JAVA_HOME", single) self.assertNotIn("$JAVA_HOME", composite) self.assertEqual(f"foo:{single}/bar:{single}/foobar", composite)
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_compile_setting_equivalence(self): self.assertEqual(JvmPlatformSettings('1.6', '1.6', ['-Xfoo:bar']), JvmPlatformSettings('1.6', '1.6', ['-Xfoo:bar']))
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])
def java8_platform(self): return JvmPlatformSettings(source_level="8", target_level="8", args=[], jvm_options=[])
def _settings(target_level, args=None): return JvmPlatformSettings(target_level, target_level, args)