public void ComparerConstruction()
{
for (int i = 0; i < 1000000; i++)
{
var comparer = new NUnitEqualityComparer();
}
}
/// <summary>
/// Construct a CollectionTally object from a comparer and a collection
/// </summary>
public CollectionTally(NUnitEqualityComparer comparer, IEnumerable c)
{
this.comparer = comparer;
foreach (object o in c)
list.Add(o);
}
public void TestToleranceDefault()
{
var defaultTolerance = Tolerance.Default;
Assert.IsTrue(defaultTolerance.IsUnsetOrDefault);
var comparer = new NUnitEqualityComparer();
Assert.IsTrue(comparer.AreEqual(2.0d, 2.1d, ref defaultTolerance));
}
public void TestToleranceExact()
{
var noneTolerance = Tolerance.Exact;
Assert.IsFalse(noneTolerance.IsUnsetOrDefault);
var comparer = new NUnitEqualityComparer();
Assert.IsFalse(comparer.AreEqual(2.0d, 2.1d, ref noneTolerance));
}
public void ComparerAreEqual()
{
var comparer = new NUnitEqualityComparer();
Tolerance tolerance = new Tolerance(0);
for (int i = 0; i < 1000000; i++)
{
var x = 10;
var y = 10;
comparer.AreEqual(x, y, ref tolerance);
}
}
public static bool?Equal(object x, object y, ref Tolerance tolerance, ComparisonState state, NUnitEqualityComparer equalityComparer)
{
if (!(x is string xString) || !(y is string yString))
{
return(null);
}
var stringComparison = equalityComparer.IgnoreCase ? StringComparison.CurrentCultureIgnoreCase : StringComparison.Ordinal;
return(xString.Equals(yString, stringComparison));
}
public NUnitEqualityComparison(NUnitEqualityComparer comparer, Tolerance tolerance)
{
_comparer = comparer;
_tolerance = tolerance;
}
internal StructuralComparer(NUnitEqualityComparer equalityComparer)
{
_equalityComparer = equalityComparer;
}
public static bool?Equal(object x, object y, ref Tolerance tolerance, ComparisonState state, NUnitEqualityComparer equalityComparer)
{
if (tolerance?.Amount is TimeSpan amount)
{
if (x is DateTime xDateTime && y is DateTime yDateTime)
{
return((xDateTime - yDateTime).Duration() <= amount);
}
if (x is TimeSpan xTimeSpan && y is TimeSpan yTimeSpan)
{
return((xTimeSpan - yTimeSpan).Duration() <= amount);
}
}
return(null);
}
internal EquatablesComparer(NUnitEqualityComparer equalityComparer)
{
_equalityComparer = equalityComparer;
}
public static bool?Equal(object x, object y, ref Tolerance tolerance, ComparisonState state, NUnitEqualityComparer equalityComparer)
{
if (!(x is Stream xStream) || !(y is Stream yStream))
{
return(null);
}
if (xStream == yStream)
{
return(true);
}
if (!xStream.CanRead)
{
throw new ArgumentException("Stream is not readable", "expected");
}
if (!yStream.CanRead)
{
throw new ArgumentException("Stream is not readable", "actual");
}
if (!xStream.CanSeek)
{
throw new ArgumentException("Stream is not seekable", "expected");
}
if (!yStream.CanSeek)
{
throw new ArgumentException("Stream is not seekable", "actual");
}
if (xStream.Length != yStream.Length)
{
return(false);
}
byte[] bufferExpected = new byte[BUFFER_SIZE];
byte[] bufferActual = new byte[BUFFER_SIZE];
BinaryReader binaryReaderExpected = new BinaryReader(xStream);
BinaryReader binaryReaderActual = new BinaryReader(yStream);
long expectedPosition = xStream.Position;
long actualPosition = yStream.Position;
try
{
binaryReaderExpected.BaseStream.Seek(0, SeekOrigin.Begin);
binaryReaderActual.BaseStream.Seek(0, SeekOrigin.Begin);
for (long readByte = 0; readByte < xStream.Length; readByte += BUFFER_SIZE)
{
binaryReaderExpected.Read(bufferExpected, 0, BUFFER_SIZE);
binaryReaderActual.Read(bufferActual, 0, BUFFER_SIZE);
for (int count = 0; count < BUFFER_SIZE; ++count)
{
if (bufferExpected[count] != bufferActual[count])
{
NUnitEqualityComparer.FailurePoint fp = new NUnitEqualityComparer.FailurePoint();
fp.Position = readByte + count;
fp.ExpectedHasData = true;
fp.ExpectedValue = bufferExpected[count];
fp.ActualHasData = true;
fp.ActualValue = bufferActual[count];
equalityComparer.FailurePoints.Insert(0, fp);
return(false);
}
}
}
}
finally
{
xStream.Position = expectedPosition;
yStream.Position = actualPosition;
}
return(true);
}
internal ValueTupleComparer(NUnitEqualityComparer equalityComparer)
: base(equalityComparer)
{
}
public static bool?Equal(object x, object y, ref Tolerance tolerance, ComparisonState state, NUnitEqualityComparer equalityComparer)
{
if (!(x is DateTimeOffset xOffset) || !(y is DateTimeOffset yOffset))
{
return(null);
}
bool result;
if (tolerance?.Amount is TimeSpan amount)
{
result = (xOffset - yOffset).Duration() <= amount;
}
else
{
result = xOffset == yOffset;
}
if (result && equalityComparer.WithSameOffset)
{
result = xOffset.Offset == yOffset.Offset;
}
return(result);
}
public static bool?Equal(object x, object y, ref Tolerance tolerance, ComparisonState state, NUnitEqualityComparer equalityComparer)
{
if (equalityComparer.CompareAsCollection && state.TopLevelComparison)
{
return(null);
}
Type xType = x.GetType();
Type yType = y.GetType();
MethodInfo equals = FirstImplementsIEquatableOfSecond(xType, yType);
if (equals != null)
{
return(InvokeFirstIEquatableEqualsSecond(x, y, equals));
}
equals = FirstImplementsIEquatableOfSecond(yType, xType);
if (xType != yType && equals != null)
{
return(InvokeFirstIEquatableEqualsSecond(y, x, equals));
}
return(null);
}
public static bool?Equal(object x, object y, ref Tolerance tolerance, ComparisonState state, NUnitEqualityComparer equalityComparer,
Func <Type, bool> isCorrectType, Func <Type, string, object, object> getValue)
{
Type xType = x.GetType();
Type yType = y.GetType();
if (!isCorrectType(xType) || !isCorrectType(yType))
{
return(null);
}
int numberOfGenericArgs = xType.GetGenericArguments().Length;
if (numberOfGenericArgs != yType.GetGenericArguments().Length)
{
return(false);
}
for (int i = 0; i < numberOfGenericArgs; i++)
{
string propertyName = i < 7 ? "Item" + (i + 1) : "Rest";
object xItem = getValue(xType, propertyName, x);
object yItem = getValue(yType, propertyName, y);
bool comparison = equalityComparer.AreEqual(xItem, yItem, ref tolerance, state.PushComparison(x, y));
if (!comparison)
{
return(false);
}
}
return(true);
}
public static bool?Equal(object x, object y, ref Tolerance tolerance, ComparisonState state, NUnitEqualityComparer equalityComparer)
{
if (!(x is DirectoryInfo xDirectoryInfo) || !(y is DirectoryInfo yDirectoryInfo))
{
return(null);
}
// Do quick compares first
if (xDirectoryInfo.Attributes != yDirectoryInfo.Attributes ||
xDirectoryInfo.CreationTime != yDirectoryInfo.CreationTime ||
xDirectoryInfo.LastAccessTime != yDirectoryInfo.LastAccessTime)
{
return(false);
}
// TODO: Find a cleaner way to do this
return(new SamePathConstraint(xDirectoryInfo.FullName).ApplyTo(yDirectoryInfo.FullName).IsSuccess);
}
public static bool?Equal(object x, object y, ref Tolerance tolerance, ComparisonState state, NUnitEqualityComparer equalityComparer)
{
if (!x.GetType().IsArray || !y.GetType().IsArray || equalityComparer.CompareAsCollection)
{
return(null);
}
Array xArray = (Array)x;
Array yArray = (Array)y;
int rank = xArray.Rank;
if (rank != yArray.Rank)
{
return(false);
}
for (int r = 1; r < rank; r++)
{
if (xArray.GetLength(r) != yArray.GetLength(r))
{
return(false);
}
}
return(EnumerablesComparer.Equal(xArray, yArray, ref tolerance, state, equalityComparer));
}
internal KeyValuePairsComparer(NUnitEqualityComparer equalityComparer)
{
_equalityComparer = equalityComparer;
}
internal ArraysComparer(NUnitEqualityComparer equalityComparer, EnumerablesComparer enumerablesComparer)
{
_equalityComparer = equalityComparer;
_enumerablesComparer = enumerablesComparer;
}
internal StringsComparer(NUnitEqualityComparer equalityComparer)
{
_equalityComparer = equalityComparer;
}
public void TearDown()
{
GlobalSettings.DefaultFloatingPointTolerance = 0d;
_comparer = new NUnitEqualityComparer();
}
internal TupleComparerBase(NUnitEqualityComparer equalityComparer)
{
_equalityComparer = equalityComparer;
}
public static bool?Equal(object x, object y, ref Tolerance tolerance, ComparisonState state, NUnitEqualityComparer equalityComparer)
{
// IDictionary<,> will eventually try to compare its key value pairs when using CollectionTally
Type xType = x.GetType();
Type yType = y.GetType();
Type xGenericTypeDefinition = xType.GetTypeInfo().IsGenericType ? xType.GetGenericTypeDefinition() : null;
Type yGenericTypeDefinition = yType.GetTypeInfo().IsGenericType ? yType.GetGenericTypeDefinition() : null;
if (xGenericTypeDefinition != typeof(KeyValuePair <,>) ||
yGenericTypeDefinition != typeof(KeyValuePair <,>))
{
return(null);
}
var keyTolerance = Tolerance.Exact;
object xKey = xType.GetProperty("Key").GetValue(x, null);
object yKey = yType.GetProperty("Key").GetValue(y, null);
object xValue = xType.GetProperty("Value").GetValue(x, null);
object yValue = yType.GetProperty("Value").GetValue(y, null);
return(equalityComparer.AreEqual(xKey, yKey, ref keyTolerance, state.PushComparison(x, y)) &&
equalityComparer.AreEqual(xValue, yValue, ref tolerance, state.PushComparison(x, y)));
}
internal CharsComparer(NUnitEqualityComparer equalityComparer)
{
_equalityComparer = equalityComparer;
}
public static bool?Equal(object x, object y, ref Tolerance tolerance, ComparisonState state, NUnitEqualityComparer equalityComparer)
{
if (equalityComparer.CompareAsCollection && state.TopLevelComparison)
{
return(null);
}
if (x is IStructuralEquatable xEquatable && y is IStructuralEquatable yEquatable)
{
// We can't pass tolerance as a ref so we pass by value and reassign later
var equalityComparison = new NUnitEqualityComparison(equalityComparer, tolerance);
// Check both directions in case they are different implementations, and only one is aware of the other.
// Like how ImmutableArray<int> is structurally equatable to int[]
// but int[] is NOT structurally equatable to ImmutableArray<int>
var xResult = xEquatable.Equals(y, equalityComparison);
var yResult = yEquatable.Equals(x, equalityComparison);
// Keep all the refs up to date
tolerance = equalityComparison.Tolerance;
return(xResult || yResult);
}
return(null);
}
public static bool?Equal(object x, object y, ref Tolerance tolerance, ComparisonState state, NUnitEqualityComparer equalityComparer)
{
if (!Numerics.IsNumericType(x) || !Numerics.IsNumericType(y))
{
return(null);
}
return(Numerics.AreEqual(x, y, ref tolerance));
}
internal DateTimeOffsetsComparer(NUnitEqualityComparer equalityComparer)
{
_equalityComparer = equalityComparer;
}
public static bool?Equal(object x, object y, ref Tolerance tolerance, ComparisonState state, NUnitEqualityComparer equalityComparer) => TupleComparerBase.Equal(x, y, ref tolerance, state, equalityComparer, IsCorrectType, GetValue);
public static bool?Equal(object x, object y, ref Tolerance tolerance, ComparisonState state, NUnitEqualityComparer equalityComparer)
{
// Issue #70 - EquivalentTo isn't compatible with IgnoreCase for dictionaries
if (!(x is DictionaryEntry xDictionaryEntry) || !(y is DictionaryEntry yDictionaryEntry))
{
return(null);
}
var keyTolerance = Tolerance.Exact;
return(equalityComparer.AreEqual(xDictionaryEntry.Key, yDictionaryEntry.Key, ref keyTolerance, state.PushComparison(x, y)) &&
equalityComparer.AreEqual(xDictionaryEntry.Value, yDictionaryEntry.Value, ref tolerance, state.PushComparison(x, y)));
}
internal DictionariesComparer(NUnitEqualityComparer equalityComparer)
{
_equalityComparer = equalityComparer;
}
public static bool?Equal(object x, object y, ref Tolerance tolerance, ComparisonState state, NUnitEqualityComparer equalityComparer)
{
if (!(x is IDictionary xDictionary) || !(y is IDictionary yDictionary))
{
return(null);
}
if (xDictionary.Count != yDictionary.Count)
{
return(false);
}
CollectionTally tally = new CollectionTally(equalityComparer, xDictionary.Keys);
tally.TryRemove(yDictionary.Keys);
if ((tally.Result.MissingItems.Count > 0) || (tally.Result.ExtraItems.Count > 0))
{
return(false);
}
foreach (object key in xDictionary.Keys)
{
if (!equalityComparer.AreEqual(xDictionary[key], yDictionary[key], ref tolerance, state.PushComparison(x, y)))
{
return(false);
}
}
return(true);
}
