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