public void Should_override_equality_operators()
{
var a = new SemanticVersion(0, 0, 1);
var b = new SemanticVersion(1, 2, 3);
var c = new SemanticVersion(0, 0, 1);
// Equality
(a == c).ShouldBeTrue();
(a == b).ShouldBeFalse();
(a != b).ShouldBeTrue();
a.Equals(c).ShouldBeTrue();
a.Equals(0).ShouldBeFalse();
a.Equals(null).ShouldBeFalse();
a.GetHashCode().ShouldBe(c.GetHashCode());
a.GetHashCode().ShouldNotBe(b.GetHashCode());
// Comparison
(a < b).ShouldBeTrue();
(b < a).ShouldBeFalse();
(a <= c).ShouldBeTrue();
(b <= a).ShouldBeFalse();
(b > a).ShouldBeTrue();
(a > b).ShouldBeFalse();
(a >= c).ShouldBeTrue();
(a >= b).ShouldBeFalse();
}
public void HashCodes()
{
var sv12a = new SemanticVersion(new Version(1, 2), null);
var sv12b = new SemanticVersion(new Version(1, 2), null);
Assert.Equal(sv12a.GetHashCode(), sv12b.GetHashCode());
var sv13 = new SemanticVersion(new Version(1, 3), null);
Assert.NotEqual(sv12a.GetHashCode(), sv13.GetHashCode());
}
public void HashCodes()
{
var sv12a = new SemanticVersion(new Version(1, 2), null);
var sv12b = new SemanticVersion(new Version(1, 2), null);
Assert.Equal(sv12a.GetHashCode(), sv12b.GetHashCode());
var sv13 = new SemanticVersion(new Version(1, 3), null);
Assert.NotEqual(sv12a.GetHashCode(), sv13.GetHashCode());
}
public void GetHashCodeNotEqualNoBuildNoPrerelease()
{
SemanticVersion left = new SemanticVersion(1, 0, 0);
SemanticVersion right = new SemanticVersion(2, 0, 0);
Assert.NotEqual(left.GetHashCode(), right.GetHashCode());
}
public void GetHashCodeNotEqual()
{
SemanticVersion left = new SemanticVersion(1, 0, 0, "foo", "bar");
SemanticVersion right = new SemanticVersion(2, 0, 0, "foo", "bar");
Assert.NotEqual(left.GetHashCode(), right.GetHashCode());
}
public void GetHashCodeNotEqualNoBuildNoPrerelease()
{
SemanticVersion left = new SemanticVersion(1, 0, 0);
SemanticVersion right = new SemanticVersion(2, 0, 0);
Assert.NotEqual(left.GetHashCode(), right.GetHashCode());
}
public void GetHashCodeNotEqual()
{
SemanticVersion left = new SemanticVersion(1, 0, 0, "foo", "bar");
SemanticVersion right = new SemanticVersion(2, 0, 0, "foo", "bar");
Assert.NotEqual(left.GetHashCode(), right.GetHashCode());
}
public void Operator_DifferentValues(SemanticVersion left, SemanticVersion right)
{
Assert.Equal(left.GetHashCode(), left.GetHashCode());
Assert.Equal(right.GetHashCode(), right.GetHashCode());
Assert.Equal(left, left);
Assert.Equal(right, right);
Assert.NotEqual(left, right);
Assert.NotEqual(left.GetHashCode(), right.GetHashCode());
Assert.False(left == right);
Assert.True(left != right);
Assert.True(left < right);
Assert.True(left <= right);
Assert.False(left > right);
Assert.False(left >= right);
}
public void NormalTypeHashCodeVerification(ushort major, ushort minor, ushort patch)
{
var semVer = new SemanticVersion(major, minor, patch);
var expected = GetSemVerHashCode(semVer);
var actual = semVer.GetHashCode();
Assert.Equal(expected, actual);
}
public void SpecialTypeHashCodeVerification(SemanticVersionType semVerType, ushort major, ushort minor, ushort patch,
string[] specialParts)
{
var semVer = new SemanticVersion(major, minor, patch, specialParts, semVerType);
var expected = GetSemVerHashCode(semVer);
var actual = semVer.GetHashCode();
Assert.Equal(expected, actual);
}
public void SemanticVersionStrictEqualityPreRelease(string versionString)
{
// Act
SemanticVersion main = null;
SemanticVersion.TryParseStrict("1.2.3-alpha", out main);
SemanticVersion semVer = null;
SemanticVersion.TryParseStrict(versionString, out semVer);
// Assert
Assert.True(main.Equals(semVer));
Assert.True(semVer.Equals(main));
Assert.True(main.GetHashCode() == semVer.GetHashCode());
}
public override int GetHashCode()
{
int result = 17;
unchecked
{
if (Name != null)
{
result = (result * 31) + Name.GetHashCode();
}
if (FullName != null)
{
result = (result * 31) + FullName.GetHashCode();
}
if (Version != null)
{
result = (result * 31) + Version.GetHashCode();
}
if (SemanticVersion != null)
{
result = (result * 31) + SemanticVersion.GetHashCode();
}
if (FileVersion != null)
{
result = (result * 31) + FileVersion.GetHashCode();
}
if (Properties != null)
{
// Use xor for dictionaries to be order-independent.
int xor_0 = 0;
foreach (var value_0 in Properties)
{
xor_0 ^= value_0.Key.GetHashCode();
if (value_0.Value != null)
{
xor_0 ^= value_0.Value.GetHashCode();
}
}
result = (result * 31) + xor_0;
}
if (Tags != null)
{
foreach (var value_1 in Tags)
{
result = result * 31;
if (value_1 != null)
{
result = (result * 31) + value_1.GetHashCode();
}
}
}
}
return(result);
}
/// <summary>Serves as the default hash function. </summary>
/// <returns>A hash code for the current object.</returns>
public override int GetHashCode()
{
unchecked
{
return(((_versionWithTokens != null ? _versionWithTokens.GetHashCode() : 0) * 397) ^ (_version != null ? _version.GetHashCode() : 0));
}
}
public override int GetHashCode()
{
return(_packageId.GetHashCode() * 3137 + _version.GetHashCode());
}
public void GetHashCodeTest()
{
SemanticVersion o = new SemanticVersion(4, 2, 1, new PreRelease(PreReleaseStage.ALPHA, 3), 45);
SemanticVersion v = o;
Assert.Equal(o.GetHashCode(), v.GetHashCode());
v = new SemanticVersion(4, 2, 1, new PreRelease(PreReleaseStage.ALPHA, 3), 45);
Assert.Equal(o.GetHashCode(), v.GetHashCode());
}
