public void Methods() { string source = @" public class MyClass { private void Method1() { } protected void Method2() { } } "; // Getting the AST node CSharpSyntaxTree tree = ASTExtractor.Extract(source); SyntaxNode node = new NodeLocator(tree).LocateFirst(typeof(ClassDeclarationSyntax)); ClassDeclarationSyntax classDeclarationNode = node as ClassDeclarationSyntax; // Creating the walker var astWalker = MockedClassASTWalker.Create(classDeclarationNode); // Getting the translation unit astWalker.Walk(); // Checking Assert.IsNotNull(astWalker.ClassDeclaration); // Checking members Assert.IsNotNull(astWalker.ClassDeclaration.MethodDeclarations); Assert.IsTrue(astWalker.ClassDeclaration.MethodDeclarations.Count() > 0); Assert.AreEqual(2, astWalker.ClassDeclaration.MethodDeclarations.Count()); Assert.IsInstanceOfType(astWalker.ClassDeclaration.MethodDeclarations.ElementAt(0), typeof(MethodDeclarationTranslationUnit)); Assert.IsInstanceOfType(astWalker.ClassDeclaration.MethodDeclarations.ElementAt(1), typeof(MethodDeclarationTranslationUnit)); }
private static void Test(string source) { // Getting the AST node CSharpSyntaxTree tree = ASTExtractor.Extract(source); SyntaxNode node = new NodeLocator(tree).LocateFirst(typeof(EnumDeclarationSyntax)); var enumDeclarationNode = node as EnumDeclarationSyntax; // Creating the walker var astWalker = MockedEnumASTWalker.Create(enumDeclarationNode); // Getting the translation unit astWalker.Walk(); // Checking Assert.IsNotNull(astWalker.EnumDeclaration); // Checking signatures Assert.IsNotNull(astWalker.EnumDeclaration.Members); Assert.IsTrue(astWalker.EnumDeclaration.Members.Count() > 0); Assert.AreEqual(3, astWalker.EnumDeclaration.Members.Count()); Assert.IsInstanceOfType(astWalker.EnumDeclaration.Members.ElementAt(0), typeof(EnumMemberTranslationUnit)); Assert.IsInstanceOfType(astWalker.EnumDeclaration.Members.ElementAt(1), typeof(EnumMemberTranslationUnit)); Assert.IsInstanceOfType(astWalker.EnumDeclaration.Members.ElementAt(2), typeof(EnumMemberTranslationUnit)); }
public void IsCompatibleVersion_ReturnsTrueFalse(int majorVersion, bool expectedResult) { var version = new Version(majorVersion, 0); var result = NodeLocator.IsCompatibleVersion(version); result.Should().Be(expectedResult); }
public void TypeFullNameRenderingSemanticModel() { var tree = CSharpSyntaxTree.ParseText(@" using System; public class MyClass : IDisposable { public void Dispose() { } } "); var node = new NodeLocator(tree).LocateLast(typeof(ClassDeclarationSyntax)); Assert.IsNotNull(node, string.Format("Node of type `{0}` should be found!", typeof(ClassDeclarationSyntax).Name)); // Loading MSCoreLib var compilation = CSharpCompilation.Create("TestAssembly") .AddReferences( MetadataReference.CreateFromFile( typeof(object).Assembly.Location)) .AddSyntaxTrees(tree); var semanticModel = compilation.GetSemanticModel(tree); ClassDeclarationSyntax classDeclarationNode = node as ClassDeclarationSyntax; BaseTypeSyntax baseTypeNode = classDeclarationNode.BaseList.Types.FirstOrDefault(); TestRetrieveTypeName(baseTypeNode, null, "IDisposable"); TestRetrieveTypeName(baseTypeNode, semanticModel, "IDisposable"); TestRetrieveTypeFullName(baseTypeNode, null, "IDisposable"); TestRetrieveTypeFullName(baseTypeNode, semanticModel, "System.IDisposable"); }
public void LocateElementWithId() { var x = Element.Create("span", "x"); var locator = NodeLocator.FromNode(x); Assert.Equal(x.Id, locator.StartingId); }
public void MethodName() { string[] methodExpectedNames = new string[] { TestSuite.Class11.Value["Method1Name"], TestSuite.Class11.Value["Method2Name"], TestSuite.Class11.Value["Method3Name"], TestSuite.Class11.Value["Method4Name"], TestSuite.Class11.Value["Method5Name"], TestSuite.Class11.Value["Method6Name"], TestSuite.Class11.Value["Method7Name"], }; IEnumerable <KeyValuePair <SyntaxNode, string> > items = new NodeLocator(Class11SyntaxTree).LocateAll(typeof(MethodDeclarationSyntax)) .Select((node, k) => new KeyValuePair <SyntaxNode, string>(node, methodExpectedNames[k])); foreach (KeyValuePair <SyntaxNode, string> item in items) { Assert.IsNotNull(item.Key, string.Format("Node of type `{0}` should be found!", typeof(MethodDeclarationSyntax).Name)); MethodDeclarationSyntax methodDeclarationNode = item.Key as MethodDeclarationSyntax; TestRetrieveMethodName(methodDeclarationNode, item.Value); } }
public void DetectVoidType() { var tree = CSharpSyntaxTree.ParseText(@" using System; public class MyClass { public void Method1() { } public int Method2() { } } "); // First method var node = new NodeLocator(tree).LocateFirst(typeof(MethodDeclarationSyntax)); Assert.IsNotNull(node, string.Format("Node of type `{0}` should be found!", typeof(MethodDeclarationSyntax).Name)); var methodDeclarationNode = node as MethodDeclarationSyntax; var helper = new MethodDeclaration(methodDeclarationNode).ReturnType; Assert.IsTrue(helper.IsVoid, "Expected void type!"); // Second method node = new NodeLocator(tree).LocateLast(typeof(MethodDeclarationSyntax)); Assert.IsNotNull(node, string.Format("Node of type `{0}` should be found!", typeof(MethodDeclarationSyntax).Name)); methodDeclarationNode = node as MethodDeclarationSyntax; helper = new MethodDeclaration(methodDeclarationNode).ReturnType; Assert.IsFalse(helper.IsVoid, "Void type not expected!"); }
/// <summary> /// Finds the <see cref="T:MemcachedNode"/> which is responsible for the specified item /// </summary> /// <param name="itemKey"></param> /// <returns></returns> private MemcachedNode LocateNode(string itemKey) { serverAccessLock.AcquireReaderLock(Timeout.Infinite); try { MemcachedNode node = NodeLocator.Locate(itemKey); if (node == null) { return(null); } if (node.IsAlive) { return(node); } MarkAsDead(node); return(LocateNode(itemKey)); } finally { serverAccessLock.ReleaseLock(); } }
public void MethodParametersAreOfCorrectType() { var source = @" class Class1 { public void Method1(int param1) { } public void Method2(int param1, string param2) { } public void Method3(int param1, string param2, object param3) { } public void Method4(int param1, string param2, object param3, bool param4) { } } "; var syntaxTree = CSharpSyntaxTree.ParseText(source); var semanticModel = CSharpCompilation.Create("Class").AddReferences( MetadataReference.CreateFromFile(typeof(object).Assembly.Location)).AddSyntaxTrees( syntaxTree).GetSemanticModel(syntaxTree); IEnumerable <SyntaxNode> nodes = new NodeLocator(syntaxTree).LocateAll( typeof(MethodDeclarationSyntax)); foreach (SyntaxNode node in nodes) { Assert.IsNotNull(node, string.Format("Node of type `{0}` should be found!", typeof(MethodDeclarationSyntax).Name)); MethodDeclarationSyntax methodDeclarationNode = node as MethodDeclarationSyntax; MethodDeclaration methodDeclaration = new MethodDeclaration(methodDeclarationNode); foreach (var param in methodDeclaration.Parameters) { Assert.IsNotNull(param, "Parameter should not be null!"); Assert.IsInstanceOfType(param, typeof(Parameter), "Wrong parameter type!"); } } }
public void MethodWithVariableDeclarations() { string source = @" public void Method() { string var1; int var2; } "; // Getting the AST node CSharpSyntaxTree tree = ASTExtractor.Extract(source); SyntaxNode node = new NodeLocator(tree).LocateLast(typeof(MethodDeclarationSyntax)); MethodDeclarationSyntax methodDeclarationNode = node as MethodDeclarationSyntax; // Creating the walker var astWalker = MockedMethodASTWalker.Create(methodDeclarationNode); // Getting the translation unit astWalker.Walk(); // Checking Assert.IsNotNull(astWalker.MethodDeclaration); // Checking members Assert.IsNotNull(astWalker.MethodDeclaration.Statements); Assert.IsTrue(astWalker.MethodDeclaration.Statements.Count() > 0); Assert.AreEqual(2, astWalker.MethodDeclaration.Statements.Count()); Assert.IsInstanceOfType(astWalker.MethodDeclaration.Statements.ElementAt(0), typeof(StatementTranslationUnit)); Assert.IsInstanceOfType(astWalker.MethodDeclaration.Statements.ElementAt(1), typeof(StatementTranslationUnit)); }
public void EmptyMethodWithNoParameters() { string source = @" public void Method() { } "; // Getting the AST node CSharpSyntaxTree tree = ASTExtractor.Extract(source); SyntaxNode node = new NodeLocator(tree).LocateLast(typeof(MethodDeclarationSyntax)); MethodDeclarationSyntax methodDeclarationNode = node as MethodDeclarationSyntax; // Creating the walker var astWalker = MockedMethodASTWalker.Create(methodDeclarationNode); // Getting the translation unit astWalker.Walk(); // Checking Assert.IsNotNull(astWalker.MethodDeclaration); // Checking members Assert.IsNotNull(astWalker.MethodDeclaration.Arguments); Assert.AreEqual(0, astWalker.MethodDeclaration.Arguments.Count()); }
public void EmptyMethodWith3Parameters() { string source = @" public void Method(string param1, int param2, bool param3) { } "; // Getting the AST node CSharpSyntaxTree tree = ASTExtractor.Extract(source); SyntaxNode node = new NodeLocator(tree).LocateLast(typeof(MethodDeclarationSyntax)); MethodDeclarationSyntax methodDeclarationNode = node as MethodDeclarationSyntax; // Creating the walker var astWalker = MockedMethodASTWalker.Create(methodDeclarationNode); // Getting the translation unit astWalker.Walk(); // Checking Assert.IsNotNull(astWalker.MethodDeclaration); // Checking members Assert.IsNotNull(astWalker.MethodDeclaration.Arguments); Assert.IsTrue(astWalker.MethodDeclaration.Arguments.Count() > 0); Assert.AreEqual(3, astWalker.MethodDeclaration.Arguments.Count()); Assert.IsInstanceOfType(astWalker.MethodDeclaration.Arguments.ElementAt(0), typeof(ArgumentDefinitionTranslationUnit)); Assert.IsInstanceOfType(astWalker.MethodDeclaration.Arguments.ElementAt(1), typeof(ArgumentDefinitionTranslationUnit)); Assert.IsInstanceOfType(astWalker.MethodDeclaration.Arguments.ElementAt(2), typeof(ArgumentDefinitionTranslationUnit)); }
static void Main(string[] args) { IList<TestNode> nodeList = new List<TestNode>(); nodeList.Add(new TestNode("abcd-123456")); //nodeList.Add(new TestNode("abcd-123478")); nodeList.Add(new TestNode("abcd-123490")); nodeList.Add(new TestNode("abcd-123401")); INodeLocator<TestNode> locator = new NodeLocator<TestNode>(); locator.Initialize(nodeList); for (int i = 0; i < 10; i++) { Console.WriteLine(locator.Locate("abc" + i).Indentity); } Random rnd = new Random(); StringBuilder sb = new StringBuilder(); for (int i = 0; i < 1000; i++) { sb.Append(rnd.Next(100000, 9999999)); } Console.WriteLine(BitConverter.ToInt32(new FNV1a().ComputeHash(System.Text.Encoding.ASCII.GetBytes(sb.ToString())),0)); //Console.WriteLine(BitConverter.ToInt32(new FNV1a().ComputeHash(System.Text.Encoding.ASCII.GetBytes(sb.ToString())), 4)); Console.ReadLine(); }
public void WalkASTDeep() { string source = @" namespace MyNamespaceA { public class MyClassA { } public class MyClassB { } namespace MyNamespaceB { public class MyClassC { } public class MyClassD { } } } "; int traversedClassesCount = 0; // Getting the AST node CSharpSyntaxTree tree = ASTExtractor.Extract(source); var node = new NodeLocator(tree).LocateLast(typeof(CompilationUnitSyntax)) as CSharpSyntaxNode; // Calling the walker var astWalker = new MultiPurposeASTWalker(node, syntaxNode => syntaxNode as ClassDeclarationSyntax != null, delegate { traversedClassesCount++; }, false); astWalker.Start(); // Checking Assert.AreEqual(4, traversedClassesCount, "Expected walker to deep traverse AST!"); }
public void Properties() { string source = @" public interface MyInterface { int Property1 { get; set; } string Property2 { get; set; } } "; // Getting the AST node CSharpSyntaxTree tree = ASTExtractor.Extract(source); SyntaxNode node = new NodeLocator(tree).LocateFirst(typeof(InterfaceDeclarationSyntax)); InterfaceDeclarationSyntax interfaceDeclarationNode = node as InterfaceDeclarationSyntax; // Creating the walker var astWalker = MockedInterfaceASTWalker.Create(interfaceDeclarationNode); // Getting the translation unit astWalker.Walk(); // Checking Assert.IsNotNull(astWalker.InterfaceDeclaration); // Checking signatures Assert.IsNotNull(astWalker.InterfaceDeclaration.Signatures); Assert.IsTrue(astWalker.InterfaceDeclaration.Signatures.Count() > 0); Assert.AreEqual(2, astWalker.InterfaceDeclaration.Signatures.Count()); Assert.IsInstanceOfType(astWalker.InterfaceDeclaration.Signatures.ElementAt(0), typeof(MethodSignatureDeclarationTranslationUnit)); Assert.IsInstanceOfType(astWalker.InterfaceDeclaration.Signatures.ElementAt(1), typeof(MethodSignatureDeclarationTranslationUnit)); }
public void ScriptNamespaceRetrievedOnInterfacePropertyType() { var tree = CSharpSyntaxTree.ParseText(@" namespace Namespace1 { [ScriptNamespace(""OverridenNamespace"")] public class Class1 { } public interface Interface1 { Class1 MyProperty { get; set; } } } "); // Loading MSCoreLib var semanticModel = (CSharpCompilation.Create("TestAssembly") .AddReferences( MetadataReference.CreateFromFile( typeof(object).Assembly.Location)) .AddSyntaxTrees(tree).AddScriptNamespaceReference().GetSemanticModel(tree)); var node = new NodeLocator(tree).LocateFirst(typeof(PropertyDeclarationSyntax)); Assert.IsNotNull(node); var propertyDeclarationNode = node as PropertyDeclarationSyntax; Assert.IsNotNull(propertyDeclarationNode); var typeReference = new PropertyDeclaration(propertyDeclarationNode, semanticModel).Type; Assert.AreEqual("OverridenNamespace.Class1", typeReference.FullName, "ScriptNamespace overriden namespace not detected!"); }
public void EmptyMethodWith2Parameters() { string source = @" class Class1 { public Class1(string param1, int param2) { } } "; // Getting the AST node CSharpSyntaxTree tree = ASTExtractor.Extract(source); SyntaxNode node = new NodeLocator(tree).LocateLast(typeof(ConstructorDeclarationSyntax)); ConstructorDeclarationSyntax constructorDeclarationNode = node as ConstructorDeclarationSyntax; // Creating the walker var astWalker = MockedConstructorASTWalker.Create(constructorDeclarationNode); // Getting the translation unit astWalker.Walk(); // Checking Assert.IsNotNull(astWalker.ConstructorDeclaration); // Checking members Assert.IsNotNull(astWalker.ConstructorDeclaration.Arguments); Assert.IsTrue(astWalker.ConstructorDeclaration.Arguments.Count() > 0); Assert.AreEqual(2, astWalker.ConstructorDeclaration.Arguments.Count()); Assert.IsInstanceOfType(astWalker.ConstructorDeclaration.Arguments.ElementAt(0), typeof(ArgumentDefinitionTranslationUnit)); Assert.IsInstanceOfType(astWalker.ConstructorDeclaration.Arguments.ElementAt(1), typeof(ArgumentDefinitionTranslationUnit)); }
public void SimpleClass() { var node = (@" namespace Root.MyNamespace1 { public class MyClass { } } ").ExtractASTRoot(); var namespaces = new NodeLocator(node).LocateAll(typeof(NamespaceDeclarationSyntax), true); Assert.AreEqual(1, namespaces.Count(), "Expecting only one namespace at root level"); var @namespace = namespaces.First() as NamespaceDeclarationSyntax; var namespaceName = @namespace.Name.ToString(); Assert.AreEqual("Root.MyNamespace1", namespaceName, "Wrong namespace name"); var classes = new NodeLocator(@namespace).LocateAll(typeof(ClassDeclarationSyntax), true); Assert.AreEqual(1, classes.Count(), "Expecting only one class in namespace"); var @class = classes.First() as ClassDeclarationSyntax; var className = @class.Identifier.Text; Assert.AreEqual("MyClass", className, "Wrong class name"); }
public void OneClass() { string source = @" public class Class1 { } "; // Getting the AST node CSharpSyntaxTree tree = ASTExtractor.Extract(source); SyntaxNode node = new NodeLocator(tree).LocateLast(typeof(CompilationUnitSyntax)); CompilationUnitSyntax programNode = node as CompilationUnitSyntax; // Creating the walker var astWalker = MockedProgramASTWalker.Create(programNode); // Getting the translation unit astWalker.Walk(); // Checking Assert.IsNotNull(astWalker.Program); // Checking members Assert.IsNotNull(astWalker.Program.Content); Assert.IsTrue(astWalker.Program.Content.Count() > 0); Assert.AreEqual(1, astWalker.Program.Content.Count()); Assert.IsInstanceOfType(astWalker.Program.Content.ElementAt(0), typeof(ClassDeclarationTranslationUnit)); }
public void UsingDirectivesAreTransplantedAtRootLevel() { var source = @" namespace Namespace1 { namespace Namespace11 { public class Class111 { } } namespace Namespace12 { public class Class121 { } } } namespace OriginalNamespace { using Namespace1.Namespace11; using Namespace1.Namespace12; [ScriptNamespace(""NewNamespace"")] public class Class1 { } } "; var tree = CSharpSyntaxTree.ParseText(source) as CSharpSyntaxTree; // Loading MSCoreLib var compilation = CSharpCompilation.Create("TestAssembly") .AddReferences( MetadataReference.CreateFromFile( typeof(object).Assembly.Location)) .AddSyntaxTrees(tree).AddScriptNamespaceReference(); // Transform new ScriptNamespaceBasedASTTransformer().Transform(ref tree, ref compilation); // Test var oldNamespaceSyntaxNodes = new NodeLocator(tree).LocateAll(typeof(NamespaceDeclarationSyntax), node => node as NamespaceDeclarationSyntax != null && new NamespaceDeclaration(node as NamespaceDeclarationSyntax).Name == "OriginalNamespace"); // TODO: The next line cannot happen because at the moment the transformer leaves the ld namespace if // using directives are present inside, later we might think about removing using directives if // a namespace contains only using directivess parte of the cleanup process //Assert.AreEqual(0, oldNamespaceSyntaxNodes.Count(), "Old namespace should not be present"); var usingSyntaxNodes = new NodeLocator(tree).LocateAll(typeof(UsingDirectiveSyntax)); Assert.IsTrue(usingSyntaxNodes.Count() >= 2, "Original using directives should still be in the transformed AST"); var inRootUsingSyntaxNodes = new NodeLocator(tree).LocateAll(typeof(UsingDirectiveSyntax), node => node.IsInRoot()); Assert.IsTrue(inRootUsingSyntaxNodes.Count() >= 2, "Original using directives should have been transplanted into root"); var directive1Nodes = new NodeLocator(tree).LocateAll(typeof(UsingDirectiveSyntax), node => node.IsInRoot() && new UsingDirective(node as UsingDirectiveSyntax).Value == "Namespace1.Namespace11"); Assert.AreEqual(1, directive1Nodes.Count(), "Existing using directive should have been transplanted into root"); var directive2Nodes = new NodeLocator(tree).LocateAll(typeof(UsingDirectiveSyntax), node => node.IsInRoot() && new UsingDirective(node as UsingDirectiveSyntax).Value == "Namespace1.Namespace12"); Assert.AreEqual(1, directive2Nodes.Count(), "Existing using directive should have been transplanted into root"); }
public void OriginalOverridenNamespacesAreAddedAsUsingDirectivesAtRootLevel() { var source = @" namespace OriginalNamespace { [ScriptNamespace(""NewNamespace"")] public class Class1 { } } "; var tree = CSharpSyntaxTree.ParseText(source) as CSharpSyntaxTree; // Loading MSCoreLib var compilation = CSharpCompilation.Create("TestAssembly") .AddReferences( MetadataReference.CreateFromFile( typeof(object).Assembly.Location)) .AddSyntaxTrees(tree).AddScriptNamespaceReference(); // Transform new ScriptNamespaceBasedASTTransformer().Transform(ref tree, ref compilation); // Test var directiveNodes = new NodeLocator(tree).LocateAll(typeof(UsingDirectiveSyntax), node => node.IsInRoot() && new UsingDirective(node as UsingDirectiveSyntax).Value == "OriginalNamespace"); Assert.AreEqual(1, directiveNodes.Count(), "Original namespace should have been transplanted into root as using directive"); }
public void ScriptNamespaceRetrievedOnClassMethodArgumentType() { var tree = CSharpSyntaxTree.ParseText(@" namespace Namespace1 { [ScriptNamespace(""OverridenNamespace"")] public class Class1 { } public class Class2 { public void MyMethod(Class1 parameter) { } } } "); // Loading MSCoreLib var semanticModel = (CSharpCompilation.Create("TestAssembly") .AddReferences( MetadataReference.CreateFromFile( typeof(object).Assembly.Location)) .AddSyntaxTrees(tree).AddScriptNamespaceReference().GetSemanticModel(tree)); var node = new NodeLocator(tree).LocateFirst(typeof(MethodDeclarationSyntax)); Assert.IsNotNull(node); var methodDeclarationNode = node as MethodDeclarationSyntax; Assert.IsNotNull(methodDeclarationNode); var parameters = new MethodDeclaration(methodDeclarationNode, semanticModel).Parameters; Assert.AreEqual(1, parameters.Count(), "1 argument expected"); var typeReference = parameters.ElementAt(0).Type; Assert.AreEqual("OverridenNamespace.Class1", typeReference.FullName, "ScriptNamespace overriden namespace not detected!"); }
private static void TestScriptNamespaceOnParameter(string source, bool withSemanticModel, string expectedFullName) { var tree = CSharpSyntaxTree.ParseText(source); // Loading MSCoreLib var semanticModel = withSemanticModel ? (CSharpCompilation.Create("TestAssembly") .AddReferences( MetadataReference.CreateFromFile( typeof(object).Assembly.Location)) .AddSyntaxTrees(tree).AddScriptNamespaceReference().GetSemanticModel(tree)) : null; var node = new NodeLocator(tree).LocateFirst(typeof(MethodDeclarationSyntax)); Assert.IsNotNull(node); var methodDeclarationNode = node as MethodDeclarationSyntax; Assert.IsNotNull(methodDeclarationNode); var translationUnitFactory = new MethodDefinitionTranslationUnitFactory(methodDeclarationNode, semanticModel, true).Create(); Assert.IsNotNull(translationUnitFactory, "Translation unit expected to be created!"); var methodTranslationUnit = (translationUnitFactory as MethodDefinitionTranslationUnit); Assert.IsNotNull(methodTranslationUnit, $"Expecting a translation unit of type {typeof(MethodDefinitionTranslationUnit).Name}!"); var translationUnit = MockedMethodDefinitionTranslationUnit.Create(methodTranslationUnit); Assert.IsNotNull(translationUnit.Arguments); Assert.AreEqual(1, translationUnit.Arguments.Count(), "Expecting 1 argument!"); var argumentTranslationUnit = translationUnit.Arguments.ElementAt(0) as ArgumentDefinitionTranslationUnit; Assert.IsNotNull(argumentTranslationUnit, $"Expected argument to be of type {typeof(ArgumentDefinitionTranslationUnit).Name}"); var mockedArgumentTranslationUnit = MockedArgumentDefinitionTranslationUnit.Create(argumentTranslationUnit); Assert.IsNotNull(mockedArgumentTranslationUnit.VariableDeclaration); var variableDeclarationTranslationUnit = mockedArgumentTranslationUnit.VariableDeclaration as VariableDeclarationTranslationUnit; Assert.IsNotNull(variableDeclarationTranslationUnit); var mockedVariableDeclarationTranslationUnit = MockedVariableDeclarationTranslationUnit.Create(variableDeclarationTranslationUnit); Assert.IsNotNull(mockedVariableDeclarationTranslationUnit.Type, "Expecting a type!"); var typeIdentifierTranslationUnit = mockedVariableDeclarationTranslationUnit.Type as TypeIdentifierTranslationUnit; Assert.IsNotNull(typeIdentifierTranslationUnit, $"Expected argument to be of type {typeof(TypeIdentifierTranslationUnit).Name}"); var typeFullName = typeIdentifierTranslationUnit.Translate(); Assert.AreEqual(expectedFullName, typeFullName, "Expected ScriptNamespace overriden type to be used!"); }
private static void TestWhenASTIsChangedThenNoEmptyNamespacesAreLeftOver(bool withCompilation = false) { var source = @" namespace OriginalNamespace { [ScriptNamespace(""NewNamespace"")] public class Class1 { } [ScriptNamespace(""NewNamespace"")] public class Class2 { } [ScriptNamespace(""NewNamespace1"")] public class Class3 { } [ScriptNamespace(""NewNamespace1"")] public class Class4 { } } "; var tree = CSharpSyntaxTree.ParseText(source) as CSharpSyntaxTree; // Loading MSCoreLib var compilation = withCompilation ? CSharpCompilation.Create("TestAssembly") .AddReferences( MetadataReference.CreateFromFile( typeof(object).Assembly.Location)) .AddSyntaxTrees(tree).AddScriptNamespaceReference() : null; // Transform if (withCompilation) { new ScriptNamespaceBasedASTTransformer().Transform(ref tree, ref compilation); } else { new ScriptNamespaceBasedASTTransformer().Transform(ref tree); } // Test var oldNamespaceSyntaxNodes = new NodeLocator(tree).LocateAll(typeof(NamespaceDeclarationSyntax), node => node as NamespaceDeclarationSyntax != null && new NamespaceDeclaration(node as NamespaceDeclarationSyntax).Name == "OriginalNamespace"); Assert.AreEqual(0, oldNamespaceSyntaxNodes.Count(), "Old namespace should not be present"); var namespaceSyntaxNodes = new NodeLocator(tree).LocateAll(typeof(NamespaceDeclarationSyntax)); Assert.IsTrue(namespaceSyntaxNodes.Count() > 0, "Namespaces expected"); foreach (var namespaceNode in namespaceSyntaxNodes) { Assert.IsFalse((namespaceNode as NamespaceDeclarationSyntax).IsNamespaceEmpty(), "No empty namespace expected"); } }
private static void DetermineLastElseAndTest(SyntaxTree syntaxTree, bool expectedElse) { SyntaxNode node = new NodeLocator(syntaxTree).LocateFirst(typeof(IfStatementSyntax)); Assert.IsNotNull(node, string.Format("Node of type `{0}` should be found!", typeof(IfStatementSyntax).Name)); IfStatementSyntax conditionalNode = node as IfStatementSyntax; TestDeterminedLastElseClause(conditionalNode, expectedElse); }
public void ClassNameFromClassWithInterface() { SyntaxNode node = new NodeLocator(Class3SyntaxTree).LocateLast(typeof(ClassDeclarationSyntax)); Assert.IsNotNull(node, string.Format("Node of type `{0}` should be found!", typeof(ClassDeclarationSyntax).Name)); ClassDeclarationSyntax classDeclarationNode = node as ClassDeclarationSyntax; TestRetrieveClassName(classDeclarationNode, TestSuite.Class3.Value["ClassName"]); }
public void InterfaceNameFromClassWithInheritance() { SyntaxNode node = new NodeLocator(Class2SyntaxTree).LocateLast(typeof(ClassDeclarationSyntax)); Assert.IsNotNull(node, string.Format("Node of type `{0}` should be found!", typeof(ClassDeclarationSyntax).Name)); ClassDeclarationSyntax classDeclarationNode = node as ClassDeclarationSyntax; TestRetrieveInterfacesName(classDeclarationNode, Class2SemanticModel, null); }
public void BaseClassNameFromClass() { SyntaxNode node = new NodeLocator(Class1SyntaxTree).LocateLast(typeof(ClassDeclarationSyntax)); Assert.IsNotNull(node, string.Format("Node of type `{0}` should be found!", typeof(ClassDeclarationSyntax).Name)); ClassDeclarationSyntax classDeclarationNode = node as ClassDeclarationSyntax; TestRetrieveBaseClassName(classDeclarationNode, Class1SemanticModel, null); }
private static void RetrieveNumberOfBodiesAndTest(SyntaxTree syntaxTree, int expectedNumberOfBodies) { SyntaxNode node = new NodeLocator(syntaxTree).LocateFirst(typeof(IfStatementSyntax)); Assert.IsNotNull(node, string.Format("Node of type `{0}` should be found!", typeof(IfStatementSyntax).Name)); IfStatementSyntax conditionalNode = node as IfStatementSyntax; TestRetrievedNumberOfBodies(conditionalNode, expectedNumberOfBodies); }
private static void TestWhenScriptNamespaceAttributeProvidedThenClassPlacedInDifferentNamespace(bool withCompilation = false) { var source = @" namespace OriginalNamespace { [ScriptNamespace(""NewNamespace"")] public class MyClass { } } "; var tree = CSharpSyntaxTree.ParseText(source) as CSharpSyntaxTree; // Loading MSCoreLib var compilation = withCompilation ? CSharpCompilation.Create("TestAssembly") .AddReferences( MetadataReference.CreateFromFile( typeof(object).Assembly.Location)) .AddSyntaxTrees(tree).AddScriptNamespaceReference() : null; // Transform if (withCompilation) { new ScriptNamespaceBasedASTTransformer().Transform(ref tree, ref compilation); } else { new ScriptNamespaceBasedASTTransformer().Transform(ref tree); } // Test var namespaceSyntaxNode = new NodeLocator(tree).LocateFirst(typeof(NamespaceDeclarationSyntax)); Assert.IsNotNull(namespaceSyntaxNode, "A namespace was expected"); var namespaceDeclarationNode = namespaceSyntaxNode as NamespaceDeclarationSyntax; Assert.IsNotNull(namespaceDeclarationNode); var namespaceHelper = new NamespaceDeclaration(namespaceDeclarationNode); Assert.AreEqual("NewNamespace", namespaceHelper.Name, "The name of the namespace should have changed"); var classSyntaxNode = new NodeLocator(tree).LocateFirst(typeof(ClassDeclarationSyntax)); Assert.IsNotNull(classSyntaxNode, "A class was expected"); var classDeclarationNode = classSyntaxNode as ClassDeclarationSyntax; Assert.IsNotNull(namespaceDeclarationNode); var classHelper = new ClassDeclaration(classDeclarationNode); Assert.AreEqual("MyClass", classHelper.Name, "The name of the class should be the same"); Assert.IsTrue(classSyntaxNode.IsChildOf(namespaceDeclarationNode), "Class expected to be child of namespace"); }
public void InterfaceTypeNameFromBaseList() { SyntaxNode node = new NodeLocator(Class3SyntaxTree).LocateLast(typeof(ClassDeclarationSyntax)); Assert.IsNotNull(node, string.Format("Node of type `{0}` should be found!", typeof(ClassDeclarationSyntax).Name)); ClassDeclarationSyntax classDeclarationNode = node as ClassDeclarationSyntax; BaseTypeSyntax baseTypeNode = classDeclarationNode.BaseList.Types.FirstOrDefault(); TestRetrieveTypeName(baseTypeNode, TestSuite.Class3.Value["Interface1Name"]); }