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); }