public override ExpressionKind Eat(ISnapshot snapshot, IElementAccessExpression expression)
{
_argumentsEater.Eat(snapshot, expression.Arguments);
// TODO : cover by functional tests
// TODO : what if array of results or targets
Eater.Eat(snapshot, expression.Operand);
return(ExpressionKind.StubCandidate);
}
public override ExpressionKind Eat(ISnapshot snapshot, IInvocationExpression expression)
{
var invokedName = _expressionHelper.GetInvokedElementName(expression);
if (invokedName.StartsWith("Method:Moq.Mock.Of"))
{
_mockOfInvocationEater.Eat(snapshot, expression);
return(ExpressionKind.Stub);
}
_argumentsEater.Eat(snapshot, expression.Arguments);
var parentKind = _parentReferenceEater.Eat(snapshot, expression);
if (invokedName.StartsWith("Method:NUnit.Framework.Assert"))
{
snapshot.Add(ExpressionKind.Assert, expression);
return(ExpressionKind.Assert);
}
if (invokedName.StartsWith("Method:Moq.Mock.Verify"))
{
snapshot.Add(ExpressionKind.Assert, expression);
return(ExpressionKind.Assert);
}
var invoked = _expressionHelper.GetInvokedElement(expression);
if (invoked is IMethod)
{
var invokedMethod = invoked as IMethod;
if (snapshot.IsInTestScope(invokedMethod.Module.Name))
{
snapshot.Add(ExpressionKind.TargetCall, expression);
return(ExpressionKind.TargetCall);
}
}
if (parentKind == ExpressionKind.None)
{
return(ExpressionKind.StubCandidate);
}
var basedOnParentKind = _expressionKindHelper.InvocationKindByParentReferenceKind(parentKind);
if (basedOnParentKind == ExpressionKind.TargetCall)
{
snapshot.Add(ExpressionKind.TargetCall, expression);
return(ExpressionKind.TargetCall);
}
return(basedOnParentKind);
}
public override ExpressionKind Eat(ISnapshot snapshot, IObjectCreationExpression expression)
{
_argumentsEater.Eat(snapshot, expression.Arguments);
if (expression.Initializer != null)
{
foreach (IMemberInitializer memberInitializer in expression.Initializer.InitializerElements)
{
var kind = Eater.Eat(snapshot, memberInitializer.Expression);
snapshot.Add(kind, memberInitializer);
}
}
return(GetCreationObjectKind(snapshot, expression));
}
public FakeOptionType EatOption(ISnapshot snapshot, IInvocationExpression invocationExpression)
{
_argumentsEater.Eat(snapshot, invocationExpression.Arguments);
if (invocationExpression.ExtensionQualifier == null)
{
throw new MoqStubWrongSyntaxException("Moq-stub invocation-option has not parent reference", this,
invocationExpression);
}
var extensionArgumentInfo =
invocationExpression.ExtensionQualifier.ManagedConvertible as ExtensionArgumentInfo;
if (extensionArgumentInfo == null || extensionArgumentInfo.Expression == null)
{
throw new MoqStubWrongSyntaxException("Moq-stub invocation-option has not parent reference", this,
invocationExpression);
}
var parentReference = extensionArgumentInfo.Expression;
if (parentReference is IInvocationExpression)
{
return(EatOption(snapshot, parentReference as IInvocationExpression));
}
if (parentReference is IReferenceExpression)
{
var declaredElement = _eatExpressionHelper.GetReferenceElement(parentReference as IReferenceExpression);
if (declaredElement is ILambdaParameterDeclaration)
{
return(FakeOptionType.Method);
}
return(EatOption(snapshot, parentReference as IReferenceExpression));
}
throw new MoqStubOptionTargetWrongTypeException(this, parentReference);
}