public void Equals()
{
EqualityAssert.Equals(4, 4);
EqualityAssert.Equals("B", "B");
EqualityAssert.Equals("B", "b", StringComparer.OrdinalIgnoreCase,
"\"B\" should be equal to \"b\" for case-insensitive ordinal comparison.");
ExceptionAssert.ThrowsAssertFailed(
() => EqualityAssert.Equals("B", "A"),
"\"B\" should not be equal to \"A\".");
ExceptionAssert.ThrowsAssertFailed(
() => EqualityAssert.Equals("B", "b", StringComparer.Ordinal),
"\"B\" should not be equal to \"b\" for case-sensitive ordinal comparison.");
EqualityAssert.Equals <string>(null, null);
ExceptionAssert.ThrowsAssertFailed(
() => EqualityAssert.Equals(null, "x"),
"(null) should not be equal to \"x\".");
ExceptionAssert.ThrowsAssertFailed(
() => EqualityAssert.Equals("x", null),
"\"x\" should not be equal to (null).");
}
public void Equals_DifferentTypes()
{
var comparer = SequenceEqualityComparer <string> .Default;
EqualityAssert.Equals(x.ToArray(), x.ToList(), comparer);
EqualityAssert.Equals(y.ToArray(), y.Select(s => s), comparer);
}
public void Equals_Nulls()
{
var comparer = SequenceEqualityComparer <string> .Default;
EqualityAssert.NotEquals(null, x, comparer);
EqualityAssert.Equals(null, null, comparer);
EqualityAssert.NotEquals(x, null, comparer);
}
public void Equals_Nulls()
{
var comparer = KeyEqualityComparer.Create((City city) => city.Name);
EqualityAssert.NotEquals(null, athens, comparer);
EqualityAssert.Equals(null, null, comparer);
EqualityAssert.NotEquals(athens, null, comparer);
}
public void Equals_String()
{
var comparer = new OrdinalStringComparer();
EqualityAssert.Equals(null, null, comparer);
EqualityAssert.NotEquals(null, "abc", comparer);
EqualityAssert.NotEquals("abc", null, comparer);
EqualityAssert.Equals("abc", "abc", comparer);
EqualityAssert.NotEquals("abc", "xyz", comparer);
}
public void Equals_NullableInt()
{
var comparer = new NullableIntComparer();
EqualityAssert.Equals(null, null, comparer);
EqualityAssert.NotEquals(null, 4, comparer);
EqualityAssert.NotEquals(4, null, comparer);
EqualityAssert.Equals(4, 4, comparer);
EqualityAssert.NotEquals(4, 7, comparer);
}
public void Equals_Empty()
{
var empty = ArrayUtility <string> .Empty;
var comparer = SequenceEqualityComparer <string> .Default;
EqualityAssert.NotEquals(empty, null, comparer);
EqualityAssert.NotEquals(empty, x, comparer);
EqualityAssert.Equals(empty, x.Take(0), comparer);
EqualityAssert.Equals(empty, empty, comparer);
}
public void Equals()
{
using (new CultureSwapper(PredefinedCulture.EnglishUnitedStates))
{
var comparer = SequenceEqualityComparer.Create(StringComparer.CurrentCulture);
EqualityAssert.NotEquals(x, y, comparer);
EqualityAssert.NotEquals(y, z, comparer);
comparer = SequenceEqualityComparer.Create(StringComparer.CurrentCultureIgnoreCase);
EqualityAssert.NotEquals(x, y, comparer);
EqualityAssert.Equals(y, z, comparer);
}
}
public void Equals()
{
var a = new IntWrapper(5);
var b = new IntWrapper(5);
EqualityAssert.Equals(a, a, EqualityComparer <IntWrapper> .Default);
EqualityAssert.Equals(a, b, EqualityComparer <IntWrapper> .Default);
EqualityAssert.Equals(a, a, ReferenceEqualityComparer <IntWrapper> .Default);
EqualityAssert.NotEquals(a, b, ReferenceEqualityComparer <IntWrapper> .Default);
int x = 5;
int y = 5;
EqualityAssert.Equals(x, x, EqualityComparer <int> .Default);
EqualityAssert.Equals(x, y, EqualityComparer <int> .Default);
EqualityAssert.NotEquals(x, x, ReferenceEqualityComparer <int> .Default);
EqualityAssert.NotEquals(x, y, ReferenceEqualityComparer <int> .Default);
}
public void Serialize_BinaryFormatter()
{
var x = new[] { "abc", "def" };
var y = new[] { "abc", "DEF" };
var z = new[] { "xyz" };
var binaryFormatter = new BinaryFormatter();
using (var stream = new MemoryStream())
{
var original = SequenceEqualityComparer.Create(StringComparer.OrdinalIgnoreCase);
binaryFormatter.Serialize(stream, original);
stream.Position = 0;
var comparer = (SequenceEqualityComparer <string>)binaryFormatter.Deserialize(stream);
EqualityAssert.Equals(x, y, comparer);
EqualityAssert.NotEquals(x, z, comparer);
}
}
public void Default()
{
Assert.IsNotNull(CachedRandom.Current);
const int length = 255;
var randoms = new ConcurrentBag <Random>();
var sequences = new ConcurrentBag <byte[]>();
Enumerable
.Range(0, 8)
.Select(_ => ThreadFactory.StartNew(() =>
{
randoms.Add(CachedRandom.Current);
sequences.Add(CachedRandom.Current.NextBytes(length));
}))
.ToList()
.ForEach(thread => thread.Join());
EnumerableAssert.HasCount(8, randoms);
EnumerableAssert.AllItemsAreUnique(randoms);
foreach (var x in sequences)
{
Assert.IsTrue(x.Distinct().Count() >= length / 5,
"Less than 20% of the elements are unique. This is highly unlikely to occur in a random sequence.");
}
foreach (var x in sequences)
{
foreach (var y in sequences)
{
if (!object.ReferenceEquals(x, y))
{
EqualityAssert.NotEquals(x, y, SequenceEqualityComparer <byte> .Default,
"Two sequences are identical. This is highly unlikely to occur in random sequences.");
}
}
}
}
public void Equals()
{
using (new CultureSwapper(PredefinedCulture.EnglishUnitedStates))
{
var comparer = KeyEqualityComparer.Create((City city) => city.Name);
EqualityAssert.Equals(añasco, añasco, comparer);
EqualityAssert.NotEquals(añasco, añascoUppercase, comparer);
EqualityAssert.NotEquals(añasco, añascoCombining, comparer,
"Precomposed character should not equal combining character sequence for default equality comparison (ordinal).");
comparer = KeyEqualityComparer.Create((City city) => city.Name, StringComparer.CurrentCulture);
EqualityAssert.Equals(añasco, añasco, comparer);
EqualityAssert.NotEquals(añasco, añascoUppercase, comparer);
EqualityAssert.Equals(añasco, añascoCombining, comparer,
"Precomposed character should equal combining character sequence for culture-sensitive comparison (en-US).");
comparer = KeyEqualityComparer.Create((City city) => city.Name, StringComparer.CurrentCultureIgnoreCase);
EqualityAssert.Equals(añasco, añasco, comparer);
EqualityAssert.Equals(añasco, añascoUppercase, comparer);
EqualityAssert.Equals(añasco, añascoCombining, comparer);
}
}
public void Equals_BuggyComparer()
{
ExceptionAssert.ThrowsAssertFailed(
() => EqualityAssert.Equals("A", "a", new BuggyComparer()),
"Hash codes of equal objects must match.");
}
