public static ExpressionSyntax ImplicitlyTypedArray(ITypeSymbol typeSymbol, SemanticModel model, HashSet <string> visitedTypes, IFrameworkSet frameworkSet)
{
if (typeSymbol is IArrayTypeSymbol arrayTypeSymbol)
{
if (visitedTypes.Contains(arrayTypeSymbol.ElementType.ToFullName()))
{
return(SyntaxFactory.ArrayCreationExpression(SyntaxFactory.ArrayType(arrayTypeSymbol.ElementType.ToTypeSyntax(frameworkSet.Context))));
}
return(SyntaxFactory.ImplicitArrayCreationExpression(
SyntaxFactory.InitializerExpression(
SyntaxKind.ArrayInitializerExpression,
SyntaxFactory.SeparatedList <ExpressionSyntax>(
new SyntaxNodeOrToken[]
{
AssignmentValueHelper.GetDefaultAssignmentValue(arrayTypeSymbol.ElementType, model, new HashSet <string>(visitedTypes, StringComparer.OrdinalIgnoreCase), frameworkSet),
SyntaxFactory.Token(SyntaxKind.CommaToken),
AssignmentValueHelper.GetDefaultAssignmentValue(arrayTypeSymbol.ElementType, model, new HashSet <string>(visitedTypes, StringComparer.OrdinalIgnoreCase), frameworkSet),
SyntaxFactory.Token(SyntaxKind.CommaToken),
AssignmentValueHelper.GetDefaultAssignmentValue(arrayTypeSymbol.ElementType, model, new HashSet <string>(visitedTypes, StringComparer.OrdinalIgnoreCase), frameworkSet),
}))));
}
var random = ValueGenerationStrategyFactory.Random;
return(SyntaxFactory.InvocationExpression(
SyntaxFactory.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
SyntaxFactory.IdentifierName("Array"),
SyntaxFactory.IdentifierName("CreateInstance")))
.WithArgumentList(
Generate.Arguments(SyntaxFactory.TypeOfExpression(SyntaxFactory.IdentifierName("int")), Generate.Literal(random.Next(int.MaxValue)), Generate.Literal(random.Next(int.MaxValue)), Generate.Literal(random.Next(int.MaxValue)))));
}
public static ExpressionSyntax ImplicitlyTyped(ITypeSymbol typeSymbol, SemanticModel model, HashSet <string> visitedTypes, IFrameworkSet frameworkSet)
{
if (typeSymbol is INamedTypeSymbol namedTypeSymbol && namedTypeSymbol.TypeArguments.Length > 0)
{
var targetType = namedTypeSymbol.TypeArguments[0];
if (visitedTypes.Contains(targetType.ToFullName()))
{
return(SyntaxFactory.ArrayCreationExpression(SyntaxFactory.ArrayType(targetType.ToTypeSyntax(frameworkSet.Context))));
}
return(SyntaxFactory.ImplicitArrayCreationExpression(
SyntaxFactory.InitializerExpression(
SyntaxKind.ArrayInitializerExpression,
SyntaxFactory.SeparatedList <ExpressionSyntax>(
new SyntaxNodeOrToken[]
{
AssignmentValueHelper.GetDefaultAssignmentValue(targetType, model, new HashSet <string>(visitedTypes, StringComparer.OrdinalIgnoreCase), frameworkSet),
SyntaxFactory.Token(SyntaxKind.CommaToken),
AssignmentValueHelper.GetDefaultAssignmentValue(targetType, model, new HashSet <string>(visitedTypes, StringComparer.OrdinalIgnoreCase), frameworkSet),
SyntaxFactory.Token(SyntaxKind.CommaToken),
AssignmentValueHelper.GetDefaultAssignmentValue(targetType, model, new HashSet <string>(visitedTypes, StringComparer.OrdinalIgnoreCase), frameworkSet),
}))));
}
return(AssignmentValueHelper.GetDefaultAssignmentValue(typeSymbol, model, frameworkSet));
}
private IEnumerable <StatementSyntax> GetPropertyAssertionBodyStatements(IPropertyModel property, ClassModel sourceModel)
{
var target = property.IsStatic ? sourceModel.TypeSyntax : sourceModel.TargetInstance;
var defaultAssignmentValue = AssignmentValueHelper.GetDefaultAssignmentValue(property.TypeInfo, sourceModel.SemanticModel, _frameworkSet);
yield return(SyntaxFactory.ExpressionStatement(SyntaxFactory.AssignmentExpression(SyntaxKind.SimpleAssignmentExpression, Generate.PropertyAccess(target, property.Name), defaultAssignmentValue)));
yield return(_frameworkSet.TestFramework.AssertFail(Strings.PlaceholderAssertionMessage));
}
private IEnumerable <StatementSyntax> GetPropertyAssertionBodyStatements(IIndexerModel indexer, ClassModel sourceModel)
{
var paramExpressions = indexer.Parameters.Select(param => AssignmentValueHelper.GetDefaultAssignmentValue(param.TypeInfo, sourceModel.SemanticModel, _frameworkSet)).ToArray();
var defaultAssignmentValue = AssignmentValueHelper.GetDefaultAssignmentValue(indexer.TypeInfo, sourceModel.SemanticModel, _frameworkSet);
yield return(SyntaxFactory.ExpressionStatement(SyntaxFactory.AssignmentExpression(SyntaxKind.SimpleAssignmentExpression, Generate.IndexerAccess(sourceModel.TargetInstance, paramExpressions), defaultAssignmentValue)));
yield return(_frameworkSet.TestFramework.AssertFail(Strings.PlaceholderAssertionMessage));
}
public IEnumerable <MethodDeclarationSyntax> Create(IOperatorModel method, ClassModel model)
{
if (method is null)
{
throw new ArgumentNullException(nameof(method));
}
if (model is null)
{
throw new ArgumentNullException(nameof(model));
}
var methodName = string.Format(CultureInfo.InvariantCulture, "CanCall{0}Operator", method.Name);
var generatedMethod = _frameworkSet.TestFramework.CreateTestMethod(methodName, false, model.IsStatic);
var paramExpressions = new List <CSharpSyntaxNode>();
foreach (var parameter in method.Parameters)
{
var defaultAssignmentValue = AssignmentValueHelper.GetDefaultAssignmentValue(parameter.TypeInfo, model.SemanticModel, _frameworkSet);
generatedMethod = generatedMethod.AddBodyStatements(SyntaxFactory.LocalDeclarationStatement(
SyntaxFactory.VariableDeclaration(SyntaxFactory.IdentifierName(Strings.Create_var))
.WithVariables(SyntaxFactory.SingletonSeparatedList(
SyntaxFactory.VariableDeclarator(SyntaxFactory.Identifier(parameter.Name))
.WithInitializer(SyntaxFactory.EqualsValueClause(defaultAssignmentValue))))));
paramExpressions.Add(SyntaxFactory.IdentifierName(parameter.Name));
}
var methodCall = method.Invoke(model, false, _frameworkSet, paramExpressions.ToArray());
var bodyStatement = SyntaxFactory.LocalDeclarationStatement(
SyntaxFactory.VariableDeclaration(
SyntaxFactory.IdentifierName(Strings.Create_var))
.WithVariables(
SyntaxFactory.SingletonSeparatedList(
SyntaxFactory.VariableDeclarator(
SyntaxFactory.Identifier(Strings.CanCallMethodGenerationStrategy_Create_result))
.WithInitializer(
SyntaxFactory.EqualsValueClause(methodCall)))));
generatedMethod = generatedMethod.AddBodyStatements(bodyStatement);
generatedMethod = generatedMethod.AddBodyStatements(_frameworkSet.TestFramework.AssertFail(Strings.PlaceholderAssertionMessage));
yield return(generatedMethod);
}
private IEnumerable <StatementSyntax> GetPropertyAssertionBodyStatements(IPropertyModel property, ClassModel sourceModel)
{
yield return(SyntaxFactory.LocalDeclarationStatement(
SyntaxFactory.VariableDeclaration(
SyntaxFactory.IdentifierName(Strings.Create_var))
.WithVariables(
SyntaxFactory.SingletonSeparatedList(
SyntaxFactory.VariableDeclarator(
SyntaxFactory.Identifier(Strings.ReadWritePropertyGenerationStrategy_GetPropertyAssertionBodyStatements_testValue))
.WithInitializer(
SyntaxFactory.EqualsValueClause(
AssignmentValueHelper.GetDefaultAssignmentValue(property.TypeInfo, sourceModel.SemanticModel, _frameworkSet)))))));
var target = property.IsStatic ? sourceModel.TypeSyntax : sourceModel.TargetInstance;
yield return(SyntaxFactory.ExpressionStatement(SyntaxFactory.AssignmentExpression(SyntaxKind.SimpleAssignmentExpression, Generate.PropertyAccess(target, property.Name), SyntaxFactory.IdentifierName(Strings.ReadWritePropertyGenerationStrategy_GetPropertyAssertionBodyStatements_testValue))));
yield return(_frameworkSet.TestFramework.AssertEqual(Generate.PropertyAccess(target, property.Name), SyntaxFactory.IdentifierName(Strings.ReadWritePropertyGenerationStrategy_GetPropertyAssertionBodyStatements_testValue)));
}
public IEnumerable <MethodDeclarationSyntax> Create(IIndexerModel indexer, ClassModel model)
{
if (indexer == null)
{
throw new ArgumentNullException(nameof(indexer));
}
if (model == null)
{
throw new ArgumentNullException(nameof(model));
}
var paramExpressions = indexer.Parameters.Select(param => AssignmentValueHelper.GetDefaultAssignmentValue(param.TypeInfo, model.SemanticModel, _frameworkSet)).ToArray();
var method = _frameworkSet.TestFramework.CreateTestMethod(string.Format(CultureInfo.InvariantCulture, "CanGet{0}", model.GetIndexerName(indexer)), false, model.IsStatic)
.AddBodyStatements(_frameworkSet.TestFramework.AssertIsInstanceOf(Generate.IndexerAccess(model.TargetInstance, paramExpressions), indexer.TypeInfo.ToTypeSyntax(_frameworkSet.Context)))
.AddBodyStatements(_frameworkSet.TestFramework.AssertFail(Strings.PlaceholderAssertionMessage));
yield return(method);
}
private IEnumerable <StatementSyntax> GetPropertyAssertionBodyStatements(IIndexerModel indexer, ClassModel sourceModel)
{
var paramExpressions = indexer.Parameters.Select(param => AssignmentValueHelper.GetDefaultAssignmentValue(param.TypeInfo, sourceModel.SemanticModel, _frameworkSet)).ToArray();
yield return(SyntaxFactory.LocalDeclarationStatement(
SyntaxFactory.VariableDeclaration(
SyntaxFactory.IdentifierName(Strings.Create_var))
.WithVariables(
SyntaxFactory.SingletonSeparatedList(
SyntaxFactory.VariableDeclarator(
SyntaxFactory.Identifier(Strings.ReadWritePropertyGenerationStrategy_GetPropertyAssertionBodyStatements_testValue))
.WithInitializer(
SyntaxFactory.EqualsValueClause(
AssignmentValueHelper.GetDefaultAssignmentValue(indexer.TypeInfo, sourceModel.SemanticModel, _frameworkSet)))))));
yield return(_frameworkSet.TestFramework.AssertIsInstanceOf(Generate.IndexerAccess(sourceModel.TargetInstance, paramExpressions), indexer.TypeInfo.ToTypeSyntax(_frameworkSet.Context)));
yield return(SyntaxFactory.ExpressionStatement(SyntaxFactory.AssignmentExpression(SyntaxKind.SimpleAssignmentExpression, Generate.IndexerAccess(sourceModel.TargetInstance, paramExpressions), SyntaxFactory.IdentifierName(Strings.ReadWritePropertyGenerationStrategy_GetPropertyAssertionBodyStatements_testValue))));
yield return(_frameworkSet.TestFramework.AssertEqual(Generate.IndexerAccess(sourceModel.TargetInstance, paramExpressions), SyntaxFactory.IdentifierName(Strings.ReadWritePropertyGenerationStrategy_GetPropertyAssertionBodyStatements_testValue)));
}
public ExpressionSyntax GetObjectCreationExpression(IFrameworkSet frameworkSet)
{
if (frameworkSet == null)
{
throw new ArgumentNullException(nameof(frameworkSet));
}
var targetConstructor = Constructors.OrderByDescending(x => x.Parameters.Count).FirstOrDefault();
var objectCreation = SyntaxFactory.ObjectCreationExpression(TypeSyntax);
if (targetConstructor != null && targetConstructor.Parameters.Count > 0)
{
return(objectCreation.WithArgumentList(Generate.Arguments(targetConstructor.Parameters.Select(x => SyntaxFactory.IdentifierName(GetConstructorParameterFieldName(x))))));
}
if (targetConstructor != null || !Declaration.ChildNodes().OfType <ConstructorDeclarationSyntax>().Any())
{
return(objectCreation.WithArgumentList(SyntaxFactory.ArgumentList()));
}
return(AssignmentValueHelper.GetDefaultAssignmentValue(TypeSymbol, SemanticModel, frameworkSet));
}
private IEnumerable <StatementSyntax> GetPropertyAssertionBodyStatements(IPropertyModel property, ClassModel sourceModel, bool withDefaults)
{
var propertyLambda = SyntaxFactory.Argument(
SyntaxFactory.SimpleLambdaExpression(
SyntaxFactory.Parameter(SyntaxFactory.Identifier(Strings.Identifier_x)),
SyntaxFactory.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.IdentifierName(Strings.Identifier_x), SyntaxFactory.IdentifierName(property.Name))));
var argumentList = new List <SyntaxNodeOrToken> {
propertyLambda
};
if (withDefaults)
{
argumentList.Add(SyntaxFactory.Token(SyntaxKind.CommaToken));
argumentList.Add(SyntaxFactory.Argument(AssignmentValueHelper.GetDefaultAssignmentValue(property.TypeInfo, sourceModel.SemanticModel, _frameworkSet)));
argumentList.Add(SyntaxFactory.Token(SyntaxKind.CommaToken));
argumentList.Add(SyntaxFactory.Argument(AssignmentValueHelper.GetDefaultAssignmentValue(property.TypeInfo, sourceModel.SemanticModel, _frameworkSet)));
}
yield return(SyntaxFactory.ExpressionStatement(
SyntaxFactory.InvocationExpression(
SyntaxFactory.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.IdentifierName("_testClass"), SyntaxFactory.IdentifierName("CheckProperty")))
.WithArgumentList(SyntaxFactory.ArgumentList(SyntaxFactory.SeparatedList <ArgumentSyntax>(argumentList)))));
}
public IEnumerable <MethodDeclarationSyntax> Create(IMethodModel method, ClassModel model)
{
if (method is null)
{
throw new ArgumentNullException(nameof(method));
}
if (model is null)
{
throw new ArgumentNullException(nameof(model));
}
var methodName = string.Format(CultureInfo.InvariantCulture, "CanCall{0}", model.GetMethodUniqueName(method));
var generatedMethod = _frameworkSet.TestFramework.CreateTestMethod(methodName, method.IsAsync, model.IsStatic);
var paramExpressions = new List <CSharpSyntaxNode>();
foreach (var parameter in method.Parameters)
{
if (parameter.Node.Modifiers.Any(x => x.Kind() == SyntaxKind.OutKeyword))
{
paramExpressions.Add(SyntaxFactory.Argument(SyntaxFactory.DeclarationExpression(SyntaxFactory.IdentifierName(Strings.Create_var), SyntaxFactory.SingleVariableDesignation(SyntaxFactory.Identifier(parameter.Name)))).WithRefKindKeyword(SyntaxFactory.Token(SyntaxKind.OutKeyword)));
}
else
{
var defaultAssignmentValue = AssignmentValueHelper.GetDefaultAssignmentValue(parameter.TypeInfo, model.SemanticModel, _frameworkSet);
generatedMethod = generatedMethod.AddBodyStatements(SyntaxFactory.LocalDeclarationStatement(
SyntaxFactory.VariableDeclaration(SyntaxFactory.IdentifierName(Strings.Create_var))
.WithVariables(SyntaxFactory.SingletonSeparatedList(
SyntaxFactory.VariableDeclarator(SyntaxFactory.Identifier(parameter.Name))
.WithInitializer(SyntaxFactory.EqualsValueClause(defaultAssignmentValue))))));
if (parameter.Node.Modifiers.Any(x => x.Kind() == SyntaxKind.RefKeyword))
{
paramExpressions.Add(SyntaxFactory.Argument(SyntaxFactory.IdentifierName(parameter.Name)).WithRefKindKeyword(SyntaxFactory.Token(SyntaxKind.RefKeyword)));
}
else
{
paramExpressions.Add(SyntaxFactory.IdentifierName(parameter.Name));
}
}
}
var methodCall = method.Invoke(model, false, _frameworkSet, paramExpressions.ToArray());
bool requiresInstance = false;
if (method.IsAsync)
{
if (model.SemanticModel.GetSymbolInfo(method.Node.ReturnType).Symbol is INamedTypeSymbol type)
{
requiresInstance = type.TypeArguments.Any();
}
}
else
{
requiresInstance = !method.IsVoid;
}
StatementSyntax bodyStatement;
if (requiresInstance)
{
bodyStatement = SyntaxFactory.LocalDeclarationStatement(
SyntaxFactory.VariableDeclaration(
SyntaxFactory.IdentifierName(Strings.Create_var))
.WithVariables(
SyntaxFactory.SingletonSeparatedList(
SyntaxFactory.VariableDeclarator(
SyntaxFactory.Identifier(Strings.CanCallMethodGenerationStrategy_Create_result))
.WithInitializer(
SyntaxFactory.EqualsValueClause(methodCall)))));
}
else
{
bodyStatement = SyntaxFactory.ExpressionStatement(methodCall);
}
generatedMethod = generatedMethod.AddBodyStatements(bodyStatement);
generatedMethod = generatedMethod.AddBodyStatements(_frameworkSet.TestFramework.AssertFail(Strings.PlaceholderAssertionMessage));
yield return(generatedMethod);
}
public IEnumerable <MethodDeclarationSyntax> Create(ClassModel method, ClassModel model)
{
if (method is null)
{
throw new ArgumentNullException(nameof(method));
}
if (model is null)
{
throw new ArgumentNullException(nameof(model));
}
var nullableParameters = new HashSet <string>(model.Constructors.SelectMany(x => x.Parameters).Where(x => x.TypeInfo.Type.SpecialType == SpecialType.System_String).Select(x => x.Name), StringComparer.OrdinalIgnoreCase);
foreach (var nullableParameter in nullableParameters)
{
var methodName = string.Format(CultureInfo.InvariantCulture, "CannotConstructWithInvalid{0}", nullableParameter.ToPascalCase());
var generatedMethod = _frameworkSet.TestFramework.CreateTestCaseMethod(methodName, false, false, SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.StringKeyword)), new object[] { null, string.Empty, " " });
foreach (var constructorModel in model.Constructors.Where(x => x.Parameters.Any(p => string.Equals(p.Name, nullableParameter, StringComparison.OrdinalIgnoreCase))))
{
var paramExpressions = constructorModel.Parameters.Select(param => string.Equals(param.Name, nullableParameter, StringComparison.OrdinalIgnoreCase) ? SyntaxFactory.IdentifierName(Strings.MsTestTestFramework_CreateTestCaseMethod_value) : AssignmentValueHelper.GetDefaultAssignmentValue(param.TypeInfo, model.SemanticModel, _frameworkSet)).ToList();
var methodCall = Generate.ObjectCreation(model.TypeSyntax, paramExpressions.ToArray());
generatedMethod = generatedMethod.AddBodyStatements(_frameworkSet.TestFramework.AssertThrows(SyntaxFactory.IdentifierName("ArgumentNullException"), methodCall));
}
yield return(generatedMethod);
}
}
public IEnumerable <MethodDeclarationSyntax> Create(IOperatorModel method, ClassModel model)
{
if (method is null)
{
throw new ArgumentNullException(nameof(method));
}
if (model is null)
{
throw new ArgumentNullException(nameof(model));
}
for (var i = 0; i < method.Parameters.Count; i++)
{
if (!method.Parameters[i].TypeInfo.Type.IsReferenceType)
{
continue;
}
var paramList = new List <CSharpSyntaxNode>();
var methodName = string.Format(CultureInfo.InvariantCulture, "CannotCall{0}OperatorWithNull{1}", method.Name, method.Parameters[i].Name.ToPascalCase());
var generatedMethod = _frameworkSet.TestFramework.CreateTestMethod(methodName, false, model.IsStatic);
for (var index = 0; index < method.Parameters.Count; index++)
{
var parameter = method.Parameters[index];
if (index == i)
{
paramList.Add(SyntaxFactory.DefaultExpression(method.Parameters[i].TypeInfo.ToTypeSyntax(_frameworkSet.Context)));
}
else
{
paramList.Add(AssignmentValueHelper.GetDefaultAssignmentValue(parameter.TypeInfo, model.SemanticModel, _frameworkSet));
}
}
var methodCall = method.Invoke(model, true, _frameworkSet, paramList.ToArray());
if (methodCall == null)
{
continue;
}
var assignment = SyntaxFactory.ParenthesizedLambdaExpression(
SyntaxFactory.Block(
SyntaxFactory.SingletonList <StatementSyntax>(
SyntaxFactory.LocalDeclarationStatement(
SyntaxFactory.VariableDeclaration(
SyntaxFactory.IdentifierName(Strings.Create_var))
.WithVariables(
SyntaxFactory.SingletonSeparatedList(
SyntaxFactory.VariableDeclarator(
SyntaxFactory.Identifier(Strings.CanCallMethodGenerationStrategy_Create_result))
.WithInitializer(
SyntaxFactory.EqualsValueClause(
methodCall))))))));
generatedMethod = generatedMethod.AddBodyStatements(_frameworkSet.TestFramework.AssertThrows(SyntaxFactory.IdentifierName("ArgumentNullException"), assignment));
yield return(generatedMethod);
}
}
public IEnumerable <MethodDeclarationSyntax> Create(IMethodModel method, ClassModel model)
{
if (method is null)
{
throw new ArgumentNullException(nameof(method));
}
if (model is null)
{
throw new ArgumentNullException(nameof(model));
}
for (var i = 0; i < method.Parameters.Count; i++)
{
if (method.Parameters[i].TypeInfo.Type.SpecialType != SpecialType.System_String)
{
continue;
}
if (method.Parameters[i].Node.Modifiers.Any(x => x.Kind() == SyntaxKind.OutKeyword))
{
continue;
}
var paramList = new List <CSharpSyntaxNode>();
var methodName = string.Format(CultureInfo.InvariantCulture, "CannotCall{0}WithInvalid{1}", model.GetMethodUniqueName(method), method.Parameters[i].Name.ToPascalCase());
var generatedMethod = _frameworkSet.TestFramework.CreateTestCaseMethod(methodName, method.IsAsync && _frameworkSet.TestFramework.AssertThrowsAsyncIsAwaitable, model.IsStatic, SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.StringKeyword)), new object[] { null, string.Empty, " " });
for (var index = 0; index < method.Parameters.Count; index++)
{
var parameter = method.Parameters[index];
if (parameter.Node.Modifiers.Any(x => x.Kind() == SyntaxKind.RefKeyword))
{
var defaultAssignmentValue = AssignmentValueHelper.GetDefaultAssignmentValue(parameter.TypeInfo, model.SemanticModel, _frameworkSet);
if (index == i)
{
defaultAssignmentValue = SyntaxFactory.DefaultExpression(method.Parameters[i].TypeInfo.ToTypeSyntax(_frameworkSet.Context));
}
generatedMethod = generatedMethod.AddBodyStatements(SyntaxFactory.LocalDeclarationStatement(
SyntaxFactory.VariableDeclaration(SyntaxFactory.IdentifierName(Strings.Create_var))
.WithVariables(SyntaxFactory.SingletonSeparatedList(
SyntaxFactory.VariableDeclarator(SyntaxFactory.Identifier(parameter.Name))
.WithInitializer(SyntaxFactory.EqualsValueClause(defaultAssignmentValue))))));
paramList.Add(SyntaxFactory.Argument(SyntaxFactory.IdentifierName(parameter.Name)).WithRefKindKeyword(SyntaxFactory.Token(SyntaxKind.RefKeyword)));
}
else if (parameter.Node.Modifiers.Any(x => x.Kind() == SyntaxKind.OutKeyword))
{
paramList.Add(SyntaxFactory.Argument(SyntaxFactory.IdentifierName("_")).WithRefKindKeyword(SyntaxFactory.Token(SyntaxKind.OutKeyword)));
}
else
{
if (index == i)
{
paramList.Add(SyntaxFactory.IdentifierName(Strings.MsTestTestFramework_CreateTestCaseMethod_value));
}
else
{
paramList.Add(AssignmentValueHelper.GetDefaultAssignmentValue(parameter.TypeInfo, model.SemanticModel, _frameworkSet));
}
}
}
var methodCall = method.Invoke(model, true, _frameworkSet, paramList.ToArray());
if (method.IsAsync)
{
generatedMethod = generatedMethod.AddBodyStatements(_frameworkSet.TestFramework.AssertThrowsAsync(SyntaxFactory.IdentifierName("ArgumentNullException"), methodCall));
}
else
{
generatedMethod = generatedMethod.AddBodyStatements(_frameworkSet.TestFramework.AssertThrows(SyntaxFactory.IdentifierName("ArgumentNullException"), methodCall));
}
yield return(generatedMethod);
}
}
private static TypeDeclarationSyntax EnsureAllConstructorParametersHaveFields(IFrameworkSet frameworkSet, ClassModel classModel, TypeDeclarationSyntax targetType)
{
var setupMethod = frameworkSet.TestFramework.CreateSetupMethod(frameworkSet.GetTargetTypeName(classModel, true));
BaseMethodDeclarationSyntax foundMethod = null, updatedMethod = null;
if (setupMethod is MethodDeclarationSyntax methodSyntax)
{
updatedMethod = foundMethod = targetType.Members.OfType <MethodDeclarationSyntax>().FirstOrDefault(x => x.Identifier.Text == methodSyntax.Identifier.Text && x.ParameterList.Parameters.Count == 0);
}
else if (setupMethod is ConstructorDeclarationSyntax)
{
updatedMethod = foundMethod = targetType.Members.OfType <ConstructorDeclarationSyntax>().FirstOrDefault(x => x.ParameterList.Parameters.Count == 0);
}
if (foundMethod != null)
{
var parametersEmitted = new HashSet <string>();
var allFields = new HashSet <string>(StringComparer.OrdinalIgnoreCase);
var fields = new List <FieldDeclarationSyntax>();
foreach (var parameterModel in classModel.Constructors.SelectMany(x => x.Parameters))
{
allFields.Add(classModel.GetConstructorParameterFieldName(parameterModel));
}
// generate fields for each constructor parameter that doesn't have an existing field
foreach (var parameterModel in classModel.Constructors.SelectMany(x => x.Parameters))
{
if (!parametersEmitted.Add(parameterModel.Name))
{
continue;
}
var fieldName = classModel.GetConstructorParameterFieldName(parameterModel);
var fieldExists = targetType.Members.OfType <FieldDeclarationSyntax>().Any(x => x.Declaration.Variables.Any(v => v.Identifier.Text == fieldName));
if (!fieldExists)
{
var variable = SyntaxFactory.VariableDeclaration(parameterModel.TypeInfo.ToTypeSyntax(frameworkSet.Context))
.AddVariables(SyntaxFactory.VariableDeclarator(fieldName));
var field = SyntaxFactory.FieldDeclaration(variable)
.AddModifiers(SyntaxFactory.Token(SyntaxKind.PrivateKeyword));
fields.Add(field);
var defaultExpression = AssignmentValueHelper.GetDefaultAssignmentValue(parameterModel.TypeInfo, classModel.SemanticModel, frameworkSet);
var statement = SyntaxFactory.ExpressionStatement(SyntaxFactory.AssignmentExpression(SyntaxKind.SimpleAssignmentExpression, SyntaxFactory.IdentifierName(fieldName), defaultExpression));
var body = updatedMethod.Body ?? SyntaxFactory.Block();
SyntaxList <StatementSyntax> newStatements;
var index = body.Statements.LastIndexOf(x => x.DescendantNodes().OfType <AssignmentExpressionSyntax>().Any(a => a.Left is IdentifierNameSyntax identifierName && allFields.Contains(identifierName.Identifier.Text)));
if (index >= 0 && index < body.Statements.Count - 1)
{
newStatements = body.Statements.Insert(index + 1, statement);
}
else
{
newStatements = body.Statements.Add(statement);
}
updatedMethod = updatedMethod.WithBody(body.WithStatements(newStatements));
}
}
if (fields.Any())
{
targetType = targetType.ReplaceNode(foundMethod, updatedMethod);
var existingField = targetType.Members.OfType <FieldDeclarationSyntax>().LastOrDefault();
if (existingField != null)
{
targetType = targetType.InsertNodesAfter(existingField, fields);
}
else
{
targetType = targetType.AddMembers(fields.OfType <MemberDeclarationSyntax>().ToArray());
}
}
}
return(targetType);
}
public IEnumerable <MethodDeclarationSyntax> Create(IMethodModel method, ClassModel model)
{
if (method is null)
{
throw new ArgumentNullException(nameof(method));
}
if (model is null)
{
throw new ArgumentNullException(nameof(model));
}
var methodName = string.Format(CultureInfo.InvariantCulture, "{0}PerformsMapping", model.GetMethodUniqueName(method));
var generatedMethod = _frameworkSet.TestFramework.CreateTestMethod(methodName, method.IsAsync, model.IsStatic);
var paramExpressions = new List <CSharpSyntaxNode>();
foreach (var parameter in method.Parameters)
{
if (parameter.Node.Modifiers.Any(x => x.Kind() == SyntaxKind.OutKeyword))
{
paramExpressions.Add(SyntaxFactory.Argument(SyntaxFactory.DeclarationExpression(SyntaxFactory.IdentifierName(Strings.Create_var), SyntaxFactory.SingleVariableDesignation(SyntaxFactory.Identifier(parameter.Name)))).WithRefKindKeyword(SyntaxFactory.Token(SyntaxKind.OutKeyword)));
}
else
{
var defaultAssignmentValue = AssignmentValueHelper.GetDefaultAssignmentValue(parameter.TypeInfo, model.SemanticModel, _frameworkSet);
generatedMethod = generatedMethod.AddBodyStatements(SyntaxFactory.LocalDeclarationStatement(
SyntaxFactory.VariableDeclaration(SyntaxFactory.IdentifierName(Strings.Create_var))
.WithVariables(SyntaxFactory.SingletonSeparatedList(
SyntaxFactory.VariableDeclarator(SyntaxFactory.Identifier(parameter.Name))
.WithInitializer(SyntaxFactory.EqualsValueClause(defaultAssignmentValue))))));
if (parameter.Node.Modifiers.Any(x => x.Kind() == SyntaxKind.RefKeyword))
{
paramExpressions.Add(SyntaxFactory.Argument(SyntaxFactory.IdentifierName(parameter.Name)).WithRefKindKeyword(SyntaxFactory.Token(SyntaxKind.RefKeyword)));
}
else
{
paramExpressions.Add(SyntaxFactory.IdentifierName(parameter.Name));
}
}
}
var methodCall = method.Invoke(model, false, _frameworkSet, paramExpressions.ToArray());
bool requiresInstance = false;
if (method.IsAsync)
{
if (model.SemanticModel.GetSymbolInfo(method.Node.ReturnType).Symbol is INamedTypeSymbol type)
{
requiresInstance = type.TypeArguments.Any();
}
}
else
{
requiresInstance = !method.IsVoid;
}
StatementSyntax bodyStatement;
if (requiresInstance)
{
bodyStatement = SyntaxFactory.LocalDeclarationStatement(
SyntaxFactory.VariableDeclaration(
SyntaxFactory.IdentifierName(Strings.Create_var))
.WithVariables(
SyntaxFactory.SingletonSeparatedList(
SyntaxFactory.VariableDeclarator(
SyntaxFactory.Identifier(Strings.CanCallMethodGenerationStrategy_Create_result))
.WithInitializer(
SyntaxFactory.EqualsValueClause(methodCall)))));
}
else
{
bodyStatement = SyntaxFactory.ExpressionStatement(methodCall);
}
generatedMethod = generatedMethod.AddBodyStatements(bodyStatement);
var returnTypeInfo = model.SemanticModel.GetTypeInfo(method.Node.ReturnType).Type;
if (returnTypeInfo == null || returnTypeInfo.SpecialType != SpecialType.None || method.Node.IsKind(SyntaxKind.IndexerDeclaration) || (returnTypeInfo.ToFullName() == typeof(Task).FullName && !(returnTypeInfo is INamedTypeSymbol namedTypeSymbol && namedTypeSymbol.IsGenericType)))
{
yield break;
}
if (returnTypeInfo is INamedTypeSymbol namedType && namedType.IsGenericType && returnTypeInfo.ToFullName() == typeof(Task).FullName)
{
returnTypeInfo = namedType.TypeArguments[0];
}
var returnTypeMembers = GetProperties(returnTypeInfo);
foreach (var methodParameter in method.Parameters)
{
if (returnTypeMembers.Contains(methodParameter.Name))
{
var returnTypeMember = returnTypeMembers.FirstOrDefault(x => string.Equals(x, methodParameter.Name, StringComparison.OrdinalIgnoreCase));
var resultProperty = Generate.PropertyAccess(SyntaxFactory.IdentifierName(Strings.CanCallMethodGenerationStrategy_Create_result), returnTypeMember);
generatedMethod = generatedMethod.AddBodyStatements(_frameworkSet.TestFramework.AssertEqual(resultProperty, SyntaxFactory.IdentifierName(methodParameter.Name)));
continue;
}
if (methodParameter.TypeInfo.Type.SpecialType == SpecialType.None && !Equals(methodParameter.TypeInfo.Type, returnTypeInfo))
{
var properties = GetProperties(methodParameter.TypeInfo.Type);
foreach (var matchedSourceProperty in properties.Where(x => returnTypeMembers.Contains(x)))
{
var returnTypeMember = returnTypeMembers.FirstOrDefault(x => string.Equals(x, matchedSourceProperty, StringComparison.OrdinalIgnoreCase));
var resultProperty = Generate.PropertyAccess(SyntaxFactory.IdentifierName(Strings.CanCallMethodGenerationStrategy_Create_result), returnTypeMember);
generatedMethod = generatedMethod.AddBodyStatements(_frameworkSet.TestFramework.AssertEqual(resultProperty, Generate.PropertyAccess(SyntaxFactory.IdentifierName(methodParameter.Name), matchedSourceProperty)));
}
}
}
yield return(generatedMethod);
}
