private static bool FluentEquals(object instance, object expected, EqualityMode mode)
{
// ReSharper disable once RedundantNameQualifier
var ret = Equals(instance, expected);
switch (mode)
{
case EqualityMode.FluentEquals:
return(ValueDifference(instance, "actual", expected, "expected").Count == 0);
case EqualityMode.OperatorEq:
case EqualityMode.OperatorNeq:
var actualType = instance.GetTypeWithoutThrowingException();
var expectedType = expected.GetTypeWithoutThrowingException();
var operatorName = mode == EqualityMode.OperatorEq ? "op_Equality" : "op_Inequality";
var ope = actualType
.GetMethod(operatorName, new[] { actualType, expectedType }) ?? expectedType
.GetMethod(operatorName, new[] { actualType, expectedType });
if (ope != null)
{
ret = (bool)ope.Invoke(null, new[] { instance, expected });
if (mode == EqualityMode.OperatorNeq)
{
ret = !ret;
}
}
break;
}
return(ret);
}
internal static ICheckLink <ICheck <T> > PerformEqualCheck <T, TE>(ICheck <T> check,
TE expected,
EqualityMode mode,
IEqualityComparer comparer = null)
{
if (typeof(T).IsNumerical() && typeof(T) == typeof(TE))
{
if (typeof(T) == typeof(double))
{
PerformEqualCheckDouble((ICheck <double>)check, expected);
return(ExtensibilityHelper.BuildCheckLink(check));
}
if (typeof(T) == typeof(float))
{
PerformEqualCheckFloat((ICheck <float>)check, expected);
return(ExtensibilityHelper.BuildCheckLink(check));
}
}
ExtensibilityHelper.BeginCheck(check)
.Analyze((sut, test) =>
{
var modeLabel = string.Empty;
var negatedMode = string.Empty;
switch (mode)
{
case EqualityMode.OperatorEq:
modeLabel = "equals to (using operator==)";
negatedMode = " (using !operator==)";
break;
case EqualityMode.OperatorNeq:
modeLabel = "equals to (using !operator!=)";
negatedMode = " (using operator!=)";
break;
}
test.DefineExpectedValue(expected, modeLabel,
$"different from{negatedMode}");
var differenceDetails = FluentEquals(sut, expected, mode, comparer);
if (!differenceDetails.IsDifferent)
{
return;
}
// shall we display the type as well?
var options = MessageOption.None;
if (sut == null ||
(expected != null &&
sut.GetType() != expected.GetType() &&
!(sut.GetType().IsNumerical() && expected.GetType().IsNumerical())))
{
options |= MessageOption.WithType;
}
// shall we display the hash too?
if (sut != null && expected != null && sut.GetType() == expected.GetType() &&
sut.ToStringProperlyFormatted() == expected.ToStringProperlyFormatted())
{
options |= MessageOption.WithHash;
}
test.SetValuesIndex(differenceDetails.GetFirstIndex());
test.Fail(differenceDetails.GetErrorMessage(sut, expected), options);
})
.OnNegate("The {0} is equal to the {1} whereas it must not.",
MessageOption.NoCheckedBlock | MessageOption.WithType)
.EndCheck();
return(ExtensibilityHelper.BuildCheckLink(check));
}
internal static AggregatedDifference FluentEquals <TS, TE>(TS sut, TE expected, EqualityMode mode, IEqualityComparer comparer = null)
{
var result = new AggregatedDifference();
if (comparer != null)
{
result.SetAsDifferent(!comparer.Equals(expected, sut));
return(result);
}
switch (mode)
{
case EqualityMode.FluentEquals:
return(DifferenceFinders.ValueDifference(sut, SutLabel, expected));
case EqualityMode.OperatorEq:
case EqualityMode.OperatorNeq:
var actualType = sut.GetTypeWithoutThrowingException();
var expectedType = expected.GetTypeWithoutThrowingException();
var operatorName = mode == EqualityMode.OperatorEq ? "op_Equality" : "op_Inequality";
var ope = actualType
.GetMethod(operatorName, new[] { actualType, expectedType }) ?? expectedType
.GetMethod(operatorName, new[] { actualType, expectedType });
if (ope != null)
{
var ret = (bool)ope.Invoke(null, new object[] { sut, expected });
if (mode == EqualityMode.OperatorNeq)
{
ret = !ret;
}
result.SetAsDifferent(!ret);
}
else
{
result.SetAsDifferent(!Equals(sut, expected));
}
break;
case EqualityMode.Equals:
result.SetAsDifferent(!Equals(expected, sut));
break;
default:
throw new NotSupportedException();
}
return(result);
}
public EqualityKeyAttribute(EqualityMode mode = EqualityMode.UseEquality)
{
Mode = mode;
}
private static AggregatedDifference FluentEquals <TS, TE>(TS instance, TE expected, EqualityMode mode)
{
var result = new AggregatedDifference();
var ret = false;
switch (mode)
{
case EqualityMode.FluentEquals:
return(ValueDifference(instance, SutLabel, expected, ExpectedLabel));
case EqualityMode.OperatorEq:
case EqualityMode.OperatorNeq:
ret = Equals(instance, expected);
var actualType = instance.GetTypeWithoutThrowingException();
var expectedType = expected.GetTypeWithoutThrowingException();
var operatorName = mode == EqualityMode.OperatorEq ? "op_Equality" : "op_Inequality";
var ope = actualType
.GetMethod(operatorName, new[] { actualType, expectedType }) ?? expectedType
.GetMethod(operatorName, new[] { actualType, expectedType });
if (ope != null)
{
ret = (bool)ope.Invoke(null, new object[] { instance, expected });
if (mode == EqualityMode.OperatorNeq)
{
ret = !ret;
}
}
break;
}
if (!ret)
{
result.Add(new DifferenceDetails(SutLabel, instance, ExpectedLabel, expected, 0));
}
return(result);
}
