public void Comparison()
{
Assert.IsTrue(typeof(IComparable<SemanticVersion>)
.IsAssignableFrom(typeof(SemanticVersion)),
"SemanticVersion is not IComparable<SemanticVersion>.");
#region Definitions
var cmp = new SemanticVersion[]
{
null,
new SemanticVersion(major: 1,
minor: 0,
patch: 0,
identifiers: new[] { "alpha" },
metadata: Empty<string>()),
new SemanticVersion(major: 1,
minor: 0,
patch: 0,
identifiers: new[] { "alpha", "1" },
metadata: Empty<string>()),
new SemanticVersion(major: 1,
minor: 0,
patch: 0,
identifiers: new[] { "alpha", "beta" },
metadata: Empty<string>()),
new SemanticVersion(major: 1,
minor: 0,
patch: 0,
identifiers: new[] { "beta" },
metadata: Empty<string>()),
new SemanticVersion(major: 1,
minor: 0,
patch: 0,
identifiers: new[] { "beta", "2" },
metadata: Empty<string>()),
new SemanticVersion(major: 1,
minor: 0,
patch: 0,
identifiers: new[] { "beta", "11" },
metadata: Empty<string>()),
new SemanticVersion(major: 1,
minor: 0,
patch: 0,
identifiers: new[] { "rc", "1" },
metadata: Empty<string>()),
new SemanticVersion(major: 1,
minor: 0,
patch: 0,
identifiers: Empty<string>(),
metadata: Empty<string>()),
};
#endregion
#region CompareTo
// Test the [CompareTo] method.
Assert.AreEqual(Ordering.Greater,
cmp[1].CompareTo<SemanticVersion>(cmp[0]),
"Comparison failed (0).");
Assert.AreEqual(Ordering.Lesser,
cmp[1].CompareTo<SemanticVersion>(cmp[2]),
"Comparison failed (1).");
Assert.AreEqual(Ordering.Lesser,
cmp[2].CompareTo<SemanticVersion>(cmp[3]),
"Comparison failed (2).");
Assert.AreEqual(Ordering.Lesser,
cmp[3].CompareTo<SemanticVersion>(cmp[4]),
"Comparison failed (3).");
Assert.AreEqual(Ordering.Lesser,
cmp[4].CompareTo<SemanticVersion>(cmp[5]),
"Comparison failed (4).");
Assert.AreEqual(Ordering.Lesser,
cmp[5].CompareTo<SemanticVersion>(cmp[6]),
"Comparison failed (5).");
Assert.AreEqual(Ordering.Lesser,
cmp[6].CompareTo<SemanticVersion>(cmp[7]),
"Comparison failed (6).");
Assert.AreEqual(Ordering.Lesser,
cmp[7].CompareTo<SemanticVersion>(cmp[8]),
"Comparison failed (7).");
// These tests are mentioned by the MSDN docs, so we're going to
// use them here just to make sure everything is working fine.
Assert.AreEqual(cmp[1].CompareTo(cmp[1]), 0,
"Comparison failed (9).");
Assert.AreEqual(cmp[1].CompareTo(cmp[2]),
-cmp[2].CompareTo(cmp[1]),
"Comparison failed (10).");
#endregion
#region Sorting
// To be extra sure, stick them in a collection, sort it, and
// check the order they come out of the collection in. We jumble
// up the items by ordering them using a newly-generated GUID.
var sl = new List<SemanticVersion>(cmp.OrderBy(ks => Guid.NewGuid()));
sl.Sort();
// [cmp] is already in the correct lowest-to-highest order.
Assert.IsTrue(sl.SequenceEqual(cmp), "Comparison failed (8).");
#endregion
#region Operators > and <
// Now we have to do practically the same tests again, but this time
// testing the comparison operators rather than the [CompareTo]
// method.
Assert.IsTrue(cmp[1] > cmp[0], "Operator comparison failed (0).");
Assert.IsTrue(cmp[2] > cmp[1], "Operator comparison failed (1).");
Assert.IsTrue(cmp[3] > cmp[2], "Operator comparison failed (2).");
Assert.IsTrue(cmp[4] > cmp[3], "Operator comparison failed (3).");
Assert.IsTrue(cmp[5] > cmp[4], "Operator comparison failed (4).");
Assert.IsTrue(cmp[6] > cmp[5], "Operator comparison failed (5).");
Assert.IsTrue(cmp[7] > cmp[6], "Operator comparison failed (6).");
Assert.IsTrue(cmp[8] > cmp[7], "Operator comparison failed (7).");
// Same tests, but with the other operator.
Assert.IsTrue(cmp[0] < cmp[1], "Operator comparison failed (8).");
Assert.IsTrue(cmp[1] < cmp[2], "Operator comparison failed (9).");
Assert.IsTrue(cmp[2] < cmp[3], "Operator comparison failed (10).");
Assert.IsTrue(cmp[3] < cmp[4], "Operator comparison failed (11).");
Assert.IsTrue(cmp[4] < cmp[5], "Operator comparison failed (12).");
Assert.IsTrue(cmp[5] < cmp[6], "Operator comparison failed (13).");
Assert.IsTrue(cmp[6] < cmp[7], "Operator comparison failed (14).");
Assert.IsTrue(cmp[7] < cmp[8], "Operator comparison failed (15).");
// These are the ones mentioned by the MSDN docs.
Assert.IsFalse(cmp[1] > cmp[1], "Operator comparison failed (16).");
Assert.IsFalse(cmp[1] < cmp[1], "Operator comparison failed (17).");
Assert.IsTrue((cmp[1] > cmp[2]) == !(cmp[2] > cmp[1]),
"Operator comparison failed (18).");
Assert.IsTrue((cmp[1] < cmp[2]) == !(cmp[2] < cmp[1]),
"Operator comparison failed (19).");
#endregion
#region Operators >= and <=
// We're also testing the [>=] and [<=] operators.
Assert.IsTrue(cmp[8] >= cmp[8], "Operator comparison failed (20).");
Assert.IsTrue(cmp[8] >= cmp[7], "Operator comparison failed (21).");
Assert.IsTrue(cmp[8] >= cmp[6], "Operator comparison failed (22).");
Assert.IsTrue(cmp[8] >= cmp[5], "Operator comparison failed (23).");
Assert.IsTrue(cmp[8] >= cmp[4], "Operator comparison failed (24).");
Assert.IsTrue(cmp[8] >= cmp[3], "Operator comparison failed (25).");
Assert.IsTrue(cmp[8] >= cmp[2], "Operator comparison failed (26).");
Assert.IsTrue(cmp[8] >= cmp[1], "Operator comparison failed (27).");
Assert.IsTrue(cmp[8] >= cmp[0], "Operator comparison failed (28).");
Assert.IsTrue(cmp[0] <= cmp[0], "Operator comparison failed (29).");
Assert.IsTrue(cmp[0] <= cmp[1], "Operator comparison failed (30).");
Assert.IsTrue(cmp[0] <= cmp[2], "Operator comparison failed (31).");
Assert.IsTrue(cmp[0] <= cmp[3], "Operator comparison failed (32).");
Assert.IsTrue(cmp[0] <= cmp[4], "Operator comparison failed (33).");
Assert.IsTrue(cmp[0] <= cmp[5], "Operator comparison failed (34).");
Assert.IsTrue(cmp[0] <= cmp[6], "Operator comparison failed (35).");
Assert.IsTrue(cmp[0] <= cmp[7], "Operator comparison failed (36).");
Assert.IsTrue(cmp[0] <= cmp[8], "Operator comparison failed (37).");
Assert.IsFalse(cmp[1] <= cmp[0], "Operator comparison failed (38).");
Assert.IsFalse(cmp[0] >= cmp[1], "Operator comparison failed (39).");
#endregion
}
public void Comparison()
{
SemanticVersion sv = new SemanticVersion(1, 0);
Assert.IsTrue(sv is IComparable <SemanticVersion>,
"SemanticVersion is not IComparable < SemanticVersion >.");
#region Definitions
var cmp = new SemanticVersion[]
{
null,
new SemanticVersion(major: 1,
minor: 0,
patch: 0,
identifiers: new[] { "alpha" },
metadata: Empty <string>()),
new SemanticVersion(major: 1,
minor: 0,
patch: 0,
identifiers: new[] { "alpha", "1" },
metadata: Empty <string>()),
new SemanticVersion(major: 1,
minor: 0,
patch: 0,
identifiers: new[] { "alpha", "beta" },
metadata: Empty <string>()),
new SemanticVersion(major: 1,
minor: 0,
patch: 0,
identifiers: new[] { "beta" },
metadata: Empty <string>()),
new SemanticVersion(major: 1,
minor: 0,
patch: 0,
identifiers: new[] { "beta", "2" },
metadata: Empty <string>()),
new SemanticVersion(major: 1,
minor: 0,
patch: 0,
identifiers: new[] { "beta", "11" },
metadata: Empty <string>()),
new SemanticVersion(major: 1,
minor: 0,
patch: 0,
identifiers: new[] { "rc", "1" },
metadata: Empty <string>()),
new SemanticVersion(major: 1,
minor: 0,
patch: 0,
identifiers: Empty <string>(),
metadata: Empty <string>()),
};
#endregion
#region CompareTo
// Test the [CompareTo] method.
Assert.AreEqual(Ordering.Greater,
cmp[1].CompareTo <SemanticVersion>(cmp[0]),
"Comparison failed (0).");
Assert.AreEqual(Ordering.Lesser,
cmp[1].CompareTo <SemanticVersion>(cmp[2]),
"Comparison failed (1).");
Assert.AreEqual(Ordering.Lesser,
cmp[2].CompareTo <SemanticVersion>(cmp[3]),
"Comparison failed (2).");
Assert.AreEqual(Ordering.Lesser,
cmp[3].CompareTo <SemanticVersion>(cmp[4]),
"Comparison failed (3).");
Assert.AreEqual(Ordering.Lesser,
cmp[4].CompareTo <SemanticVersion>(cmp[5]),
"Comparison failed (4).");
Assert.AreEqual(Ordering.Lesser,
cmp[5].CompareTo <SemanticVersion>(cmp[6]),
"Comparison failed (5).");
Assert.AreEqual(Ordering.Lesser,
cmp[6].CompareTo <SemanticVersion>(cmp[7]),
"Comparison failed (6).");
Assert.AreEqual(Ordering.Lesser,
cmp[7].CompareTo <SemanticVersion>(cmp[8]),
"Comparison failed (7).");
// These tests are mentioned by the MSDN docs, so we're going to
// use them here just to make sure everything is working fine.
Assert.AreEqual(cmp[1].CompareTo(cmp[1]), 0,
"Comparison failed (9).");
Assert.AreEqual(cmp[1].CompareTo(cmp[2]),
-cmp[2].CompareTo(cmp[1]),
"Comparison failed (10).");
#endregion
#region Sorting
// To be extra sure, stick them in a collection, sort it, and
// check the order they come out of the collection in. We jumble
// up the items by ordering them using a newly-generated GUID.
var sl = new List <SemanticVersion>(cmp.OrderBy(ks => Guid.NewGuid()));
sl.Sort();
// [cmp] is already in the correct lowest-to-highest order.
Assert.IsTrue(sl.SequenceEqual(cmp), "Comparison failed (8).");
#endregion
#region Operators > and <
// Now we have to do practically the same tests again, but this time
// testing the comparison operators rather than the [CompareTo]
// method.
Assert.IsTrue(cmp[1] > cmp[0], "Operator comparison failed (0).");
Assert.IsTrue(cmp[2] > cmp[1], "Operator comparison failed (1).");
Assert.IsTrue(cmp[3] > cmp[2], "Operator comparison failed (2).");
Assert.IsTrue(cmp[4] > cmp[3], "Operator comparison failed (3).");
Assert.IsTrue(cmp[5] > cmp[4], "Operator comparison failed (4).");
Assert.IsTrue(cmp[6] > cmp[5], "Operator comparison failed (5).");
Assert.IsTrue(cmp[7] > cmp[6], "Operator comparison failed (6).");
Assert.IsTrue(cmp[8] > cmp[7], "Operator comparison failed (7).");
// Same tests, but with the other operator.
Assert.IsTrue(cmp[0] < cmp[1], "Operator comparison failed (8).");
Assert.IsTrue(cmp[1] < cmp[2], "Operator comparison failed (9).");
Assert.IsTrue(cmp[2] < cmp[3], "Operator comparison failed (10).");
Assert.IsTrue(cmp[3] < cmp[4], "Operator comparison failed (11).");
Assert.IsTrue(cmp[4] < cmp[5], "Operator comparison failed (12).");
Assert.IsTrue(cmp[5] < cmp[6], "Operator comparison failed (13).");
Assert.IsTrue(cmp[6] < cmp[7], "Operator comparison failed (14).");
Assert.IsTrue(cmp[7] < cmp[8], "Operator comparison failed (15).");
// These are the ones mentioned by the MSDN docs.
Assert.IsFalse(cmp[1] > cmp[1], "Operator comparison failed (16).");
Assert.IsFalse(cmp[1] < cmp[1], "Operator comparison failed (17).");
Assert.IsTrue((cmp[1] > cmp[2]) == !(cmp[2] > cmp[1]),
"Operator comparison failed (18).");
Assert.IsTrue((cmp[1] < cmp[2]) == !(cmp[2] < cmp[1]),
"Operator comparison failed (19).");
#endregion
#region Operators >= and <=
// We're also testing the [>=] and [<=] operators.
Assert.IsTrue(cmp[8] >= cmp[8], "Operator comparison failed (20).");
Assert.IsTrue(cmp[8] >= cmp[7], "Operator comparison failed (21).");
Assert.IsTrue(cmp[8] >= cmp[6], "Operator comparison failed (22).");
Assert.IsTrue(cmp[8] >= cmp[5], "Operator comparison failed (23).");
Assert.IsTrue(cmp[8] >= cmp[4], "Operator comparison failed (24).");
Assert.IsTrue(cmp[8] >= cmp[3], "Operator comparison failed (25).");
Assert.IsTrue(cmp[8] >= cmp[2], "Operator comparison failed (26).");
Assert.IsTrue(cmp[8] >= cmp[1], "Operator comparison failed (27).");
Assert.IsTrue(cmp[8] >= cmp[0], "Operator comparison failed (28).");
Assert.IsTrue(cmp[0] <= cmp[0], "Operator comparison failed (29).");
Assert.IsTrue(cmp[0] <= cmp[1], "Operator comparison failed (30).");
Assert.IsTrue(cmp[0] <= cmp[2], "Operator comparison failed (31).");
Assert.IsTrue(cmp[0] <= cmp[3], "Operator comparison failed (32).");
Assert.IsTrue(cmp[0] <= cmp[4], "Operator comparison failed (33).");
Assert.IsTrue(cmp[0] <= cmp[5], "Operator comparison failed (34).");
Assert.IsTrue(cmp[0] <= cmp[6], "Operator comparison failed (35).");
Assert.IsTrue(cmp[0] <= cmp[7], "Operator comparison failed (36).");
Assert.IsTrue(cmp[0] <= cmp[8], "Operator comparison failed (37).");
Assert.IsFalse(cmp[1] <= cmp[0], "Operator comparison failed (38).");
Assert.IsFalse(cmp[0] >= cmp[1], "Operator comparison failed (39).");
#endregion
}
