private CompilationUnitSyntax GenerateTestClassFile(ClassDeclarationSyntax classDeclaration)
{
var methods = classDeclaration.DescendantNodes().OfType <MethodDeclarationSyntax>()
.Where(x => x.Modifiers.Any(y => y.ValueText == "public"));
string ns = (classDeclaration.Parent as NamespaceDeclarationSyntax)?.Name.ToString();
List <string> methodsNames = new List <string>();
foreach (MethodDeclarationSyntax method in methods)
{
string tempMethodName = GetMethodName(methodsNames, method.Identifier.ToString(), 0);
methodsNames.Add(tempMethodName);
}
CompilationUnitSyntax result = CompilationUnit();
result = result.WithUsings(GenerateUsingDirective());
string className = classDeclaration.Identifier.ValueText;
ClassDeclarationSyntax testClassDeclaration = ClassDeclaration(className + "Test");
var classAttribute = Attribute(IdentifierName("TestClass"));
var classAttributesList = SingletonList(AttributeList(SingletonSeparatedList(classAttribute)));
testClassDeclaration = testClassDeclaration.WithAttributeLists(classAttributesList);
testClassDeclaration = testClassDeclaration.WithModifiers(TokenList(Token(SyntaxKind.PublicKeyword)));
testClassDeclaration = testClassDeclaration.WithMembers(GenerateMethodsList(methodsNames));
SyntaxList <MemberDeclarationSyntax> classes = SingletonList <MemberDeclarationSyntax>(testClassDeclaration);
NamespaceDeclarationSyntax namespaceDeclaration =
NamespaceDeclaration(QualifiedName(IdentifierName(ns), IdentifierName("Test")));
namespaceDeclaration = namespaceDeclaration.WithMembers(classes);
result = result.WithMembers(SingletonList <MemberDeclarationSyntax>(namespaceDeclaration));
return(result);
}
public static NamespaceDeclarationSyntax AddNamespaceTo(
ICodeGenerationService service,
NamespaceDeclarationSyntax destination,
INamespaceSymbol @namespace,
CodeGenerationOptions options,
IList <bool> availableIndices,
CancellationToken cancellationToken
)
{
var declaration = GenerateNamespaceDeclaration(
service,
@namespace,
options,
cancellationToken
);
if (!(declaration is NamespaceDeclarationSyntax))
{
throw new ArgumentException(
CSharpWorkspaceResources.Namespace_can_not_be_added_in_this_destination
);
}
var members = Insert(
destination.Members,
(NamespaceDeclarationSyntax)declaration,
options,
availableIndices
);
return(destination.WithMembers(members));
}
private static SyntaxTree MakeProgram(string sourceFilePath, IOKind ioKind, string methodName, string className, string namespaceName)
{
ParsingResult result = Parsing.ParseFromFile(sourceFilePath);
if (!result.Success)
{
throw new Exception("Syntax error in source file.");
}
else
{
if (!result.ParsedAll)
{
Console.WriteLine("Could not parse the whole source file, output might not work as intended.");
}
MethodDeclarationSyntax method = Exprs.Method(methodName, ioKind, result.SyntaxGenerators);
if (ioKind == IOKind.Argument)
{
method = method.WithParameterList(SyntaxFactory.ParseParameterList("(IEnumerable<byte> input)"));
}
ClassDeclarationSyntax @class = Exprs.Class(className);
@class = @class.WithMembers(SyntaxFactory.SingletonList <MemberDeclarationSyntax>(method));
NamespaceDeclarationSyntax @namespace = Exprs.Namespace(namespaceName);
@namespace = @namespace.WithMembers(SyntaxFactory.SingletonList <MemberDeclarationSyntax>(@class));
CompilationUnitSyntax cu = SyntaxFactory.CompilationUnit().AddMembers(@namespace);
return(SyntaxFactory.SyntaxTree(cu, path: sourceFilePath));
}
}
public static SourceText GeneratePrintMembersText(
RecordDeclarationSyntax recordDeclaration,
INamedTypeSymbol recordSymbol,
Dictionary <SymbolClassification, List <ISymbol> > groups)
{
MemberDeclarationSyntax printMembersMethod = SyntaxFactory.MethodDeclaration(
attributeLists: s_emptyAttributeList,
modifiers: GetPrintMembersModifiers(recordSymbol),
returnType: SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.BoolKeyword)),
explicitInterfaceSpecifier: null,
identifier: s_printMembersIdentifier,
typeParameterList: null,
parameterList: SyntaxFactory.ParameterList(
SyntaxFactory.SeparatedList <ParameterSyntax>(
new[] { SyntaxFactory.Parameter(s_emptyAttributeList, s_emptyTokenList, s_stringBuilderType, s_builderIdentifier, null) }
)
),
constraintClauses: s_emptyConstraintList,
body: GenerateBody(recordDeclaration, recordSymbol, groups),
expressionBody: null
);
string namespaceFullyQualifiedName = GetFullyQualifiedNameOfNamespace(recordSymbol.ContainingNamespace);
recordDeclaration = recordDeclaration.WithMembers(new SyntaxList <MemberDeclarationSyntax>(printMembersMethod));
if (namespaceFullyQualifiedName.Length == 0)
{
return(recordDeclaration.NormalizeWhitespace().GetText(Encoding.UTF8));
}
NamespaceDeclarationSyntax namespaceDeclaration = SyntaxFactory.NamespaceDeclaration(SyntaxFactory.IdentifierName(namespaceFullyQualifiedName));
return(namespaceDeclaration.WithMembers(new SyntaxList <MemberDeclarationSyntax>(recordDeclaration)).NormalizeWhitespace().GetText(Encoding.UTF8));
}
public static string Generate(List <ClassMetadata> classInfo, List <UsingDirectiveSyntax> usings)
{
var result = string.Empty;
foreach (ClassMetadata Class in classInfo)
{
NamespaceDeclarationSyntax namespaceDeclaration = NamespaceDeclaration(
QualifiedName(IdentifierName(Class.NameSpace), IdentifierName("NUnitTests")));
CompilationUnitSyntax testClass = CompilationUnit()
.WithUsings(GetDefaultUsings(Class, usings))
.WithMembers(SingletonList <MemberDeclarationSyntax>(
namespaceDeclaration
.WithMembers(SingletonList <MemberDeclarationSyntax>(
ClassDeclaration(Class.Name + "NUnitTests")
.WithModifiers(TokenList(Token(SyntaxKind.PublicKeyword)))
.WithAttributeLists(
SingletonList(
AttributeList(
SingletonSeparatedList(
Attribute(
IdentifierName("TestFixture"))))))
.WithMembers(GetMethodsAndProperties(Class))))));
result += testClass.NormalizeWhitespace().ToFullString();
}
return(result);
}
/// <summary>
/// Takes a namespace declaration and returns a new namespace declaration containing only
/// the ServiceContract interfaces, converted to an asynchronous version
/// </summary>
/// <param name="originalNamespace">The namespace declaration to replace</param>
/// <returns></returns>
private static NamespaceDeclarationSyntax ComputeNewNamespaceDeclarationNode(NamespaceDeclarationSyntax originalNamespace)
{
var serviceContractInterfaces =
originalNamespace.DescendantNodes().OfType<InterfaceDeclarationSyntax>().Where(
i => i.GetAttribute<ServiceContractAttribute>() != null);
return originalNamespace.WithMembers(Syntax.List<MemberDeclarationSyntax>(serviceContractInterfaces.Select(ComputeNewServiceContractInterfaceNode)));
}
/// <summary>
/// Takes a namespace declaration and returns a new namespace declaration containing only
/// the ServiceContract interfaces, converted to an asynchronous version
/// </summary>
/// <param name="originalNamespace">The namespace declaration to replace</param>
/// <returns></returns>
private static NamespaceDeclarationSyntax ComputeNewNamespaceDeclarationNode(NamespaceDeclarationSyntax originalNamespace)
{
var serviceContractInterfaces =
originalNamespace.DescendantNodes().OfType <InterfaceDeclarationSyntax>().Where(
i => i.GetAttribute <ServiceContractAttribute>() != null);
return(originalNamespace.WithMembers(Syntax.List <MemberDeclarationSyntax>(serviceContractInterfaces.Select(ComputeNewServiceContractInterfaceNode))));
}
public static NamespaceDeclarationSyntax InsertMember(NamespaceDeclarationSyntax namespaceDeclaration, MemberDeclarationSyntax member)
{
if (namespaceDeclaration == null)
{
throw new ArgumentNullException(nameof(namespaceDeclaration));
}
return(namespaceDeclaration.WithMembers(InsertMember(namespaceDeclaration.Members, member)));
}
private static NamespaceDeclarationSyntax ReorderNsMembers(NamespaceDeclarationSyntax ns)
{
Debug.Assert(ns.Members.All(m => m is TypeDeclarationSyntax));
var types = ns.Members.OfType <TypeDeclarationSyntax>().OrderBy(t => t.Identifier.Text).ToList();
ns = ns.WithMembers(new SyntaxList <MemberDeclarationSyntax>(types));
return(ns);
}
public static Task <List <GeneratedTestClass> > Generate(string code)
{
return(Task.Run(() => {
List <GeneratedTestClass> generatedClasses = new List <GeneratedTestClass>();
var tree = CSharpSyntaxTree.ParseText(code);
var syntaxRoot = tree.GetRoot();
var mscorlib = MetadataReference.CreateFromFile(typeof(object).Assembly.Location);
var compilation = CSharpCompilation.Create("MyCompilation",
syntaxTrees: new[] { tree }, references: new[] { mscorlib });
var model = compilation.GetSemanticModel(tree);
var classDeclarations = syntaxRoot.DescendantNodes().OfType <ClassDeclarationSyntax>();
foreach (var clsInfo in classDeclarations)
{
string className = clsInfo.Identifier.ValueText;
string clsNamespace = ((NamespaceDeclarationSyntax)clsInfo.Parent).Name.ToString();
NamespaceDeclarationSyntax template_namespace = NamespaceDeclaration(
QualifiedName(
IdentifierName(className), IdentifierName("Test")));
var template_usings = GetTemplateUsing(clsNamespace);
var template_methods = GetTemplateMethods(clsInfo, model);
var template_fields = GetTemplateFields(clsInfo, model);
var template_members = List(template_fields.Concat(template_methods));
var template_classname = className + "Tests";
//Class declaration
var classTemplate =
CompilationUnit()
.WithUsings(template_usings)
.WithMembers(SingletonList <MemberDeclarationSyntax>(template_namespace
.WithMembers(SingletonList <MemberDeclarationSyntax>(ClassDeclaration(template_classname)
.WithAttributeLists(
SingletonList(
AttributeList(
SingletonSeparatedList(
Attribute(
IdentifierName("TestClass"))))))
.WithModifiers(TokenList(Token(SyntaxKind.PublicKeyword)))
.WithMembers(template_members)))));
string generatedCode = classTemplate.NormalizeWhitespace().ToFullString();
string generatedName = template_classname + ".cs";
generatedClasses.Add(new GeneratedTestClass(generatedName, generatedCode));
}
return generatedClasses;
}));
}
private TSyntax AddNullableRegions <TSyntax>(TSyntax node, CancellationToken cancellationToken)
where TSyntax : SyntaxNode
{
return(node switch
{
CompilationUnitSyntax compilationUnit => (TSyntax)(object)compilationUnit.WithMembers(AddNullableRegions(compilationUnit.Members, cancellationToken)),
NamespaceDeclarationSyntax ns => (TSyntax)(object)ns.WithMembers(AddNullableRegions(ns.Members, cancellationToken)),
TypeDeclarationSyntax type => (TSyntax)(object)AddNullableRegionsAroundTypeMembers(type, cancellationToken),
_ => node,
});
public static NamespaceDeclarationSyntax WithMembers(
this NamespaceDeclarationSyntax namespaceDeclaration,
MemberDeclarationSyntax member)
{
if (namespaceDeclaration == null)
{
throw new ArgumentNullException(nameof(namespaceDeclaration));
}
return(namespaceDeclaration.WithMembers(SingletonList(member)));
}
internal static NamespaceDeclarationSyntax AddMethodTo(
NamespaceDeclarationSyntax destination,
IMethodSymbol method,
CodeGenerationOptions options,
IList <bool> availableIndices)
{
var declaration = GenerateMethodDeclaration(method, CodeGenerationDestination.Namespace, options);
var members = Insert(destination.Members, declaration, options, availableIndices, after: LastMethod);
return(destination.WithMembers(members.ToSyntaxList()));
}
public static MemberDeclarationSyntax RemoveMember(
this NamespaceDeclarationSyntax declaration,
MemberDeclarationSyntax member,
int index)
{
MemberDeclarationSyntax newMember = member.RemoveSingleLineDocumentationComment();
declaration = declaration
.WithMembers(declaration.Members.Replace(member, newMember));
return(declaration
.RemoveNode(declaration.Members[index], MemberDeclarationRefactoring.GetRemoveOptions(newMember)));
}
private static MemberDeclarationSyntax RemoveMember(
NamespaceDeclarationSyntax namespaceDeclaration,
MemberDeclarationSyntax member,
int index)
{
MemberDeclarationSyntax newMember = RemoveSingleLineDocumentationComment(member);
namespaceDeclaration = namespaceDeclaration
.WithMembers(namespaceDeclaration.Members.Replace(member, newMember));
return(namespaceDeclaration
.RemoveNode(namespaceDeclaration.Members[index], GetRemoveOptions(newMember)));
}
public static NamespaceDeclarationSyntax AddNamedTypeTo(
ICodeGenerationService service,
NamespaceDeclarationSyntax destination,
INamedTypeSymbol namedType,
CodeGenerationOptions options,
IList <bool> availableIndices)
{
var declaration = GenerateNamedTypeDeclaration(service, namedType, CodeGenerationDestination.Namespace, options);
var members = Insert(destination.Members, declaration, options, availableIndices);
return(ConditionallyAddFormattingAnnotationTo(
destination.WithMembers(members),
members));
}
private static SyntaxList <MemberDeclarationSyntax> GenerateClass(NamespaceDeclarationSyntax namespaceDeclaration, Type type, string serviceName)
{
var className = type.Name.TrimStart('I') + "_____UraganoClientProxy";
//var serviceProviderProperty = SyntaxFactory.PropertyDeclaration(SyntaxFactory.ParseTypeName("IServiceProvider"), " ServiceProvider")
// .AddModifiers(SyntaxFactory.Token(SyntaxKind.PrivateKeyword))
// .AddAccessorListAccessors(
// SyntaxFactory.AccessorDeclaration(SyntaxKind.GetAccessorDeclaration).WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken)));
var classDeclaration = SyntaxFactory.ClassDeclaration(className)
.AddModifiers(SyntaxFactory.Token(SyntaxKind.PublicKeyword))
.AddBaseListTypes(
SyntaxFactory.SimpleBaseType(SyntaxFactory.ParseTypeName("DynamicProxyAbstract")),
SyntaxFactory.SimpleBaseType(GenerateQualifiedNameSyntax(type)))
//.AddMembers(serviceProviderProperty)
.AddMembers(GenerateMethods(type, className, serviceName));
return(SyntaxFactory.SingletonList <MemberDeclarationSyntax>(namespaceDeclaration.WithMembers(SyntaxFactory.SingletonList <MemberDeclarationSyntax>(classDeclaration))));
}
public static NamespaceDeclarationSyntax RemoveMember(NamespaceDeclarationSyntax namespaceDeclaration, MemberDeclarationSyntax member)
{
if (namespaceDeclaration == null)
{
throw new ArgumentNullException(nameof(namespaceDeclaration));
}
if (member == null)
{
throw new ArgumentNullException(nameof(member));
}
int index = namespaceDeclaration.Members.IndexOf(member);
MemberDeclarationSyntax newMember = RemoveSingleLineDocumentationComment(member);
namespaceDeclaration = namespaceDeclaration.WithMembers(namespaceDeclaration.Members.ReplaceAt(index, newMember));
return(namespaceDeclaration.RemoveNode(namespaceDeclaration.Members[index], GetRemoveOptions(newMember)));
}
/// <summary>
/// Takes a namespace declaration and returns a new namespace declaration containing only
/// the ServiceContract interfaces, converted to an asynchronous version
/// </summary>
/// <param name="originalNamespace">The namespace declaration to replace</param>
/// <param name="semanticModel"></param>
/// <returns></returns>
private static NamespaceDeclarationSyntax ComputeNewNamespaceDeclarationNode(NamespaceDeclarationSyntax originalNamespace, SemanticModel semanticModel, IBindingModelSyntaxGenerator generator)
{
var classDeclarations =
originalNamespace.DescendantNodes().OfType <ClassDeclarationSyntax>();
var newNamespaceDeclaration = originalNamespace.WithMembers(SyntaxFactory.List <MemberDeclarationSyntax>());
foreach (var classDeclaration in classDeclarations)
{
var classSymbol = semanticModel.GetDeclaredSymbol(classDeclaration);
var modelDefinition = ModelDefinition.GetModelDefinition(classSymbol);
if (modelDefinition == null)
{
continue;
}
var newClassDeclaration = SyntaxFactory.ClassDeclaration(classDeclaration.Identifier.Text).WithModifiers(SyntaxTokenList.Create(SyntaxFactory.Token(SyntaxKind.PartialKeyword)));
newClassDeclaration = newClassDeclaration.AddMembers(GetProtectedFillEntityMethodDeclaration(modelDefinition));
var toEntityMethodDeclaration = GetPublicToEntityMethodDeclaration(modelDefinition);
if (toEntityMethodDeclaration != null)
{
newClassDeclaration = newClassDeclaration.AddMembers(toEntityMethodDeclaration);
}
if (!modelDefinition.IsAbstract)
{
newClassDeclaration = newClassDeclaration.AddMembers(
GetToBindingModelMethodDeclaration(modelDefinition, generator));
}
newNamespaceDeclaration = newNamespaceDeclaration.AddMembers(newClassDeclaration);
}
return(newNamespaceDeclaration);
}
public ICompiledWelfareService CreateCompilation()
{
var compilationUnit = CompilationUnit()
.WithUsings(List <UsingDirectiveSyntax>(usings.ToArray()));
var classDeclaration = ClassDeclaration($"{serviceName}")
.WithModifiers(
TokenList(
Token(SyntaxKind.PublicKeyword)))
.WithBaseList(
BaseList(
SingletonSeparatedList <BaseTypeSyntax>(
SimpleBaseType(
IdentifierName($"{nameof(IWelfareService)}")))));
classDeclaration = classDeclaration.WithMembers(SingletonList <MemberDeclarationSyntax>(GenerateWelfareRules(welfareRules)));
namespaceDeclarationSyntax = namespaceDeclarationSyntax.WithMembers(SingletonList <MemberDeclarationSyntax>(classDeclaration));
compilationUnit = compilationUnit.WithMembers(SingletonList <MemberDeclarationSyntax>(namespaceDeclarationSyntax));
return(new CompiledWelfareService(compilationUnit.NormalizeWhitespace(), namespaceType));
}
public override SyntaxNode VisitNamespaceDeclaration(NamespaceDeclarationSyntax node)
{
node = (NamespaceDeclarationSyntax)base.VisitNamespaceDeclaration(node);
return(node.WithMembers(SortMembers(node.Members)));
}
public List <GeneratedTestResult> GenerateTestsAsync(string taskInputFile, string outputDirectory)
{
//taskInputFile.Wait();
string source = taskInputFile;
var res = new List <GeneratedTestResult>();
var syntaxTree = CSharpSyntaxTree.ParseText(source);
var compilationUnitSyntax = syntaxTree.GetCompilationUnitRoot();
var classes = compilationUnitSyntax.DescendantNodes().OfType <ClassDeclarationSyntax>();
foreach (var classDeclaration in classes)
{
var publicMethods = classDeclaration.DescendantNodes().OfType <MethodDeclarationSyntax>()
.Where(x => x.Modifiers.Any(y => y.ValueText == "public"));
var ns = (classDeclaration.Parent as NamespaceDeclarationSyntax)?.Name.ToString();
var className = classDeclaration.Identifier.ValueText;
var methodsName = new List <string>();
foreach (var method in publicMethods)
{
var name = GetMethodName(methodsName, method.Identifier.ToString(), 0);
methodsName.Add(name);
}
NamespaceDeclarationSyntax namespaceDeclarationSyntax = NamespaceDeclaration(QualifiedName(
IdentifierName(ns), IdentifierName("Test")));
CompilationUnitSyntax compilationUnit = CompilationUnit()
.WithUsings(GetUsings())
.WithMembers(SingletonList <MemberDeclarationSyntax>(namespaceDeclarationSyntax
.WithMembers(SingletonList <MemberDeclarationSyntax>(ClassDeclaration(className + "Test")
.WithAttributeLists(SingletonList(AttributeList(SingletonSeparatedList(Attribute(IdentifierName("TestClass"))))))
.WithModifiers(TokenList(Token(SyntaxKind.PublicKeyword)))
.WithMembers(GetMethodsSyntaxList(methodsName))))));
var outputPath = Path.Combine(outputDirectory, className + "Test.cs");
res.Add(new GeneratedTestResult
{
Result = compilationUnit.NormalizeWhitespace().ToFullString(),
OutputPath = outputPath
});
}
return(res);
}
public static NamespaceDeclarationSyntax WithMembers(this NamespaceDeclarationSyntax syntax, params MemberDeclarationSyntax[] members)
{
return(syntax.WithMembers(SyntaxFactory.List(members)));
}
private List <TestClassTemplate> GetTestTemplates(string sourceCode)
{
SyntaxProcessor syntaxProcessor = new SyntaxProcessor();
SyntaxProcessResult syntaxProcessResult = syntaxProcessor.Process(sourceCode);
List <TestClassTemplate> result = new List <TestClassTemplate>();
foreach (ClassInformation classInfo in syntaxProcessResult.Classes)
{
NamespaceDeclarationSyntax namespaceDeclaration = NamespaceDeclaration(
QualifiedName(
IdentifierName(classInfo.NamespaceName),
IdentifierName("Tests")));
CompilationUnitSyntax testClass = CompilationUnit()
.WithUsings(GetTemplateUsings(classInfo))
.WithMembers(SingletonList <MemberDeclarationSyntax>(namespaceDeclaration
.WithMembers(SingletonList <MemberDeclarationSyntax>(ClassDeclaration(classInfo.Name + "Tests")
.WithAttributeLists(
SingletonList(
AttributeList(
SingletonSeparatedList(
Attribute(
IdentifierName("TestClass"))))))
.WithModifiers(TokenList(Token(SyntaxKind.PublicKeyword)))
.WithMembers(GetTestMethods(classInfo.Methods))))));
string fileName = classInfo.Name + "Tests.cs";
string innerText = testClass.NormalizeWhitespace().ToFullString();
result.Add(new TestClassTemplate(fileName, innerText));
}
return(result);
}
private List <TestClassInfo> GetTestTemplates(string sourceCode)
{
CodeAnalyzer analyzer = new CodeAnalyzer();
List <ClassInfo> classes = analyzer.Parse(sourceCode);
List <TestClassInfo> testClasses = new List <TestClassInfo>();
foreach (ClassInfo classInfo in classes)
{
Console.WriteLine(classInfo.Name + " " + classInfo.Namespace);
NamespaceDeclarationSyntax namespaceDeclaration = NamespaceDeclaration(
QualifiedName(
IdentifierName(classInfo.Namespace),
IdentifierName("Tests")));
CompilationUnitSyntax testClass = CompilationUnit()
.WithUsings(GetUsings(classInfo))
.WithMembers(SingletonList <MemberDeclarationSyntax>(namespaceDeclaration
.WithMembers(SingletonList <MemberDeclarationSyntax>(ClassDeclaration(classInfo.Name + "Tests")
.WithAttributeLists(
SingletonList(
AttributeList(
SingletonSeparatedList(
Attribute(
IdentifierName("TestClass"))))))
.WithModifiers(TokenList(Token(SyntaxKind.PublicKeyword)))
.WithMembers(GetTestMethods(classInfo.MethodList))))));
string fileName = classInfo.Name + "Tests.cs";
string innerText = testClass.NormalizeWhitespace().ToFullString();
testClasses.Add(new TestClassInfo(fileName, innerText));
}
return(testClasses);
}
private SyntaxTree renameProgramClass(SyntaxTree tree)
{
ClassDeclarationSyntax mainClass = this.getTopLevelClasses(tree).First();
SyntaxTree newTree = null;
if (mainClass != null)
{
SyntaxToken newIdentifier = SyntaxFactory.Identifier(SESCriptBuilderInstance.ProgramName);
SyntaxList <MemberDeclarationSyntax> members = mainClass.Members;
if (members != null && members.Count() > 0)
{
SyntaxList <MemberDeclarationSyntax> newMembers = new SyntaxList <MemberDeclarationSyntax>();
foreach (MemberDeclarationSyntax member in members)
{
MemberDeclarationSyntax newMember = member;
if (member.GetType() == typeof(ConstructorDeclarationSyntax))
{
ConstructorDeclarationSyntax cons = member as ConstructorDeclarationSyntax;
SyntaxToken identifier = cons.Identifier;
if (identifier != null)
{
newMember = SyntaxFactory.ConstructorDeclaration(cons.AttributeLists, cons.Modifiers, newIdentifier, cons.ParameterList, cons.Initializer, cons.Body, cons.ExpressionBody, cons.SemicolonToken);
}
}
newMembers = newMembers.Add(newMember);
}
members = newMembers;
}
ClassDeclarationSyntax newClass = mainClass.WithIdentifier(newIdentifier).WithMembers(members);
if (newClass != null)
{
IEnumerable <NamespaceDeclarationSyntax> namespaces = tree.GetRootAsync().Result.DescendantNodes().OfType <NamespaceDeclarationSyntax>();
CompilationUnitSyntax newComp = null;
CompilationUnitSyntax oldComp = tree.GetCompilationUnitRoot();
SyntaxList <MemberDeclarationSyntax> newClassMembers = new SyntaxList <MemberDeclarationSyntax>();
newClassMembers = newClassMembers.Add(newClass);
if (namespaces != null && namespaces.Count() > 0)
{
NamespaceDeclarationSyntax ns = namespaces.First();
if (ns != null)
{
NamespaceDeclarationSyntax newNs = ns.WithMembers(newClassMembers);
SyntaxList <MemberDeclarationSyntax> newNsMembers = new SyntaxList <MemberDeclarationSyntax>();
newNsMembers = newNsMembers.Add(newNs);
newComp = oldComp.WithMembers(newNsMembers);
}
}
else
{
newComp = oldComp.WithMembers(newClassMembers);
}
if (newComp != null)
{
newTree = newComp.SyntaxTree;
}
}
}
return(newTree);
}
public override SyntaxNode VisitNamespaceDeclaration(NamespaceDeclarationSyntax node)
{
return(node.WithMembers(ReplaceMembers(node.Members)));
}
public static Task <List <TestClass> > GetTestClasses(string code)
{
return(Task.Run(() =>
{
List <TestClass> result = new List <TestClass>();
var tree = CSharpSyntaxTree.ParseText(code);
var mscorlib = MetadataReference.CreateFromFile(typeof(object).Assembly.Location);
var compilation = CSharpCompilation.Create("MyCompilation",
syntaxTrees: new[] { tree }, references: new[] { mscorlib });
model = compilation.GetSemanticModel(tree);
var root = tree.GetRoot();
var classes = root.DescendantNodes().OfType <ClassDeclarationSyntax>();
var attr = Attribute(IdentifierName("TestClass()"));
var attributes = SingletonList(AttributeList(SingletonSeparatedList(attr)));
foreach (ClassDeclarationSyntax classDeclaration in classes)
{
List <MemberDeclarationSyntax> fields = new List <MemberDeclarationSyntax>();
var constructor = classDeclaration.Members.FirstOrDefault(m => m.Kind() == SyntaxKind.ConstructorDeclaration);
string className = classDeclaration.Identifier.ValueText;
NamespaceDeclarationSyntax testClassNamespace = NamespaceDeclaration(IdentifierName(className + "Test"));
string testClassName = className + "Tests";
var methods = GetTestMethods(classDeclaration);
if (methods.Count > 0)
{
if (!classDeclaration.Modifiers.Where(m => m.Kind() == SyntaxKind.StaticKeyword).Any())
{
methods = methods.Insert(0, GetClassinitializeMethod(classDeclaration, constructor as ConstructorDeclarationSyntax, fields));
}
var usings = GetTestUsingDirectives(((NamespaceDeclarationSyntax)classDeclaration.Parent).Name.ToString());
var newTree = CompilationUnit()
.WithUsings(usings)
.WithMembers(SingletonList <MemberDeclarationSyntax>(testClassNamespace
.WithMembers(SingletonList <MemberDeclarationSyntax>(ClassDeclaration(testClassName)
.WithMembers(List(fields).AddRange(methods))
.WithModifiers(TokenList(Token(SyntaxKind.PublicKeyword)))
.WithAttributeLists(attributes))))
);
result.Add(new TestClass(testClassName + ".cs", newTree.NormalizeWhitespace().ToFullString()));
}
}
return result;
}
));
}
// method that generates test classes for each class found in code
public static Task <List <GeneratedTestClass> > Generate(string code)
{
return(Task.Run(() => {
List <GeneratedTestClass> generatedClasses = new List <GeneratedTestClass>();
// using Roslyn to parse/build syntax tree
var tree = CSharpSyntaxTree.ParseText(code);
var syntaxRoot = tree.GetRoot();
var classDeclarations = syntaxRoot.DescendantNodes().OfType <ClassDeclarationSyntax>();
foreach (var clsInfo in classDeclarations)
{
// get class name, namespace name and public methods
string className = clsInfo.Identifier.ValueText;
string clsNamespace = ((NamespaceDeclarationSyntax)clsInfo.Parent).Name.ToString();
var publicMethods = clsInfo.DescendantNodes().OfType <MethodDeclarationSyntax>().Where(
method => method.Modifiers.Any(modifier => modifier.ValueText == "public")).Select(obj => obj.Identifier.ValueText);
// use roslyn to generate test class code
// declare namespace, template usings and methods
NamespaceDeclarationSyntax template_namespace = NamespaceDeclaration(
QualifiedName(
IdentifierName(className), IdentifierName("Test")));
var template_usings = getTemplateUsing(clsNamespace);
var template_methods = getTemplateMethods(publicMethods);
var template_classname = className + "Tests";
// creating compilation unit --> transfer to code
var template_class = CompilationUnit()
.WithUsings(template_usings)
.WithMembers(SingletonList <MemberDeclarationSyntax>(template_namespace
.WithMembers(SingletonList <MemberDeclarationSyntax>(ClassDeclaration(template_classname)
.WithAttributeLists(
SingletonList(
AttributeList(
SingletonSeparatedList(
Attribute(
IdentifierName("TestClass"))))))
.WithModifiers(TokenList(Token(SyntaxKind.PublicKeyword)))
.WithMembers(template_methods)))));
string generatedCode = template_class.NormalizeWhitespace().ToFullString();
string generatedName = template_classname + ".cs";
generatedClasses.Add(new GeneratedTestClass(generatedName, generatedCode));
}
return generatedClasses;
}));
}
public IEnumerable <FileSource> GetTestTemplates()
{
List <FileSource> testTemplates = new List <FileSource>();
foreach (ClassInfo classInfo in _syntaxTreeInfo.Classes)
{
NamespaceDeclarationSyntax namespaceDeclaration = NamespaceDeclaration(QualifiedName(
IdentifierName(classInfo.NamespaceName), IdentifierName("Tests")));
CompilationUnitSyntax compilationUnit = CompilationUnit()
.WithUsings(GetUsingDirectives(classInfo))
.WithMembers(SingletonList <MemberDeclarationSyntax>(namespaceDeclaration
.WithMembers(SingletonList <MemberDeclarationSyntax>(ClassDeclaration(classInfo.Name + "Tests")
.WithAttributeLists(
SingletonList(
AttributeList(
SingletonSeparatedList(
Attribute(
IdentifierName("TestClass"))))))
.WithModifiers(TokenList(Token(SyntaxKind.PublicKeyword)))
.WithMembers(GetClassMembers(classInfo))))));
string fileName = $"{classInfo.Name}Tests.cs";
byte[] fileData = Encoding.Default.GetBytes(compilationUnit.NormalizeWhitespace().ToFullString());
testTemplates.Add(new FileSource(fileData, fileName));
}
return(testTemplates);
}
public static NamespaceDeclarationSyntax WithSingleMember(this NamespaceDeclarationSyntax @namespace, MemberDeclarationSyntax member) => @namespace.WithMembers(SingletonList(member));