diff options
Diffstat (limited to 'framework/src/maven/apache-maven-3.3.3/maven-artifact/src/test')
3 files changed, 1184 insertions, 0 deletions
diff --git a/framework/src/maven/apache-maven-3.3.3/maven-artifact/src/test/java/org/apache/maven/artifact/versioning/ComparableVersionTest.java b/framework/src/maven/apache-maven-3.3.3/maven-artifact/src/test/java/org/apache/maven/artifact/versioning/ComparableVersionTest.java new file mode 100644 index 00000000..6cf372f7 --- /dev/null +++ b/framework/src/maven/apache-maven-3.3.3/maven-artifact/src/test/java/org/apache/maven/artifact/versioning/ComparableVersionTest.java @@ -0,0 +1,231 @@ +package org.apache.maven.artifact.versioning; + +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ + +import java.util.Locale; + +import junit.framework.TestCase; + +/** + * Test ComparableVersion. + * + * @author <a href="mailto:hboutemy@apache.org">Hervé Boutemy</a> + */ +@SuppressWarnings( "unchecked" ) +public class ComparableVersionTest + extends TestCase +{ + private Comparable newComparable( String version ) + { + ComparableVersion ret = new ComparableVersion( version ); + String canonical = ret.getCanonical(); + String parsedCanonical = new ComparableVersion( canonical ).getCanonical(); + + System.out.println( "canonical( " + version + " ) = " + canonical ); + assertEquals( "canonical( " + version + " ) = " + canonical + " -> canonical: " + parsedCanonical, canonical, + parsedCanonical ); + + return ret; + } + + private static final String[] VERSIONS_QUALIFIER = + { "1-alpha2snapshot", "1-alpha2", "1-alpha-123", "1-beta-2", "1-beta123", "1-m2", "1-m11", "1-rc", "1-cr2", + "1-rc123", "1-SNAPSHOT", "1", "1-sp", "1-sp2", "1-sp123", "1-abc", "1-def", "1-pom-1", "1-1-snapshot", + "1-1", "1-2", "1-123" }; + + private static final String[] VERSIONS_NUMBER = + { "2.0", "2-1", "2.0.a", "2.0.0.a", "2.0.2", "2.0.123", "2.1.0", "2.1-a", "2.1b", "2.1-c", "2.1-1", "2.1.0.1", + "2.2", "2.123", "11.a2", "11.a11", "11.b2", "11.b11", "11.m2", "11.m11", "11", "11.a", "11b", "11c", "11m" }; + + private void checkVersionsOrder( String[] versions ) + { + Comparable[] c = new Comparable[versions.length]; + for ( int i = 0; i < versions.length; i++ ) + { + c[i] = newComparable( versions[i] ); + } + + for ( int i = 1; i < versions.length; i++ ) + { + Comparable low = c[i - 1]; + for ( int j = i; j < versions.length; j++ ) + { + Comparable high = c[j]; + assertTrue( "expected " + low + " < " + high, low.compareTo( high ) < 0 ); + assertTrue( "expected " + high + " > " + low, high.compareTo( low ) > 0 ); + } + } + } + + private void checkVersionsEqual( String v1, String v2 ) + { + Comparable c1 = newComparable( v1 ); + Comparable c2 = newComparable( v2 ); + assertTrue( "expected " + v1 + " == " + v2, c1.compareTo( c2 ) == 0 ); + assertTrue( "expected " + v2 + " == " + v1, c2.compareTo( c1 ) == 0 ); + assertTrue( "expected same hashcode for " + v1 + " and " + v2, c1.hashCode() == c2.hashCode() ); + assertTrue( "expected " + v1 + ".equals( " + v2 + " )", c1.equals( c2 ) ); + assertTrue( "expected " + v2 + ".equals( " + v1 + " )", c2.equals( c1 ) ); + } + + private void checkVersionsOrder( String v1, String v2 ) + { + Comparable c1 = newComparable( v1 ); + Comparable c2 = newComparable( v2 ); + assertTrue( "expected " + v1 + " < " + v2, c1.compareTo( c2 ) < 0 ); + assertTrue( "expected " + v2 + " > " + v1, c2.compareTo( c1 ) > 0 ); + } + + public void testVersionsQualifier() + { + checkVersionsOrder( VERSIONS_QUALIFIER ); + } + + public void testVersionsNumber() + { + checkVersionsOrder( VERSIONS_NUMBER ); + } + + public void testVersionsEqual() + { + newComparable( "1.0-alpha" ); + checkVersionsEqual( "1", "1" ); + checkVersionsEqual( "1", "1.0" ); + checkVersionsEqual( "1", "1.0.0" ); + checkVersionsEqual( "1.0", "1.0.0" ); + checkVersionsEqual( "1", "1-0" ); + checkVersionsEqual( "1", "1.0-0" ); + checkVersionsEqual( "1.0", "1.0-0" ); + // no separator between number and character + checkVersionsEqual( "1a", "1-a" ); + checkVersionsEqual( "1a", "1.0-a" ); + checkVersionsEqual( "1a", "1.0.0-a" ); + checkVersionsEqual( "1.0a", "1-a" ); + checkVersionsEqual( "1.0.0a", "1-a" ); + checkVersionsEqual( "1x", "1-x" ); + checkVersionsEqual( "1x", "1.0-x" ); + checkVersionsEqual( "1x", "1.0.0-x" ); + checkVersionsEqual( "1.0x", "1-x" ); + checkVersionsEqual( "1.0.0x", "1-x" ); + + // aliases + checkVersionsEqual( "1ga", "1" ); + checkVersionsEqual( "1final", "1" ); + checkVersionsEqual( "1cr", "1rc" ); + + // special "aliases" a, b and m for alpha, beta and milestone + checkVersionsEqual( "1a1", "1-alpha-1" ); + checkVersionsEqual( "1b2", "1-beta-2" ); + checkVersionsEqual( "1m3", "1-milestone-3" ); + + // case insensitive + checkVersionsEqual( "1X", "1x" ); + checkVersionsEqual( "1A", "1a" ); + checkVersionsEqual( "1B", "1b" ); + checkVersionsEqual( "1M", "1m" ); + checkVersionsEqual( "1Ga", "1" ); + checkVersionsEqual( "1GA", "1" ); + checkVersionsEqual( "1Final", "1" ); + checkVersionsEqual( "1FinaL", "1" ); + checkVersionsEqual( "1FINAL", "1" ); + checkVersionsEqual( "1Cr", "1Rc" ); + checkVersionsEqual( "1cR", "1rC" ); + checkVersionsEqual( "1m3", "1Milestone3" ); + checkVersionsEqual( "1m3", "1MileStone3" ); + checkVersionsEqual( "1m3", "1MILESTONE3" ); + } + + public void testVersionComparing() + { + checkVersionsOrder( "1", "2" ); + checkVersionsOrder( "1.5", "2" ); + checkVersionsOrder( "1", "2.5" ); + checkVersionsOrder( "1.0", "1.1" ); + checkVersionsOrder( "1.1", "1.2" ); + checkVersionsOrder( "1.0.0", "1.1" ); + checkVersionsOrder( "1.0.1", "1.1" ); + checkVersionsOrder( "1.1", "1.2.0" ); + + checkVersionsOrder( "1.0-alpha-1", "1.0" ); + checkVersionsOrder( "1.0-alpha-1", "1.0-alpha-2" ); + checkVersionsOrder( "1.0-alpha-1", "1.0-beta-1" ); + + checkVersionsOrder( "1.0-beta-1", "1.0-SNAPSHOT" ); + checkVersionsOrder( "1.0-SNAPSHOT", "1.0" ); + checkVersionsOrder( "1.0-alpha-1-SNAPSHOT", "1.0-alpha-1" ); + + checkVersionsOrder( "1.0", "1.0-1" ); + checkVersionsOrder( "1.0-1", "1.0-2" ); + checkVersionsOrder( "1.0.0", "1.0-1" ); + + checkVersionsOrder( "2.0-1", "2.0.1" ); + checkVersionsOrder( "2.0.1-klm", "2.0.1-lmn" ); + checkVersionsOrder( "2.0.1", "2.0.1-xyz" ); + + checkVersionsOrder( "2.0.1", "2.0.1-123" ); + checkVersionsOrder( "2.0.1-xyz", "2.0.1-123" ); + } + + /** + * Test <a href="https://jira.codehaus.org/browse/MNG-5568">MNG-5568</a> edge case + * which was showing transitive inconsistency: since A > B and B > C then we should have A > C + * otherwise sorting a list of ComparableVersions() will in some cases throw runtime exception; + * see Netbeans issues <a href="https://netbeans.org/bugzilla/show_bug.cgi?id=240845">240845</a> and + * <a href="https://netbeans.org/bugzilla/show_bug.cgi?id=226100">226100</a> + */ + public void testMng5568() + { + String a = "6.1.0"; + String b = "6.1.0rc3"; + String c = "6.1H.5-beta"; // this is the unusual version string, with 'H' in the middle + + checkVersionsOrder( b, a ); // classical + checkVersionsOrder( b, c ); // now b < c, but before MNG-5568, we had b > c + checkVersionsOrder( a, c ); + } + + public void testLocaleIndependent() + { + Locale orig = Locale.getDefault(); + Locale[] locales = { Locale.ENGLISH, new Locale( "tr" ), Locale.getDefault() }; + try + { + for ( Locale locale : locales ) + { + Locale.setDefault( locale ); + checkVersionsEqual( "1-abcdefghijklmnopqrstuvwxyz", "1-ABCDEFGHIJKLMNOPQRSTUVWXYZ" ); + } + } + finally + { + Locale.setDefault( orig ); + } + } + + public void testReuse() + { + ComparableVersion c1 = new ComparableVersion( "1" ); + c1.parseVersion( "2" ); + + Comparable c2 = newComparable( "2" ); + + assertEquals( "reused instance should be equivalent to new instance", c1, c2 ); + } +} diff --git a/framework/src/maven/apache-maven-3.3.3/maven-artifact/src/test/java/org/apache/maven/artifact/versioning/DefaultArtifactVersionTest.java b/framework/src/maven/apache-maven-3.3.3/maven-artifact/src/test/java/org/apache/maven/artifact/versioning/DefaultArtifactVersionTest.java new file mode 100644 index 00000000..fc5a2742 --- /dev/null +++ b/framework/src/maven/apache-maven-3.3.3/maven-artifact/src/test/java/org/apache/maven/artifact/versioning/DefaultArtifactVersionTest.java @@ -0,0 +1,223 @@ +package org.apache.maven.artifact.versioning; + +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ + +import junit.framework.TestCase; + +/** + * Test DefaultArtifactVersion. + * + * @author <a href="mailto:brett@apache.org">Brett Porter</a> + */ +public class DefaultArtifactVersionTest + extends TestCase +{ + private ArtifactVersion newArtifactVersion( String version ) + { + return new DefaultArtifactVersion( version ); + } + + private void checkVersionParsing( String version, int major, int minor, int incremental, int buildnumber, + String qualifier ) + { + ArtifactVersion artifactVersion = newArtifactVersion( version ); + String parsed = + "'" + version + "' parsed as ('" + artifactVersion.getMajorVersion() + "', '" + + artifactVersion.getMinorVersion() + "', '" + artifactVersion.getIncrementalVersion() + "', '" + + artifactVersion.getBuildNumber() + "', '" + artifactVersion.getQualifier() + "'), "; + assertEquals( parsed + "check major version", major, artifactVersion.getMajorVersion() ); + assertEquals( parsed + "check minor version", minor, artifactVersion.getMinorVersion() ); + assertEquals( parsed + "check incremental version", incremental, artifactVersion.getIncrementalVersion() ); + assertEquals( parsed + "check build number", buildnumber, artifactVersion.getBuildNumber() ); + assertEquals( parsed + "check qualifier", qualifier, artifactVersion.getQualifier() ); + assertEquals( "check " + version + " string value", version, artifactVersion.toString() ); + } + + public void testVersionParsing() + { + checkVersionParsing( "1", 1, 0, 0, 0, null ); + checkVersionParsing( "1.2", 1, 2, 0, 0, null ); + checkVersionParsing( "1.2.3", 1, 2, 3, 0, null ); + checkVersionParsing( "1.2.3-1", 1, 2, 3, 1, null ); + checkVersionParsing( "1.2.3-alpha-1", 1, 2, 3, 0, "alpha-1" ); + checkVersionParsing( "1.2-alpha-1", 1, 2, 0, 0, "alpha-1" ); + checkVersionParsing( "1.2-alpha-1-20050205.060708-1", 1, 2, 0, 0, "alpha-1-20050205.060708-1" ); + checkVersionParsing( "RELEASE", 0, 0, 0, 0, "RELEASE" ); + checkVersionParsing( "2.0-1", 2, 0, 0, 1, null ); + + // 0 at the beginning of a number has a special handling + checkVersionParsing( "02", 0, 0, 0, 0, "02" ); + checkVersionParsing( "0.09", 0, 0, 0, 0, "0.09" ); + checkVersionParsing( "0.2.09", 0, 0, 0, 0, "0.2.09" ); + checkVersionParsing( "2.0-01", 2, 0, 0, 0, "01" ); + + // version schemes not really supported: fully transformed as qualifier + checkVersionParsing( "1.0.1b", 0, 0, 0, 0, "1.0.1b" ); + checkVersionParsing( "1.0M2", 0, 0, 0, 0, "1.0M2" ); + checkVersionParsing( "1.0RC2", 0, 0, 0, 0, "1.0RC2" ); + checkVersionParsing( "1.1.2.beta1", 1, 1, 2, 0, "beta1" ); + checkVersionParsing( "1.7.3.beta1", 1, 7, 3, 0, "beta1" ); + checkVersionParsing( "1.7.3.0", 0, 0, 0, 0, "1.7.3.0" ); + checkVersionParsing( "1.7.3.0-1", 0, 0, 0, 0, "1.7.3.0-1" ); + checkVersionParsing( "PATCH-1193602", 0, 0, 0, 0, "PATCH-1193602" ); + checkVersionParsing( "5.0.0alpha-2006020117", 0, 0, 0, 0, "5.0.0alpha-2006020117" ); + checkVersionParsing( "1.0.0.-SNAPSHOT", 0, 0, 0, 0, "1.0.0.-SNAPSHOT" ); + checkVersionParsing( "1..0-SNAPSHOT", 0, 0, 0, 0, "1..0-SNAPSHOT" ); + checkVersionParsing( "1.0.-SNAPSHOT", 0, 0, 0, 0, "1.0.-SNAPSHOT" ); + checkVersionParsing( ".1.0-SNAPSHOT", 0, 0, 0, 0, ".1.0-SNAPSHOT" ); + + checkVersionParsing( "1.2.3.200705301630", 0, 0, 0, 0, "1.2.3.200705301630" ); + checkVersionParsing( "1.2.3-200705301630", 1, 2, 3, 0, "200705301630" ); + } + + public void testVersionComparing() + { + assertVersionEqual( "1", "1" ); + assertVersionOlder( "1", "2" ); + assertVersionOlder( "1.5", "2" ); + assertVersionOlder( "1", "2.5" ); + assertVersionEqual( "1", "1.0" ); + assertVersionEqual( "1", "1.0.0" ); + assertVersionOlder( "1.0", "1.1" ); + assertVersionOlder( "1.1", "1.2" ); + assertVersionOlder( "1.0.0", "1.1" ); + assertVersionOlder( "1.1", "1.2.0" ); + + assertVersionOlder( "1.1.2.alpha1", "1.1.2" ); + assertVersionOlder( "1.1.2.alpha1", "1.1.2.beta1" ); + assertVersionOlder( "1.1.2.beta1", "1.2" ); + + assertVersionOlder( "1.0-alpha-1", "1.0" ); + assertVersionOlder( "1.0-alpha-1", "1.0-alpha-2" ); + assertVersionOlder( "1.0-alpha-2", "1.0-alpha-15" ); + assertVersionOlder( "1.0-alpha-1", "1.0-beta-1" ); + + assertVersionOlder( "1.0-beta-1", "1.0-SNAPSHOT" ); + assertVersionOlder( "1.0-SNAPSHOT", "1.0" ); + assertVersionOlder( "1.0-alpha-1-SNAPSHOT", "1.0-alpha-1" ); + + assertVersionOlder( "1.0", "1.0-1" ); + assertVersionOlder( "1.0-1", "1.0-2" ); + assertVersionEqual( "2.0-0", "2.0" ); + assertVersionOlder( "2.0", "2.0-1" ); + assertVersionOlder( "2.0.0", "2.0-1" ); + assertVersionOlder( "2.0-1", "2.0.1" ); + + assertVersionOlder( "2.0.1-klm", "2.0.1-lmn" ); + assertVersionOlder( "2.0.1", "2.0.1-xyz" ); + assertVersionOlder( "2.0.1-xyz-1", "2.0.1-1-xyz" ); + + assertVersionOlder( "2.0.1", "2.0.1-123" ); + assertVersionOlder( "2.0.1-xyz", "2.0.1-123" ); + + assertVersionOlder( "1.2.3-10000000000", "1.2.3-10000000001" ); + assertVersionOlder( "1.2.3-1", "1.2.3-10000000001" ); + assertVersionOlder( "2.3.0-v200706262000", "2.3.0-v200706262130" ); // org.eclipse:emf:2.3.0-v200706262000 + // org.eclipse.wst.common_core.feature_2.0.0.v200706041905-7C78EK9E_EkMNfNOd2d8qq + assertVersionOlder( "2.0.0.v200706041905-7C78EK9E_EkMNfNOd2d8qq", "2.0.0.v200706041906-7C78EK9E_EkMNfNOd2d8qq" ); + } + + public void testVersionSnapshotComparing() + { + assertVersionEqual( "1-SNAPSHOT", "1-SNAPSHOT" ); + assertVersionOlder( "1-SNAPSHOT", "2-SNAPSHOT" ); + assertVersionOlder( "1.5-SNAPSHOT", "2-SNAPSHOT" ); + assertVersionOlder( "1-SNAPSHOT", "2.5-SNAPSHOT" ); + assertVersionEqual( "1-SNAPSHOT", "1.0-SNAPSHOT" ); + assertVersionEqual( "1-SNAPSHOT", "1.0.0-SNAPSHOT" ); + assertVersionOlder( "1.0-SNAPSHOT", "1.1-SNAPSHOT" ); + assertVersionOlder( "1.1-SNAPSHOT", "1.2-SNAPSHOT" ); + assertVersionOlder( "1.0.0-SNAPSHOT", "1.1-SNAPSHOT" ); + assertVersionOlder( "1.1-SNAPSHOT", "1.2.0-SNAPSHOT" ); + + // assertVersionOlder( "1.0-alpha-1-SNAPSHOT", "1.0-SNAPSHOT" ); + assertVersionOlder( "1.0-alpha-1-SNAPSHOT", "1.0-alpha-2-SNAPSHOT" ); + assertVersionOlder( "1.0-alpha-1-SNAPSHOT", "1.0-beta-1-SNAPSHOT" ); + + assertVersionOlder( "1.0-beta-1-SNAPSHOT", "1.0-SNAPSHOT-SNAPSHOT" ); + assertVersionOlder( "1.0-SNAPSHOT-SNAPSHOT", "1.0-SNAPSHOT" ); + assertVersionOlder( "1.0-alpha-1-SNAPSHOT-SNAPSHOT", "1.0-alpha-1-SNAPSHOT" ); + + assertVersionOlder( "1.0-SNAPSHOT", "1.0-1-SNAPSHOT" ); + assertVersionOlder( "1.0-1-SNAPSHOT", "1.0-2-SNAPSHOT" ); + // assertVersionEqual( "2.0-0-SNAPSHOT", "2.0-SNAPSHOT" ); + assertVersionOlder( "2.0-SNAPSHOT", "2.0-1-SNAPSHOT" ); + assertVersionOlder( "2.0.0-SNAPSHOT", "2.0-1-SNAPSHOT" ); + assertVersionOlder( "2.0-1-SNAPSHOT", "2.0.1-SNAPSHOT" ); + + assertVersionOlder( "2.0.1-klm-SNAPSHOT", "2.0.1-lmn-SNAPSHOT" ); + // assertVersionOlder( "2.0.1-xyz-SNAPSHOT", "2.0.1-SNAPSHOT" ); + assertVersionOlder( "2.0.1-SNAPSHOT", "2.0.1-123-SNAPSHOT" ); + assertVersionOlder( "2.0.1-xyz-SNAPSHOT", "2.0.1-123-SNAPSHOT" ); + } + + public void testSnapshotVsReleases() + { + assertVersionOlder( "1.0-RC1", "1.0-SNAPSHOT" ); + assertVersionOlder( "1.0-rc1", "1.0-SNAPSHOT" ); + assertVersionOlder( "1.0-rc-1", "1.0-SNAPSHOT" ); + } + + public void testHashCode() + { + ArtifactVersion v1 = newArtifactVersion( "1" ); + ArtifactVersion v2 = newArtifactVersion( "1.0" ); + assertEquals( true, v1.equals( v2 ) ); + assertEquals( v1.hashCode(), v2.hashCode() ); + } + + public void testEqualsNullSafe() + { + assertFalse( newArtifactVersion( "1" ).equals( null ) ); + } + + public void testEqualsTypeSafe() + { + assertFalse( newArtifactVersion( "1" ).equals( "non-an-artifact-version-instance" ) ); + } + + public void testNonNumericVersionRepresentationReturnsANumberFormatException() + { + try + { + new DefaultArtifactVersion( "..." ); + } + catch ( Exception e ) + { + assertTrue( "We expect a NumberFormatException to be thrown.", e instanceof NumberFormatException ); + } + } + + private void assertVersionOlder( String left, String right ) + { + assertTrue( left + " should be older than " + right, + newArtifactVersion( left ).compareTo( newArtifactVersion( right ) ) < 0 ); + assertTrue( right + " should be newer than " + left, + newArtifactVersion( right ).compareTo( newArtifactVersion( left ) ) > 0 ); + } + + private void assertVersionEqual( String left, String right ) + { + assertTrue( left + " should be equal to " + right, + newArtifactVersion( left ).compareTo( newArtifactVersion( right ) ) == 0 ); + assertTrue( right + " should be equal to " + left, + newArtifactVersion( right ).compareTo( newArtifactVersion( left ) ) == 0 ); + } +} diff --git a/framework/src/maven/apache-maven-3.3.3/maven-artifact/src/test/java/org/apache/maven/artifact/versioning/VersionRangeTest.java b/framework/src/maven/apache-maven-3.3.3/maven-artifact/src/test/java/org/apache/maven/artifact/versioning/VersionRangeTest.java new file mode 100644 index 00000000..14b16cba --- /dev/null +++ b/framework/src/maven/apache-maven-3.3.3/maven-artifact/src/test/java/org/apache/maven/artifact/versioning/VersionRangeTest.java @@ -0,0 +1,730 @@ +package org.apache.maven.artifact.versioning; + +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ + +import java.util.List; + +import junit.framework.TestCase; + +import org.apache.maven.artifact.Artifact; + +/** + * Tests version range construction. + * + * @author <a href="mailto:brett@apache.org">Brett Porter</a> + */ +public class VersionRangeTest + extends TestCase +{ + private static final String CHECK_NUM_RESTRICTIONS = "check number of restrictions"; + + private static final String CHECK_UPPER_BOUND = "check upper bound"; + + private static final String CHECK_UPPER_BOUND_INCLUSIVE = "check upper bound is inclusive"; + + private static final String CHECK_LOWER_BOUND = "check lower bound"; + + private static final String CHECK_LOWER_BOUND_INCLUSIVE = "check lower bound is inclusive"; + + private static final String CHECK_VERSION_RECOMMENDATION = "check version recommended"; + + private static final String CHECK_SELECTED_VERSION_KNOWN = "check selected version known"; + + private static final String CHECK_SELECTED_VERSION = "check selected version"; + + public void testRange() + throws InvalidVersionSpecificationException, OverConstrainedVersionException + { + Artifact artifact = null; + + VersionRange range = VersionRange.createFromVersionSpec( "(,1.0]" ); + List<Restriction> restrictions = range.getRestrictions(); + assertEquals( CHECK_NUM_RESTRICTIONS, 1, restrictions.size() ); + Restriction restriction = restrictions.get( 0 ); + assertNull( CHECK_LOWER_BOUND, restriction.getLowerBound() ); + assertFalse( CHECK_LOWER_BOUND_INCLUSIVE, restriction.isLowerBoundInclusive() ); + assertEquals( CHECK_UPPER_BOUND, "1.0", restriction.getUpperBound().toString() ); + assertTrue( CHECK_UPPER_BOUND_INCLUSIVE, restriction.isUpperBoundInclusive() ); + assertNull( CHECK_VERSION_RECOMMENDATION, range.getRecommendedVersion() ); + assertFalse( CHECK_SELECTED_VERSION_KNOWN, range.isSelectedVersionKnown( artifact ) ); + assertNull( CHECK_SELECTED_VERSION, range.getSelectedVersion( artifact ) ); + + range = VersionRange.createFromVersionSpec( "1.0" ); + assertEquals( CHECK_VERSION_RECOMMENDATION, "1.0", range.getRecommendedVersion().toString() ); + restrictions = range.getRestrictions(); + assertEquals( CHECK_NUM_RESTRICTIONS, 1, restrictions.size() ); + restriction = restrictions.get( 0 ); + assertNull( CHECK_LOWER_BOUND, restriction.getLowerBound() ); + assertFalse( CHECK_LOWER_BOUND_INCLUSIVE, restriction.isLowerBoundInclusive() ); + assertNull( CHECK_UPPER_BOUND, restriction.getUpperBound() ); + assertFalse( CHECK_UPPER_BOUND_INCLUSIVE, restriction.isUpperBoundInclusive() ); + assertTrue( CHECK_SELECTED_VERSION_KNOWN, range.isSelectedVersionKnown( artifact ) ); + assertEquals( CHECK_SELECTED_VERSION, "1.0", range.getSelectedVersion( artifact ).toString() ); + + range = VersionRange.createFromVersionSpec( "[1.0]" ); + restrictions = range.getRestrictions(); + assertEquals( CHECK_NUM_RESTRICTIONS, 1, restrictions.size() ); + restriction = restrictions.get( 0 ); + assertEquals( CHECK_LOWER_BOUND, "1.0", restriction.getLowerBound().toString() ); + assertTrue( CHECK_LOWER_BOUND_INCLUSIVE, restriction.isLowerBoundInclusive() ); + assertEquals( CHECK_UPPER_BOUND, "1.0", restriction.getUpperBound().toString() ); + assertTrue( CHECK_UPPER_BOUND_INCLUSIVE, restriction.isUpperBoundInclusive() ); + assertNull( CHECK_VERSION_RECOMMENDATION, range.getRecommendedVersion() ); + assertFalse( CHECK_SELECTED_VERSION_KNOWN, range.isSelectedVersionKnown( artifact ) ); + assertNull( CHECK_SELECTED_VERSION, range.getSelectedVersion( artifact ) ); + + range = VersionRange.createFromVersionSpec( "[1.2,1.3]" ); + restrictions = range.getRestrictions(); + assertEquals( CHECK_NUM_RESTRICTIONS, 1, restrictions.size() ); + restriction = restrictions.get( 0 ); + assertEquals( CHECK_LOWER_BOUND, "1.2", restriction.getLowerBound().toString() ); + assertTrue( CHECK_LOWER_BOUND_INCLUSIVE, restriction.isLowerBoundInclusive() ); + assertEquals( CHECK_UPPER_BOUND, "1.3", restriction.getUpperBound().toString() ); + assertTrue( CHECK_UPPER_BOUND_INCLUSIVE, restriction.isUpperBoundInclusive() ); + assertNull( CHECK_VERSION_RECOMMENDATION, range.getRecommendedVersion() ); + assertFalse( CHECK_SELECTED_VERSION_KNOWN, range.isSelectedVersionKnown( artifact ) ); + assertNull( CHECK_SELECTED_VERSION, range.getSelectedVersion( artifact ) ); + + range = VersionRange.createFromVersionSpec( "[1.0,2.0)" ); + restrictions = range.getRestrictions(); + assertEquals( CHECK_NUM_RESTRICTIONS, 1, restrictions.size() ); + restriction = restrictions.get( 0 ); + assertEquals( CHECK_LOWER_BOUND, "1.0", restriction.getLowerBound().toString() ); + assertTrue( CHECK_LOWER_BOUND_INCLUSIVE, restriction.isLowerBoundInclusive() ); + assertEquals( CHECK_UPPER_BOUND, "2.0", restriction.getUpperBound().toString() ); + assertFalse( CHECK_UPPER_BOUND_INCLUSIVE, restriction.isUpperBoundInclusive() ); + assertNull( CHECK_VERSION_RECOMMENDATION, range.getRecommendedVersion() ); + assertFalse( CHECK_SELECTED_VERSION_KNOWN, range.isSelectedVersionKnown( artifact ) ); + assertNull( CHECK_SELECTED_VERSION, range.getSelectedVersion( artifact ) ); + + range = VersionRange.createFromVersionSpec( "[1.5,)" ); + restrictions = range.getRestrictions(); + assertEquals( CHECK_NUM_RESTRICTIONS, 1, restrictions.size() ); + restriction = restrictions.get( 0 ); + assertEquals( CHECK_LOWER_BOUND, "1.5", restriction.getLowerBound().toString() ); + assertTrue( CHECK_LOWER_BOUND_INCLUSIVE, restriction.isLowerBoundInclusive() ); + assertNull( CHECK_UPPER_BOUND, restriction.getUpperBound() ); + assertFalse( CHECK_UPPER_BOUND_INCLUSIVE, restriction.isUpperBoundInclusive() ); + assertNull( CHECK_VERSION_RECOMMENDATION, range.getRecommendedVersion() ); + assertFalse( CHECK_SELECTED_VERSION_KNOWN, range.isSelectedVersionKnown( artifact ) ); + assertNull( CHECK_SELECTED_VERSION, range.getSelectedVersion( artifact ) ); + + range = VersionRange.createFromVersionSpec( "(,1.0],[1.2,)" ); + restrictions = range.getRestrictions(); + assertEquals( CHECK_NUM_RESTRICTIONS, 2, restrictions.size() ); + restriction = restrictions.get( 0 ); + assertNull( CHECK_LOWER_BOUND, restriction.getLowerBound() ); + assertFalse( CHECK_LOWER_BOUND_INCLUSIVE, restriction.isLowerBoundInclusive() ); + assertEquals( CHECK_UPPER_BOUND, "1.0", restriction.getUpperBound().toString() ); + assertTrue( CHECK_UPPER_BOUND_INCLUSIVE, restriction.isUpperBoundInclusive() ); + assertNull( CHECK_VERSION_RECOMMENDATION, range.getRecommendedVersion() ); + restriction = restrictions.get( 1 ); + assertEquals( CHECK_LOWER_BOUND, "1.2", restriction.getLowerBound().toString() ); + assertTrue( CHECK_LOWER_BOUND_INCLUSIVE, restriction.isLowerBoundInclusive() ); + assertNull( CHECK_UPPER_BOUND, restriction.getUpperBound() ); + assertFalse( CHECK_UPPER_BOUND_INCLUSIVE, restriction.isUpperBoundInclusive() ); + assertNull( CHECK_VERSION_RECOMMENDATION, range.getRecommendedVersion() ); + assertFalse( CHECK_SELECTED_VERSION_KNOWN, range.isSelectedVersionKnown( artifact ) ); + assertNull( CHECK_SELECTED_VERSION, range.getSelectedVersion( artifact ) ); + + range = VersionRange.createFromVersionSpec( "[1.0,)" ); + assertFalse( range.containsVersion( new DefaultArtifactVersion( "1.0-SNAPSHOT" ) ) ); + + range = VersionRange.createFromVersionSpec( "[1.0,1.1-SNAPSHOT]" ); + assertTrue( range.containsVersion( new DefaultArtifactVersion( "1.1-SNAPSHOT" ) ) ); + + range = VersionRange.createFromVersionSpec( "[5.0.9.0,5.0.10.0)" ); + assertTrue( range.containsVersion( new DefaultArtifactVersion( "5.0.9.0" ) ) ); + } + + public void testInvalidRanges() + { + checkInvalidRange( "(1.0)" ); + checkInvalidRange( "[1.0)" ); + checkInvalidRange( "(1.0]" ); + checkInvalidRange( "(1.0,1.0]" ); + checkInvalidRange( "[1.0,1.0)" ); + checkInvalidRange( "(1.0,1.0)" ); + checkInvalidRange( "[1.1,1.0]" ); + checkInvalidRange( "[1.0,1.2),1.3" ); + // overlap + checkInvalidRange( "[1.0,1.2),(1.1,1.3]" ); + // overlap + checkInvalidRange( "[1.1,1.3),(1.0,1.2]" ); + // ordering + checkInvalidRange( "(1.1,1.2],[1.0,1.1)" ); + } + + public void testIntersections() + throws InvalidVersionSpecificationException + { + VersionRange range1 = VersionRange.createFromVersionSpec( "1.0" ); + VersionRange range2 = VersionRange.createFromVersionSpec( "1.1" ); + VersionRange mergedRange = range1.restrict( range2 ); + // TODO: current policy is to retain the original version - is this correct, do we need strategies or is that handled elsewhere? +// assertEquals( CHECK_VERSION_RECOMMENDATION, "1.1", mergedRange.getRecommendedVersion().toString() ); + assertEquals( CHECK_VERSION_RECOMMENDATION, "1.0", mergedRange.getRecommendedVersion().toString() ); + List<Restriction> restrictions = mergedRange.getRestrictions(); + assertEquals( CHECK_NUM_RESTRICTIONS, 1, restrictions.size() ); + Restriction restriction = restrictions.get( 0 ); + assertNull( CHECK_LOWER_BOUND, restriction.getLowerBound() ); + assertFalse( CHECK_LOWER_BOUND_INCLUSIVE, restriction.isLowerBoundInclusive() ); + assertNull( CHECK_UPPER_BOUND, restriction.getUpperBound() ); + assertFalse( CHECK_UPPER_BOUND_INCLUSIVE, restriction.isUpperBoundInclusive() ); + + mergedRange = range2.restrict( range1 ); + assertEquals( CHECK_VERSION_RECOMMENDATION, "1.1", mergedRange.getRecommendedVersion().toString() ); + restrictions = mergedRange.getRestrictions(); + assertEquals( CHECK_NUM_RESTRICTIONS, 1, restrictions.size() ); + restriction = restrictions.get( 0 ); + assertNull( CHECK_LOWER_BOUND, restriction.getLowerBound() ); + assertFalse( CHECK_LOWER_BOUND_INCLUSIVE, restriction.isLowerBoundInclusive() ); + assertNull( CHECK_UPPER_BOUND, restriction.getUpperBound() ); + assertFalse( CHECK_UPPER_BOUND_INCLUSIVE, restriction.isUpperBoundInclusive() ); + + // TODO: test reversed restrictions on all below + range1 = VersionRange.createFromVersionSpec( "[1.0,)" ); + range2 = VersionRange.createFromVersionSpec( "1.1" ); + mergedRange = range1.restrict( range2 ); + assertEquals( CHECK_VERSION_RECOMMENDATION, "1.1", mergedRange.getRecommendedVersion().toString() ); + restrictions = mergedRange.getRestrictions(); + assertEquals( CHECK_NUM_RESTRICTIONS, 1, restrictions.size() ); + restriction = restrictions.get( 0 ); + assertEquals( CHECK_LOWER_BOUND, "1.0", restriction.getLowerBound().toString() ); + assertTrue( CHECK_LOWER_BOUND_INCLUSIVE, restriction.isLowerBoundInclusive() ); + assertNull( CHECK_UPPER_BOUND, restriction.getUpperBound() ); + assertFalse( CHECK_UPPER_BOUND_INCLUSIVE, restriction.isUpperBoundInclusive() ); + + range1 = VersionRange.createFromVersionSpec( "[1.1,)" ); + range2 = VersionRange.createFromVersionSpec( "1.1" ); + mergedRange = range1.restrict( range2 ); + assertEquals( CHECK_VERSION_RECOMMENDATION, "1.1", mergedRange.getRecommendedVersion().toString() ); + restrictions = mergedRange.getRestrictions(); + assertEquals( CHECK_NUM_RESTRICTIONS, 1, restrictions.size() ); + restriction = restrictions.get( 0 ); + assertEquals( CHECK_LOWER_BOUND, "1.1", restriction.getLowerBound().toString() ); + assertTrue( CHECK_LOWER_BOUND_INCLUSIVE, restriction.isLowerBoundInclusive() ); + assertNull( CHECK_UPPER_BOUND, restriction.getUpperBound() ); + assertFalse( CHECK_UPPER_BOUND_INCLUSIVE, restriction.isUpperBoundInclusive() ); + + range1 = VersionRange.createFromVersionSpec( "[1.1]" ); + range2 = VersionRange.createFromVersionSpec( "1.1" ); + mergedRange = range1.restrict( range2 ); + assertEquals( CHECK_VERSION_RECOMMENDATION, "1.1", mergedRange.getRecommendedVersion().toString() ); + restrictions = mergedRange.getRestrictions(); + assertEquals( CHECK_NUM_RESTRICTIONS, 1, restrictions.size() ); + restriction = restrictions.get( 0 ); + assertEquals( CHECK_LOWER_BOUND, "1.1", restriction.getLowerBound().toString() ); + assertTrue( CHECK_LOWER_BOUND_INCLUSIVE, restriction.isLowerBoundInclusive() ); + assertEquals( CHECK_UPPER_BOUND, "1.1", restriction.getLowerBound().toString() ); + assertTrue( CHECK_UPPER_BOUND_INCLUSIVE, restriction.isUpperBoundInclusive() ); + + range1 = VersionRange.createFromVersionSpec( "(1.1,)" ); + range2 = VersionRange.createFromVersionSpec( "1.1" ); + mergedRange = range1.restrict( range2 ); + assertNull( CHECK_VERSION_RECOMMENDATION, mergedRange.getRecommendedVersion() ); + restrictions = mergedRange.getRestrictions(); + assertEquals( CHECK_NUM_RESTRICTIONS, 1, restrictions.size() ); + restriction = restrictions.get( 0 ); + assertEquals( CHECK_LOWER_BOUND, "1.1", restriction.getLowerBound().toString() ); + assertFalse( CHECK_LOWER_BOUND_INCLUSIVE, restriction.isLowerBoundInclusive() ); + assertNull( CHECK_UPPER_BOUND, restriction.getUpperBound() ); + assertFalse( CHECK_UPPER_BOUND_INCLUSIVE, restriction.isUpperBoundInclusive() ); + + range1 = VersionRange.createFromVersionSpec( "[1.2,)" ); + range2 = VersionRange.createFromVersionSpec( "1.1" ); + mergedRange = range1.restrict( range2 ); + assertNull( CHECK_VERSION_RECOMMENDATION, mergedRange.getRecommendedVersion() ); + restrictions = mergedRange.getRestrictions(); + assertEquals( CHECK_NUM_RESTRICTIONS, 1, restrictions.size() ); + restriction = restrictions.get( 0 ); + assertEquals( CHECK_LOWER_BOUND, "1.2", restriction.getLowerBound().toString() ); + assertTrue( CHECK_LOWER_BOUND_INCLUSIVE, restriction.isLowerBoundInclusive() ); + assertNull( CHECK_UPPER_BOUND, restriction.getUpperBound() ); + assertFalse( CHECK_UPPER_BOUND_INCLUSIVE, restriction.isUpperBoundInclusive() ); + + range1 = VersionRange.createFromVersionSpec( "(,1.2]" ); + range2 = VersionRange.createFromVersionSpec( "1.1" ); + mergedRange = range1.restrict( range2 ); + assertEquals( CHECK_VERSION_RECOMMENDATION, "1.1", mergedRange.getRecommendedVersion().toString() ); + restrictions = mergedRange.getRestrictions(); + assertEquals( CHECK_NUM_RESTRICTIONS, 1, restrictions.size() ); + restriction = restrictions.get( 0 ); + assertNull( CHECK_LOWER_BOUND, restriction.getLowerBound() ); + assertFalse( CHECK_LOWER_BOUND_INCLUSIVE, restriction.isLowerBoundInclusive() ); + assertEquals( CHECK_UPPER_BOUND, "1.2", restriction.getUpperBound().toString() ); + assertTrue( CHECK_UPPER_BOUND_INCLUSIVE, restriction.isUpperBoundInclusive() ); + + range1 = VersionRange.createFromVersionSpec( "(,1.1]" ); + range2 = VersionRange.createFromVersionSpec( "1.1" ); + mergedRange = range1.restrict( range2 ); + assertEquals( CHECK_VERSION_RECOMMENDATION, "1.1", mergedRange.getRecommendedVersion().toString() ); + restrictions = mergedRange.getRestrictions(); + assertEquals( CHECK_NUM_RESTRICTIONS, 1, restrictions.size() ); + restriction = restrictions.get( 0 ); + assertNull( CHECK_LOWER_BOUND, restriction.getLowerBound() ); + assertFalse( CHECK_LOWER_BOUND_INCLUSIVE, restriction.isLowerBoundInclusive() ); + assertEquals( CHECK_UPPER_BOUND, "1.1", restriction.getUpperBound().toString() ); + assertTrue( CHECK_UPPER_BOUND_INCLUSIVE, restriction.isUpperBoundInclusive() ); + + range1 = VersionRange.createFromVersionSpec( "(,1.1)" ); + range2 = VersionRange.createFromVersionSpec( "1.1" ); + mergedRange = range1.restrict( range2 ); + assertNull( CHECK_VERSION_RECOMMENDATION, mergedRange.getRecommendedVersion() ); + restrictions = mergedRange.getRestrictions(); + assertEquals( CHECK_NUM_RESTRICTIONS, 1, restrictions.size() ); + restriction = restrictions.get( 0 ); + assertNull( CHECK_LOWER_BOUND, restriction.getLowerBound() ); + assertFalse( CHECK_LOWER_BOUND_INCLUSIVE, restriction.isLowerBoundInclusive() ); + assertEquals( CHECK_UPPER_BOUND, "1.1", restriction.getUpperBound().toString() ); + assertFalse( CHECK_UPPER_BOUND_INCLUSIVE, restriction.isUpperBoundInclusive() ); + + range1 = VersionRange.createFromVersionSpec( "(,1.0]" ); + range2 = VersionRange.createFromVersionSpec( "1.1" ); + mergedRange = range1.restrict( range2 ); + assertNull( CHECK_VERSION_RECOMMENDATION, mergedRange.getRecommendedVersion() ); + restrictions = mergedRange.getRestrictions(); + assertEquals( CHECK_NUM_RESTRICTIONS, 1, restrictions.size() ); + restriction = restrictions.get( 0 ); + assertNull( CHECK_LOWER_BOUND, restriction.getLowerBound() ); + assertFalse( CHECK_LOWER_BOUND_INCLUSIVE, restriction.isLowerBoundInclusive() ); + assertEquals( CHECK_UPPER_BOUND, "1.0", restriction.getUpperBound().toString() ); + assertTrue( CHECK_UPPER_BOUND_INCLUSIVE, restriction.isUpperBoundInclusive() ); + + range1 = VersionRange.createFromVersionSpec( "(,1.0], [1.1,)" ); + range2 = VersionRange.createFromVersionSpec( "1.2" ); + mergedRange = range1.restrict( range2 ); + assertEquals( CHECK_VERSION_RECOMMENDATION, "1.2", mergedRange.getRecommendedVersion().toString() ); + restrictions = mergedRange.getRestrictions(); + assertEquals( CHECK_NUM_RESTRICTIONS, 2, restrictions.size() ); + restriction = restrictions.get( 0 ); + assertNull( CHECK_LOWER_BOUND, restriction.getLowerBound() ); + assertFalse( CHECK_LOWER_BOUND_INCLUSIVE, restriction.isLowerBoundInclusive() ); + assertEquals( CHECK_UPPER_BOUND, "1.0", restriction.getUpperBound().toString() ); + assertTrue( CHECK_UPPER_BOUND_INCLUSIVE, restriction.isUpperBoundInclusive() ); + restriction = restrictions.get( 1 ); + assertEquals( CHECK_LOWER_BOUND, "1.1", restriction.getLowerBound().toString() ); + assertTrue( CHECK_LOWER_BOUND_INCLUSIVE, restriction.isLowerBoundInclusive() ); + assertNull( CHECK_UPPER_BOUND, restriction.getUpperBound() ); + assertFalse( CHECK_UPPER_BOUND_INCLUSIVE, restriction.isUpperBoundInclusive() ); + + range1 = VersionRange.createFromVersionSpec( "(,1.0], [1.1,)" ); + range2 = VersionRange.createFromVersionSpec( "1.0.5" ); + mergedRange = range1.restrict( range2 ); + assertNull( CHECK_VERSION_RECOMMENDATION, mergedRange.getRecommendedVersion() ); + restrictions = mergedRange.getRestrictions(); + assertEquals( CHECK_NUM_RESTRICTIONS, 2, restrictions.size() ); + restriction = restrictions.get( 0 ); + assertNull( CHECK_LOWER_BOUND, restriction.getLowerBound() ); + assertFalse( CHECK_LOWER_BOUND_INCLUSIVE, restriction.isLowerBoundInclusive() ); + assertEquals( CHECK_UPPER_BOUND, "1.0", restriction.getUpperBound().toString() ); + assertTrue( CHECK_UPPER_BOUND_INCLUSIVE, restriction.isUpperBoundInclusive() ); + restriction = restrictions.get( 1 ); + assertEquals( CHECK_LOWER_BOUND, "1.1", restriction.getLowerBound().toString() ); + assertTrue( CHECK_LOWER_BOUND_INCLUSIVE, restriction.isLowerBoundInclusive() ); + assertNull( CHECK_UPPER_BOUND, restriction.getUpperBound() ); + assertFalse( CHECK_UPPER_BOUND_INCLUSIVE, restriction.isUpperBoundInclusive() ); + + range1 = VersionRange.createFromVersionSpec( "(,1.1), (1.1,)" ); + range2 = VersionRange.createFromVersionSpec( "1.1" ); + mergedRange = range1.restrict( range2 ); + assertNull( CHECK_VERSION_RECOMMENDATION, mergedRange.getRecommendedVersion() ); + restrictions = mergedRange.getRestrictions(); + assertEquals( CHECK_NUM_RESTRICTIONS, 2, restrictions.size() ); + restriction = restrictions.get( 0 ); + assertNull( CHECK_LOWER_BOUND, restriction.getLowerBound() ); + assertFalse( CHECK_LOWER_BOUND_INCLUSIVE, restriction.isLowerBoundInclusive() ); + assertEquals( CHECK_UPPER_BOUND, "1.1", restriction.getUpperBound().toString() ); + assertFalse( CHECK_UPPER_BOUND_INCLUSIVE, restriction.isUpperBoundInclusive() ); + restriction = restrictions.get( 1 ); + assertEquals( CHECK_LOWER_BOUND, "1.1", restriction.getLowerBound().toString() ); + assertFalse( CHECK_LOWER_BOUND_INCLUSIVE, restriction.isLowerBoundInclusive() ); + assertNull( CHECK_UPPER_BOUND, restriction.getUpperBound() ); + assertFalse( CHECK_UPPER_BOUND_INCLUSIVE, restriction.isUpperBoundInclusive() ); + + range1 = VersionRange.createFromVersionSpec( "[1.1,1.3]" ); + range2 = VersionRange.createFromVersionSpec( "(1.1,)" ); + mergedRange = range1.restrict( range2 ); + assertNull( CHECK_VERSION_RECOMMENDATION, mergedRange.getRecommendedVersion() ); + restrictions = mergedRange.getRestrictions(); + assertEquals( CHECK_NUM_RESTRICTIONS, 1, restrictions.size() ); + restriction = restrictions.get( 0 ); + assertEquals( CHECK_LOWER_BOUND, "1.1", restriction.getLowerBound().toString() ); + assertFalse( CHECK_LOWER_BOUND_INCLUSIVE, restriction.isLowerBoundInclusive() ); + assertEquals( CHECK_UPPER_BOUND, "1.3", restriction.getUpperBound().toString() ); + assertTrue( CHECK_UPPER_BOUND_INCLUSIVE, restriction.isUpperBoundInclusive() ); + + range1 = VersionRange.createFromVersionSpec( "(,1.3)" ); + range2 = VersionRange.createFromVersionSpec( "[1.2,1.3]" ); + mergedRange = range1.restrict( range2 ); + assertNull( CHECK_VERSION_RECOMMENDATION, mergedRange.getRecommendedVersion() ); + restrictions = mergedRange.getRestrictions(); + assertEquals( CHECK_NUM_RESTRICTIONS, 1, restrictions.size() ); + restriction = restrictions.get( 0 ); + assertEquals( CHECK_LOWER_BOUND, "1.2", restriction.getLowerBound().toString() ); + assertTrue( CHECK_LOWER_BOUND_INCLUSIVE, restriction.isLowerBoundInclusive() ); + assertEquals( CHECK_UPPER_BOUND, "1.3", restriction.getUpperBound().toString() ); + assertFalse( CHECK_UPPER_BOUND_INCLUSIVE, restriction.isUpperBoundInclusive() ); + + range1 = VersionRange.createFromVersionSpec( "[1.1,1.3]" ); + range2 = VersionRange.createFromVersionSpec( "[1.2,)" ); + mergedRange = range1.restrict( range2 ); + assertNull( CHECK_VERSION_RECOMMENDATION, mergedRange.getRecommendedVersion() ); + restrictions = mergedRange.getRestrictions(); + assertEquals( CHECK_NUM_RESTRICTIONS, 1, restrictions.size() ); + restriction = restrictions.get( 0 ); + assertEquals( CHECK_LOWER_BOUND, "1.2", restriction.getLowerBound().toString() ); + assertTrue( CHECK_LOWER_BOUND_INCLUSIVE, restriction.isLowerBoundInclusive() ); + assertEquals( CHECK_UPPER_BOUND, "1.3", restriction.getUpperBound().toString() ); + assertTrue( CHECK_UPPER_BOUND_INCLUSIVE, restriction.isUpperBoundInclusive() ); + + range1 = VersionRange.createFromVersionSpec( "(,1.3]" ); + range2 = VersionRange.createFromVersionSpec( "[1.2,1.4]" ); + mergedRange = range1.restrict( range2 ); + assertNull( CHECK_VERSION_RECOMMENDATION, mergedRange.getRecommendedVersion() ); + restrictions = mergedRange.getRestrictions(); + assertEquals( CHECK_NUM_RESTRICTIONS, 1, restrictions.size() ); + restriction = restrictions.get( 0 ); + assertEquals( CHECK_LOWER_BOUND, "1.2", restriction.getLowerBound().toString() ); + assertTrue( CHECK_LOWER_BOUND_INCLUSIVE, restriction.isLowerBoundInclusive() ); + assertEquals( CHECK_UPPER_BOUND, "1.3", restriction.getUpperBound().toString() ); + assertTrue( CHECK_UPPER_BOUND_INCLUSIVE, restriction.isUpperBoundInclusive() ); + + range1 = VersionRange.createFromVersionSpec( "(1.2,1.3]" ); + range2 = VersionRange.createFromVersionSpec( "[1.1,1.4]" ); + mergedRange = range1.restrict( range2 ); + assertNull( CHECK_VERSION_RECOMMENDATION, mergedRange.getRecommendedVersion() ); + restrictions = mergedRange.getRestrictions(); + assertEquals( CHECK_NUM_RESTRICTIONS, 1, restrictions.size() ); + restriction = restrictions.get( 0 ); + assertEquals( CHECK_LOWER_BOUND, "1.2", restriction.getLowerBound().toString() ); + assertFalse( CHECK_LOWER_BOUND_INCLUSIVE, restriction.isLowerBoundInclusive() ); + assertEquals( CHECK_UPPER_BOUND, "1.3", restriction.getUpperBound().toString() ); + assertTrue( CHECK_UPPER_BOUND_INCLUSIVE, restriction.isUpperBoundInclusive() ); + + range1 = VersionRange.createFromVersionSpec( "(1.2,1.3)" ); + range2 = VersionRange.createFromVersionSpec( "[1.1,1.4]" ); + mergedRange = range1.restrict( range2 ); + assertNull( CHECK_VERSION_RECOMMENDATION, mergedRange.getRecommendedVersion() ); + restrictions = mergedRange.getRestrictions(); + assertEquals( CHECK_NUM_RESTRICTIONS, 1, restrictions.size() ); + restriction = restrictions.get( 0 ); + assertEquals( CHECK_LOWER_BOUND, "1.2", restriction.getLowerBound().toString() ); + assertFalse( CHECK_LOWER_BOUND_INCLUSIVE, restriction.isLowerBoundInclusive() ); + assertEquals( CHECK_UPPER_BOUND, "1.3", restriction.getUpperBound().toString() ); + assertFalse( CHECK_UPPER_BOUND_INCLUSIVE, restriction.isUpperBoundInclusive() ); + + range1 = VersionRange.createFromVersionSpec( "[1.2,1.3)" ); + range2 = VersionRange.createFromVersionSpec( "[1.1,1.4]" ); + mergedRange = range1.restrict( range2 ); + assertNull( CHECK_VERSION_RECOMMENDATION, mergedRange.getRecommendedVersion() ); + restrictions = mergedRange.getRestrictions(); + assertEquals( CHECK_NUM_RESTRICTIONS, 1, restrictions.size() ); + restriction = restrictions.get( 0 ); + assertEquals( CHECK_LOWER_BOUND, "1.2", restriction.getLowerBound().toString() ); + assertTrue( CHECK_LOWER_BOUND_INCLUSIVE, restriction.isLowerBoundInclusive() ); + assertEquals( CHECK_UPPER_BOUND, "1.3", restriction.getUpperBound().toString() ); + assertFalse( CHECK_UPPER_BOUND_INCLUSIVE, restriction.isUpperBoundInclusive() ); + + range1 = VersionRange.createFromVersionSpec( "[1.0,1.1]" ); + range2 = VersionRange.createFromVersionSpec( "[1.1,1.4]" ); + mergedRange = range1.restrict( range2 ); + assertNull( CHECK_VERSION_RECOMMENDATION, mergedRange.getRecommendedVersion() ); + restrictions = mergedRange.getRestrictions(); + assertEquals( CHECK_NUM_RESTRICTIONS, 1, restrictions.size() ); + restriction = restrictions.get( 0 ); + assertEquals( CHECK_LOWER_BOUND, "1.1", restriction.getLowerBound().toString() ); + assertTrue( CHECK_LOWER_BOUND_INCLUSIVE, restriction.isLowerBoundInclusive() ); + assertEquals( CHECK_UPPER_BOUND, "1.1", restriction.getUpperBound().toString() ); + assertTrue( CHECK_UPPER_BOUND_INCLUSIVE, restriction.isUpperBoundInclusive() ); + + range1 = VersionRange.createFromVersionSpec( "[1.0,1.1)" ); + range2 = VersionRange.createFromVersionSpec( "[1.1,1.4]" ); + mergedRange = range1.restrict( range2 ); + assertNull( CHECK_VERSION_RECOMMENDATION, mergedRange.getRecommendedVersion() ); + restrictions = mergedRange.getRestrictions(); + assertEquals( CHECK_NUM_RESTRICTIONS, 0, restrictions.size() ); + + range1 = VersionRange.createFromVersionSpec( "[1.0,1.2],[1.3,1.5]" ); + range2 = VersionRange.createFromVersionSpec( "[1.1]" ); + mergedRange = range1.restrict( range2 ); + assertNull( CHECK_VERSION_RECOMMENDATION, mergedRange.getRecommendedVersion() ); + restrictions = mergedRange.getRestrictions(); + assertEquals( CHECK_NUM_RESTRICTIONS, 1, restrictions.size() ); + restriction = restrictions.get( 0 ); + assertEquals( CHECK_LOWER_BOUND, "1.1", restriction.getLowerBound().toString() ); + assertTrue( CHECK_LOWER_BOUND_INCLUSIVE, restriction.isLowerBoundInclusive() ); + assertEquals( CHECK_UPPER_BOUND, "1.1", restriction.getUpperBound().toString() ); + assertTrue( CHECK_UPPER_BOUND_INCLUSIVE, restriction.isUpperBoundInclusive() ); + + range1 = VersionRange.createFromVersionSpec( "[1.0,1.2],[1.3,1.5]" ); + range2 = VersionRange.createFromVersionSpec( "[1.4]" ); + mergedRange = range1.restrict( range2 ); + assertNull( CHECK_VERSION_RECOMMENDATION, mergedRange.getRecommendedVersion() ); + restrictions = mergedRange.getRestrictions(); + assertEquals( CHECK_NUM_RESTRICTIONS, 1, restrictions.size() ); + restriction = restrictions.get( 0 ); + assertEquals( CHECK_LOWER_BOUND, "1.4", restriction.getLowerBound().toString() ); + assertTrue( CHECK_LOWER_BOUND_INCLUSIVE, restriction.isLowerBoundInclusive() ); + assertEquals( CHECK_UPPER_BOUND, "1.4", restriction.getUpperBound().toString() ); + assertTrue( CHECK_UPPER_BOUND_INCLUSIVE, restriction.isUpperBoundInclusive() ); + + range1 = VersionRange.createFromVersionSpec( "[1.0,1.2],[1.3,1.5]" ); + range2 = VersionRange.createFromVersionSpec( "[1.1,1.4]" ); + mergedRange = range1.restrict( range2 ); + assertNull( CHECK_VERSION_RECOMMENDATION, mergedRange.getRecommendedVersion() ); + restrictions = mergedRange.getRestrictions(); + assertEquals( CHECK_NUM_RESTRICTIONS, 2, restrictions.size() ); + restriction = restrictions.get( 0 ); + assertEquals( CHECK_LOWER_BOUND, "1.1", restriction.getLowerBound().toString() ); + assertTrue( CHECK_LOWER_BOUND_INCLUSIVE, restriction.isLowerBoundInclusive() ); + assertEquals( CHECK_UPPER_BOUND, "1.2", restriction.getUpperBound().toString() ); + assertTrue( CHECK_UPPER_BOUND_INCLUSIVE, restriction.isUpperBoundInclusive() ); + restriction = restrictions.get( 1 ); + assertEquals( CHECK_LOWER_BOUND, "1.3", restriction.getLowerBound().toString() ); + assertTrue( CHECK_LOWER_BOUND_INCLUSIVE, restriction.isLowerBoundInclusive() ); + assertEquals( CHECK_UPPER_BOUND, "1.4", restriction.getUpperBound().toString() ); + assertTrue( CHECK_UPPER_BOUND_INCLUSIVE, restriction.isUpperBoundInclusive() ); + + range1 = VersionRange.createFromVersionSpec( "[1.0,1.2),(1.3,1.5]" ); + range2 = VersionRange.createFromVersionSpec( "[1.1,1.4]" ); + mergedRange = range1.restrict( range2 ); + assertNull( CHECK_VERSION_RECOMMENDATION, mergedRange.getRecommendedVersion() ); + restrictions = mergedRange.getRestrictions(); + assertEquals( CHECK_NUM_RESTRICTIONS, 2, restrictions.size() ); + restriction = restrictions.get( 0 ); + assertEquals( CHECK_LOWER_BOUND, "1.1", restriction.getLowerBound().toString() ); + assertTrue( CHECK_LOWER_BOUND_INCLUSIVE, restriction.isLowerBoundInclusive() ); + assertEquals( CHECK_UPPER_BOUND, "1.2", restriction.getUpperBound().toString() ); + assertFalse( CHECK_UPPER_BOUND_INCLUSIVE, restriction.isUpperBoundInclusive() ); + restriction = restrictions.get( 1 ); + assertEquals( CHECK_LOWER_BOUND, "1.3", restriction.getLowerBound().toString() ); + assertFalse( CHECK_LOWER_BOUND_INCLUSIVE, restriction.isLowerBoundInclusive() ); + assertEquals( CHECK_UPPER_BOUND, "1.4", restriction.getUpperBound().toString() ); + assertTrue( CHECK_UPPER_BOUND_INCLUSIVE, restriction.isUpperBoundInclusive() ); + + range1 = VersionRange.createFromVersionSpec( "[1.0,1.2],[1.3,1.5]" ); + range2 = VersionRange.createFromVersionSpec( "(1.1,1.4)" ); + mergedRange = range1.restrict( range2 ); + assertNull( CHECK_VERSION_RECOMMENDATION, mergedRange.getRecommendedVersion() ); + restrictions = mergedRange.getRestrictions(); + assertEquals( CHECK_NUM_RESTRICTIONS, 2, restrictions.size() ); + restriction = restrictions.get( 0 ); + assertEquals( CHECK_LOWER_BOUND, "1.1", restriction.getLowerBound().toString() ); + assertFalse( CHECK_LOWER_BOUND_INCLUSIVE, restriction.isLowerBoundInclusive() ); + assertEquals( CHECK_UPPER_BOUND, "1.2", restriction.getUpperBound().toString() ); + assertTrue( CHECK_UPPER_BOUND_INCLUSIVE, restriction.isUpperBoundInclusive() ); + restriction = restrictions.get( 1 ); + assertEquals( CHECK_LOWER_BOUND, "1.3", restriction.getLowerBound().toString() ); + assertTrue( CHECK_LOWER_BOUND_INCLUSIVE, restriction.isLowerBoundInclusive() ); + assertEquals( CHECK_UPPER_BOUND, "1.4", restriction.getUpperBound().toString() ); + assertFalse( CHECK_UPPER_BOUND_INCLUSIVE, restriction.isUpperBoundInclusive() ); + + range1 = VersionRange.createFromVersionSpec( "[1.0,1.2),(1.3,1.5]" ); + range2 = VersionRange.createFromVersionSpec( "(1.1,1.4)" ); + mergedRange = range1.restrict( range2 ); + assertNull( CHECK_VERSION_RECOMMENDATION, mergedRange.getRecommendedVersion() ); + restrictions = mergedRange.getRestrictions(); + assertEquals( CHECK_NUM_RESTRICTIONS, 2, restrictions.size() ); + restriction = restrictions.get( 0 ); + assertEquals( CHECK_LOWER_BOUND, "1.1", restriction.getLowerBound().toString() ); + assertFalse( CHECK_LOWER_BOUND_INCLUSIVE, restriction.isLowerBoundInclusive() ); + assertEquals( CHECK_UPPER_BOUND, "1.2", restriction.getUpperBound().toString() ); + assertFalse( CHECK_UPPER_BOUND_INCLUSIVE, restriction.isUpperBoundInclusive() ); + restriction = restrictions.get( 1 ); + assertEquals( CHECK_LOWER_BOUND, "1.3", restriction.getLowerBound().toString() ); + assertFalse( CHECK_LOWER_BOUND_INCLUSIVE, restriction.isLowerBoundInclusive() ); + assertEquals( CHECK_UPPER_BOUND, "1.4", restriction.getUpperBound().toString() ); + assertFalse( CHECK_UPPER_BOUND_INCLUSIVE, restriction.isUpperBoundInclusive() ); + + range1 = VersionRange.createFromVersionSpec( "(,1.1),(1.4,)" ); + range2 = VersionRange.createFromVersionSpec( "[1.1,1.4]" ); + mergedRange = range1.restrict( range2 ); + assertNull( CHECK_VERSION_RECOMMENDATION, mergedRange.getRecommendedVersion() ); + restrictions = mergedRange.getRestrictions(); + assertEquals( CHECK_NUM_RESTRICTIONS, 0, restrictions.size() ); + + range1 = VersionRange.createFromVersionSpec( "(,1.1],[1.4,)" ); + range2 = VersionRange.createFromVersionSpec( "(1.1,1.4)" ); + mergedRange = range1.restrict( range2 ); + assertNull( CHECK_VERSION_RECOMMENDATION, mergedRange.getRecommendedVersion() ); + restrictions = mergedRange.getRestrictions(); + assertEquals( CHECK_NUM_RESTRICTIONS, 0, restrictions.size() ); + + range1 = VersionRange.createFromVersionSpec( "[,1.1],[1.4,]" ); + range2 = VersionRange.createFromVersionSpec( "[1.2,1.3]" ); + mergedRange = range1.restrict( range2 ); + assertNull( CHECK_VERSION_RECOMMENDATION, mergedRange.getRecommendedVersion() ); + restrictions = mergedRange.getRestrictions(); + assertEquals( CHECK_NUM_RESTRICTIONS, 0, restrictions.size() ); + + range1 = VersionRange.createFromVersionSpec( "[1.0,1.2],[1.3,1.5]" ); + range2 = VersionRange.createFromVersionSpec( "[1.1,1.4],[1.6,]" ); + mergedRange = range1.restrict( range2 ); + assertNull( CHECK_VERSION_RECOMMENDATION, mergedRange.getRecommendedVersion() ); + restrictions = mergedRange.getRestrictions(); + assertEquals( CHECK_NUM_RESTRICTIONS, 2, restrictions.size() ); + restriction = restrictions.get( 0 ); + assertEquals( CHECK_LOWER_BOUND, "1.1", restriction.getLowerBound().toString() ); + assertTrue( CHECK_LOWER_BOUND_INCLUSIVE, restriction.isLowerBoundInclusive() ); + assertEquals( CHECK_UPPER_BOUND, "1.2", restriction.getUpperBound().toString() ); + assertTrue( CHECK_UPPER_BOUND_INCLUSIVE, restriction.isUpperBoundInclusive() ); + restriction = restrictions.get( 1 ); + assertEquals( CHECK_LOWER_BOUND, "1.3", restriction.getLowerBound().toString() ); + assertTrue( CHECK_LOWER_BOUND_INCLUSIVE, restriction.isLowerBoundInclusive() ); + assertEquals( CHECK_UPPER_BOUND, "1.4", restriction.getUpperBound().toString() ); + assertTrue( CHECK_UPPER_BOUND_INCLUSIVE, restriction.isUpperBoundInclusive() ); + + range1 = VersionRange.createFromVersionSpec( "[1.0,1.2],[1.3,1.5]" ); + range2 = VersionRange.createFromVersionSpec( "[1.1,1.4],[1.5,]" ); + mergedRange = range1.restrict( range2 ); + assertNull( CHECK_VERSION_RECOMMENDATION, mergedRange.getRecommendedVersion() ); + restrictions = mergedRange.getRestrictions(); + assertEquals( CHECK_NUM_RESTRICTIONS, 3, restrictions.size() ); + restriction = restrictions.get( 0 ); + assertEquals( CHECK_LOWER_BOUND, "1.1", restriction.getLowerBound().toString() ); + assertTrue( CHECK_LOWER_BOUND_INCLUSIVE, restriction.isLowerBoundInclusive() ); + assertEquals( CHECK_UPPER_BOUND, "1.2", restriction.getUpperBound().toString() ); + assertTrue( CHECK_UPPER_BOUND_INCLUSIVE, restriction.isUpperBoundInclusive() ); + restriction = restrictions.get( 1 ); + assertEquals( CHECK_LOWER_BOUND, "1.3", restriction.getLowerBound().toString() ); + assertTrue( CHECK_LOWER_BOUND_INCLUSIVE, restriction.isLowerBoundInclusive() ); + assertEquals( CHECK_UPPER_BOUND, "1.4", restriction.getUpperBound().toString() ); + assertTrue( CHECK_UPPER_BOUND_INCLUSIVE, restriction.isUpperBoundInclusive() ); + restriction = restrictions.get( 2 ); + assertEquals( CHECK_LOWER_BOUND, "1.5", restriction.getLowerBound().toString() ); + assertTrue( CHECK_LOWER_BOUND_INCLUSIVE, restriction.isLowerBoundInclusive() ); + assertEquals( CHECK_UPPER_BOUND, "1.5", restriction.getUpperBound().toString() ); + assertTrue( CHECK_UPPER_BOUND_INCLUSIVE, restriction.isUpperBoundInclusive() ); + + range1 = VersionRange.createFromVersionSpec( "[1.0,1.2],[1.3,1.7]" ); + range2 = VersionRange.createFromVersionSpec( "[1.1,1.4],[1.5,1.6]" ); + mergedRange = range1.restrict( range2 ); + assertNull( CHECK_VERSION_RECOMMENDATION, mergedRange.getRecommendedVersion() ); + restrictions = mergedRange.getRestrictions(); + assertEquals( CHECK_NUM_RESTRICTIONS, 3, restrictions.size() ); + restriction = restrictions.get( 0 ); + assertEquals( CHECK_LOWER_BOUND, "1.1", restriction.getLowerBound().toString() ); + assertTrue( CHECK_LOWER_BOUND_INCLUSIVE, restriction.isLowerBoundInclusive() ); + assertEquals( CHECK_UPPER_BOUND, "1.2", restriction.getUpperBound().toString() ); + assertTrue( CHECK_UPPER_BOUND_INCLUSIVE, restriction.isUpperBoundInclusive() ); + restriction = restrictions.get( 1 ); + assertEquals( CHECK_LOWER_BOUND, "1.3", restriction.getLowerBound().toString() ); + assertTrue( CHECK_LOWER_BOUND_INCLUSIVE, restriction.isLowerBoundInclusive() ); + assertEquals( CHECK_UPPER_BOUND, "1.4", restriction.getUpperBound().toString() ); + assertTrue( CHECK_UPPER_BOUND_INCLUSIVE, restriction.isUpperBoundInclusive() ); + restriction = restrictions.get( 2 ); + assertEquals( CHECK_LOWER_BOUND, "1.5", restriction.getLowerBound().toString() ); + assertTrue( CHECK_LOWER_BOUND_INCLUSIVE, restriction.isLowerBoundInclusive() ); + assertEquals( CHECK_UPPER_BOUND, "1.6", restriction.getUpperBound().toString() ); + assertTrue( CHECK_UPPER_BOUND_INCLUSIVE, restriction.isUpperBoundInclusive() ); + + // test restricting empty sets + range1 = VersionRange.createFromVersionSpec( "[,1.1],[1.4,]" ); + range2 = VersionRange.createFromVersionSpec( "[1.2,1.3]" ); + range1 = range1.restrict( range2 ); + mergedRange = range1.restrict( range2 ); + assertNull( CHECK_VERSION_RECOMMENDATION, mergedRange.getRecommendedVersion() ); + restrictions = mergedRange.getRestrictions(); + assertEquals( CHECK_NUM_RESTRICTIONS, 0, restrictions.size() ); + + range1 = VersionRange.createFromVersionSpec( "[,1.1],[1.4,]" ); + range2 = VersionRange.createFromVersionSpec( "[1.2,1.3]" ); + range2 = range1.restrict( range2 ); + mergedRange = range1.restrict( range2 ); + assertNull( CHECK_VERSION_RECOMMENDATION, mergedRange.getRecommendedVersion() ); + restrictions = mergedRange.getRestrictions(); + assertEquals( CHECK_NUM_RESTRICTIONS, 0, restrictions.size() ); + } + + public void testReleaseRangeBoundsContainsSnapshots() + throws InvalidVersionSpecificationException + { + VersionRange range = VersionRange.createFromVersionSpec( "[1.0,1.2]" ); + + assertTrue( range.containsVersion( new DefaultArtifactVersion( "1.1-SNAPSHOT" ) ) ); + assertTrue( range.containsVersion( new DefaultArtifactVersion( "1.2-SNAPSHOT" ) ) ); + assertFalse( range.containsVersion( new DefaultArtifactVersion( "1.0-SNAPSHOT" ) ) ); + } + + public void testSnapshotRangeBoundsCanContainSnapshots() + throws InvalidVersionSpecificationException + { + VersionRange range = VersionRange.createFromVersionSpec( "[1.0,1.2-SNAPSHOT]" ); + + assertTrue( range.containsVersion( new DefaultArtifactVersion( "1.1-SNAPSHOT" ) ) ); + assertTrue( range.containsVersion( new DefaultArtifactVersion( "1.2-SNAPSHOT" ) ) ); + + range = VersionRange.createFromVersionSpec( "[1.0-SNAPSHOT,1.2]" ); + + assertTrue( range.containsVersion( new DefaultArtifactVersion( "1.0-SNAPSHOT" ) ) ); + assertTrue( range.containsVersion( new DefaultArtifactVersion( "1.1-SNAPSHOT" ) ) ); + } + + public void testSnapshotSoftVersionCanContainSnapshot() + throws InvalidVersionSpecificationException + { + VersionRange range = VersionRange.createFromVersionSpec( "1.0-SNAPSHOT" ); + + assertTrue( range.containsVersion( new DefaultArtifactVersion( "1.0-SNAPSHOT" ) ) ); + } + + private void checkInvalidRange( String version ) + { + try + { + VersionRange.createFromVersionSpec( version ); + fail( "Version " + version + " should have failed to construct" ); + } + catch ( InvalidVersionSpecificationException expected ) + { + // expected + } + } + + public void testContains() throws InvalidVersionSpecificationException + { + ArtifactVersion actualVersion = new DefaultArtifactVersion( "2.0.5" ); + assertTrue( enforceVersion( "2.0.5", actualVersion ) ); + assertTrue( enforceVersion( "2.0.4", actualVersion ) ); + assertTrue( enforceVersion( "[2.0.5]", actualVersion ) ); + assertFalse( enforceVersion( "[2.0.6,)", actualVersion ) ); + assertFalse( enforceVersion( "[2.0.6]", actualVersion ) ); + assertTrue( enforceVersion( "[2.0,2.1]", actualVersion ) ); + assertFalse( enforceVersion( "[2.0,2.0.3]", actualVersion ) ); + assertTrue( enforceVersion( "[2.0,2.0.5]", actualVersion ) ); + assertFalse( enforceVersion( "[2.0,2.0.5)", actualVersion ) ); + } + + public boolean enforceVersion( String requiredVersionRange, ArtifactVersion actualVersion ) + throws InvalidVersionSpecificationException + { + VersionRange vr = null; + + vr = VersionRange.createFromVersionSpec( requiredVersionRange ); + + return vr.containsVersion( actualVersion ); + } + + public void testOrder0() + { + // assertTrue( new DefaultArtifactVersion( "1.0-alpha10" ).compareTo( new DefaultArtifactVersion( "1.0-alpha1" ) ) > 0 ); + } +} |