/// <summary>
/// Apply both member constraints to an actual value, succeeding
/// succeeding only if both of them succeed.
/// </summary>
/// <param name="actual">The actual value</param>
/// <returns>True if the constraints both succeeded</returns>
public override bool Matches(object actual)
{
this.actual = actual;
failurePoint = left.Matches(actual)
? right.Matches(actual)
? FailurePoint.None
: FailurePoint.Right
: FailurePoint.Left;
return failurePoint == FailurePoint.None;
}
/// <summary>
/// Apply both member constraints to an actual value, succeeding
/// succeeding only if both of them succeed.
/// </summary>
/// <param name="actual">The actual value</param>
/// <returns>True if the constraints both succeeded</returns>
public override bool Matches(object actual)
{
this.actual = actual;
failurePoint = left.Matches(actual)
? right.Matches(actual)
? FailurePoint.None
: FailurePoint.Right
: FailurePoint.Left;
return(failurePoint == FailurePoint.None);
}
public bool AreEqual <T1, T2>(T1 x, T2 y, ref Tolerance tolerance)
{
Guard.OperationValid(CanCompare(x, y), "Unexpected call");
var xEnumerable = x as IEnumerable;
var yEnumerable = y as IEnumerable;
if (_equalityComparer.CheckRecursion(xEnumerable, yEnumerable))
{
return(false);
}
var expectedEnum = xEnumerable.GetEnumerator();
using (expectedEnum as IDisposable)
{
var actualEnum = yEnumerable.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.ObjectsEqual(expectedEnum.Current, actualEnum.Current, ref tolerance))
{
FailurePoint fp = new 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);
}
}
}
}
}
private bool EnumerablesEqual(IEnumerable x, IEnumerable y, ref Tolerance tolerance)
{
IEnumerator expectedEnum = x.GetEnumerator();
IEnumerator actualEnum = y.GetEnumerator();
int count;
for (count = 0; ; count++)
{
bool expectedHasData = expectedEnum.MoveNext();
bool actualHasData = actualEnum.MoveNext();
if (!expectedHasData && !actualHasData)
{
return(true);
}
if (expectedHasData != actualHasData ||
!AreEqual(expectedEnum.Current, actualEnum.Current, ref tolerance))
{
FailurePoint fp = new FailurePoint();
fp.Position = count;
fp.ExpectedHasData = expectedHasData;
if (expectedHasData)
{
fp.ExpectedValue = expectedEnum.Current;
}
fp.ActualHasData = actualHasData;
if (actualHasData)
{
fp.ActualValue = actualEnum.Current;
}
failurePoints.Insert(0, fp);
return(false);
}
}
}
private bool EnumerablesEqual(IEnumerable x, IEnumerable y, ref Tolerance tolerance)
{
IEnumerator expectedEnum = x.GetEnumerator();
IEnumerator actualEnum = y.GetEnumerator();
int count;
for (count = 0; ; count++)
{
bool expectedHasData = expectedEnum.MoveNext();
bool actualHasData = actualEnum.MoveNext();
if (!expectedHasData && !actualHasData)
return true;
if (expectedHasData != actualHasData ||
!AreEqual(expectedEnum.Current, actualEnum.Current, ref tolerance))
{
FailurePoint fp = new FailurePoint();
fp.Position = count;
fp.ExpectedHasData = expectedHasData;
if (expectedHasData)
fp.ExpectedValue = expectedEnum.Current;
fp.ActualHasData = actualHasData;
if (actualHasData)
fp.ActualValue = actualEnum.Current;
failurePoints.Insert(0, fp);
return false;
}
}
}
private bool StreamsEqual(Stream x, Stream y)
{
if (x == y) return true;
if (!x.CanRead)
throw new ArgumentException("Stream is not readable", "expected");
if (!y.CanRead)
throw new ArgumentException("Stream is not readable", "actual");
if (!x.CanSeek)
throw new ArgumentException("Stream is not seekable", "expected");
if (!y.CanSeek)
throw new ArgumentException("Stream is not seekable", "actual");
if (x.Length != y.Length) return false;
byte[] bufferExpected = new byte[BUFFER_SIZE];
byte[] bufferActual = new byte[BUFFER_SIZE];
BinaryReader binaryReaderExpected = new BinaryReader(x);
BinaryReader binaryReaderActual = new BinaryReader(y);
long expectedPosition = x.Position;
long actualPosition = y.Position;
try
{
binaryReaderExpected.BaseStream.Seek(0, SeekOrigin.Begin);
binaryReaderActual.BaseStream.Seek(0, SeekOrigin.Begin);
for (long readByte = 0; readByte < x.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])
{
FailurePoint fp = new FailurePoint();
fp.Position = readByte + count;
fp.ExpectedHasData = true;
fp.ExpectedValue = bufferExpected[count];
fp.ActualHasData = true;
fp.ActualValue = bufferActual[count];
failurePoints.Insert(0, fp);
return false;
}
}
}
}
finally
{
x.Position = expectedPosition;
y.Position = actualPosition;
}
return true;
}
private bool CollectionsEqual(ICollection x, ICollection y, ref Tolerance tolerance)
{
IEnumerator expectedEnum = null;
IEnumerator actualEnum = null;
try
{
expectedEnum = x.GetEnumerator();
actualEnum = y.GetEnumerator();
int count;
for (count = 0; ; count++)
{
bool expectedHasData = expectedEnum.MoveNext();
bool actualHasData = actualEnum.MoveNext();
if (!expectedHasData && !actualHasData)
return true;
if (expectedHasData != actualHasData ||
!AreEqual(expectedEnum.Current, actualEnum.Current, ref tolerance))
{
FailurePoint fp = new FailurePoint();
fp.Position = count;
fp.ExpectedHasData = expectedHasData;
if (expectedHasData)
fp.ExpectedValue = expectedEnum.Current;
fp.ActualHasData = actualHasData;
if (actualHasData)
fp.ActualValue = actualEnum.Current;
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 AreEqual <T1, T2>(T1 x, T2 y, ref Tolerance tolerance)
{
Guard.OperationValid(CanCompare(x, y), "Should not be called");
Stream xStream = (Stream)(object)x;
Stream yStream = (Stream)(object)y;
if (xStream == yStream)
{
return(true);
}
Guard.OperationValid(
xStream.CanRead && xStream.CanSeek && yStream.CanRead && yStream.CanSeek,
"Both streams must be readable and seekable");
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])
{
FailurePoint fp = new 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);
}
public override bool Matches(object actual)
{
base.actual = actual;
failurePoint = ((!Left.Matches(actual)) ? FailurePoint.Left : ((!Right.Matches(actual)) ? FailurePoint.Right : FailurePoint.None));
return(failurePoint == FailurePoint.None);
}
