public void ReleaseSatisfies(string versionString, string version, bool result)
{
var comparator = VersionComparator.Parse(versionString);
Assert.NotNull(comparator);
Assert.Equal(result, comparator.Match(Version.Parse(version)));
}
public void ParseReleaseFloating(string versionString, string version, string releasePrefix)
{
var comparator = VersionComparator.Parse(versionString);
Assert.NotNull(comparator);
Assert.Equal(VersionFloatBehavior.Prerelease, comparator.FloatBehavior);
Assert.Equal(releasePrefix, comparator.ReleasePrefix);
}
public void ParseTailOperators(string versionString, string op)
{
var comparator = VersionComparator.Parse(versionString);
Assert.NotNull(comparator);
Assert.Equal(Version.Parse("1.0"), comparator.Version);
Assert.Equal(ParseOperator(op), comparator.Operator);
}
public void ParseRevisionFloating(string versionString, string version)
{
var comparator = VersionComparator.Parse(versionString);
Assert.NotNull(comparator);
Assert.Equal(VersionFloatBehavior.Revision, comparator.FloatBehavior);
Assert.Equal(Version.Parse(version), comparator.Version);
}
public void ParseMajorFloating()
{
var comparator = VersionComparator.Parse("*");
Assert.NotNull(comparator);
Assert.Equal(VersionFloatBehavior.Major, comparator.FloatBehavior);
Assert.Equal(VersionOperator.Equal, comparator.Operator);
Assert.Equal(new Version(0, 0, 0), comparator.Version);
}
public void ParseMissingBoundaryByHyphen(string comparatorString, string boundaryString, bool missingLower)
{
var comparator = Assert.IsType <VersionComparator>(VersionComparatorFactory.Parse(comparatorString));
var boundary = VersionComparator.Parse(boundaryString);
Assert.Equal(boundary.Version, comparator.Version);
Assert.Equal(boundary.FloatBehavior, comparator.FloatBehavior);
Assert.Equal(boundary.ReleasePrefix, comparator.ReleasePrefix);
Assert.Equal(missingLower ? VersionOperator.LessThanEqual : VersionOperator.GreaterThanEqual, comparator.Operator);
}
public void Should_be_possible_to_compare_two_elements_with_version_dataType_with_equals_operator()
{
VersionComparator comparator = new VersionComparator();
bool compareResult = comparator.Compare("5.7.23", "5.7.23", OperationEnumeration.equals);
Assert.IsTrue(compareResult, "the value is not expected for equals operation");
compareResult = comparator.Compare("5.7.21", "5.7.23", OperationEnumeration.equals);
Assert.IsFalse(compareResult, "the value is not expected for equals operation");
}
public void Should_be_possible_to_define_any_separator_for_version_number()
{
VersionComparator comparator = new VersionComparator();
bool compareResult = comparator.Compare("5#7#8", "5#7#8", OperationEnumeration.equals);
Assert.IsTrue(compareResult, "the value is not expected for equals operation");
compareResult = comparator.Compare("5#7#8", "5%7%8", OperationEnumeration.equals);
Assert.IsTrue(compareResult, "the value is not expected for equals operation");
}
public void Should_complete_with_zero_the_version_number_when_is_not_complete()
{
VersionComparator comparator = new VersionComparator();
bool compareResult = comparator.Compare("5.7", "5.7.22", OperationEnumeration.lessthanorequal);
Assert.IsTrue(compareResult, "the value is not expected for equals operation");
compareResult = comparator.Compare("5.7.8", "5", OperationEnumeration.greaterthan);
Assert.IsTrue(compareResult, "the value is not expected for equals operation");
}
public void ParseVersionByCaret(string comparatorString, string lowerBoundary, string upperBoundary)
{
var comparator = Assert.IsType <VersionCompositeComparator>(VersionComparatorFactory.Parse(comparatorString));
Assert.Equal(2, comparator.Count);
var lowerComparator = Assert.IsType <VersionComparator>(comparator.First());
var upperComparator = Assert.IsType <VersionComparator>(comparator[1]);
Assert.Equal(VersionComparator.Parse(lowerBoundary), lowerComparator);
Assert.Equal(VersionComparator.Parse(upperBoundary), upperComparator);
}
public ModDependencyMetadata(
string modName,
VersionNumber requiredVersionUpperBound = null,
VersionComparator requiredVersionUpperBoundComparator = VersionComparator.None,
VersionNumber requiredVersionLowerBound = null, VersionComparator
requiredVersionLowerBoundComparator = VersionComparator.None)
{
ModName = modName;
RequiredVersionUpperBound = requiredVersionUpperBound;
RequiredVersionUpperBoundComparator = requiredVersionUpperBoundComparator;
RequiredVersionLowerBound = requiredVersionLowerBound;
RequiredVersionLowerBoundComparator = requiredVersionLowerBoundComparator;
}
public void Should_be_possible_to_compare_two_elements_with_version_dataType_with_less_than_or_equals_operator()
{
VersionComparator comparator = new VersionComparator();
bool compareResult = comparator.Compare("5.7.22", "5.7.22", OperationEnumeration.lessthanorequal);
Assert.IsTrue(compareResult, "the value is not expected for equals operation");
compareResult = comparator.Compare("5.6.1", "5.6.2", OperationEnumeration.lessthanorequal);
Assert.IsTrue(compareResult, "the value is not expected for equals operation");
compareResult = comparator.Compare("5.0.0", "5.0.0", OperationEnumeration.lessthanorequal);
Assert.IsTrue(compareResult, "the value is not expected for equals operation");
}
public RemoteAssemblyState GetAssemblyState(string url, string version)
{
bool isRequestForLatestStable = version == null;
List <RemoteAssemblyState> candidates = new List <RemoteAssemblyState>();
foreach (RemoteAssemblyState state in this.RemoteAssemblies)
{
if (state.Url == url)
{
if (isRequestForLatestStable)
{
if (state.IsStable)
{
// TODO: don't add candidates that aren't marked as stable by the server.
// A user could potentially specifically request version-2-alpha, but latest-stable should return version-1-release
candidates.Add(state);
}
}
else if (state.Version == version)
{
candidates.Add(state);
}
}
}
if (candidates.Count == 0)
{
return(null);
}
if (candidates.Count == 1)
{
return(candidates[0]);
}
VersionComparator vc = new VersionComparator();
candidates.Sort(new AssemblyComparerByVersion());
candidates[0].IsLatestStable = true;
return(candidates[0]);
}
public void ParseByHyphen(string comparatorString, string lowerBoundary, string upperBoundary)
{
var comparator = Assert.IsType <VersionCompositeComparator>(VersionComparatorFactory.Parse(comparatorString));
Assert.Equal(2, comparator.Count);
var lowerComparator = Assert.IsType <VersionComparator>(comparator.First());
var upperComparator = Assert.IsType <VersionComparator>(comparator[1]);
var lowerVersion = VersionComparator.Parse(lowerBoundary);
var upperVersion = VersionComparator.Parse(upperBoundary);
Assert.Equal(lowerVersion.Version, lowerComparator.Version);
Assert.Equal(upperVersion.Version, upperComparator.Version);
Assert.Equal(lowerVersion.FloatBehavior, lowerComparator.FloatBehavior);
Assert.Equal(upperVersion.FloatBehavior, upperComparator.FloatBehavior);
Assert.Equal(lowerVersion.ReleasePrefix, lowerComparator.ReleasePrefix);
Assert.Equal(upperVersion.ReleasePrefix, upperComparator.ReleasePrefix);
Assert.Equal(VersionOperator.GreaterThanEqual, lowerComparator.Operator);
Assert.Equal(VersionOperator.LessThanEqual, upperComparator.Operator);
}
public void ParseSimpleComparator(string comparatorString)
{
var comparator = Assert.IsType <VersionComparator>(VersionComparatorFactory.Parse(comparatorString));
Assert.Equal(VersionComparator.Parse(comparatorString), comparator);
}
public int Compare(string x, string y)
{
return(VersionComparator.Compare(x, y));
}
public void ParseMajorAndMinorByTilde(string comparatorString, string boundaryString)
{
var comparator = Assert.IsType <VersionComparator>(VersionComparatorFactory.Parse(comparatorString));
Assert.Equal(VersionComparator.Parse(boundaryString), comparator);
}
