private bool ValueEquityAssertTypesMatch(object expected, object actual, bool equals)
{
var expectedType = expected.GetType();
var actualType = actual.GetType();
if (expectedType.IsArray && actualType.IsArray)
{
AssertHandler.OnAssertInconclusive(
string.Format(AssertMessages.Assert_UnexpectedArrayFormat, equals ? "Assert.SequenceEquals" : "Assert.NotSequenceEquals"));
return(false);
}
if (!ReferenceOrValueTypesMatch(expectedType, actualType))
{
return(false);
}
if (expectedType.IsCOMObject && actualType.IsCOMObject)
{
AssertHandler.OnAssertInconclusive(
string.Format(AssertMessages.Assert_UnexpectedReferenceComparisonFormat, equals ? "Assert.AreSame" : "Assert.AreNotSame"));
return(false);
}
if (expectedType != actualType)
{
AssertHandler.OnAssertInconclusive(AssertMessages.Assert_MismatchedTypes);
return(false);
}
return(true);
}
public void ParameterInRange(string parameter, double minimum, double maximum, int invocation = 1, string message = "")
{
var usage = GetUsageOrAssert(parameter, invocation, message);
if (Asserted || !usage.HasValue)
{
return;
}
if (usage.Value.IsMissing)
{
AssertHandler.OnAssertFailed(string.Format(AssertMessages.Assert_VerifyParameterNotPassed, parameter, invocation, message));
Asserted = true;
return;
}
var underTest = usage.Value.Value is ComVariant ? ((ComVariant)(usage.Value.Value)).Value : usage.Value.Value;
if (!(underTest is double))
{
AssertHandler.OnAssertInconclusive(string.Format(AssertMessages.Assert_VerifyParameterNonNumeric, parameter, invocation, message));
Asserted = true;
return;
}
// passing case.
if ((double)underTest >= minimum && (double)underTest <= maximum)
{
return;
}
AssertHandler.OnAssertFailed(string.Format(AssertMessages.Assert_ParameterResultFormat, $"{minimum} - {maximum}", underTest, message));
Asserted = true;
}
private bool ReferenceOrValueTypesMatch(Type expectedType, Type actualType)
{
if (expectedType != null && !expectedType.IsCOMObject && (actualType == null || actualType.IsCOMObject))
{
AssertHandler.OnAssertInconclusive(AssertMessages.Assert_ValueReferenceMismatch);
return(false);
}
if (actualType != null && !actualType.IsCOMObject && (expectedType == null || expectedType.IsCOMObject))
{
AssertHandler.OnAssertInconclusive(AssertMessages.Assert_ReferenceValueMismatch);
return(false);
}
return(true);
}
public void ParameterIsType(string parameter, string typeName, int invocation = 1, string message = "")
{
var usage = GetUsageOrAssert(parameter, invocation, message);
if (Asserted || !usage.HasValue)
{
return;
}
//TODO
AssertHandler.OnAssertInconclusive(AssertMessages.Assert_NotImplemented);
//if (usage.Value.TypeName.ToLower().Equals(typeName.ToLower()))
//{
// return;
//}
//AssertHandler.OnAssertFailed(string.Format(RubberduckUI.Assert_ParameterResultFormat, typeName, usage.Value.TypeName, message));
//Asserted = true;
}
private UsageInfo?GetUsageOrAssert(string parameter, int invocation, string message = "", [CallerMemberName] string methodName = "")
{
if (invocation > InvocationCount || invocation < 1)
{
// ReSharper disable once ExplicitCallerInfoArgument
AssertHandler.OnAssertFailed(string.Format(AssertMessages.Assert_VerifyNoInvocationFormat, parameter, _usages.Count, message), methodName);
Asserted = true;
return(null);
}
var uses = _usages.Where(u => u.Parameter.Equals(parameter.ToLower()) && u.Invocation == invocation).ToArray();
if (uses.Length != 1)
{
AssertHandler.OnAssertInconclusive(AssertMessages.Assert_VerifyInternalErrorMessage);
Asserted = true;
return(null);
}
return(uses[0]);
}
/// <summary>
/// Verifies that two specified objects are not equal. The assertion fails if the objects are equal.
/// </summary>
/// <param name="expected">The expected value.</param>
/// <param name="actual">The actual value.</param>
/// <param name="message">An optional message to display if the assertion fails.</param>
/// <remarks>
/// <paramref name="expected"/> and <paramref name="actual"/> must be the same type.
/// </remarks>
public void AreNotEqual(object expected, object actual, string message = null)
{
// vbNullString is marshaled as a null. assume value semantics:
expected = expected ?? string.Empty;
actual = actual ?? string.Empty;
if (expected.GetType() != actual.GetType())
{
AssertHandler.OnAssertInconclusive("[expected] and [actual] values are not the same type.");
return;
}
if (!expected.Equals(actual))
{
AssertHandler.OnAssertSucceeded();
}
else
{
AssertHandler.OnAssertFailed("AreNotEqual", string.Concat("expected: ", expected.ToString(), "; actual: ", actual.ToString(), ". ", message));
}
}
protected bool SequenceEquityParametersAreArrays(object expected, object actual, bool equals)
{
var expectedType = expected?.GetType();
var actualType = actual?.GetType();
if (expectedType == null && actualType == null)
{
AssertHandler.OnAssertInconclusive(
string.Format(AssertMessages.Assert_UnexpectedNullArraysFormat, equals ? "Assert.AreSame" : "Assert.AreNotSame"));
return(false);
}
if (!ReferenceOrValueTypesMatch(expectedType, actualType))
{
return(false);
}
if (expectedType != null && !expectedType.IsArray && actualType != null && actualType.IsArray)
{
AssertHandler.OnAssertInconclusive(string.Format(AssertMessages.Assert_ParameterIsNotArrayFormat, "[Expected]"));
return(false);
}
if (actualType != null && !actualType.IsArray && expectedType != null && expectedType.IsArray)
{
AssertHandler.OnAssertInconclusive(string.Format(AssertMessages.Assert_ParameterIsNotArrayFormat, "[Actual]"));
return(false);
}
if (actualType != null && !actualType.IsArray && (expectedType == null || expectedType.IsArray))
{
AssertHandler.OnAssertInconclusive(AssertMessages.Assert_NeitherParameterIsArray);
return(false);
}
return(true);
}
private bool ReferenceEquityAssertTypesMatch(object expected, object actual, bool same)
{
var expectedType = expected?.GetType();
var actualType = actual?.GetType();
if ((expectedType == null && actualType == null) ||
((expectedType == null || expectedType.IsCOMObject) && (actualType == null || actualType.IsCOMObject)))
{
return(true);
}
if (!ReferenceOrValueTypesMatch(expectedType, actualType))
{
return(false);
}
if (expectedType != null && !expectedType.IsCOMObject && actualType != null && !actualType.IsCOMObject)
{
AssertHandler.OnAssertInconclusive(
string.Format(AssertMessages.Assert_UnexpectedValueComparisonFormat, same ? "Assert.AreEqual" : "Assert.AreNotEqual"));
return(false);
}
return(true);
}
private bool IsEasterEgg(object value)
{
if (value.GetType() == typeof(AssertClass))
{
AssertHandler.OnAssertInconclusive(AssertMessages.Assert_EasterEggAssertClassPassed);
Asserted = true;
return(true);
}
if (value.GetType() == typeof(IVerify))
{
AssertHandler.OnAssertInconclusive(AssertMessages.Assert_EasterEggIVerifyPassed);
Asserted = true;
return(true);
}
if (value.GetType() == typeof(IFake))
{
AssertHandler.OnAssertInconclusive(AssertMessages.Assert_EasterEggIFakePassed);
Asserted = true;
return(true);
}
return(false);
}
/// <summary>
/// Indicates that the assertion cannot be verified.
/// </summary>
/// <param name="message">An optional message to display.</param>
public void Inconclusive(string message = "")
{
AssertHandler.OnAssertInconclusive(message);
}