public bool?Equal(object x, object y, ref Tolerance tolerance, ComparisonState state)
{
if (!(x is IEnumerable xIEnumerable) || !(y is IEnumerable yIEnumerable))
{
return(null);
}
var expectedEnum = xIEnumerable.GetEnumerator();
using (expectedEnum as IDisposable)
{
var actualEnum = yIEnumerable.GetEnumerator();
using (actualEnum as IDisposable)
{
for (int count = 0; ; count++)
{
bool expectedHasData = expectedEnum.MoveNext();
bool actualHasData = actualEnum.MoveNext();
if (!expectedHasData && !actualHasData)
{
return(true);
}
if (expectedHasData != actualHasData ||
!_equalityComparer.AreEqual(expectedEnum.Current, actualEnum.Current, ref tolerance, state.PushComparison(x, y)))
{
NUnitEqualityComparer.FailurePoint fp = new NUnitEqualityComparer.FailurePoint();
fp.Position = count;
fp.ExpectedHasData = expectedHasData;
if (expectedHasData)
{
fp.ExpectedValue = expectedEnum.Current;
}
fp.ActualHasData = actualHasData;
if (actualHasData)
{
fp.ActualValue = actualEnum.Current;
}
_equalityComparer.FailurePoints.Insert(0, fp);
return(false);
}
}
}
}
}
public bool?Equal(object x, object y, ref Tolerance tolerance, bool topLevelComparison = true)
{
if (!(x is IEnumerable) || !(y is IEnumerable))
{
return(null);
}
IEnumerable xIEnumerable = (IEnumerable)x;
IEnumerable yIEnumerable = (IEnumerable)y;
IEnumerator expectedEnum = null;
IEnumerator actualEnum = null;
try
{
expectedEnum = xIEnumerable.GetEnumerator();
actualEnum = yIEnumerable.GetEnumerator();
int count;
for (count = 0; ; count++)
{
bool expectedHasData = expectedEnum.MoveNext();
bool actualHasData = actualEnum.MoveNext();
if (!expectedHasData && !actualHasData)
{
return(true);
}
if (expectedHasData != actualHasData ||
!_equalityComparer.AreEqual(expectedEnum.Current, actualEnum.Current, ref tolerance, topLevelComparison: false))
{
NUnitEqualityComparer.FailurePoint fp = new NUnitEqualityComparer.FailurePoint();
fp.Position = count;
fp.ExpectedHasData = expectedHasData;
if (expectedHasData)
{
fp.ExpectedValue = expectedEnum.Current;
}
fp.ActualHasData = actualHasData;
if (actualHasData)
{
fp.ActualValue = actualEnum.Current;
}
_equalityComparer.FailurePoints.Insert(0, fp);
return(false);
}
}
}
finally
{
var expectedDisposable = expectedEnum as IDisposable;
if (expectedDisposable != null)
{
expectedDisposable.Dispose();
}
var actualDisposable = actualEnum as IDisposable;
if (actualDisposable != null)
{
actualDisposable.Dispose();
}
}
}
public bool?Equal(object x, object y, ref Tolerance tolerance, ComparisonState state)
{
if (!(x is Stream) || !(y is Stream))
{
return(null);
}
Stream xStream = (Stream)x;
Stream yStream = (Stream)y;
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);
}
