public bool?Equal(object x, object y, ref Tolerance tolerance, ComparisonState state) { 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)); }
public bool?Equal(object x, object y, ref Tolerance tolerance, ComparisonState state) { if (!(x is DateTimeOffset) || !(y is DateTimeOffset)) { return(null); } bool result; DateTimeOffset xOffset = (DateTimeOffset)x; DateTimeOffset yOffset = (DateTimeOffset)y; if (tolerance != null && tolerance.Amount is TimeSpan) { TimeSpan amount = (TimeSpan)tolerance.Amount; result = (xOffset - yOffset).Duration() <= amount; } else { result = xOffset == yOffset; } if (result && _equalityComparer.WithSameOffset) { result = xOffset.Offset == yOffset.Offset; } return(result); }
public bool?Equal(object x, object y, ref Tolerance tolerance, ComparisonState state) { 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 bool?Equal(object x, object y, ref Tolerance tolerance, ComparisonState state) { 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 bool?Equal(object x, object y, ref Tolerance tolerance, ComparisonState state) { 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 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 bool?Equal(object x, object y, ref Tolerance tolerance, ComparisonState state) { if (!(x is IDictionary) || !(y is IDictionary)) { return(null); } IDictionary xDictionary = (IDictionary)x; IDictionary yDictionary = (IDictionary)y; 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); }
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 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))); }
public static bool?Equal(object x, object y, ref Tolerance tolerance, ComparisonState state, NUnitEqualityComparer equalityComparer) { if (!(x is char xChar) || !(y is char yChar)) { return(null); } bool caseInsensitive = equalityComparer.IgnoreCase; char c1 = caseInsensitive ? Char.ToLower(xChar) : xChar; char c2 = caseInsensitive ? Char.ToLower(yChar) : yChar; return(c1 == c2); }
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, ComparisonState state) { if (!(x is string) || !(y is string)) { return(null); } string xString = (string)x; string yString = (string)y; bool caseInsensitive = _equalityComparer.IgnoreCase; string s1 = caseInsensitive ? xString.ToLower() : xString; string s2 = caseInsensitive ? yString.ToLower() : yString; return(s1.Equals(s2)); }
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); }
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 bool?Equal(object x, object y, ref Tolerance tolerance, ComparisonState state) { if (tolerance == null || !(tolerance.Amount is TimeSpan)) { return(null); } TimeSpan amount = (TimeSpan)tolerance.Amount; if (x is DateTime && y is DateTime) { return(((DateTime)x - (DateTime)y).Duration() <= amount); } if (x is TimeSpan && y is TimeSpan) { return(((TimeSpan)x - (TimeSpan)y).Duration() <= amount); } return(null); }
public bool?Equal(object x, object y, ref Tolerance tolerance, ComparisonState state) { // 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))); }
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 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); }