java.lang.module.ModuleDescriptor.Version#parse ( )源码实例Demo

/**
 * Returns a {@link Requires} for a dependence on a module with the given
 * (and possibly empty) set of modifiers, and optionally the version
 * recorded at compile time.
 */
public static Requires newRequires(Set<Requires.Modifier> mods,
                                   String mn,
                                   String compiledVersion)
{
    Version version = null;
    if (compiledVersion != null) {
        // use the cached version if the same version string
        Version ver = cachedVersion;
        if (ver != null && compiledVersion.equals(ver.toString())) {
            version = ver;
        } else {
            version = Version.parse(compiledVersion);
        }
    }
    return JLMA.newRequires(mods, mn, version);
}
 

/**
 * Returns a {@link Requires} for a dependence on a module with the given
 * (and possibly empty) set of modifiers, and optionally the version
 * recorded at compile time.
 */
public static Requires newRequires(Set<Requires.Modifier> mods,
                                   String mn,
                                   String compiledVersion)
{
    Version version = null;
    if (compiledVersion != null) {
        // use the cached version if the same version string
        Version ver = cachedVersion;
        if (ver != null && compiledVersion.equals(ver.toString())) {
            version = ver;
        } else {
            version = Version.parse(compiledVersion);
        }
    }
    return JLMA.newRequires(mods, mn, version);
}
 

@Test(dataProvider = "validVersions")
public void testEqualsAndHashCode(String vs, String ignore) {

    Version v1 = Version.parse(vs);
    Version v2 = Version.parse(vs);
    assertEquals(v1, v2);
    assertEquals(v2, v1);
    assertEquals(v1.hashCode(), v2.hashCode());

    Version v3 = Version.parse("1.0-rhubarb");
    assertNotEquals(v1, v3);
    assertNotEquals(v2, v3);
    assertNotEquals(v3, v1);
    assertNotEquals(v3, v2);

}
 

/**
 * Test compareTo with equal versions.
 */
@Test(dataProvider = "equalVersions")
public void testCompareEqualsVersions(String vs1, String vs2) {

    Version v1 = Version.parse(vs1);
    assertTrue(v1.compareTo(v1) == 0);

    Version v2 = Version.parse(vs2);
    assertTrue(v2.compareTo(v2) == 0);

    assertTrue(v1.compareTo(v2) == 0);
    assertTrue(v2.compareTo(v1) == 0);
    assertEquals(v1, v2);
    assertEquals(v2, v1);

}
 

/**
 * Sets the module version.
 *
 * @throws IllegalArgumentException if {@code v} is null or cannot be
 *         parsed as a version string
 *
 * @see Version#parse(String)
 */
public Builder version(String v) {
    Version ver = cachedVersion;
    if (ver != null && v.equals(ver.toString())) {
        version = ver;
    } else {
        cachedVersion = version = Version.parse(v);
    }
    return this;
}
 

/**
 * Sets the module version.
 *
 * @throws IllegalArgumentException if {@code v} is null or cannot be
 *         parsed as a version string
 *
 * @see Version#parse(String)
 */
public Builder version(String v) {
    Version ver = cachedVersion;
    if (ver != null && v.equals(ver.toString())) {
        version = ver;
    } else {
        cachedVersion = version = Version.parse(v);
    }
    return this;
}
 

@Override
public Version convert(String value) {
    try {
        return Version.parse(value);
    } catch (IllegalArgumentException x) {
        throw new CommandException("err.invalid.version", x.getMessage());
    }
}
 

/**
 * Test compareTo with ordered versions.
 */
@Test(dataProvider = "orderedVersions")
public void testCompareOrderedVersions(String vs1, String vs2) {

    Version v1 = Version.parse(vs1);
    assertTrue(v1.compareTo(v1) == 0);

    Version v2 = Version.parse(vs2);
    assertTrue(v2.compareTo(v2) == 0);

    // v1 < v2
    assertTrue(v1.compareTo(v2) < 0);
    assertTrue(v2.compareTo(v1) > 0);

}
 

public void testRequiresWithCompiledVersion() {
    Version v = Version.parse("1.0");
    Requires r = requires(Set.of(), "foo", v);
    assertEquals(r, r);
    assertTrue(r.compareTo(r) == 0);
    assertEquals(r.modifiers(), Set.of());
    assertEquals(r.name(), "foo");
    assertTrue(r.compiledVersion().isPresent());
    assertEquals(r.compiledVersion().get().toString(), "1.0");
}
 

public void testRequiresEqualsAndHashCode() {
    Requires r1 = requires("foo");
    Requires r2 = requires("foo");
    assertEquals(r1, r2);
    assertTrue(r1.hashCode() == r2.hashCode());

    r1 = requires(EnumSet.allOf(Requires.Modifier.class), "foo");
    r2 = requires(EnumSet.allOf(Requires.Modifier.class), "foo");
    assertEquals(r1, r2);
    assertTrue(r1.hashCode() == r2.hashCode());

    r1 = requires("foo");
    r2 = requires("bar");
    assertNotEquals(r1, r2);

    r1 = requires(EnumSet.allOf(Requires.Modifier.class), "foo");
    r2 = requires(Set.of(), "foo");
    assertNotEquals(r1, r2);

    Version v1 = Version.parse("1.0");
    r1 = requires(EnumSet.allOf(Requires.Modifier.class), "foo", v1);
    r2 = requires(EnumSet.allOf(Requires.Modifier.class), "foo", v1);
    assertEquals(r1, r2);
    assertTrue(r1.hashCode() == r2.hashCode());

    Version v2 = Version.parse("2.0");
    r1 = requires(EnumSet.allOf(Requires.Modifier.class), "foo", v1);
    r2 = requires(EnumSet.allOf(Requires.Modifier.class), "foo", v2);
    assertNotEquals(r1, r2);
}
 

public void testVersion1() {
    Version v1 = Version.parse("1.0");
    Version v2 = ModuleDescriptor.newModule("foo")
            .version(v1)
            .build()
            .version()
            .get();
    assertEquals(v1, v2);
}
 

public void testVersion2() {
    String vs = "1.0";
    Version v1 = ModuleDescriptor.newModule("foo")
            .version(vs)
            .build()
            .version()
            .get();
    Version v2 = Version.parse(vs);
    assertEquals(v1, v2);
}
 

private boolean isParsableVersion(String vs) {
    try {
        Version.parse(vs);
        return true;
    } catch (IllegalArgumentException e) {
        return false;
    }
}
 

@Test(dataProvider = "validVersions")
public void testParseValidVersions(String vs, String ignore) {
    Version v = Version.parse(vs);
    assertEquals(v.toString(), vs);
}
 

@Test(dataProvider = "invalidVersions",
      expectedExceptions = IllegalArgumentException.class )
public void testParseInvalidVersions(String vs, String ignore) {
    Version.parse(vs);
}