/// <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); }