public void TestToleranceDefault()
{
GlobalSettings.DefaultFloatingPointTolerance = 0.5d;
var defaultTolerance = Tolerance.Default;
Assert.IsTrue(defaultTolerance.IsUnsetOrDefault);
Assert.IsTrue(_comparer.AreEqual(2.0d, 2.1d, ref defaultTolerance));
}
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 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 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 bool?Equal(object x, object y, ref Tolerance tolerance, bool topLevelComparison = true)
{
// Issue #70 - EquivalentTo isn't compatible with IgnoreCase for dictionaries
if (!(x is DictionaryEntry) || !(y is DictionaryEntry))
{
return(null);
}
DictionaryEntry xDictionaryEntry = (DictionaryEntry)x;
DictionaryEntry yDictionaryEntry = (DictionaryEntry)y;
var keyTolerance = Tolerance.Exact;
return(_equalityComparer.AreEqual(xDictionaryEntry.Key, yDictionaryEntry.Key, ref keyTolerance, false) &&
_equalityComparer.AreEqual(xDictionaryEntry.Value, yDictionaryEntry.Value, ref tolerance, false));
}
public bool?Equal(object x, object y, ref Tolerance tolerance)
{
Type xType = x.GetType();
Type yType = y.GetType();
string xTypeName = GetTypeNameWithoutGenerics(xType.FullName);
string yTypeName = GetTypeNameWithoutGenerics(yType.FullName);
if (xTypeName != NameOfType || yTypeName != NameOfType)
{
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);
if (!comparison)
{
return(false);
}
}
return(true);
}
public bool?Equal(object x, object y, ref Tolerance tolerance)
{
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);
if (!tally.TryRemove(yDictionary.Keys) || tally.Count > 0)
{
return(false);
}
foreach (object key in xDictionary.Keys)
{
if (!_equalityComparer.AreEqual(xDictionary[key], yDictionary[key], ref tolerance))
{
return(false);
}
}
return(true);
}
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 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 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 bool?Equal(object x, object y, ref Tolerance tolerance, bool topLevelComparison = true)
{
// 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, false) &&
_equalityComparer.AreEqual(xValue, yValue, ref tolerance, false));
}
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 override bool Matches(object actual)
{
// set the base class value so it appears in the error message
this.actual = actual;
Tolerance tolerance = Tolerance.Empty;
// Loop through the expected values and return true on first match
foreach (object value in expected)
{
if (comparer.AreEqual(value, actual, ref tolerance))
{
return(true);
}
}
// No matches, return false
return(false);
}
public override bool Equals(object other)
{
var left = obj;
var right = other;
if (left is string == false && right is string)
{
right = Alvis.TestHelper.SmartConvert(right, left.GetType());
}
if (comparison.HasFlag(ObjectComparison.Unordered))
{
left = Sorted(left);
right = Sorted(right);
}
var tolerance = Tolerance.Default;
return(comparer.AreEqual(left, right, ref tolerance));
}
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 override ConstraintResult ApplyTo <TActual>(TActual actual)
{
return(new EqualAstConstraintResult(this, actual, _comparer.AreEqual(_expected, actual, ref _tolerance)));
}
public new bool Equals(object x, object y)
{
return(_comparer.AreEqual(x, y, ref _tolerance));
}