public void TestAnalyzeClass()
{
string code1 = @"class TestClass { public void TestMethod( int test = 0; test = 1;){}}";
SyntaxTree tree1 = CSharpSyntaxTree.ParseText(code1);
ClassDeclarationSyntax classNode = tree1.GetRootAsync().Result.DescendantNodes().OfType <ClassDeclarationSyntax>().First();
List <SyntaxTree> trees1 = new List <SyntaxTree> {
tree1
};
Compilation comp1 = CSharpCompilation.Create("TestCompilation1", trees1);
ScriptAnalyzer analyzer = this.createAnalyzer(comp1);
TaggedSyntaxLibrary lib = analyzer.AnalyzeNode(classNode);
Assert.IsNotNull(lib, "Library defined");
Assert.AreEqual(1, lib.TaggedSyntaxTrees.Count(), "Has one tree");
TaggedSyntaxTree tree = lib.TaggedSyntaxTrees.First();
CollectionAssert.Contains(tree.TaggedNodes, classNode, "Tree contains class node");
IEnumerable <SyntaxNode> nodes = classNode.DescendantNodes();
foreach (SyntaxNode node in nodes)
{
CollectionAssert.DoesNotContain(tree.TaggedNodes, node, "SubNode is not added to tree");
}
}
public void TestAnalyzeOverrideMethodFromVirtual()
{
string code1 = @"class TestClass { public void MainMethod(){ SubClass test = new SubClass(); test.TestMethod();}}";
string code2 = @"class SuperClass { public void TestMethod(){this.TestMethod2();} public virtual void TestMethod2(){}}";
string code3 = @"class SubClass:SuperClass { public override void TestMethod2(){}}";
SyntaxTree tree1 = CSharpSyntaxTree.ParseText(code1);
SyntaxTree tree2 = CSharpSyntaxTree.ParseText(code2);
SyntaxTree tree3 = CSharpSyntaxTree.ParseText(code3);
MethodDeclarationSyntax mainNode = tree1.GetRootAsync().Result.DescendantNodes().OfType <MethodDeclarationSyntax>().First();
MethodDeclarationSyntax superNode1 = tree2.GetRootAsync().Result.DescendantNodes().OfType <MethodDeclarationSyntax>().First();
MethodDeclarationSyntax superNode2 = tree2.GetRootAsync().Result.DescendantNodes().OfType <MethodDeclarationSyntax>().Last();
MethodDeclarationSyntax subNode = tree3.GetRootAsync().Result.DescendantNodes().OfType <MethodDeclarationSyntax>().First();
List <SyntaxTree> trees1 = new List <SyntaxTree> {
tree1, tree2, tree3
};
Compilation comp1 = CSharpCompilation.Create("TestCompilation1", trees1);
ScriptAnalyzer analyzer = this.createAnalyzer(comp1);
TaggedSyntaxLibrary lib = analyzer.AnalyzeNode(mainNode);
Assert.IsNotNull(lib, "Library defined");
Assert.AreEqual(3, lib.TaggedSyntaxTrees.Count(), "Has three trees");
TaggedSyntaxTree rTree1 = lib.TaggedSyntaxTrees.First();
TaggedSyntaxTree rTree2 = lib.TaggedSyntaxTrees.ElementAt(1);
TaggedSyntaxTree rTree3 = lib.TaggedSyntaxTrees.ElementAt(2);
CollectionAssert.Contains(rTree1.TaggedNodes, mainNode, "Main tree contains main method");
CollectionAssert.Contains(rTree3.TaggedNodes, superNode1, "Super tree contains first method");
CollectionAssert.Contains(rTree3.TaggedNodes, superNode2, "Super tree contains first method");
CollectionAssert.Contains(rTree2.TaggedNodes, subNode, "Sub tree contains sub method");
}
public List <SyntaxNode> GetSyntaxNodesFromClass(ClassDeclarationSyntax node, TaggedSyntaxLibrary lib)
{
List <SyntaxNode> nodes = new List <SyntaxNode>();
INamedTypeSymbol classSymbol = this.symbolHelper.GetSymbol(node) as INamedTypeSymbol;
if (classSymbol != null)
{
List <ISymbol> symbols = new List <ISymbol>();
INamedTypeSymbol baseType = classSymbol.BaseType;
if (baseType != null)
{
symbols.Add(baseType);
}
ImmutableArray <INamedTypeSymbol> interfaces = classSymbol.Interfaces;
if (interfaces != null && interfaces.Count() > 0)
{
foreach (INamedTypeSymbol inter in interfaces)
{
if (inter != null)
{
symbols.Add(inter);
}
}
}
// check for override methods
List <IMethodSymbol> oMethods = this.getOverrideMethodSymbolsFromClass(node);
if (oMethods != null && oMethods.Count() > 0)
{
foreach (IMethodSymbol oMethod in oMethods)
{
IMethodSymbol overridden = oMethod.OverriddenMethod;
if (overridden != null)
{
List <SyntaxNode> oNodes = ScriptAnalyzerResourceHelper.GetSyntaxNodesFromSymbol(overridden);
if (oNodes != null && oNodes.Count() > 0)
{
MethodDeclarationSyntax oNode = oNodes.First() as MethodDeclarationSyntax;
if (oNode != null)
{
TaggedSyntaxTree tTree = lib.GetTreeFromNode(oNode);
if (tTree != null && tTree.IsTagged(oNode))
{
symbols.Add(oMethod);
}
}
}
}
}
}
nodes = ScriptAnalyzerResourceHelper.GetSyntaxNodesFromSymbols(symbols);
}
return(nodes);
}
public void TestTagUnknownNode()
{
SyntaxTree tree = CSharpSyntaxTree.ParseText(@"namespace Test{public class TestClass{}}");
TaggedSyntaxTree fTree = new TaggedSyntaxTree(tree);
SyntaxNode node = SyntaxFactory.ClassDeclaration("test2");
bool succes = fTree.TagNode(node);
Assert.IsFalse(succes, "Adding was not succesfull");
Assert.IsNotNull(fTree.TaggedNodes, "Added notes is set");
Assert.AreEqual(0, fTree.TaggedNodes.Count, "Zero nodes are added");
}
public void TestConstructor()
{
SyntaxTree tree = CSharpSyntaxTree.ParseText(@"namespace Test{public class TestClass{}}");
TaggedSyntaxTree fTree = new TaggedSyntaxTree(tree);
Assert.IsNotNull(fTree, "Object created");
Assert.IsNotNull(fTree.TaggedNodes, "List created");
Assert.AreEqual(0, fTree.TaggedNodes.Count, "List is empty");
Assert.IsNotNull(fTree.OriginalTree, "Original tree not null");
Assert.AreEqual(tree, fTree.OriginalTree, "Original tree is correct syntax tree");
Assert.IsNotNull(fTree.OriginalRoot, "Original root is set");
Assert.AreEqual(tree.GetRootAsync().Result, fTree.OriginalRoot, "Original root is correct root");
}
public void TestTagAllParents()
{
SyntaxTree tree = CSharpSyntaxTree.ParseText(@"namespace Test{public class TestClass{}}");
TaggedSyntaxTree fTree = new TaggedSyntaxTree(tree);
SyntaxNode root = tree.GetRootAsync().Result;
NamespaceDeclarationSyntax testNs = root.DescendantNodes().OfType <NamespaceDeclarationSyntax>().First();
ClassDeclarationSyntax testClass = root.DescendantNodes().OfType <ClassDeclarationSyntax>().First();
bool succes = fTree.TagNode(testClass);
fTree.TagAllParents();
Assert.IsTrue(fTree.IsTagged(root), "HasNode returns true for added root");
Assert.IsTrue(fTree.IsTagged(testNs), "HasNode returns true for namespace");
Assert.IsTrue(fTree.IsTagged(testClass), "HasNode returns true for class node");
}
public void TestIsTagged()
{
SyntaxTree tree = CSharpSyntaxTree.ParseText(@"namespace Test{public class TestClass{}}");
TaggedSyntaxTree fTree = new TaggedSyntaxTree(tree);
SyntaxNode node = SyntaxFactory.ClassDeclaration("test2");
SyntaxNode root = tree.GetRootAsync().Result;
NamespaceDeclarationSyntax testNs = root.DescendantNodes().OfType <NamespaceDeclarationSyntax>().First();
ClassDeclarationSyntax unknown = SyntaxFactory.ClassDeclaration("test2");
bool succes = fTree.TagNode(root);
Assert.IsTrue(fTree.IsTagged(root), "HasNode returns true for added root");
Assert.IsFalse(fTree.IsTagged(testNs), "HasNode returns false for not added node (although its in the original tree)");
Assert.IsFalse(fTree.IsTagged(unknown), "HasNode returns false for unknown node");
}
public void TestTagNode()
{
TaggedSyntaxLibrary lib = new TaggedSyntaxLibrary();
ClassDeclarationSyntax node = SyntaxFactory.ClassDeclaration("test");
bool result = lib.TagNode(node);
Assert.IsTrue(result, "Expect result to be true");
Assert.IsNotNull(lib.TaggedSyntaxTrees, "Has created list of tagged syntax trees");
Assert.AreEqual(1, lib.TaggedSyntaxTrees.Count(), "List has one tagged tree");
TaggedSyntaxTree tree = lib.TaggedSyntaxTrees.First();
Assert.AreEqual(node.SyntaxTree, tree.OriginalTree, "Tagged Syntax tree has the correct syntaxtree");
Assert.IsTrue(tree.IsTagged(node), "The node is tagged on the tree");
}
public TaggedSyntaxLibrary analyze(Project project = null)
{
TaggedSyntaxLibrary lib = new TaggedSyntaxLibrary();
if (project == null)
{
project = this.project;
}
if (project != null)
{
SyntaxTree program = this.findMainTree(project);
if (program != null)
{
List <SyntaxNode> entryNodes = this.getEntryNodes(program);
ScriptAnalyzer analyzer = this.createScriptAnalyzer(project);
if (entryNodes != null && entryNodes.Count > 0)
{
foreach (SyntaxNode entryNode in entryNodes)
{
analyzer.AnalyzeNode(entryNode, lib);
}
if (lib.TaggedSyntaxTrees.Count() > 0)
{
TaggedSyntaxTree mainDTree = lib.GetTreeFromNode(entryNodes.First());
IEnumerable <TaggedSyntaxTree> dTrees = lib.TaggedSyntaxTrees.Where(t => t != mainDTree);
if (mainDTree != null)
{
this.mainTree = mainDTree.GetSyntaxTree();
}
if (dTrees != null && dTrees.Count() > 0)
{
this.dependencies = this.parseTaggedSyntaxTrees(dTrees);
}
}
}
}
}
// analyze three methods
return(lib);
}
public void TestTagNode()
{
SyntaxTree tree = CSharpSyntaxTree.ParseText(@"namespace Test{public class TestClass{}}");
TaggedSyntaxTree fTree = new TaggedSyntaxTree(tree);
ClassDeclarationSyntax node = tree.GetRootAsync().Result.DescendantNodes().OfType <ClassDeclarationSyntax>().First();
bool succes = fTree.TagNode(node);
Assert.IsTrue(succes, "Tagging was succesfull");
Assert.IsNotNull(fTree.TaggedNodes, "Tagged notes is set");
Assert.AreEqual(1, fTree.TaggedNodes.Count, "Only one node is tagged");
CollectionAssert.Contains(fTree.TaggedNodes, node, "Right node is tagged");
succes = fTree.TagNode(node);
Assert.IsFalse(succes, "Tagging should be unsuccessfull (already tagged node)");
Assert.IsNotNull(fTree.TaggedNodes, "Tagged notes still set");
Assert.AreEqual(1, fTree.TaggedNodes.Count, "Tagged notes still has only one node");
CollectionAssert.Contains(fTree.TaggedNodes, node, "The correct node is still tagged");
}
