[jsemver] 11/95: Make major refactoring toward object-orientation
Alexandre Viau
reazem-guest at moszumanska.debian.org
Mon Feb 16 14:58:25 UTC 2015
This is an automated email from the git hooks/post-receive script.
reazem-guest pushed a commit to branch master
in repository jsemver.
commit 5d0aa683cbde382de4d7dfa71657cd6fcd326f0f
Author: Zafar Khaja <zafarkhaja at gmail.com>
Date: Sun Mar 3 23:13:48 2013 +0400
Make major refactoring toward object-orientation
---
pom.xml | 2 +-
.../zafarkhaja/semver/AlphaNumericVersion.java | 120 ++++++
.../github/zafarkhaja/semver/NormalVersion.java | 135 +++++++
.../java/com/github/zafarkhaja/semver/Version.java | 237 +++++------
.../zafarkhaja/semver/AlphaNumericVersionTest.java | 166 ++++++++
.../zafarkhaja/semver/NormalVersionTest.java | 195 +++++++++
.../com/github/zafarkhaja/semver/VersionTest.java | 439 +++++++++------------
7 files changed, 885 insertions(+), 409 deletions(-)
diff --git a/pom.xml b/pom.xml
index 5f2e0d4..abccb5a 100644
--- a/pom.xml
+++ b/pom.xml
@@ -4,7 +4,7 @@
<groupId>com.github.zafarkhaja</groupId>
<artifactId>semver</artifactId>
- <version>0.1.0-SNAPSHOT</version>
+ <version>0.2.0-SNAPSHOT</version>
<packaging>jar</packaging>
<name>semver</name>
diff --git a/src/main/java/com/github/zafarkhaja/semver/AlphaNumericVersion.java b/src/main/java/com/github/zafarkhaja/semver/AlphaNumericVersion.java
new file mode 100644
index 0000000..b68acfc
--- /dev/null
+++ b/src/main/java/com/github/zafarkhaja/semver/AlphaNumericVersion.java
@@ -0,0 +1,120 @@
+/*
+ * The MIT License
+ *
+ * Copyright 2013 Zafar Khaja <zafarkhaja at gmail.com>.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+package com.github.zafarkhaja.semver;
+
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+/**
+ *
+ * @author Zafar Khaja <zafarkhaja at gmail.com>
+ */
+class AlphaNumericVersion implements Comparable<AlphaNumericVersion> {
+
+ static final String FORMAT = "([0-9A-Za-z-]+(?:\\.[0-9A-Za-z-]+)*)";
+ private static final Pattern PATTERN = Pattern.compile("^" + FORMAT + "$");
+
+ private String value;
+
+ AlphaNumericVersion(String value) {
+ if (value == null) {
+ throw new NullPointerException(
+ "Alpha-numeric version MUST NOT be NULL"
+ );
+ }
+ Matcher matcher = PATTERN.matcher(value);
+ if (!matcher.matches()) {
+ throw new IllegalArgumentException(
+ "Alpha-numeric version MUST consist of dot separated identifiers [0-9A-Za-z-]"
+ );
+ }
+ this.value = matcher.group(0);
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (this == other) {
+ return true;
+ }
+ if (!(other instanceof AlphaNumericVersion)) {
+ return false;
+ }
+ return compareTo((AlphaNumericVersion) other) == 0 ? true : false;
+ }
+
+ @Override
+ public int hashCode() {
+ return value.hashCode();
+ }
+
+ @Override
+ public String toString() {
+ return value;
+ }
+
+ @Override
+ public int compareTo(AlphaNumericVersion other) {
+ String[] thisIds = value.split("\\.");
+ String[] otherIds = other.value.split("\\.");
+
+ int result = compareIdentifierArrays(thisIds, otherIds);
+ if (result == 0) {
+ result = thisIds.length - otherIds.length;
+ }
+ return result;
+ }
+
+ private int compareIdentifierArrays(String[] ids1, String[] ids2) {
+ int result = 0;
+ int length = getLeastCommonArrayLength(ids1, ids2);
+ for (int i = 0; i < length; i++) {
+ result = compareIdentifiers(ids1[i], ids2[i]);
+ if (result != 0) {
+ break;
+ }
+ }
+ return result;
+ }
+
+ private int getLeastCommonArrayLength(String[] arr1, String[] arr2) {
+ return arr1.length <= arr2.length ? arr1.length : arr2.length;
+ }
+
+ private int compareIdentifiers(String id1, String id2) {
+ if (isInt(id1) && isInt(id2)) {
+ return Integer.parseInt(id1) - Integer.parseInt(id2);
+ } else {
+ return id1.compareTo(id2);
+ }
+ }
+
+ private boolean isInt(String str) {
+ try {
+ Integer.parseInt(str);
+ } catch (NumberFormatException e) {
+ return false;
+ }
+ return true;
+ }
+}
diff --git a/src/main/java/com/github/zafarkhaja/semver/NormalVersion.java b/src/main/java/com/github/zafarkhaja/semver/NormalVersion.java
new file mode 100644
index 0000000..dda755d
--- /dev/null
+++ b/src/main/java/com/github/zafarkhaja/semver/NormalVersion.java
@@ -0,0 +1,135 @@
+/*
+ * The MIT License
+ *
+ * Copyright 2013 Zafar Khaja <zafarkhaja at gmail.com>.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+package com.github.zafarkhaja.semver;
+
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+/**
+ *
+ * @author Zafar Khaja <zafarkhaja at gmail.com>
+ */
+class NormalVersion implements Comparable<NormalVersion> {
+
+ private int major;
+ private int minor;
+ private int patch;
+
+ static final String FORMAT = "(\\d+)\\.(\\d+)\\.(\\d+)";
+ private static final Pattern PATTERN = Pattern.compile("^" + FORMAT + "$");
+
+ NormalVersion(int major, int minor, int patch) {
+ if (major < 0 || minor < 0 || patch < 0) {
+ throw new IllegalArgumentException(
+ "Major, minor and patch versions MUST be non-negative integers."
+ );
+ }
+ this.major = major;
+ this.minor = minor;
+ this.patch = patch;
+ }
+
+ static NormalVersion valueOf(String value) {
+ Matcher matcher = PATTERN.matcher(value);
+ if (!matcher.matches()) {
+ throw new IllegalArgumentException("Illegal normal version format");
+ }
+ return new NormalVersion(
+ Integer.parseInt(matcher.group(1)),
+ Integer.parseInt(matcher.group(2)),
+ Integer.parseInt(matcher.group(3))
+ );
+ }
+
+ int getMajor() {
+ return major;
+ }
+
+ int getMinor() {
+ return minor;
+ }
+
+ int getPatch() {
+ return patch;
+ }
+
+ void incrementMajor() {
+ major = major + 1;
+ minor = 0;
+ patch = 0;
+ }
+
+ void incrementMinor() {
+ minor = minor + 1;
+ patch = 0;
+ }
+
+ void incrementPatch() {
+ patch = patch + 1;
+ }
+
+ @Override
+ public int compareTo(NormalVersion other) {
+ int result = major - other.major;
+ if (result == 0) {
+ result = minor - other.minor;
+ if (result == 0) {
+ result = patch - other.patch;
+ }
+ }
+ return result;
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (this == other) {
+ return true;
+ }
+ if (!(other instanceof NormalVersion)) {
+ return false;
+ }
+ return compareTo((NormalVersion) other) == 0 ? true : false;
+ }
+
+ @Override
+ public int hashCode() {
+ int hash = 17;
+ hash = 31 * hash + major;
+ hash = 31 * hash + minor;
+ hash = 31 * hash + patch;
+ return hash;
+ }
+
+ /**
+ * Returns the string representation of this normal version.
+ *
+ * A normal version number MUST take the form X.Y.Z where X, Y, and Z are
+ * non-negative integers. X is the major version, Y is the minor version,
+ * and Z is the patch version. (SemVer p.2)
+ */
+ @Override
+ public String toString() {
+ return String.format("%d.%d.%d", major, minor, patch);
+ }
+}
diff --git a/src/main/java/com/github/zafarkhaja/semver/Version.java b/src/main/java/com/github/zafarkhaja/semver/Version.java
index 537bac5..60dfd76 100644
--- a/src/main/java/com/github/zafarkhaja/semver/Version.java
+++ b/src/main/java/com/github/zafarkhaja/semver/Version.java
@@ -21,7 +21,6 @@
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
-
package com.github.zafarkhaja.semver;
import java.util.regex.Matcher;
@@ -33,78 +32,93 @@ import java.util.regex.Pattern;
*/
public class Version implements Comparable<Version> {
- private String rawVersion;
-
- private int majorVersion;
- private int minorVersion;
- private int patchVersion;
+ private NormalVersion normal;
+ private AlphaNumericVersion preRelease;
+ private AlphaNumericVersion build;
- private String preReleaseVersion;
- private String buildVersion;
+ private static final String PRE_RELEASE_PREFIX = "-";
+ private static final String BUILD_PREFIX = "+";
- private static final String NORMAL_VERSION =
- "((?<major>\\d+)\\.(?<minor>\\d+)\\.(?<patch>\\d+))";
+ private static final Pattern SEMVER_PATTERN;
- private static final String PRE_RELEASE_VERSION =
- "(?:-(?<preRelease>[0-9A-Za-z-]+(?:\\.[0-9A-Za-z-]+)*))?";
-
- private static final String BUILD_VERSION =
- "(?:\\+(?<build>[0-9A-Za-z-]+(?:\\.[0-9A-Za-z-]+)*))?";
+ static {
+ StringBuilder sb = new StringBuilder();
+
+ sb.append("^");
+ sb.append(NormalVersion.FORMAT);
+ sb.append("(?:");
+ sb.append(PRE_RELEASE_PREFIX);
+ sb.append(AlphaNumericVersion.FORMAT);
+ sb.append(")?");
+ sb.append("(?:");
+ sb.append("\\");
+ sb.append(BUILD_PREFIX);
+ sb.append(AlphaNumericVersion.FORMAT);
+ sb.append(")?");
+ sb.append("$");
+
+ SEMVER_PATTERN = Pattern.compile(sb.toString());
+ }
- private static final Pattern SEMVER_PATTERN = Pattern.compile(
- "^" + NORMAL_VERSION + PRE_RELEASE_VERSION + BUILD_VERSION + "$"
- );
+ Version(
+ NormalVersion normal,
+ AlphaNumericVersion preRelease,
+ AlphaNumericVersion build
+ ) {
+ this.normal = normal;
+ this.preRelease = preRelease;
+ this.build = build;
+ }
- public Version(String version) {
- Matcher matcher = SEMVER_PATTERN.matcher(version);
+ public static Version valueOf(String value) {
+ Matcher matcher = SEMVER_PATTERN.matcher(value);
if (!matcher.matches()) {
throw new IllegalArgumentException(
"Illegal version format"
);
}
- rawVersion = version;
- majorVersion = Integer.parseInt(matcher.group("major"));
- minorVersion = Integer.parseInt(matcher.group("minor"));
- patchVersion = Integer.parseInt(matcher.group("patch"));
+ NormalVersion normal = new NormalVersion(
+ Integer.parseInt(matcher.group(1)),
+ Integer.parseInt(matcher.group(2)),
+ Integer.parseInt(matcher.group(3))
+ );
+
+ AlphaNumericVersion preRelease =
+ (matcher.group(4) != null) ?
+ new AlphaNumericVersion(matcher.group(4)) :
+ null;
- preReleaseVersion = matcher.group("preRelease");
- buildVersion = matcher.group("build");
+ AlphaNumericVersion build =
+ (matcher.group(5) != null) ?
+ new AlphaNumericVersion(matcher.group(5)) :
+ null;
+
+ return new Version(normal, preRelease, build);
}
public int getMajorVersion() {
- return majorVersion;
+ return normal.getMajor();
}
public int getMinorVersion() {
- return minorVersion;
+ return normal.getMinor();
}
public int getPatchVersion() {
- return patchVersion;
+ return normal.getPatch();
}
- public String getPreReleaseVersion() {
- return preReleaseVersion;
- }
-
- public String getBuildVersion() {
- return buildVersion;
+ public String getNormalVersion() {
+ return normal.toString();
}
- public void bumpMajorVersion() {
- majorVersion = majorVersion + 1;
- minorVersion = 0;
- patchVersion = 0;
- }
-
- public void bumpMinorVersion() {
- minorVersion = minorVersion + 1;
- patchVersion = 0;
+ public String getPreReleaseVersion() {
+ return (preRelease != null) ? preRelease.toString() : "";
}
- public void bumpPatchVersion() {
- patchVersion = patchVersion + 1;
+ public String getBuildVersion() {
+ return (build != null) ? build.toString() : "";
}
public boolean greaterThan(Version other) {
@@ -126,9 +140,9 @@ public class Version implements Comparable<Version> {
@Override
public boolean equals(Object other) {
if (this == other) {
- return true;
+ return true;
}
- if (null == other || this.getClass() != other.getClass()) {
+ if (!(other instanceof Version)) {
return false;
}
return compareTo((Version) other) == 0 ? true : false;
@@ -137,128 +151,55 @@ public class Version implements Comparable<Version> {
@Override
public int hashCode() {
int hash = 5;
- hash = 97 * hash + majorVersion;
- hash = 97 * hash + minorVersion;
- hash = 97 * hash + patchVersion;
- hash = 97 * hash + (
- preReleaseVersion != null ? preReleaseVersion.hashCode(): 0
- );
- hash = 97 * hash + (
- buildVersion != null ? buildVersion.hashCode() : 0
- );
+ hash = 97 * hash + (normal != null ? normal.hashCode() : 0);
+ hash = 97 * hash + (preRelease != null ? preRelease.hashCode() : 0);
+ hash = 97 * hash + (build != null ? build.hashCode() : 0);
return hash;
}
@Override
public String toString() {
- return rawVersion;
- }
-
- @Override
- public int compareTo(Version other) {
- int result = compareNormalVersions(other);
- if (result == 0) {
- result = comparePreReleaseVersions(other);
+ StringBuilder sb = new StringBuilder(getNormalVersion());
+ if (preRelease != null) {
+ sb.append(PRE_RELEASE_PREFIX);
+ sb.append(getPreReleaseVersion());
}
- if (result == 0) {
- result = compareBuildVersions(other);
+ if (build != null) {
+ sb.append(BUILD_PREFIX);
+ sb.append(getBuildVersion());
}
- return result;
+ return sb.toString();
}
- private int compareNormalVersions(Version other) {
- int result = compareInts(majorVersion, other.getMajorVersion());
+ @Override
+ public int compareTo(Version other) {
+ int result = normal.compareTo(other.normal);
if (result == 0) {
- result = compareInts(minorVersion, other.getMinorVersion());
+ result = comparePreReleases(other);
if (result == 0) {
- result = compareInts(patchVersion, other.getPatchVersion());
+ result = compareBuilds(other);
}
}
return result;
}
- private int compareInts(int thisOp, int otherOp) {
- return (thisOp == otherOp) ? 0 : ((thisOp > otherOp) ? 1 : -1);
- }
-
- private int comparePreReleaseVersions(Version other) {
- if (preReleaseVersion == null ^ other.getPreReleaseVersion() == null) {
- return preReleaseVersion == null ? 1 : -1;
- } else {
- return compareAlphaNumericVersions(
- preReleaseVersion,
- other.getPreReleaseVersion()
- );
- }
- }
-
- private int compareBuildVersions(Version other) {
- if (buildVersion == null ^ other.getBuildVersion() == null) {
- return buildVersion == null ? -1 : 1;
- } else {
- return compareAlphaNumericVersions(
- buildVersion,
- other.getBuildVersion()
- );
- }
- }
-
- private int compareAlphaNumericVersions(String thisOp, String otherOp) {
- if (thisOp == null && otherOp == null) {
- return 0;
- }
- String[] thisIdents = thisOp.split("\\.");
- String[] otherIdents = otherOp.split("\\.");
-
- int result = compareIdentifierArrays(thisIdents, otherIdents);
- if (result == 0 && thisIdents.length != otherIdents.length) {
- result = (thisIdents.length > otherIdents.length) ? 1 : -1;
+ private int comparePreReleases(Version other) {
+ int result = 0;
+ if (preRelease != null && other.preRelease != null) {
+ result = preRelease.compareTo(other.preRelease);
+ } else if (preRelease == null ^ other.preRelease == null) {
+ result = preRelease == null ? 1 : -1;
}
return result;
}
- private int compareIdentifierArrays(String[] thisArr, String[] otherArr) {
+ private int compareBuilds(Version other) {
int result = 0;
- for (int i = 0; i < getSmallestArrayLength(thisArr, otherArr); i++) {
- result = compareIdentifiers(thisArr[i], otherArr[i]);
- if (result != 0) {
- break;
- }
+ if (build != null && other.build != null) {
+ result = build.compareTo(other.build);
+ } else if (build == null ^ other.build == null) {
+ result = build == null ? -1 : 1;
}
return result;
}
-
- private int getSmallestArrayLength(String[] thisArr, String[] otherArr) {
- if (thisArr.length <= otherArr.length) {
- return thisArr.length;
- } else {
- return otherArr.length;
- }
- }
-
- private int compareIdentifiers(String thisIdent, String otherIdent) {
- if (isInt(thisIdent) && isInt(otherIdent)) {
- return compareInts(
- Integer.parseInt(thisIdent),
- Integer.parseInt(otherIdent)
- );
- } else if (isInt(thisIdent) || isInt(otherIdent)) {
- /**
- * Numeric identifiers always have lower precedence
- * than non-numeric identifiers.
- */
- return isInt(thisIdent) ? -1 : 1;
- } else {
- return thisIdent.compareTo(otherIdent);
- }
- }
-
- private boolean isInt(String str) {
- try {
- Integer.parseInt(str);
- } catch (NumberFormatException e) {
- return false;
- }
- return true;
- }
}
diff --git a/src/test/java/com/github/zafarkhaja/semver/AlphaNumericVersionTest.java b/src/test/java/com/github/zafarkhaja/semver/AlphaNumericVersionTest.java
new file mode 100644
index 0000000..b7afd4d
--- /dev/null
+++ b/src/test/java/com/github/zafarkhaja/semver/AlphaNumericVersionTest.java
@@ -0,0 +1,166 @@
+/*
+ * The MIT License
+ *
+ * Copyright 2013 Zafar Khaja <zafarkhaja at gmail.com>.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+package com.github.zafarkhaja.semver;
+
+import static org.junit.Assert.*;
+import org.junit.Test;
+import org.junit.experimental.runners.Enclosed;
+import org.junit.runner.RunWith;
+
+/**
+ *
+ * @author Zafar Khaja <zafarkhaja at gmail.com>
+ */
+ at RunWith(Enclosed.class)
+public class AlphaNumericVersionTest {
+
+ public static class CoreFunctionalityTest {
+
+ @Test
+ public void mustConsistOfDotSeparatedIdentifiersOfAlphaNumericsAndHyphen() {
+ String[] invalidVersions = {
+ null,
+ "",
+ "123!",
+ "1a:2b:3c",
+ "123,abc,123",
+ };
+ for (String ver : invalidVersions) {
+ try {
+ AlphaNumericVersion v = new AlphaNumericVersion(ver);
+ } catch (Exception e) {
+ continue;
+ }
+ fail("Alpha-numeric version MUST consist of dot separated identifiers [0-9A-Za-z-]");
+ }
+ }
+
+ @Test
+ public void mustCompareEachIdentifierSeparately() {
+ AlphaNumericVersion v1 = new AlphaNumericVersion("beta.2.abc");
+ AlphaNumericVersion v2 = new AlphaNumericVersion("beta.1.edf");
+ assertTrue(0 < v1.compareTo(v2));
+ }
+
+ @Test
+ public void shouldCompareIdentifiersCountIfCommonIdentifiersAreEqual() {
+ AlphaNumericVersion v1 = new AlphaNumericVersion("beta.abc");
+ AlphaNumericVersion v2 = new AlphaNumericVersion("beta.abc.def");
+ assertTrue(0 > v1.compareTo(v2));
+ }
+
+ @Test
+ public void shouldComapareDigitsOnlyIdentifiersNumerically() {
+ AlphaNumericVersion v1 = new AlphaNumericVersion("alpha.123");
+ AlphaNumericVersion v2 = new AlphaNumericVersion("alpha.321");
+ assertTrue(0 > v1.compareTo(v2));
+ }
+
+ @Test
+ public void shouldCompareMixedIdentifiersLexicallyInAsciiSortOrder() {
+ AlphaNumericVersion v1 = new AlphaNumericVersion("beta.abc");
+ AlphaNumericVersion v2 = new AlphaNumericVersion("beta.111");
+ assertTrue(0 < v1.compareTo(v2));
+ }
+
+ @Test
+ public void shouldOverrideEqualsMethod() {
+ AlphaNumericVersion v1 = new AlphaNumericVersion("alpha.123");
+ AlphaNumericVersion v2 = new AlphaNumericVersion("alpha.123");
+ AlphaNumericVersion v3 = new AlphaNumericVersion("alpha.321");
+ assertTrue(v1.equals(v2));
+ assertFalse(v1.equals(v3));
+ }
+ }
+
+ public static class EqualsMethodTest {
+
+ @Test
+ public void shouldBeReflexive() {
+ AlphaNumericVersion v = new AlphaNumericVersion("alpha.123");
+ assertTrue(v.equals(v));
+ }
+
+ @Test
+ public void shouldBeSymmetric() {
+ AlphaNumericVersion v1 = new AlphaNumericVersion("alpha.123");
+ AlphaNumericVersion v2 = new AlphaNumericVersion("alpha.123");
+ assertTrue(v1.equals(v2));
+ assertTrue(v2.equals(v1));
+ }
+
+ @Test
+ public void shouldBeTransitive() {
+ AlphaNumericVersion v1 = new AlphaNumericVersion("alpha.123");
+ AlphaNumericVersion v2 = new AlphaNumericVersion("alpha.123");
+ AlphaNumericVersion v3 = new AlphaNumericVersion("alpha.123");
+ assertTrue(v1.equals(v2));
+ assertTrue(v2.equals(v3));
+ assertTrue(v1.equals(v3));
+ }
+
+ @Test
+ public void shouldBeConsistent() {
+ AlphaNumericVersion v1 = new AlphaNumericVersion("alpha.123");
+ AlphaNumericVersion v2 = new AlphaNumericVersion("alpha.123");
+ assertTrue(v1.equals(v2));
+ assertTrue(v1.equals(v2));
+ assertTrue(v1.equals(v2));
+ }
+
+ @Test
+ public void shouldReturnFalseIfOtherVersionIsOfDifferentType() {
+ AlphaNumericVersion v = new AlphaNumericVersion("alpha.123");
+ assertFalse(v.equals(new String("alpha.123")));
+ }
+
+ @Test
+ public void shouldReturnFalseIfOtherVersionIsNull() {
+ AlphaNumericVersion v1 = new AlphaNumericVersion("alpha.123");
+ AlphaNumericVersion v2 = null;
+ assertFalse(v1.equals(v2));
+ }
+ }
+
+ public static class HashCodeMethodTest {
+
+ @Test
+ public void shouldReturnSameHashCodeIfVersionsAreEqual() {
+ AlphaNumericVersion v1 = new AlphaNumericVersion("alpha.123");
+ AlphaNumericVersion v2 = new AlphaNumericVersion("alpha.123");
+ assertTrue(v1.equals(v2));
+ assertEquals(v1.hashCode(), v2.hashCode());
+ }
+ }
+
+ public static class ToStringMethodTest {
+
+ @Test
+ public void shouldReturnStringRepresentation() {
+ String value = "beta.abc.def";
+ AlphaNumericVersion v = new AlphaNumericVersion(value);
+ assertEquals(value, v.toString());
+ }
+ }
+}
diff --git a/src/test/java/com/github/zafarkhaja/semver/NormalVersionTest.java b/src/test/java/com/github/zafarkhaja/semver/NormalVersionTest.java
new file mode 100644
index 0000000..4d4cbc0
--- /dev/null
+++ b/src/test/java/com/github/zafarkhaja/semver/NormalVersionTest.java
@@ -0,0 +1,195 @@
+/*
+ * The MIT License
+ *
+ * Copyright 2013 Zafar Khaja <zafarkhaja at gmail.com>.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+package com.github.zafarkhaja.semver;
+
+import static org.junit.Assert.*;
+import org.junit.Test;
+import org.junit.experimental.runners.Enclosed;
+import org.junit.runner.RunWith;
+
+/**
+ *
+ * @author Zafar Khaja <zafarkhaja at gmail.com>
+ */
+ at RunWith(Enclosed.class)
+public class NormalVersionTest {
+
+ public static class CoreFunctionalityTest {
+
+ @Test
+ public void mustConsistOfMajorMinorAndPatchVersions() {
+ NormalVersion v = new NormalVersion(1, 2, 3);
+ assertEquals(1, v.getMajor());
+ assertEquals(2, v.getMinor());
+ assertEquals(3, v.getPatch());
+ }
+
+ @Test
+ public void mustTakeTheFormOfXDotYDotZWhereXyzAreNonNegativeIntegers() {
+ NormalVersion v = new NormalVersion(1, 2, 3);
+ assertEquals("1.2.3", v.toString());
+ }
+
+ @Test
+ public void shouldAcceptOnlyNonNegativeMajorMinorAndPatchVersions() {
+ int[][] invalidVersions = {{-1, 2, 3}, {1, -2, 3}, {1, 2, -3}};
+ for (int[] versionParts : invalidVersions) {
+ try {
+ NormalVersion v = new NormalVersion(
+ versionParts[0],
+ versionParts[1],
+ versionParts[2]
+ );
+ } catch (IllegalArgumentException e) {
+ continue;
+ }
+ fail("Major, minor and patch versions MUST be non-negative integers.");
+ }
+ }
+
+ @Test
+ public void mustIncreaseEachElementNumericallyByIncrementsOfOne() {
+ int major = 1, minor = 2, patch = 3;
+ NormalVersion v = new NormalVersion(major, minor, patch);
+ v.incrementPatch();
+ assertEquals(patch + 1, v.getPatch());
+ v.incrementMinor();
+ assertEquals(minor + 1, v.getMinor());
+ v.incrementMajor();
+ assertEquals(major + 1, v.getMajor());
+ }
+
+ @Test
+ public void mustResetMinorAndPatchToZeroWhenMajorIsIncremented() {
+ NormalVersion v = new NormalVersion(1, 2, 3);
+ v.incrementMajor();
+ assertEquals(2, v.getMajor());
+ assertEquals(0, v.getMinor());
+ assertEquals(0, v.getPatch());
+ }
+
+ @Test
+ public void mustResetPatchToZeroWhenMinorIsIncremented() {
+ NormalVersion v = new NormalVersion(1, 2, 3);
+ v.incrementMinor();
+ assertEquals(1, v.getMajor());
+ assertEquals(3, v.getMinor());
+ assertEquals(0, v.getPatch());
+ }
+
+ @Test
+ public void mustCompareMajorMinorAndPatchNumerically() {
+ NormalVersion v = new NormalVersion(1, 2, 3);
+ assertTrue(0 < v.compareTo(new NormalVersion(0, 2, 3)));
+ assertTrue(0 == v.compareTo(new NormalVersion(1, 2, 3)));
+ assertTrue(0 > v.compareTo(new NormalVersion(1, 2, 4)));
+ }
+
+ @Test
+ public void shouldOverrideEqualsMethod() {
+ NormalVersion v1 = new NormalVersion(1, 2, 3);
+ NormalVersion v2 = new NormalVersion(1, 2, 3);
+ NormalVersion v3 = new NormalVersion(3, 2, 1);
+ assertTrue(v1.equals(v2));
+ assertFalse(v1.equals(v3));
+ }
+
+ @Test
+ public void shouldHaveStaticFactoryMethod() {
+ NormalVersion v = NormalVersion.valueOf("1.2.3");
+ assertEquals(1, v.getMajor());
+ assertEquals(2, v.getMinor());
+ assertEquals(3, v.getPatch());
+ }
+ }
+
+ public static class EqualsMethodTest {
+
+ @Test
+ public void shouldBeReflexive() {
+ NormalVersion v = new NormalVersion(1, 2, 3);
+ assertTrue(v.equals(v));
+ }
+
+ @Test
+ public void shouldBeSymmetric() {
+ NormalVersion v1 = new NormalVersion(1, 2, 3);
+ NormalVersion v2 = new NormalVersion(1, 2, 3);
+ assertTrue(v1.equals(v2));
+ assertTrue(v2.equals(v1));
+ }
+
+ @Test
+ public void shouldBeTransitive() {
+ NormalVersion v1 = new NormalVersion(1, 2, 3);
+ NormalVersion v2 = new NormalVersion(1, 2, 3);
+ NormalVersion v3 = new NormalVersion(1, 2, 3);
+ assertTrue(v1.equals(v2));
+ assertTrue(v2.equals(v3));
+ assertTrue(v1.equals(v3));
+ }
+
+ @Test
+ public void shouldBeConsistent() {
+ NormalVersion v1 = new NormalVersion(1, 2, 3);
+ NormalVersion v2 = new NormalVersion(1, 2, 3);
+ assertTrue(v1.equals(v2));
+ assertTrue(v1.equals(v2));
+ assertTrue(v1.equals(v2));
+ }
+
+ @Test
+ public void shouldReturnFalseIfOtherVersionIsOfDifferentType() {
+ NormalVersion v = new NormalVersion(1, 2, 3);
+ assertFalse(v.equals(new String("1.2.3")));
+ }
+
+ @Test
+ public void shouldReturnFalseIfOtherVersionIsNull() {
+ NormalVersion v1 = new NormalVersion(1, 2, 3);
+ NormalVersion v2 = null;
+ assertFalse(v1.equals(v2));
+ }
+ }
+
+ public static class HashCodeMethodTest {
+
+ @Test
+ public void shouldReturnSameHashCodeIfVersionsAreEqual() {
+ NormalVersion v1 = new NormalVersion(1, 2, 3);
+ NormalVersion v2 = new NormalVersion(1, 2, 3);
+ assertTrue(v1.equals(v2));
+ assertEquals(v1.hashCode(), v2.hashCode());
+ }
+ }
+
+ public static class ToStringMethodTest {
+
+ @Test
+ public void shouldReturnStringRepresentation() {
+ NormalVersion v = new NormalVersion(1, 2, 3);
+ assertEquals("1.2.3", v.toString());
+ }
+ }
+}
diff --git a/src/test/java/com/github/zafarkhaja/semver/VersionTest.java b/src/test/java/com/github/zafarkhaja/semver/VersionTest.java
index fc34064..00bbf8c 100644
--- a/src/test/java/com/github/zafarkhaja/semver/VersionTest.java
+++ b/src/test/java/com/github/zafarkhaja/semver/VersionTest.java
@@ -21,285 +21,204 @@
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
-
package com.github.zafarkhaja.semver;
import static org.junit.Assert.*;
import org.junit.Test;
+import org.junit.experimental.runners.Enclosed;
+import org.junit.runner.RunWith;
/**
*
* @author Zafar Khaja <zafarkhaja at gmail.com>
*/
+ at RunWith(Enclosed.class)
public class VersionTest {
- @Test public void
- mustConsistOfMajorMinorAndPatchVersions() {
- Version version = new Version("1.2.3");
- assertNotNull(version.getMajorVersion());
- assertNotNull(version.getMinorVersion());
- assertNotNull(version.getPatchVersion());
- }
-
- @Test public void
- mustTakeTheFormOfXDotYDotZWhereXyzAreNonNegativeIntegers() {
- Version version = new Version("1.2.3");
- assertEquals(1, version.getMajorVersion());
- assertEquals(2, version.getMinorVersion());
- assertEquals(3, version.getPatchVersion());
- }
-
- @Test public void
- shouldAcceptOnlyNonNegativeMajorMinorAndPatchVersions() {
- String[] versionStrings = {"-1.2.3", "1.-2.3", "1.2.-3"};
- for (String illegalVersion : versionStrings) {
- try {
- Version version = new Version(illegalVersion);
- } catch (IllegalArgumentException e) {
- continue;
+ public static class CoreFunctionalityTest {
+
+ @Test
+ public void mayHavePreReleaseFollowingPatchAppendedWithHyphen() {
+ Version v = Version.valueOf("1.2.3-alpha");
+ assertEquals("alpha", v.getPreReleaseVersion());
+ }
+
+ @Test
+ public void preReleaseShouldHaveLowerPrecedenceThanAssociatedNormal() {
+ Version v1 = Version.valueOf("1.3.7");
+ Version v2 = Version.valueOf("1.3.7-alpha");
+ assertTrue(0 < v1.compareTo(v2));
+ assertTrue(0 > v2.compareTo(v1));
+ }
+
+ @Test
+ public void mayHaveBuildFollowingPatchOrPreReleaseAppendedWithPlus() {
+ Version v = Version.valueOf("1.2.3+build");
+ assertEquals("build", v.getBuildVersion());
+ }
+
+ @Test
+ public void shouldCompareBuildIfNormalAndPreReleaseAreEqual() {
+ Version v1 = Version.valueOf("1.3.7-beta+build.1");
+ Version v2 = Version.valueOf("1.3.7-beta+build.2");
+ assertTrue(0 > v1.compareTo(v2));
+ }
+
+ @Test
+ public void buildShouldHaveHigherPrecedenceThanAssociatedNormal() {
+ Version v1 = Version.valueOf("1.3.7");
+ Version v2 = Version.valueOf("1.3.7+build");
+ assertTrue(0 > v1.compareTo(v2));
+ assertTrue(0 < v2.compareTo(v1));
+ }
+
+ @Test
+ public void shouldHaveGreaterThanMethodReturningBoolean() {
+ Version v1 = Version.valueOf("2.3.7");
+ Version v2 = Version.valueOf("1.3.7");
+ assertTrue(v1.greaterThan(v2));
+ assertFalse(v2.greaterThan(v1));
+ assertFalse(v1.greaterThan(v1));
+ }
+
+ @Test
+ public void shouldHaveGreaterThanOrEqualsToMethodReturningBoolean() {
+ Version v1 = Version.valueOf("2.3.7");
+ Version v2 = Version.valueOf("1.3.7");
+ assertTrue(v1.greaterThanOrEqualsTo(v2));
+ assertFalse(v2.greaterThanOrEqualsTo(v1));
+ assertTrue(v1.greaterThanOrEqualsTo(v1));
+ }
+
+ @Test
+ public void shouldHaveLessThanMethodReturningBoolean() {
+ Version v1 = Version.valueOf("2.3.7");
+ Version v2 = Version.valueOf("1.3.7");
+ assertFalse(v1.lessThan(v2));
+ assertTrue(v2.lessThan(v1));
+ assertFalse(v1.lessThan(v1));
+ }
+
+ @Test
+ public void shouldHaveLessThanOrEqualsToMethodReturningBoolean() {
+ Version v1 = Version.valueOf("2.3.7");
+ Version v2 = Version.valueOf("1.3.7");
+ assertFalse(v1.lessThanOrEqualsTo(v2));
+ assertTrue(v2.lessThanOrEqualsTo(v1));
+ assertTrue(v1.lessThanOrEqualsTo(v1));
+ }
+
+ @Test
+ public void shouldOverrideEqualsMethod() {
+ Version v1 = Version.valueOf("2.3.7");
+ Version v2 = Version.valueOf("2.3.7");
+ Version v3 = Version.valueOf("1.3.7");
+ assertTrue(v1.equals(v1));
+ assertTrue(v1.equals(v2));
+ assertFalse(v1.equals(v3));
+ }
+
+ @Test
+ public void shouldCorrectlyCompareAllVersionsFromSpecification() {
+ String[] versions = {
+ "1.0.0-alpha",
+ "1.0.0-alpha.1",
+ "1.0.0-beta.2",
+ "1.0.0-beta.11",
+ "1.0.0-rc.1",
+ "1.0.0-rc.1+build.1",
+ "1.0.0",
+ "1.0.0+0.3.7",
+ "1.3.7+build",
+ "1.3.7+build.2.b8f12d7",
+ "1.3.7+build.11.e0f985a"
+ };
+ for (int i = 1; i < versions.length; i++) {
+ Version v1 = Version.valueOf(versions[i-1]);
+ Version v2 = Version.valueOf(versions[i]);
+ assertTrue(v1.lessThan(v2));
}
- fail("An expected exception has not been thrown.");
+ }
+
+ @Test
+ public void shouldHaveStaticFactoryMethod() {
+ Version v = Version.valueOf("1.0.0-rc.1+build.1");
+ assertEquals(1, v.getMajorVersion());
+ assertEquals(0, v.getMinorVersion());
+ assertEquals(0, v.getPatchVersion());
+ assertEquals("1.0.0", v.getNormalVersion());
+ assertEquals("rc.1", v.getPreReleaseVersion());
+ assertEquals("build.1", v.getBuildVersion());
}
}
- @Test public void
- mustIncreaseEachElementNumericallyByIncrementsOfOne() {
- Version version = new Version("1.2.3");
- version.bumpPatchVersion();
- assertEquals(4, version.getPatchVersion());
- version.bumpMinorVersion();
- assertEquals(3, version.getMinorVersion());
- version.bumpMajorVersion();
- assertEquals(2, version.getMajorVersion());
- }
-
- @Test public void
- mustResetToZeroMinorAndPatchVersionsWhenMajorVersionIsIncremented() {
- Version version = new Version("1.2.3");
- version.bumpMajorVersion();
- assertEquals(2, version.getMajorVersion());
- assertEquals(0, version.getMinorVersion());
- assertEquals(0, version.getPatchVersion());
- }
-
- @Test public void
- mustResetToZeroPatchVersionWhenMinorVersionIsIncremented() {
- Version version = new Version("1.2.3");
- version.bumpMinorVersion();
- assertEquals(1, version.getMajorVersion());
- assertEquals(3, version.getMinorVersion());
- assertEquals(0, version.getPatchVersion());
- }
-
- @Test public void
- mayHavePreReleaseVersionFollowingPatchVersionAppendedWithDash() {
- Version version = new Version("1.2.3-alpha");
- assertEquals("alpha", version.getPreReleaseVersion());
- }
-
- @Test public void
- preReleaseVersionMustCompriseDotSeparatedIdentifiersOfAlphaNumericsAndDash() {
- Version version = new Version("1.0.0-x.7.z.92");
- assertEquals("x.7.z.92", version.getPreReleaseVersion());
- }
-
- @Test public void
- mayHaveBuildVersionFollowingPatchOrPreReleaseVersionsAppendedWithPlus() {
- Version version = new Version("1.2.3+build");
- assertEquals("build", version.getBuildVersion());
- }
-
- @Test public void
- buildVersionMustCompriseDotSeparatedIdentifiersOfAlphaNumericsAndDash() {
- Version version = new Version("1.3.7+build.11.e0f985a");
- assertEquals("build.11.e0f985a", version.getBuildVersion());
- }
-
- @Test public void
- mustCompareMajorMinorAndPatchVersionsNumerically() {
- Version version = new Version("1.2.3");
- assertEquals(1, version.compareTo(new Version("0.2.3")));
- assertEquals(0, version.compareTo(new Version("1.2.3")));
- assertEquals(-1, version.compareTo(new Version("1.2.4")));
- }
-
- @Test public void
- mustComparePreReleaseAndBuildVersionsByComparingEachIdentifierSeparately() {
- Version version1 = new Version("1.3.7+build.2.b8f12d7");
- Version version2 = new Version("1.3.7+build.11.e0f985a");
- assertEquals(-1, version1.compareTo(version2));
- }
-
- @Test public void
- shouldComparePreReleaseVersionsIfNormalVersionsAreEqual() {
- Version version1 = new Version("1.3.7-beta");
- Version version2 = new Version("1.3.7-alpha");
- assertEquals(1, version1.compareTo(version2));
- }
-
- @Test public void
- preReleaseVersionShouldHaveLowerPrecedenceThanAssociatedNormalVersion() {
- Version version1 = new Version("1.3.7");
- Version version2 = new Version("1.3.7-alpha");
- assertEquals(1, version1.compareTo(version2));
- assertEquals(-1, version2.compareTo(version1));
- }
-
- @Test public void
- shouldCompareBuildVersionsIfNormalAndPreReleaseVersionsAreEqual() {
- Version version1 = new Version("1.3.7-beta+build.1");
- Version version2 = new Version("1.3.7-beta+build.2");
- assertEquals(-1, version1.compareTo(version2));
- }
-
- @Test public void
- buildVersionShouldHaveHigherPrecedenceThanAssociatedNormalVersion() {
- Version version1 = new Version("1.3.7");
- Version version2 = new Version("1.3.7+build");
- assertEquals(-1, version1.compareTo(version2));
- assertEquals(1, version2.compareTo(version1));
- }
-
- @Test public void
- shouldCompareAccordingToIdentifiersCountIfCommonIdentifiersAreEqual() {
- Version version1 = new Version("1.3.7-beta+build.3");
- Version version2 = new Version("1.3.7-beta+build");
- assertEquals(1, version1.compareTo(version2));
- }
-
- @Test public void
- numericIdentifiersShouldHaveLowerPrecedenceThanNonNumericIdentfiers() {
- Version version1 = new Version("1.3.7-beta+build.3");
- Version version2 = new Version("1.3.7-beta+build.a");
- assertEquals(-1, version1.compareTo(version2));
- }
-
- @Test public void
- shouldHaveGreaterThanConvenienceMethodReturningBoolean() {
- Version version1 = new Version("2.3.7");
- Version version2 = new Version("1.3.7");
- assertTrue(version1.greaterThan(version2));
- assertFalse(version2.greaterThan(version1));
- assertFalse(version1.greaterThan(version1));
- }
-
- @Test public void
- shouldHaveGreaterThanOrEqualsToConvenienceMethodReturningBoolean() {
- Version version1 = new Version("2.3.7");
- Version version2 = new Version("1.3.7");
- assertTrue(version1.greaterThanOrEqualsTo(version2));
- assertFalse(version2.greaterThanOrEqualsTo(version1));
- assertTrue(version1.greaterThanOrEqualsTo(version1));
- }
-
- @Test public void
- shouldHaveLessThanConvenienceMethodReturningBoolean() {
- Version version1 = new Version("2.3.7");
- Version version2 = new Version("1.3.7");
- assertFalse(version1.lessThan(version2));
- assertTrue(version2.lessThan(version1));
- assertFalse(version1.lessThan(version1));
- }
-
- @Test public void
- shouldHaveLessThanOrEqualsToConvenienceMethodReturningBoolean() {
- Version version1 = new Version("2.3.7");
- Version version2 = new Version("1.3.7");
- assertFalse(version1.lessThanOrEqualsTo(version2));
- assertTrue(version2.lessThanOrEqualsTo(version1));
- assertTrue(version1.lessThanOrEqualsTo(version1));
- }
-
- @Test public void
- shouldOverrideEqualsMethodForConvenience() {
- Version version1 = new Version("2.3.7");
- Version version2 = new Version("2.3.7");
- Version version3 = new Version("1.3.7");
- assertTrue(version1.equals(version1));
- assertTrue(version1.equals(version2));
- assertFalse(version1.equals(version3));
- }
-
- @Test public void
- equalsMethodShouldBeReflexive() {
- Version version1 = new Version("2.3.7");
- assertTrue(version1.equals(version1));
- }
-
- @Test public void
- equalsMethodShouldBeSymmetric() {
- Version version1 = new Version("2.3.7");
- Version version2 = new Version("2.3.7");
- assertTrue(version1.equals(version2));
- assertTrue(version2.equals(version1));
- }
-
- @Test public void
- equalsMethodShouldBeTransitive() {
- Version version1 = new Version("2.3.7");
- Version version2 = new Version("2.3.7");
- Version version3 = new Version("2.3.7");
- assertTrue(version1.equals(version2));
- assertTrue(version2.equals(version3));
- assertTrue(version1.equals(version3));
- }
-
- @Test public void
- equalsMethodShouldBeConsistent() {
- Version version1 = new Version("2.3.7");
- Version version2 = new Version("2.3.7");
- assertTrue(version1.equals(version2));
- assertTrue(version1.equals(version2));
- assertTrue(version1.equals(version2));
- }
-
- @Test public void
- equalsMethodShouldReturnFalseIfOtherVersionIsNotInstanceOfVersion() {
- Version version1 = new Version("2.3.7");
- assertFalse(version1.equals(new String("2.3.7")));
- }
-
- @Test public void
- equalsMethodShouldReturnFalseIfOtherVersionIsNull() {
- Version version1 = new Version("2.3.7");
- Version version2 = null;
- assertFalse(version1.equals(version2));
- }
-
- @Test public void
- hashCodeMethodShouldReturnSameHashCodeIfVersionsAreEqual() {
- Version version1 = new Version("2.3.7");
- Version version2 = new Version("2.3.7");
- assertTrue(version1.equals(version2));
- assertEquals(version1.hashCode(), version2.hashCode());
+ public static class EqualsMethodTest {
+
+ @Test
+ public void shouldBeReflexive() {
+ Version v1 = Version.valueOf("2.3.7");
+ assertTrue(v1.equals(v1));
+ }
+
+ @Test
+ public void shouldBeSymmetric() {
+ Version v1 = Version.valueOf("2.3.7");
+ Version v2 = Version.valueOf("2.3.7");
+ assertTrue(v1.equals(v2));
+ assertTrue(v2.equals(v1));
+ }
+
+ @Test
+ public void shouldBeTransitive() {
+ Version v1 = Version.valueOf("2.3.7");
+ Version v2 = Version.valueOf("2.3.7");
+ Version v3 = Version.valueOf("2.3.7");
+ assertTrue(v1.equals(v2));
+ assertTrue(v2.equals(v3));
+ assertTrue(v1.equals(v3));
+ }
+
+ @Test
+ public void shouldBeConsistent() {
+ Version v1 = Version.valueOf("2.3.7");
+ Version v2 = Version.valueOf("2.3.7");
+ assertTrue(v1.equals(v2));
+ assertTrue(v1.equals(v2));
+ assertTrue(v1.equals(v2));
+ }
+
+ @Test
+ public void shouldReturnFalseIfOtherVersionIsOfDifferentType() {
+ Version v1 = Version.valueOf("2.3.7");
+ assertFalse(v1.equals(new String("2.3.7")));
+ }
+
+ @Test
+ public void shouldReturnFalseIfOtherVersionIsNull() {
+ Version v1 = Version.valueOf("2.3.7");
+ Version v2 = null;
+ assertFalse(v1.equals(v2));
+ }
}
- @Test public void
- shouldOverrideToStringMethod() {
- String versionString = "1.2.3-beta+build";
- Version version = new Version(versionString);
- assertEquals(versionString, version.toString());
+ public static class HashCodeMethodTest {
+
+ @Test
+ public void shouldReturnSameHashCodeIfVersionsAreEqual() {
+ Version v1 = Version.valueOf("2.3.7");
+ Version v2 = Version.valueOf("2.3.7");
+ assertTrue(v1.equals(v2));
+ assertEquals(v1.hashCode(), v2.hashCode());
+ }
}
- @Test public void
- shouldCorrectlyCompareAllVersionsFromSpecification() {
- String[] versionStrings = {
- "1.0.0-alpha",
- "1.0.0-alpha.1",
- "1.0.0-beta.2",
- "1.0.0-beta.11",
- "1.0.0-rc.1",
- "1.0.0-rc.1+build.1",
- "1.0.0",
- "1.0.0+0.3.7",
- "1.3.7+build",
- "1.3.7+build.2.b8f12d7",
- "1.3.7+build.11.e0f985a"
- };
- for (int i = 1; i < versionStrings.length; i++) {
- Version version1 = new Version(versionStrings[i-1]);
- Version version2 = new Version(versionStrings[i]);
- assertTrue(version1.lessThan(version2));
+ public static class ToStringMethodTest {
+
+ @Test
+ public void shouldReturnStringRepresentation() {
+ String value = "1.2.3-beta+build";
+ Version v = Version.valueOf(value);
+ assertEquals(value, v.toString());
}
}
}
--
Alioth's /usr/local/bin/git-commit-notice on /srv/git.debian.org/git/pkg-java/jsemver.git
More information about the pkg-java-commits
mailing list