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)
