< prev index next >
test/java/lang/module/ModuleDescriptorTest.java
Print this page
*** 48,62 ****
--- 48,64 ----
import java.util.EnumSet;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Objects;
+ import java.util.Optional;
import java.util.Set;
import java.util.stream.Collectors;
import static java.lang.module.ModuleDescriptor.Requires.Modifier.*;
+ import jdk.internal.misc.JavaLangModuleAccess;
import jdk.internal.misc.SharedSecrets;
import jdk.internal.module.ModuleInfoWriter;
import org.testng.annotations.DataProvider;
import org.testng.annotations.Test;
import static org.testng.Assert.*;
*** 986,995 ****
--- 988,1098 ----
public void testEmptyVersion() {
ModuleDescriptor.newModule("foo").version("");
}
+ @DataProvider(name = "unparseableVersions")
+ public Object[][] unparseableVersions() {
+ return new Object[][]{
+
+ { null, "A1" }, // no version < unparseable
+ { "A1", "A2" }, // unparseable < unparseable
+ { "A1", "1.0" }, // unparseable < parseable
+
+ };
+ }
+
+ /**
+ * Basic test for unparseable module versions
+ */
+ @Test(dataProvider = "unparseableVersions")
+ public void testUnparseableModuleVersion(String vs1, String vs2) {
+ ModuleDescriptor descriptor1 = newModule("m", vs1);
+ ModuleDescriptor descriptor2 = newModule("m", vs2);
+
+ if (vs1 != null && !isParsableVersion(vs1)) {
+ assertFalse(descriptor1.version().isPresent());
+ assertTrue(descriptor1.rawVersion().isPresent());
+ assertEquals(descriptor1.rawVersion().get(), vs1);
+ }
+
+ if (vs2 != null && !isParsableVersion(vs2)) {
+ assertFalse(descriptor2.version().isPresent());
+ assertTrue(descriptor2.rawVersion().isPresent());
+ assertEquals(descriptor2.rawVersion().get(), vs2);
+ }
+
+ assertFalse(descriptor1.equals(descriptor2));
+ assertFalse(descriptor2.equals(descriptor1));
+ assertTrue(descriptor1.compareTo(descriptor2) == -1);
+ assertTrue(descriptor2.compareTo(descriptor1) == 1);
+ }
+
+ /**
+ * Basic test for requiring a module with an unparseable version recorded
+ * at compile version.
+ */
+ @Test(dataProvider = "unparseableVersions")
+ public void testUnparseableCompiledVersion(String vs1, String vs2) {
+ Requires r1 = newRequires("m", vs1);
+ Requires r2 = newRequires("m", vs2);
+
+ if (vs1 != null && !isParsableVersion(vs1)) {
+ assertFalse(r1.compiledVersion().isPresent());
+ assertTrue(r1.rawCompiledVersion().isPresent());
+ assertEquals(r1.rawCompiledVersion().get(), vs1);
+ }
+
+ if (vs2 != null && !isParsableVersion(vs2)) {
+ assertFalse(r2.compiledVersion().isPresent());
+ assertTrue(r2.rawCompiledVersion().isPresent());
+ assertEquals(r2.rawCompiledVersion().get(), vs2);
+ }
+
+ assertFalse(r1.equals(r2));
+ assertFalse(r2.equals(r1));
+ assertTrue(r1.compareTo(r2) == -1);
+ assertTrue(r2.compareTo(r1) == 1);
+ }
+
+ private ModuleDescriptor newModule(String name, String vs) {
+ JavaLangModuleAccess JLMA = SharedSecrets.getJavaLangModuleAccess();
+ Builder builder = JLMA.newModuleBuilder(name, false, Set.of());
+ if (vs != null)
+ builder.version(vs);
+ builder.requires("java.base");
+ ByteBuffer bb = ModuleInfoWriter.toByteBuffer(builder.build());
+ return ModuleDescriptor.read(bb);
+ }
+
+ private Requires newRequires(String name, String vs) {
+ JavaLangModuleAccess JLMA = SharedSecrets.getJavaLangModuleAccess();
+ Builder builder = JLMA.newModuleBuilder("foo", false, Set.of());
+ if (vs == null) {
+ builder.requires(name);
+ } else {
+ JLMA.requires(builder, Set.of(), name, vs);
+ }
+ Set<ModuleDescriptor.Requires> requires = builder.build().requires();
+ Iterator<ModuleDescriptor.Requires> iterator = requires.iterator();
+ ModuleDescriptor.Requires r = iterator.next();
+ if (r.name().equals("java.base")) {
+ r = iterator.next();
+ }
+ return r;
+ }
+
+ private boolean isParsableVersion(String vs) {
+ try {
+ Version.parse(vs);
+ return true;
+ } catch (IllegalArgumentException e) {
+ return false;
+ }
+ }
+
+
// toNameAndVersion
public void testToNameAndVersion() {
ModuleDescriptor md1 = ModuleDescriptor.newModule("foo").build();
assertEquals(md1.toNameAndVersion(), "foo");
*** 1168,1230 ****
Builder builder = ModuleDescriptor.newModule("foo");
builder.mainClass(mainClass);
}
- // osName
-
- public void testOsName() {
- String osName = ModuleDescriptor.newModule("foo").osName("Linux").build().osName().get();
- assertEquals(osName, "Linux");
- }
-
- @Test(expectedExceptions = IllegalArgumentException.class)
- public void testNullOsName() {
- ModuleDescriptor.newModule("foo").osName(null);
- }
-
- @Test(expectedExceptions = IllegalArgumentException.class)
- public void testEmptyOsName() {
- ModuleDescriptor.newModule("foo").osName("");
- }
-
-
- // osArch
-
- public void testOsArch() {
- String osArch = ModuleDescriptor.newModule("foo").osName("arm").build().osName().get();
- assertEquals(osArch, "arm");
- }
-
- @Test(expectedExceptions = IllegalArgumentException.class)
- public void testNullOsArch() {
- ModuleDescriptor.newModule("foo").osArch(null);
- }
-
- @Test(expectedExceptions = IllegalArgumentException.class)
- public void testEmptyOsArch() {
- ModuleDescriptor.newModule("foo").osArch("");
- }
-
-
- // osVersion
-
- public void testOsVersion() {
- String osVersion = ModuleDescriptor.newModule("foo").osName("11.2").build().osName().get();
- assertEquals(osVersion, "11.2");
- }
-
- @Test(expectedExceptions = IllegalArgumentException.class)
- public void testNullOsVersion() {
- ModuleDescriptor.newModule("foo").osVersion(null);
- }
-
- @Test(expectedExceptions = IllegalArgumentException.class)
- public void testEmptyOsVersion() {
- ModuleDescriptor.newModule("foo").osVersion("");
- }
-
// reads
private static InputStream EMPTY_INPUT_STREAM = new InputStream() {
@Override
public int read() {
--- 1271,1280 ----
*** 1237,1247 ****
public int read() throws IOException {
throw new IOException();
}
};
! // basic test reading module-info.class
public void testRead() throws Exception {
Module base = Object.class.getModule();
try (InputStream in = base.getResourceAsStream("module-info.class")) {
ModuleDescriptor descriptor = ModuleDescriptor.read(in);
--- 1287,1299 ----
public int read() throws IOException {
throw new IOException();
}
};
! /**
! * Basic test reading module-info.class
! */
public void testRead() throws Exception {
Module base = Object.class.getModule();
try (InputStream in = base.getResourceAsStream("module-info.class")) {
ModuleDescriptor descriptor = ModuleDescriptor.read(in);
*** 1254,1263 ****
--- 1306,1316 ----
ModuleDescriptor descriptor = ModuleDescriptor.read(bb);
assertFalse(bb.hasRemaining()); // no more remaining bytes
assertEquals(descriptor.name(), "java.base");
}
}
+
/**
* Test ModuleDescriptor with a packager finder
*/
public void testReadsWithPackageFinder() throws Exception {
ModuleDescriptor descriptor = ModuleDescriptor.newModule("foo")
< prev index next >