protected MemberAccessExpressionSyntax StrictnessExpression()
{
return
(VeryStrict ? TypesForSymbols.StrictnessVeryStrict() :
Strict?TypesForSymbols.StrictnessStrict() :
TypesForSymbols.StrictnessLenient());
}
private MemberDeclarationSyntax MockVirtualMethod()
{
var parameters = F.SeparatedList(Symbol.Parameters.Select(ps => TypesForSymbols.AsParameterSyntax(ps)));
if (ArglistParameterName != null && TypesForSymbols.RuntimeArgumentHandle() != null)
{
parameters = parameters.Add(F.Parameter(F.Identifier(ArglistParameterName)).WithType(TypesForSymbols.RuntimeArgumentHandle()));
}
var method = F.MethodDeclaration(ReturnTypeWithoutReadonly, F.Identifier(MemberMockName))
.WithModifiers(F.TokenList(F.Token(SyntaxKind.ProtectedKeyword), F.Token(SyntaxKind.VirtualKeyword)))
.WithParameterList(F.ParameterList(parameters))
.WithBody(F.Block(ThrowMockMissingStatement("VirtualMethod")));
if (Symbol.TypeParameters.Any())
{
method = method.WithTypeParameterList(TypeParameterList());
var constraints = TypesForSymbols.AsConstraintClauses(Symbol.TypeParameters);
if (constraints.Any())
{
method = method.AddConstraintClauses(constraints);
}
}
return(method);
}
private MemberDeclarationSyntax TypedMockProviderField()
{
return(F.FieldDeclaration(F.VariableDeclaration(TypesForSymbols.TypedMockProvider()).WithVariables(
F.SingletonSeparatedList(F.VariableDeclarator(F.Identifier(MockProviderName))
.WithInitializer(F.EqualsValueClause(F.ObjectCreationExpression(TypesForSymbols.TypedMockProvider())
.WithArgumentList(F.ArgumentList())))))
).WithModifiers(F.TokenList(F.Token(SyntaxKind.PrivateKeyword), F.Token(SyntaxKind.ReadOnlyKeyword))));
}
private MemberDeclarationSyntax ExplicitInterfaceMember()
{
var decoratedValueTypeSyntax = ValueTypeSyntax;
if (Symbol.ReturnsByRef)
{
decoratedValueTypeSyntax = F.RefType(decoratedValueTypeSyntax);
}
else if (Symbol.ReturnsByRefReadonly)
{
decoratedValueTypeSyntax = F.RefType(decoratedValueTypeSyntax).WithReadOnlyKeyword(F.Token(SyntaxKind.ReadOnlyKeyword));
}
var mockedProperty = F.PropertyDeclaration(decoratedValueTypeSyntax, Symbol.Name)
.WithExplicitInterfaceSpecifier(F.ExplicitInterfaceSpecifier(TypesForSymbols.ParseName(InterfaceSymbol)));
if (Symbol.IsReadOnly)
{
ExpressionSyntax elementAccess = F.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, F.IdentifierName(MemberMockName),
F.IdentifierName("Value"));
if (Symbol.ReturnsByRef || Symbol.ReturnsByRefReadonly)
{
elementAccess = TypesForSymbols.WrapByRef(elementAccess, ValueTypeSyntax);
}
mockedProperty = mockedProperty.WithExpressionBody(F.ArrowExpressionClause(elementAccess))
.WithSemicolonToken(F.Token(SyntaxKind.SemicolonToken));
}
else
{
if (!Symbol.IsWriteOnly)
{
mockedProperty = mockedProperty.AddAccessorListAccessors(F.AccessorDeclaration(SyntaxKind.GetAccessorDeclaration)
.WithExpressionBody(F.ArrowExpressionClause(F.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression,
F.IdentifierName(MemberMockName),
F.IdentifierName("Value"))))
.WithSemicolonToken(F.Token(SyntaxKind.SemicolonToken))
);
}
if (!Symbol.IsReadOnly)
{
mockedProperty = mockedProperty.AddAccessorListAccessors(F.AccessorDeclaration(SyntaxKind.SetAccessorDeclaration)
.WithExpressionBody(
F.ArrowExpressionClause(
F.AssignmentExpression(SyntaxKind.SimpleAssignmentExpression,
F.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, F.IdentifierName(MemberMockName),
F.IdentifierName("Value")),
F.IdentifierName("value"))))
.WithSemicolonToken(F.Token(SyntaxKind.SemicolonToken))
);
}
}
return(mockedProperty);
}
private MemberDeclarationSyntax ExplicitInterfaceMember()
{
var decoratedValueTypeSyntax = ValueTypeSyntax;
if (Symbol.ReturnsByRef)
{
decoratedValueTypeSyntax = F.RefType(decoratedValueTypeSyntax);
}
else if (Symbol.ReturnsByRefReadonly)
{
decoratedValueTypeSyntax = F.RefType(decoratedValueTypeSyntax).WithReadOnlyKeyword(F.Token(SyntaxKind.ReadOnlyKeyword));
}
var mockedIndexer = F.IndexerDeclaration(decoratedValueTypeSyntax)
.WithParameterList(KeyType.BuildParameterList())
.WithExplicitInterfaceSpecifier(F.ExplicitInterfaceSpecifier(TypesForSymbols.ParseName(InterfaceSymbol)));
var arguments = KeyType.BuildArgumentList();
if (Symbol.IsReadOnly)
{
ExpressionSyntax elementAccess = F.ElementAccessExpression(F.IdentifierName(MemberMockName))
.WithExpressionsAsArgumentList(arguments);
if (Symbol.ReturnsByRef || Symbol.ReturnsByRefReadonly)
{
elementAccess = TypesForSymbols.WrapByRef(elementAccess, ValueTypeSyntax);
}
mockedIndexer = mockedIndexer.WithExpressionBody(F.ArrowExpressionClause(elementAccess))
.WithSemicolonToken(F.Token(SyntaxKind.SemicolonToken));
}
else
{
if (!Symbol.IsWriteOnly)
{
mockedIndexer = mockedIndexer.AddAccessorListAccessors(F.AccessorDeclaration(SyntaxKind.GetAccessorDeclaration)
.WithExpressionBody(F.ArrowExpressionClause(F.ElementAccessExpression(F.IdentifierName(MemberMockName))
.WithExpressionsAsArgumentList(arguments)))
.WithSemicolonToken(F.Token(SyntaxKind.SemicolonToken))
);
}
if (!Symbol.IsReadOnly)
{
mockedIndexer = mockedIndexer.AddAccessorListAccessors(F.AccessorDeclaration(SyntaxKind.SetAccessorDeclaration)
.WithExpressionBody(F.ArrowExpressionClause(
F.AssignmentExpression(SyntaxKind.SimpleAssignmentExpression,
F.ElementAccessExpression(F.IdentifierName(MemberMockName)).WithExpressionsAsArgumentList(arguments),
F.IdentifierName("value"))))
.WithSemicolonToken(F.Token(SyntaxKind.SemicolonToken)));
}
}
return(mockedIndexer);
}
protected ThrowStatementSyntax ThrowMockMissingStatement(string mockType)
{
return(F.ThrowStatement(F.ObjectCreationExpression(TypesForSymbols.MockMissingException())
.WithExpressionsAsArgumentList(
F.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, TypesForSymbols.MockType(),
F.IdentifierName(mockType)),
F.LiteralExpression(SyntaxKind.StringLiteralExpression, F.Literal(ClassSymbol.Name)),
F.LiteralExpression(SyntaxKind.StringLiteralExpression, F.Literal(InterfaceSymbol.Name)),
F.LiteralExpression(SyntaxKind.StringLiteralExpression, F.Literal(Symbol.Name)),
F.LiteralExpression(SyntaxKind.StringLiteralExpression, F.Literal(MemberMockName))
)
));
}
protected override MethodDeclarationSyntax ExplicitInterfaceMemberMethodDeclaration(TypeSyntax returnType)
{
var m = base.ExplicitInterfaceMemberMethodDeclaration(returnType).WithTypeParameterList(TypeParameterList());
var constraints = TypesForSymbols.AsClassConstraintClausesForReferenceTypes(Symbol.TypeParameters);
if (constraints.Any())
{
m = m.AddConstraintClauses(constraints);
}
return(m);
}
private MemberDeclarationSyntax ExplicitInterfaceMember()
{
var parameters = F.SeparatedList(Symbol.Parameters.Select(p => TypesForSymbols.AsParameterSyntax(p)));
if (ArglistParameterName != null)
{
parameters = parameters.Add(F.Parameter(F.Token(SyntaxKind.ArgListKeyword)));
}
var arguments = Symbol.Parameters.AsArgumentList();
if (ArglistParameterName != null && TypesForSymbols.RuntimeArgumentHandle() != null)
{
arguments = arguments.Add(F.Argument(F.LiteralExpression(SyntaxKind.ArgListExpression, F.Token(SyntaxKind.ArgListKeyword))));
}
var mockedMethod = F.MethodDeclaration(ReturnType, Symbol.Name)
.WithParameterList(F.ParameterList(parameters))
.WithExplicitInterfaceSpecifier(F.ExplicitInterfaceSpecifier(TypesForSymbols.ParseName(InterfaceSymbol)));
if (Symbol.TypeParameters.Any())
{
mockedMethod = mockedMethod.WithTypeParameterList(TypeParameterList());
}
var invocation = Symbol.TypeParameters.Any()
? (ExpressionSyntax)F.GenericName(MemberMockName)
.WithTypeArgumentList(F.TypeArgumentList(
F.SeparatedList(Symbol.TypeParameters.Select(typeParameter =>
TypesForSymbols.ParseTypeName(typeParameter, false)))))
: F.IdentifierName(MemberMockName);
invocation = F.InvocationExpression(invocation, F.ArgumentList(arguments));
if (Symbol.ReturnsByRef || Symbol.ReturnsByRefReadonly)
{
invocation = F.RefExpression(invocation);
}
mockedMethod = mockedMethod
.WithExpressionBody(F.ArrowExpressionClause(invocation))
.WithSemicolonToken(F.Token(SyntaxKind.SemicolonToken));
return(mockedMethod);
}
private MemberDeclarationSyntax MockProviderMethod()
{
var m = F.MethodDeclaration(MockMemberType, F.Identifier(MemberMockName)).WithTypeParameterList(TypeParameterList());
m = m.WithModifiers(F.TokenList(F.Token(SyntaxKind.PublicKeyword)));
var keyCreation = F.LocalDeclarationStatement(F.VariableDeclaration(F.IdentifierName("var")).WithVariables(F.SingletonSeparatedList(F
.VariableDeclarator(F.Identifier("key")).WithInitializer(F.EqualsValueClause(TypesOfTypeParameters())))));
var mockCreation = F.SimpleLambdaExpression(F.Parameter(F.Identifier("keyString")), F.ObjectCreationExpression(MockMemberType)
.WithExpressionsAsArgumentList(
F.ThisExpression(),
F.LiteralExpression(SyntaxKind.StringLiteralExpression, F.Literal(ClassSymbol.Name)),
F.LiteralExpression(SyntaxKind.StringLiteralExpression, F.Literal(InterfaceSymbol.Name)),
F.BinaryExpression(SyntaxKind.AddExpression, F.LiteralExpression(SyntaxKind.StringLiteralExpression, F.Literal(Symbol.Name)),
F.IdentifierName("keyString")),
F.BinaryExpression(SyntaxKind.AddExpression,
F.BinaryExpression(SyntaxKind.AddExpression,
F.LiteralExpression(SyntaxKind.StringLiteralExpression, F.Literal(MemberMockName)), F.IdentifierName("keyString")),
F.LiteralExpression(
SyntaxKind.StringLiteralExpression,
F.Literal("()"))),
StrictnessExpression()
));
var returnStatement = F.ReturnStatement(F.CastExpression(MockMemberType, F.InvocationExpression(
F.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, F.IdentifierName(MockProviderName),
F.IdentifierName("GetOrAdd")))
.WithArgumentList(
F.ArgumentList(F.SeparatedList(new[] { F.Argument(F.IdentifierName("key")), F.Argument(mockCreation) })))));
m = m.WithBody(F.Block(keyCreation, returnStatement));
var constraints = TypesForSymbols.AsConstraintClauses(Symbol.TypeParameters);
if (constraints.Any())
{
m = m.AddConstraintClauses(constraints);
}
return(m);
}
private MemberDeclarationSyntax ExplicitInterfaceMember()
{
var mockedProperty = F.PropertyDeclaration(ValueWithReadonlyTypeSyntax, Symbol.Name)
.WithExplicitInterfaceSpecifier(F.ExplicitInterfaceSpecifier(TypesForSymbols.ParseName(InterfaceSymbol)));
if (Symbol.IsReadOnly)
{
ExpressionSyntax invocation = F.InvocationExpression(F.IdentifierName(MemberMockName));
if (Symbol.ReturnsByRef || Symbol.ReturnsByRefReadonly)
{
invocation = F.RefExpression(invocation);
}
mockedProperty = mockedProperty
.WithExpressionBody(F.ArrowExpressionClause(invocation))
.WithSemicolonToken(F.Token(SyntaxKind.SemicolonToken));
}
else
{
if (!Symbol.IsWriteOnly)
{
mockedProperty = mockedProperty.AddAccessorListAccessors(F.AccessorDeclaration(SyntaxKind.GetAccessorDeclaration)
.WithExpressionBody(F.ArrowExpressionClause(F.InvocationExpression(F.IdentifierName(MemberMockName))))
.WithSemicolonToken(F.Token(SyntaxKind.SemicolonToken))
);
}
if (!Symbol.IsReadOnly)
{
mockedProperty = mockedProperty.AddAccessorListAccessors(F.AccessorDeclaration(SyntaxKind.SetAccessorDeclaration)
.WithExpressionBody(F.ArrowExpressionClause(F.InvocationExpression(F.IdentifierName(MemberMockName),
F.ArgumentList(F.SeparatedList(new[] { F.Argument(F.IdentifierName("value")) })))))
.WithSemicolonToken(F.Token(SyntaxKind.SemicolonToken))
);
}
}
return(mockedProperty);
}
private MemberDeclarationSyntax MockSetVirtualMethod()
{
var uniquifier = new Uniquifier(Symbol.Parameters.Select(p => p.Name));
var parameterList = F.SeparatedList(Symbol.Parameters.Select(a =>
F.Parameter(F.Identifier(a.Name)).WithType(TypesForSymbols.ParseTypeName(a.Type, a.NullableOrOblivious()))))
.Add(F.Parameter(F.Identifier(uniquifier.GetUniqueName("value"))).WithType(ValueTypeSyntax));
return(F.MethodDeclaration(F.PredefinedType(F.Token(SyntaxKind.VoidKeyword)), F.Identifier(MemberMockName))
.WithModifiers(F.TokenList(F.Token(SyntaxKind.ProtectedKeyword), F.Token(SyntaxKind.VirtualKeyword)))
.WithParameterList(F.ParameterList(parameterList))
.WithBody(F.Block(ThrowMockMissingStatement("VirtualIndexerSet"))));
}
public PropertyBasedMethodMock(MocklisTypesForSymbols typesForSymbols, INamedTypeSymbol classSymbol, INamedTypeSymbol interfaceSymbol,
IMethodSymbol symbol, string mockMemberName, bool strict, bool veryStrict) : base(typesForSymbols, classSymbol, interfaceSymbol, symbol,
mockMemberName, strict, veryStrict)
{
var parametersBuilder = new SingleTypeOrValueTupleBuilder(TypesForSymbols);
var returnValuesBuilder = new SingleTypeOrValueTupleBuilder(TypesForSymbols);
if (!symbol.ReturnsVoid)
{
returnValuesBuilder.AddReturnValue(symbol.ReturnType, symbol.ReturnTypeIsNullableOrOblivious());
}
foreach (var parameter in symbol.Parameters)
{
switch (parameter.RefKind)
{
case RefKind.Ref:
{
parametersBuilder.AddParameter(parameter);
returnValuesBuilder.AddParameter(parameter);
break;
}
case RefKind.Out:
{
returnValuesBuilder.AddParameter(parameter);
break;
}
case RefKind.In:
{
parametersBuilder.AddParameter(parameter);
break;
}
case RefKind.None:
{
parametersBuilder.AddParameter(parameter);
break;
}
}
}
ParametersType = parametersBuilder.Build();
ReturnValuesType = returnValuesBuilder.Build();
var parameterTypeSyntax = ParametersType.BuildTypeSyntax();
var returnValueTypeSyntax = ReturnValuesType.BuildTypeSyntax();
if (returnValueTypeSyntax == null)
{
MockMemberType = parameterTypeSyntax == null
? TypesForSymbols.ActionMethodMock()
: TypesForSymbols.ActionMethodMock(parameterTypeSyntax);
}
else
{
MockMemberType = parameterTypeSyntax == null
? TypesForSymbols.FuncMethodMock(returnValueTypeSyntax)
: TypesForSymbols.FuncMethodMock(parameterTypeSyntax, returnValueTypeSyntax);
}
}
private TypeArgumentListSyntax TypeArgumentList()
{
return(F.TypeArgumentList(
F.SeparatedList <TypeSyntax>(Symbol.TypeParameters.Select(typeParameter =>
F.IdentifierName(TypesForSymbols.FindTypeParameterName(typeParameter.Name))))));
}
public void AddReturnValue(ITypeSymbol returnType, bool nullable)
{
Items.Add(new BuilderEntry("returnValue", TypesForSymbols.ParseTypeName(returnType, nullable), true));
}
public void AddParameter(IParameterSymbol parameter)
{
var x = TypesForSymbols.ParseTypeName(parameter.Type, parameter.NullableOrOblivious());
Items.Add(new BuilderEntry(parameter.Name, x, false));
}
protected MemberDeclarationSyntax ExplicitInterfaceMember()
{
var baseReturnType = Symbol.ReturnsVoid
? F.PredefinedType(F.Token(SyntaxKind.VoidKeyword))
: TypesForSymbols.ParseTypeName(Symbol.ReturnType, Symbol.ReturnTypeIsNullableOrOblivious());
var returnType = baseReturnType;
if (Symbol.ReturnsByRef)
{
returnType = F.RefType(returnType);
}
else if (Symbol.ReturnsByRefReadonly)
{
returnType = F.RefType(returnType).WithReadOnlyKeyword(F.Token(SyntaxKind.ReadOnlyKeyword));
}
var mockedMethod = ExplicitInterfaceMemberMethodDeclaration(returnType);
var memberMockInstance = ExplicitInterfaceMemberMemberMockInstance();
ExpressionSyntax invocation = F.InvocationExpression(
F.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression,
memberMockInstance, F.IdentifierName("Call")))
.WithExpressionsAsArgumentList(ParametersType.BuildArgumentListWithOriginalNames());
// look at the return parameters. If we don't have any we can just make the call.
// if we only have one and that's the return value, we can just return it.
if (ReturnValuesType.Count == 0 ||
ReturnValuesType.Count == 1 && ReturnValuesType[0].IsReturnValue)
{
if (Symbol.ReturnsByRef || Symbol.ReturnsByRefReadonly)
{
invocation = TypesForSymbols.WrapByRef(invocation, baseReturnType);
}
mockedMethod = mockedMethod.WithExpressionBody(F.ArrowExpressionClause(invocation))
.WithSemicolonToken(F.Token(SyntaxKind.SemicolonToken));
}
// if we only have one and that's not a return value, we can just assign it to the out or ref parameter it corresponds to.
else if (ReturnValuesType.Count == 1)
{
mockedMethod = mockedMethod.WithBody(F.Block(F.ExpressionStatement(F.AssignmentExpression(SyntaxKind.SimpleAssignmentExpression,
F.IdentifierName(ReturnValuesType[0].OriginalName), invocation))));
}
else
{
// if we have more than one, put it in a temporary variable. (consider name clashes with method parameter names)
var x = new Uniquifier(Symbol.Parameters.Select(m => m.Name));
string tmp = x.GetUniqueName("tmp");
var statements = new List <StatementSyntax>
{
F.LocalDeclarationStatement(F.VariableDeclaration(F.IdentifierName("var")).WithVariables(
F.SingletonSeparatedList(F.VariableDeclarator(F.Identifier(tmp)).WithInitializer(F.EqualsValueClause(invocation)))))
};
// then for any out or ref parameters, set their values from the temporary variable.
foreach (var rv in ReturnValuesType.Where(a => !a.IsReturnValue))
{
statements.Add(F.ExpressionStatement(F.AssignmentExpression(SyntaxKind.SimpleAssignmentExpression,
F.IdentifierName(rv.OriginalName),
F.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, F.IdentifierName(tmp),
F.IdentifierName(rv.TupleSafeName)))));
}
// finally, if there is a 'proper' return type, return the corresponding value from the temporary variable.
foreach (var rv in ReturnValuesType.Where(a => a.IsReturnValue))
{
ExpressionSyntax memberAccess = F.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, F.IdentifierName(tmp),
F.IdentifierName(rv.TupleSafeName));
if (Symbol.ReturnsByRef || Symbol.ReturnsByRefReadonly)
{
memberAccess = TypesForSymbols.WrapByRef(memberAccess, baseReturnType);
}
statements.Add(F.ReturnStatement(memberAccess));
}
mockedMethod = mockedMethod.WithBody(F.Block(statements));
}
return(mockedMethod);
}
protected virtual MethodDeclarationSyntax ExplicitInterfaceMemberMethodDeclaration(TypeSyntax returnType)
{
return(F.MethodDeclaration(returnType, Symbol.Name)
.WithParameterList(Symbol.Parameters.AsParameterList(TypesForSymbols))
.WithExplicitInterfaceSpecifier(F.ExplicitInterfaceSpecifier(TypesForSymbols.ParseName(InterfaceSymbol))));
}
private ImplicitArrayCreationExpressionSyntax TypesOfTypeParameters()
{
return(F.ImplicitArrayCreationExpression(F.InitializerExpression(SyntaxKind.ArrayInitializerExpression,
F.SeparatedList <ExpressionSyntax>(Symbol.TypeParameters.Select(typeParameter =>
F.TypeOfExpression(F.IdentifierName(TypesForSymbols.FindTypeParameterName(typeParameter.Name))))))));
}
private MemberDeclarationSyntax MockGetVirtualMethod()
{
return(F.MethodDeclaration(ValueTypeSyntax, F.Identifier(MemberMockName))
.WithModifiers(F.TokenList(F.Token(SyntaxKind.ProtectedKeyword), F.Token(SyntaxKind.VirtualKeyword)))
.WithParameterList(F.ParameterList(F.SeparatedList(Symbol.Parameters.Select(a =>
F.Parameter(F.Identifier(a.Name)).WithType(TypesForSymbols.ParseTypeName(a.Type, a.NullableOrOblivious()))))))
.WithBody(F.Block(ThrowMockMissingStatement("VirtualIndexerGet"))));
}
private TypeParameterListSyntax TypeParameterList()
{
return(F.TypeParameterList(F.SeparatedList(Symbol.TypeParameters.Select(typeParameter =>
F.TypeParameter(TypesForSymbols.FindTypeParameterName(typeParameter.Name))))));
}
private MemberDeclarationSyntax ExplicitInterfaceMember()
{
var mockedIndexer = F.IndexerDeclaration(ValueWithReadonlyTypeSyntax)
.WithParameterList(F.BracketedParameterList(F.SeparatedList(Symbol.Parameters.Select(a =>
F.Parameter(F.Identifier(a.Name)).WithType(TypesForSymbols.ParseTypeName(a.Type, a.NullableOrOblivious()))))))
.WithExplicitInterfaceSpecifier(F.ExplicitInterfaceSpecifier(TypesForSymbols.ParseName(InterfaceSymbol)));
if (Symbol.IsReadOnly)
{
ExpressionSyntax invocation = F.InvocationExpression(F.IdentifierName(MemberMockName),
F.ArgumentList(F.SeparatedList(Symbol.Parameters.Select(a => F.Argument(F.IdentifierName(a.Name))))));
if (Symbol.ReturnsByRef || Symbol.ReturnsByRefReadonly)
{
invocation = F.RefExpression(invocation);
}
mockedIndexer = mockedIndexer
.WithExpressionBody(F.ArrowExpressionClause(invocation))
.WithSemicolonToken(F.Token(SyntaxKind.SemicolonToken));
}
else
{
if (!Symbol.IsWriteOnly)
{
var argumentList = F.SeparatedList(Symbol.Parameters.Select(a => F.Argument(F.IdentifierName(a.Name))));
mockedIndexer = mockedIndexer.AddAccessorListAccessors(F.AccessorDeclaration(SyntaxKind.GetAccessorDeclaration)
.WithExpressionBody(F.ArrowExpressionClause(F.InvocationExpression(F.IdentifierName(MemberMockName))
.WithArgumentList(F.ArgumentList(argumentList))))
.WithSemicolonToken(F.Token(SyntaxKind.SemicolonToken))
);
}
if (!Symbol.IsReadOnly)
{
var argumentList = F.SeparatedList(Symbol.Parameters.Select(a => F.Argument(F.IdentifierName(a.Name))))
.Add(F.Argument(F.IdentifierName("value")));
mockedIndexer = mockedIndexer.AddAccessorListAccessors(F.AccessorDeclaration(SyntaxKind.SetAccessorDeclaration)
.WithExpressionBody(F.ArrowExpressionClause(F.InvocationExpression(F.IdentifierName(MemberMockName),
F.ArgumentList(argumentList))))
.WithSemicolonToken(F.Token(SyntaxKind.SemicolonToken))
);
}
}
return(mockedIndexer);
}
private MemberDeclarationSyntax ExplicitInterfaceMember()
{
var mockedProperty = F.EventDeclaration(EventHandlerTypeSyntax, Symbol.Name)
.WithExplicitInterfaceSpecifier(F.ExplicitInterfaceSpecifier(TypesForSymbols.ParseName(InterfaceSymbol)));
mockedProperty = mockedProperty.AddAccessorListAccessors(F.AccessorDeclaration(SyntaxKind.AddAccessorDeclaration)
.WithExpressionBody(F.ArrowExpressionClause(F.InvocationExpression(
F.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, F.IdentifierName(MemberMockName),
F.IdentifierName("Add")))
.WithExpressionsAsArgumentList(F.IdentifierName("value"))))
.WithSemicolonToken(F.Token(SyntaxKind.SemicolonToken))
);
mockedProperty = mockedProperty.AddAccessorListAccessors(F.AccessorDeclaration(SyntaxKind.RemoveAccessorDeclaration)
.WithExpressionBody(F.ArrowExpressionClause(F.InvocationExpression(
F.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression,
F.IdentifierName(MemberMockName), F.IdentifierName("Remove")))
.WithExpressionsAsArgumentList(F.IdentifierName("value"))))
.WithSemicolonToken(F.Token(SyntaxKind.SemicolonToken)));
return(mockedProperty);
}
