Update with sonarqube suggestions

nmayorsplit · nmayorsplit · commit 3b813d885959 · 2024-05-15T12:15:39.000-03:00
diff --git a/client/src/main/java/io/split/engine/matchers/BetweenSemverMatcher.java b/client/src/main/java/io/split/engine/matchers/BetweenSemverMatcher.java
@@ -16,24 +16,24 @@ public BetweenSemverMatcher(String semverStart, String semverEnd) {
 
     @Override
     public boolean match(Object matchValue, String bucketingKey, Map<String, Object> attributes, EvaluationContext evaluationContext) {
-        if (matchValue == null || _semverStart == null || _semverEnd == null || !(matchValue instanceof String)) {
+        if (!(matchValue instanceof String) || _semverStart == null || _semverEnd == null) {
             return false;
         }
         Semver matchSemver = Semver.build(matchValue.toString());
         if (matchSemver == null) {
             return false;
         }
 
-        return matchSemver.Compare(_semverStart) >= 0 && matchSemver.Compare(_semverEnd) <= 0;
+        return matchSemver.compare(_semverStart) >= 0 && matchSemver.compare(_semverEnd) <= 0;
     }
 
     @Override
     public String toString() {
         StringBuilder bldr = new StringBuilder();
         bldr.append("between semver ");
-        bldr.append(_semverStart.Version());
+        bldr.append(_semverStart.version());
         bldr.append(" and ");
-        bldr.append(_semverEnd.Version());
+        bldr.append(_semverEnd.version());
         return bldr.toString();
     }
 
diff --git a/client/src/main/java/io/split/engine/matchers/EqualToSemverMatcher.java b/client/src/main/java/io/split/engine/matchers/EqualToSemverMatcher.java
@@ -14,22 +14,22 @@ public EqualToSemverMatcher(String semVer) {
 
     @Override
     public boolean match(Object matchValue, String bucketingKey, Map<String, Object> attributes, EvaluationContext evaluationContext) {
-        if (matchValue == null || _semVer == null) {
+        if (!(matchValue instanceof String) || _semVer == null) {
             return false;
         }
         Semver matchSemver = Semver.build(matchValue.toString());
         if (matchSemver == null) {
             return false;
         }
 
-        return matchSemver.Version().equals(_semVer.Version());
+        return matchSemver.version().equals(_semVer.version());
     }
 
     @Override
     public String toString() {
         StringBuilder bldr = new StringBuilder();
         bldr.append("== semver ");
-        bldr.append(_semVer.Version());
+        bldr.append(_semVer.version());
         return bldr.toString();
     }
 
diff --git a/client/src/main/java/io/split/engine/matchers/GreaterThanOrEqualToSemverMatcher.java b/client/src/main/java/io/split/engine/matchers/GreaterThanOrEqualToSemverMatcher.java
@@ -14,22 +14,22 @@ public GreaterThanOrEqualToSemverMatcher(String semVer) {
 
     @Override
     public boolean match(Object matchValue, String bucketingKey, Map<String, Object> attributes, EvaluationContext evaluationContext) {
-        if (matchValue == null || _semVer == null || !(matchValue instanceof String)) {
+        if (!(matchValue instanceof String)|| _semVer == null) {
             return false;
         }
         Semver matchSemver = Semver.build(matchValue.toString());
         if (matchSemver == null) {
             return false;
         }
 
-        return matchSemver.Compare(_semVer) >= 0;
+        return matchSemver.compare(_semVer) >= 0;
     }
 
     @Override
     public String toString() {
         StringBuilder bldr = new StringBuilder();
         bldr.append(">= semver ");
-        bldr.append(_semVer.Version());
+        bldr.append(_semVer.version());
         return bldr.toString();
     }
 
diff --git a/client/src/main/java/io/split/engine/matchers/InListSemverMatcher.java b/client/src/main/java/io/split/engine/matchers/InListSemverMatcher.java
@@ -22,7 +22,7 @@ public InListSemverMatcher(Collection<String> whitelist) {
 
     @Override
     public boolean match(Object matchValue, String bucketingKey, Map<String, Object> attributes, EvaluationContext evaluationContext) {
-        if (matchValue == null || !(matchValue instanceof String) || _semverlist.isEmpty()) {
+        if (!(matchValue instanceof String) || _semverlist.isEmpty()) {
             return false;
         }
         Semver matchSemver = Semver.build(matchValue.toString());
@@ -31,7 +31,7 @@ public boolean match(Object matchValue, String bucketingKey, Map<String, Object>
         }
 
         for (Semver semverItem : _semverlist) {
-            if (semverItem.Version().equals(matchSemver.Version())) return true;
+            if (semverItem.version().equals(matchSemver.version())) return true;
         }
         return false;
     }
@@ -47,7 +47,7 @@ public String toString() {
                 bldr.append(',');
             }
             bldr.append('"');
-            bldr.append(item.Version());
+            bldr.append(item.version());
             bldr.append('"');
             first = false;
         }
diff --git a/client/src/main/java/io/split/engine/matchers/LessThanOrEqualToSemverMatcher.java b/client/src/main/java/io/split/engine/matchers/LessThanOrEqualToSemverMatcher.java
@@ -14,22 +14,22 @@ public LessThanOrEqualToSemverMatcher(String semVer) {
 
     @Override
     public boolean match(Object matchValue, String bucketingKey, Map<String, Object> attributes, EvaluationContext evaluationContext) {
-        if (matchValue == null || !(matchValue instanceof String) || _semVer == null) {
+        if (!(matchValue instanceof String) || _semVer == null) {
             return false;
         }
         Semver matchSemver = Semver.build(matchValue.toString());
         if (matchSemver == null) {
             return false;
         }
 
-        return matchSemver.Compare(_semVer) <= 0;
+        return matchSemver.compare(_semVer) <= 0;
     }
 
     @Override
     public String toString() {
         StringBuilder bldr = new StringBuilder();
         bldr.append("<= semver ");
-        bldr.append(_semVer.Version());
+        bldr.append(_semVer.version());
         return bldr.toString();
     }
 
diff --git a/client/src/main/java/io/split/engine/matchers/Semver.java b/client/src/main/java/io/split/engine/matchers/Semver.java
@@ -7,9 +7,9 @@
 import java.util.Arrays;
 
 public class Semver {
-    private static final String MetadataDelimiter = "+";
-    private static final String PreReleaseDelimiter = "-";
-    private static final String ValueDelimiter = "\\.";
+    private static final String METADATA_DELIMITER = "+";
+    private static final String PRERELEASE_DELIMITER = "-";
+    private static final String VALUE_DELIMITER = "\\.";
     private static final Logger _log = LoggerFactory.getLogger(Semver.class);
 
     private Long _major;
@@ -30,31 +30,31 @@ public static Semver build(String version) {
         }
     }
 
-    public String Version() {
+    public String version() {
       return _version;
     }
 
-    public Long Major() {
+    public Long major() {
         return _major;
     }
 
-    public Long Minor() {
+    public Long minor() {
         return _minor;
     }
 
-    public Long Patch() {
+    public Long patch() {
         return _patch;
     }
 
-    public String[] PreRelease() {
+    public String[] prerelease() {
         return _preRelease;
     }
 
-    public String Metadata() {
+    public String metadata() {
         return _metadata;
     }
 
-    public boolean IsStable() {
+    public boolean isStable() {
         return _isStable;
     }
 
@@ -65,44 +65,44 @@ public boolean IsStable() {
      *         a value less than {@code 0} if {@code this < toCompare}; and
      *         a value greater than {@code 0} if {@code this > toCompare}
      */
-    public int Compare(Semver toCompare) {
-        if (_version.equals(toCompare.Version())) {
+    public int compare(Semver toCompare) {
+        if (_version.equals(toCompare.version())) {
             return 0;
         }
         // Compare major, minor, and patch versions numerically
-        int result = Long.compare(_major, toCompare.Major());
+        int result = Long.compare(_major, toCompare.major());
         if (result != 0) {
             return result;
         }
-        result = Long.compare(_minor, toCompare.Minor());
+        result = Long.compare(_minor, toCompare.minor());
         if (result != 0) {
             return result;
         }
-        result = Long.compare(_patch, toCompare.Patch());
+        result = Long.compare(_patch, toCompare.patch());
         if (result != 0) {
             return result;
         }
-        if (!_isStable && toCompare.IsStable()) {
+        if (!_isStable && toCompare.isStable()) {
             return -1;
-        } else if (_isStable && !toCompare.IsStable()) {
+        } else if (_isStable && !toCompare.isStable()) {
             return 1;
         }
         // Compare pre-release versions lexically
-        int minLength = Math.min(_preRelease.length, toCompare.PreRelease().length);
+        int minLength = Math.min(_preRelease.length, toCompare.prerelease().length);
         for (int i = 0; i < minLength; i++) {
-            if (_preRelease[i].equals(toCompare.PreRelease()[i])) {
+            if (_preRelease[i].equals(toCompare.prerelease()[i])) {
                 continue;
             }
             if ( isNumeric(_preRelease[i]) &&  isNumeric(toCompare._preRelease[i])) {
                 return Long.compare(Integer.parseInt(_preRelease[i]), Long.parseLong(toCompare._preRelease[i]));
             }
-            return AdjustNumber(_preRelease[i].compareTo(toCompare._preRelease[i]));
+            return adjustNumber(_preRelease[i].compareTo(toCompare._preRelease[i]));
         }
         // Compare lengths of pre-release versions
         return Integer.compare(_preRelease.length, toCompare._preRelease.length);
     }
 
-    private int AdjustNumber(int number) {
+    private int adjustNumber(int number) {
         if (number > 0) return 1;
         if (number < 0) return -1;
         return 0;
@@ -114,7 +114,7 @@ private Semver(String version) throws SemverParseException {
         _version = setVersion();
     }
     private String setAndRemoveMetadataIfExists(String version) throws SemverParseException {
-        int index = version.indexOf(MetadataDelimiter);
+        int index = version.indexOf(METADATA_DELIMITER);
         if (index == -1) {
             return version;
         }
@@ -125,20 +125,20 @@ private String setAndRemoveMetadataIfExists(String version) throws SemverParseEx
         return version.substring(0, index);
     }
     private String setAndRemovePreReleaseIfExists(String vWithoutMetadata) throws SemverParseException {
-        int index = vWithoutMetadata.indexOf(PreReleaseDelimiter);
+        int index = vWithoutMetadata.indexOf(PRERELEASE_DELIMITER);
         if (index == -1) {
             _isStable = true;
             return vWithoutMetadata;
         }
         String preReleaseData = vWithoutMetadata.substring(index+1);
-        _preRelease = preReleaseData.split(ValueDelimiter);
+        _preRelease = preReleaseData.split(VALUE_DELIMITER);
         if (_preRelease == null || Arrays.stream(_preRelease).allMatch(pr -> pr == null || pr.isEmpty())) {
             throw new SemverParseException("Unable to convert to Semver, incorrect pre release data");
         }
         return vWithoutMetadata.substring(0, index);
     }
     private void setMajorMinorAndPatch(String version) throws SemverParseException {
-        String[] vParts = version.split(ValueDelimiter);
+        String[] vParts = version.split(VALUE_DELIMITER);
         if (vParts.length != 3)
             throw new SemverParseException("Unable to convert to Semver, incorrect format: " + version);
         _major = Long.parseLong(vParts[0]);
@@ -147,7 +147,7 @@ private void setMajorMinorAndPatch(String version) throws SemverParseException {
     }
 
     private String setVersion() {
-        String toReturn = _major + ValueDelimiter + _minor + ValueDelimiter + _patch;
+        String toReturn = _major + VALUE_DELIMITER + _minor + VALUE_DELIMITER + _patch;
         if (_preRelease != null && _preRelease.length != 0)
         {
             for (int i = 0; i < _preRelease.length; i++)
@@ -157,10 +157,10 @@ private String setVersion() {
                     _preRelease[i] = Long.toString(Long.parseLong(_preRelease[i]));
                 }
             }
-            toReturn = toReturn + PreReleaseDelimiter + String.join(ValueDelimiter, _preRelease);
+            toReturn = toReturn + PRERELEASE_DELIMITER + String.join(VALUE_DELIMITER, _preRelease);
         }
         if (_metadata != null && !_metadata.isEmpty()) {
-            toReturn = toReturn + MetadataDelimiter + _metadata;
+            toReturn = toReturn + METADATA_DELIMITER + _metadata;
         }
         return toReturn;
     }
diff --git a/client/src/test/java/io/split/engine/matchers/SemverTest.java b/client/src/test/java/io/split/engine/matchers/SemverTest.java
@@ -1,6 +1,5 @@
 package io.split.engine.matchers;
 
-import org.apache.commons.lang3.RandomStringUtils;
 import org.junit.Test;
 
 import java.io.*;
@@ -61,8 +60,8 @@ public void testCompareVersions() throws IOException {
             versions.add(Arrays.asList(values));
         }
         for(List<String> version : versions) {
-            assertTrue(Semver.build(version.get(0)).Compare(Semver.build(version.get(1))) == 1);
-            assertTrue(Semver.build(version.get(1)).Compare(Semver.build(version.get(0))) == -1);
+            assertTrue(Semver.build(version.get(0)).compare(Semver.build(version.get(1))) == 1);
+            assertTrue(Semver.build(version.get(1)).compare(Semver.build(version.get(0))) == -1);
         }
 
         versions.clear();
@@ -78,9 +77,9 @@ public void testCompareVersions() throws IOException {
             Semver version2 = Semver.build(version.get(1));
 
             if (version.get(2).equals("true")) {
-                assertTrue(version1.Version().equals(version2.Version()));
+                assertTrue(version1.version().equals(version2.version()));
             } else {
-                assertTrue(!version1.Version().equals(version2.Version()));
+                assertTrue(!version1.version().equals(version2.version()));
             }
         }
 
@@ -98,16 +97,16 @@ public void testCompareVersions() throws IOException {
             Semver version3 = Semver.build(version.get(2));
 
             if (version.get(3).equals("true")) {
-                assertTrue(version2.Compare(version1) >= 0 && version3.Compare(version2) >= 0);
+                assertTrue(version2.compare(version1) >= 0 && version3.compare(version2) >= 0);
             } else {
-                assertTrue(version2.Compare(version1) < 0 || version3.Compare(version2) < 0);
+                assertTrue(version2.compare(version1) < 0 || version3.compare(version2) < 0);
             }
         }
 
     }
     @Test
     public void testLeadingZeros() {
-        assertTrue(Semver.build("1.01.2").Version().equals("1\\.1\\.2"));
-        assertTrue(Semver.build("1.01.2-rc.01").Version().equals("1\\.1\\.2-rc\\.1"));
+        assertTrue(Semver.build("1.01.2").version().equals("1\\.1\\.2"));
+        assertTrue(Semver.build("1.01.2-rc.01").version().equals("1\\.1\\.2-rc\\.1"));
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -14,22 +14,22 @@ public EqualToSemverMatcher(String semVer) {`
`14`	`14`
`15`	`15`	`@Override`
`16`	`16`	`public boolean match(Object matchValue, String bucketingKey, Map<String, Object> attributes, EvaluationContext evaluationContext) {`
`17`		`- if (matchValue == null \|\| _semVer == null) {`
	`17`	`+ if (!(matchValue instanceof String) \|\| _semVer == null) {`
`18`	`18`	`return false;`
`19`	`19`	`}`
`20`	`20`	`Semver matchSemver = Semver.build(matchValue.toString());`
`21`	`21`	`if (matchSemver == null) {`
`22`	`22`	`return false;`
`23`	`23`	`}`
`24`	`24`
`25`		`- return matchSemver.Version().equals(_semVer.Version());`
	`25`	`+ return matchSemver.version().equals(_semVer.version());`
`26`	`26`	`}`
`27`	`27`
`28`	`28`	`@Override`
`29`	`29`	`public String toString() {`
`30`	`30`	`StringBuilder bldr = new StringBuilder();`
`31`	`31`	`bldr.append("== semver ");`
`32`		`- bldr.append(_semVer.Version());`
	`32`	`+ bldr.append(_semVer.version());`
`33`	`33`	`return bldr.toString();`
`34`	`34`	`}`
`35`	`35`
Original file line number	Diff line number	Diff line change
`@@ -14,22 +14,22 @@ public GreaterThanOrEqualToSemverMatcher(String semVer) {`
`14`	`14`
`15`	`15`	`@Override`
`16`	`16`	`public boolean match(Object matchValue, String bucketingKey, Map<String, Object> attributes, EvaluationContext evaluationContext) {`
`17`		`- if (matchValue == null \|\| _semVer == null \|\| !(matchValue instanceof String)) {`
	`17`	`+ if (!(matchValue instanceof String)\|\| _semVer == null) {`
`18`	`18`	`return false;`
`19`	`19`	`}`
`20`	`20`	`Semver matchSemver = Semver.build(matchValue.toString());`
`21`	`21`	`if (matchSemver == null) {`
`22`	`22`	`return false;`
`23`	`23`	`}`
`24`	`24`
`25`		`- return matchSemver.Compare(_semVer) >= 0;`
	`25`	`+ return matchSemver.compare(_semVer) >= 0;`
`26`	`26`	`}`
`27`	`27`
`28`	`28`	`@Override`
`29`	`29`	`public String toString() {`
`30`	`30`	`StringBuilder bldr = new StringBuilder();`
`31`	`31`	`bldr.append(">= semver ");`
`32`		`- bldr.append(_semVer.Version());`
	`32`	`+ bldr.append(_semVer.version());`
`33`	`33`	`return bldr.toString();`
`34`	`34`	`}`
`35`	`35`
Original file line number	Diff line number	Diff line change
`@@ -22,7 +22,7 @@ public InListSemverMatcher(Collection<String> whitelist) {`
`22`	`22`
`23`	`23`	`@Override`
`24`	`24`	`public boolean match(Object matchValue, String bucketingKey, Map<String, Object> attributes, EvaluationContext evaluationContext) {`
`25`		`- if (matchValue == null \|\| !(matchValue instanceof String) \|\| _semverlist.isEmpty()) {`
	`25`	`+ if (!(matchValue instanceof String) \|\| _semverlist.isEmpty()) {`
`26`	`26`	`return false;`
`27`	`27`	`}`
`28`	`28`	`Semver matchSemver = Semver.build(matchValue.toString());`
`@@ -31,7 +31,7 @@ public boolean match(Object matchValue, String bucketingKey, Map<String, Object>`
`31`	`31`	`}`
`32`	`32`
`33`	`33`	`for (Semver semverItem : _semverlist) {`
`34`		`- if (semverItem.Version().equals(matchSemver.Version())) return true;`
	`34`	`+ if (semverItem.version().equals(matchSemver.version())) return true;`
`35`	`35`	`}`
`36`	`36`	`return false;`
`37`	`37`	`}`
`@@ -47,7 +47,7 @@ public String toString() {`
`47`	`47`	`bldr.append(',');`
`48`	`48`	`}`
`49`	`49`	`bldr.append('"');`
`50`		`- bldr.append(item.Version());`
	`50`	`+ bldr.append(item.version());`
`51`	`51`	`bldr.append('"');`
`52`	`52`	`first = false;`
`53`	`53`	`}`
Original file line number	Diff line number	Diff line change
`@@ -14,22 +14,22 @@ public LessThanOrEqualToSemverMatcher(String semVer) {`
`14`	`14`
`15`	`15`	`@Override`
`16`	`16`	`public boolean match(Object matchValue, String bucketingKey, Map<String, Object> attributes, EvaluationContext evaluationContext) {`
`17`		`- if (matchValue == null \|\| !(matchValue instanceof String) \|\| _semVer == null) {`
	`17`	`+ if (!(matchValue instanceof String) \|\| _semVer == null) {`
`18`	`18`	`return false;`
`19`	`19`	`}`
`20`	`20`	`Semver matchSemver = Semver.build(matchValue.toString());`
`21`	`21`	`if (matchSemver == null) {`
`22`	`22`	`return false;`
`23`	`23`	`}`
`24`	`24`
`25`		`- return matchSemver.Compare(_semVer) <= 0;`
	`25`	`+ return matchSemver.compare(_semVer) <= 0;`
`26`	`26`	`}`
`27`	`27`
`28`	`28`	`@Override`
`29`	`29`	`public String toString() {`
`30`	`30`	`StringBuilder bldr = new StringBuilder();`
`31`	`31`	`bldr.append("<= semver ");`
`32`		`- bldr.append(_semVer.Version());`
	`32`	`+ bldr.append(_semVer.version());`
`33`	`33`	`return bldr.toString();`
`34`	`34`	`}`
`35`	`35`
Original file line number	Diff line number	Diff line change
`@@ -7,9 +7,9 @@`
`7`	`7`	`import java.util.Arrays;`
`8`	`8`
`9`	`9`	`public class Semver {`
`10`		`- private static final String MetadataDelimiter = "+";`
`11`		`- private static final String PreReleaseDelimiter = "-";`
`12`		`- private static final String ValueDelimiter = "\\.";`
	`10`	`+ private static final String METADATA_DELIMITER = "+";`
	`11`	`+ private static final String PRERELEASE_DELIMITER = "-";`
	`12`	`+ private static final String VALUE_DELIMITER = "\\.";`
`13`	`13`	`private static final Logger _log = LoggerFactory.getLogger(Semver.class);`
`14`	`14`
`15`	`15`	`private Long _major;`
`@@ -30,31 +30,31 @@ public static Semver build(String version) {`
`30`	`30`	`}`
`31`	`31`	`}`
`32`	`32`
`33`		`- public String Version() {`
	`33`	`+ public String version() {`
`34`	`34`	`return _version;`
`35`	`35`	`}`
`36`	`36`
`37`		`- public Long Major() {`
	`37`	`+ public Long major() {`
`38`	`38`	`return _major;`
`39`	`39`	`}`
`40`	`40`
`41`		`- public Long Minor() {`
	`41`	`+ public Long minor() {`
`42`	`42`	`return _minor;`
`43`	`43`	`}`
`44`	`44`
`45`		`- public Long Patch() {`
	`45`	`+ public Long patch() {`
`46`	`46`	`return _patch;`
`47`	`47`	`}`
`48`	`48`
`49`		`- public String[] PreRelease() {`
	`49`	`+ public String[] prerelease() {`
`50`	`50`	`return _preRelease;`
`51`	`51`	`}`
`52`	`52`
`53`		`- public String Metadata() {`
	`53`	`+ public String metadata() {`
`54`	`54`	`return _metadata;`
`55`	`55`	`}`
`56`	`56`
`57`		`- public boolean IsStable() {`
	`57`	`+ public boolean isStable() {`
`58`	`58`	`return _isStable;`
`59`	`59`	`}`
`60`	`60`
`@@ -65,44 +65,44 @@ public boolean IsStable() {`
`65`	`65`	`* a value less than {@code 0} if {@code this < toCompare}; and`
`66`	`66`	`* a value greater than {@code 0} if {@code this > toCompare}`
`67`	`67`	`*/`
`68`		`- public int Compare(Semver toCompare) {`
`69`		`- if (_version.equals(toCompare.Version())) {`
	`68`	`+ public int compare(Semver toCompare) {`
	`69`	`+ if (_version.equals(toCompare.version())) {`
`70`	`70`	`return 0;`
`71`	`71`	`}`
`72`	`72`	`// Compare major, minor, and patch versions numerically`
`73`		`- int result = Long.compare(_major, toCompare.Major());`
	`73`	`+ int result = Long.compare(_major, toCompare.major());`
`74`	`74`	`if (result != 0) {`
`75`	`75`	`return result;`
`76`	`76`	`}`
`77`		`- result = Long.compare(_minor, toCompare.Minor());`
	`77`	`+ result = Long.compare(_minor, toCompare.minor());`
`78`	`78`	`if (result != 0) {`
`79`	`79`	`return result;`
`80`	`80`	`}`
`81`		`- result = Long.compare(_patch, toCompare.Patch());`
	`81`	`+ result = Long.compare(_patch, toCompare.patch());`
`82`	`82`	`if (result != 0) {`
`83`	`83`	`return result;`
`84`	`84`	`}`
`85`		`- if (!_isStable && toCompare.IsStable()) {`
	`85`	`+ if (!_isStable && toCompare.isStable()) {`
`86`	`86`	`return -1;`
`87`		`- } else if (_isStable && !toCompare.IsStable()) {`
	`87`	`+ } else if (_isStable && !toCompare.isStable()) {`
`88`	`88`	`return 1;`
`89`	`89`	`}`
`90`	`90`	`// Compare pre-release versions lexically`
`91`		`- int minLength = Math.min(_preRelease.length, toCompare.PreRelease().length);`
	`91`	`+ int minLength = Math.min(_preRelease.length, toCompare.prerelease().length);`
`92`	`92`	`for (int i = 0; i < minLength; i++) {`
`93`		`- if (_preRelease[i].equals(toCompare.PreRelease()[i])) {`
	`93`	`+ if (_preRelease[i].equals(toCompare.prerelease()[i])) {`
`94`	`94`	`continue;`
`95`	`95`	`}`
`96`	`96`	`if ( isNumeric(_preRelease[i]) && isNumeric(toCompare._preRelease[i])) {`
`97`	`97`	`return Long.compare(Integer.parseInt(_preRelease[i]), Long.parseLong(toCompare._preRelease[i]));`
`98`	`98`	`}`
`99`		`- return AdjustNumber(_preRelease[i].compareTo(toCompare._preRelease[i]));`
	`99`	`+ return adjustNumber(_preRelease[i].compareTo(toCompare._preRelease[i]));`
`100`	`100`	`}`
`101`	`101`	`// Compare lengths of pre-release versions`
`102`	`102`	`return Integer.compare(_preRelease.length, toCompare._preRelease.length);`
`103`	`103`	`}`
`104`	`104`
`105`		`- private int AdjustNumber(int number) {`
	`105`	`+ private int adjustNumber(int number) {`
`106`	`106`	`if (number > 0) return 1;`
`107`	`107`	`if (number < 0) return -1;`
`108`	`108`	`return 0;`
`@@ -114,7 +114,7 @@ private Semver(String version) throws SemverParseException {`
`114`	`114`	`_version = setVersion();`
`115`	`115`	`}`
`116`	`116`	`private String setAndRemoveMetadataIfExists(String version) throws SemverParseException {`
`117`		`- int index = version.indexOf(MetadataDelimiter);`
	`117`	`+ int index = version.indexOf(METADATA_DELIMITER);`
`118`	`118`	`if (index == -1) {`
`119`	`119`	`return version;`
`120`	`120`	`}`
`@@ -125,20 +125,20 @@ private String setAndRemoveMetadataIfExists(String version) throws SemverParseEx`
`125`	`125`	`return version.substring(0, index);`
`126`	`126`	`}`
`127`	`127`	`private String setAndRemovePreReleaseIfExists(String vWithoutMetadata) throws SemverParseException {`
`128`		`- int index = vWithoutMetadata.indexOf(PreReleaseDelimiter);`
	`128`	`+ int index = vWithoutMetadata.indexOf(PRERELEASE_DELIMITER);`
`129`	`129`	`if (index == -1) {`
`130`	`130`	`_isStable = true;`
`131`	`131`	`return vWithoutMetadata;`
`132`	`132`	`}`
`133`	`133`	`String preReleaseData = vWithoutMetadata.substring(index+1);`
`134`		`- _preRelease = preReleaseData.split(ValueDelimiter);`
	`134`	`+ _preRelease = preReleaseData.split(VALUE_DELIMITER);`
`135`	`135`	`if (_preRelease == null \|\| Arrays.stream(_preRelease).allMatch(pr -> pr == null \|\| pr.isEmpty())) {`
`136`	`136`	`throw new SemverParseException("Unable to convert to Semver, incorrect pre release data");`
`137`	`137`	`}`
`138`	`138`	`return vWithoutMetadata.substring(0, index);`
`139`	`139`	`}`
`140`	`140`	`private void setMajorMinorAndPatch(String version) throws SemverParseException {`
`141`		`- String[] vParts = version.split(ValueDelimiter);`
	`141`	`+ String[] vParts = version.split(VALUE_DELIMITER);`
`142`	`142`	`if (vParts.length != 3)`
`143`	`143`	`throw new SemverParseException("Unable to convert to Semver, incorrect format: " + version);`
`144`	`144`	`_major = Long.parseLong(vParts[0]);`
`@@ -147,7 +147,7 @@ private void setMajorMinorAndPatch(String version) throws SemverParseException {`
`147`	`147`	`}`
`148`	`148`
`149`	`149`	`private String setVersion() {`
`150`		`- String toReturn = _major + ValueDelimiter + _minor + ValueDelimiter + _patch;`
	`150`	`+ String toReturn = _major + VALUE_DELIMITER + _minor + VALUE_DELIMITER + _patch;`
`151`	`151`	`if (_preRelease != null && _preRelease.length != 0)`
`152`	`152`	`{`
`153`	`153`	`for (int i = 0; i < _preRelease.length; i++)`
`@@ -157,10 +157,10 @@ private String setVersion() {`
`157`	`157`	`_preRelease[i] = Long.toString(Long.parseLong(_preRelease[i]));`
`158`	`158`	`}`
`159`	`159`	`}`
`160`		`- toReturn = toReturn + PreReleaseDelimiter + String.join(ValueDelimiter, _preRelease);`
	`160`	`+ toReturn = toReturn + PRERELEASE_DELIMITER + String.join(VALUE_DELIMITER, _preRelease);`
`161`	`161`	`}`
`162`	`162`	`if (_metadata != null && !_metadata.isEmpty()) {`
`163`		`- toReturn = toReturn + MetadataDelimiter + _metadata;`
	`163`	`+ toReturn = toReturn + METADATA_DELIMITER + _metadata;`
`164`	`164`	`}`
`165`	`165`	`return toReturn;`
`166`	`166`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,5 @@`
`1`	`1`	`package io.split.engine.matchers;`
`2`	`2`
`3`		`-import org.apache.commons.lang3.RandomStringUtils;`
`4`	`3`	`import org.junit.Test;`
`5`	`4`
`6`	`5`	`import java.io.*;`
`@@ -61,8 +60,8 @@ public void testCompareVersions() throws IOException {`
`61`	`60`	`versions.add(Arrays.asList(values));`
`62`	`61`	`}`
`63`	`62`	`for(List<String> version : versions) {`
`64`		`- assertTrue(Semver.build(version.get(0)).Compare(Semver.build(version.get(1))) == 1);`
`65`		`- assertTrue(Semver.build(version.get(1)).Compare(Semver.build(version.get(0))) == -1);`
	`63`	`+ assertTrue(Semver.build(version.get(0)).compare(Semver.build(version.get(1))) == 1);`
	`64`	`+ assertTrue(Semver.build(version.get(1)).compare(Semver.build(version.get(0))) == -1);`
`66`	`65`	`}`
`67`	`66`
`68`	`67`	`versions.clear();`
`@@ -78,9 +77,9 @@ public void testCompareVersions() throws IOException {`
`78`	`77`	`Semver version2 = Semver.build(version.get(1));`
`79`	`78`
`80`	`79`	`if (version.get(2).equals("true")) {`
`81`		`- assertTrue(version1.Version().equals(version2.Version()));`
	`80`	`+ assertTrue(version1.version().equals(version2.version()));`
`82`	`81`	`} else {`
`83`		`- assertTrue(!version1.Version().equals(version2.Version()));`
	`82`	`+ assertTrue(!version1.version().equals(version2.version()));`
`84`	`83`	`}`
`85`	`84`	`}`
`86`	`85`
`@@ -98,16 +97,16 @@ public void testCompareVersions() throws IOException {`
`98`	`97`	`Semver version3 = Semver.build(version.get(2));`
`99`	`98`
`100`	`99`	`if (version.get(3).equals("true")) {`
`101`		`- assertTrue(version2.Compare(version1) >= 0 && version3.Compare(version2) >= 0);`
	`100`	`+ assertTrue(version2.compare(version1) >= 0 && version3.compare(version2) >= 0);`
`102`	`101`	`} else {`
`103`		`- assertTrue(version2.Compare(version1) < 0 \|\| version3.Compare(version2) < 0);`
	`102`	`+ assertTrue(version2.compare(version1) < 0 \|\| version3.compare(version2) < 0);`
`104`	`103`	`}`
`105`	`104`	`}`
`106`	`105`
`107`	`106`	`}`
`108`	`107`	`@Test`
`109`	`108`	`public void testLeadingZeros() {`
`110`		`- assertTrue(Semver.build("1.01.2").Version().equals("1\\.1\\.2"));`
`111`		`- assertTrue(Semver.build("1.01.2-rc.01").Version().equals("1\\.1\\.2-rc\\.1"));`
	`109`	`+ assertTrue(Semver.build("1.01.2").version().equals("1\\.1\\.2"));`
	`110`	`+ assertTrue(Semver.build("1.01.2-rc.01").version().equals("1\\.1\\.2-rc\\.1"));`
`112`	`111`	`}`
`113`	`112`	`}`