private static void TestVisibility(string source, string className, string propertyName, SyntaxKind expectedVisibility)
{
// Assembling some code
IAssemblyLoader assemblyLoader = new Utils.AsmlDasmlAssemblyLoader(source);
// Loading the assembly
IAssemblyProxy assembly = assemblyLoader.Load();
// Locating the class
ITypeInfoProxy classDefinition = assembly.LocateType(className);
Assert.IsNotNull(classDefinition);
// Locating the method
IPropertyInfoProxy propertyDeclaration = classDefinition.LocateProperty(propertyName);
Assert.IsNotNull(propertyDeclaration);
// Generating the AST
var factory = new PropertyDeclarationSyntaxFactory(propertyDeclaration);
var syntaxNode = factory.Create();
Assert.IsNotNull(syntaxNode, "A node was expected to be built");
Assert.IsInstanceOfType(syntaxNode, typeof(PropertyDeclarationSyntax), "Expected a property declaration node to be built");
var propertyDeclarationSyntaxNode = syntaxNode as PropertyDeclarationSyntax;
var modifiers = propertyDeclarationSyntaxNode.Modifiers;
Assert.IsTrue(Utils.CheckModifier(modifiers, expectedVisibility), "Method does not have correct visibility");
}
/// <summary>
/// Initializes a new instance of the <see cref="Visibility"/> class.
/// </summary>
/// <param name="property">The <see cref="IPropertyInfoProxy"/> to analyze.</param>
public Visibility(IPropertyInfoProxy property)
{
if (property == null)
{
throw new ArgumentNullException(nameof(property));
}
this.property = property;
}
/// <summary>
/// Initializes a new instance of the <see cref="PropertyDeclarationSyntaxFactory"/> class.
/// </summary>
/// <param name="propertyInfo"></param>
/// <param name="typeLookup"></param>
/// <param name="withBody"></param>
public PropertyDeclarationSyntaxFactory(IPropertyInfoProxy propertyInfo, ITypeLookup typeLookup, bool withBody = true)
: base(propertyInfo, withBody)
{
if (typeLookup == null)
{
throw new ArgumentNullException(nameof(typeLookup));
}
this.typeLookup = typeLookup;
}
/// <summary>
/// Initializes a new instance of the <see cref="PropertyDeclarationSyntaxFactory"/> class.
/// </summary>
/// <param name="methodInfo"></param>
/// <param name="withBody"></param>
public PropertyDeclarationSyntaxFactory(IPropertyInfoProxy propertyInfo, bool withBody = true)
{
if (propertyInfo == null)
{
throw new ArgumentNullException(nameof(propertyInfo));
}
this.propertyInfo = propertyInfo;
this.withBody = withBody;
}
public void StaticModifierCorrectlyAcquired()
{
// Assembling some code
IAssemblyLoader assemblyLoader = new Utils.AsmlDasmlAssemblyLoader(@"
namespace MyNamespace {
public class MyClass {
public static int MyProperty1 {
get { return 0; }
set { }
}
public int MyProperty2 {
get { return 0; }
set { }
}
}
}
");
// Loading the assembly
IAssemblyProxy assembly = assemblyLoader.Load();
// Locating the class
ITypeInfoProxy classDefinition = assembly.LocateType("MyClass");
Assert.IsNotNull(classDefinition);
Action <string, bool> CheckStatic = (propertyName, expected) =>
{
// Locating the property
IPropertyInfoProxy propertyDeclaration = classDefinition.LocateProperty(propertyName);
Assert.IsNotNull(propertyDeclaration);
// Generating the AST
var factory = new PropertyDeclarationSyntaxFactory(propertyDeclaration);
var syntaxNode = factory.Create();
Assert.IsNotNull(syntaxNode, "A node was expected to be built");
Assert.IsInstanceOfType(syntaxNode, typeof(PropertyDeclarationSyntax), "Expected a property declaration node to be built");
var propertyDeclarationSyntaxNode = syntaxNode as PropertyDeclarationSyntax;
var modifiers = propertyDeclarationSyntaxNode.Modifiers;
Assert.IsNotNull(modifiers);
var staticModifier = modifiers.Where(modifier => modifier.Kind() == SyntaxKind.StaticKeyword);
Assert.AreEqual(expected ? 1 : 0, staticModifier.Count(), expected ? "Expected one static modifier" : "No static modifier expected");
};
CheckStatic("MyProperty1", true);
CheckStatic("MyProperty2", false);
}
public void NoBody()
{
// Assembling some code
IAssemblyLoader assemblyLoader = new Utils.AsmlDasmlAssemblyLoader(@"
namespace MyNamespace {
public interface MyInterface {
int MyProperty { get; set; }
}
}
");
// Loading the assembly
IAssemblyProxy assembly = assemblyLoader.Load();
// Locating the class
ITypeInfoProxy interfaceDefinition = assembly.LocateType("MyInterface");
Assert.IsNotNull(interfaceDefinition);
// Locating the property
IPropertyInfoProxy propertyDeclaration = interfaceDefinition.LocateProperty("MyProperty");
Assert.IsNotNull(propertyDeclaration);
// Generating the AST
var factory = new PropertyDeclarationSyntaxFactory(propertyDeclaration, false);
var syntaxNode = factory.Create();
Assert.IsNotNull(syntaxNode, "A node was expected to be built");
Assert.IsInstanceOfType(syntaxNode, typeof(PropertyDeclarationSyntax), "Expected a property declaration node to be built");
var propertyDeclarationSyntaxNode = syntaxNode as PropertyDeclarationSyntax;
Assert.IsNotNull(propertyDeclarationSyntaxNode.AccessorList);
var accessors = propertyDeclarationSyntaxNode.AccessorList.Accessors;
Assert.IsNotNull(accessors);
Assert.AreEqual(2, accessors.Count, "2 accessors expected");
var body1 = accessors.First().Body;
var body2 = accessors.Last().Body;
Assert.IsNull(body1, "Expected a null body");
Assert.IsNull(body2, "Expected a null body");
}
public void ReturnTypeCorrectlyAcquired()
{
// Assembling some code
IAssemblyLoader assemblyLoader = new Utils.AsmlDasmlAssemblyLoader(@"
namespace MyNamespace {
public class MyClass {
public int MyProperty {
get { return 0; }
set { }
}
}
}
");
// Loading the assembly
IAssemblyProxy assembly = assemblyLoader.Load();
// Locating the class
ITypeInfoProxy classDefinition = assembly.LocateType("MyClass");
Assert.IsNotNull(classDefinition);
// Locating the property
IPropertyInfoProxy propertyDeclaration = classDefinition.LocateProperty("MyProperty");
Assert.IsNotNull(propertyDeclaration);
// Generating the AST
var factory = new PropertyDeclarationSyntaxFactory(propertyDeclaration);
var syntaxNode = factory.Create() as PropertyDeclarationSyntax;
Assert.IsNotNull(syntaxNode, "A node was expected to be built");
Assert.IsInstanceOfType(syntaxNode, typeof(PropertyDeclarationSyntax), "Expected a property declaration node to be built");
var returnType = syntaxNode.Type;
Assert.IsNotNull(returnType);
var typeIdentifier = returnType as QualifiedNameSyntax;
Assert.IsNotNull(typeIdentifier, "Type expected to be qualified name");
Assert.AreEqual("System.Int32", typeIdentifier.ToString(), "Parameter name does not match");
}
public void NameCorrectlyAcquired()
{
// Assembling some code
IAssemblyLoader assemblyLoader = new Utils.AsmlDasmlAssemblyLoader(@"
namespace MyNamespace {
public class MyClass {
public int MyProperty {
get { return 0; }
set { }
}
}
}
");
// Loading the assembly
IAssemblyProxy assembly = assemblyLoader.Load();
// Locating the class
ITypeInfoProxy classDefinition = assembly.LocateType("MyClass");
Assert.IsNotNull(classDefinition);
// Locating the property
IPropertyInfoProxy propertyDeclaration = classDefinition.LocateProperty("MyProperty");
Assert.IsNotNull(propertyDeclaration);
// Generating the AST
var factory = new PropertyDeclarationSyntaxFactory(propertyDeclaration);
var syntaxNode = factory.Create();
Assert.IsNotNull(syntaxNode, "A node was expected to be built");
Assert.IsInstanceOfType(syntaxNode, typeof(PropertyDeclarationSyntax), "Expected a property declaration node to be built");
var propertyDeclarationSyntaxNode = syntaxNode as PropertyDeclarationSyntax;
var name = propertyDeclarationSyntaxNode.Identifier.Text;
Assert.AreEqual("MyProperty", name, "Property name not correctly acquired");
}
private static void TestReturnTypeCorrectlyAcquired(string source, string className, string propertyName, string expectedTypeFullName)
{
// Assembling some code
IAssemblyLoader assemblyLoader = new ScriptSharpReflectionUtils.AsmlDasmlAssemblyLoader(source,
ScriptNamespaceAttributeHelper.AttributeSourceCode);
// Loading the assembly
IAssemblyProxy assembly = assemblyLoader.Load();
ITypeLookup lookup = new LinearSearchTypeLookup(assembly);
// Locating the class
ITypeInfoProxy classDefinition = assembly.LocateType(className);
Assert.IsNotNull(classDefinition);
// Locating the property
IPropertyInfoProxy propertyDeclaration = classDefinition.LocateProperty(propertyName);
Assert.IsNotNull(propertyDeclaration);
// Generating the AST
var factory = new PropertyDeclarationSyntaxFactory(propertyDeclaration, lookup);
var syntaxNode = factory.Create() as PropertyDeclarationSyntax;
Assert.IsNotNull(syntaxNode, "A node was expected to be built");
Assert.IsInstanceOfType(syntaxNode, typeof(PropertyDeclarationSyntax), "Expected a property declaration node to be built");
var returnType = syntaxNode.Type;
Assert.IsNotNull(returnType);
var typeIdentifier = returnType as QualifiedNameSyntax;
Assert.IsNotNull(typeIdentifier, "Type expected to be qualified name");
Assert.AreEqual(expectedTypeFullName, typeIdentifier.ToString(), "Parameter name does not match");
}
protected virtual ISyntaxFactory CreatePropertyDeclarationSyntaxFactory(IPropertyInfoProxy propertyInfo) => new PropertyDeclarationSyntaxFactory(propertyInfo);
protected override ISyntaxFactory CreatePropertyDeclarationSyntaxFactory(IPropertyInfoProxy propertyInfo) => new PropertyDeclarationSyntaxFactory(propertyInfo, this.typeLookup);
public void DummyBody()
{
// Assembling some code
IAssemblyLoader assemblyLoader = new Utils.AsmlDasmlAssemblyLoader(@"
namespace MyNamespace {
public class MyClass {
int MyProperty {
get { return 0; }
set { }
}
}
}
");
// Loading the assembly
IAssemblyProxy assembly = assemblyLoader.Load();
// Locating the class
ITypeInfoProxy classDefinition = assembly.LocateType("MyClass");
Assert.IsNotNull(classDefinition);
// Locating the property
IPropertyInfoProxy propertyDeclaration = classDefinition.LocateProperty("MyProperty");
Assert.IsNotNull(propertyDeclaration);
// Generating the AST
var factory = new PropertyDeclarationSyntaxFactory(propertyDeclaration);
var syntaxNode = factory.Create();
Assert.IsNotNull(syntaxNode, "A node was expected to be built");
Assert.IsInstanceOfType(syntaxNode, typeof(PropertyDeclarationSyntax), "Expected a property declaration node to be built");
var propertyDeclarationSyntaxNode = syntaxNode as PropertyDeclarationSyntax;
Assert.IsNotNull(propertyDeclarationSyntaxNode.AccessorList);
var accessors = propertyDeclarationSyntaxNode.AccessorList.Accessors;
Assert.IsNotNull(accessors);
Assert.AreEqual(2, accessors.Count, "2 accessors expected");
var body1 = accessors.First().Body;
var body2 = accessors.Last().Body;
Assert.IsNotNull(body1, "Expected a body");
Assert.IsNotNull(body2, "Expected a body");
var statements1 = body1.Statements;
var statements2 = body2.Statements;
Assert.IsNotNull(statements1, "Expected a non empty body");
Assert.AreEqual(1, statements1.Count(), "Expected a body with 1 statement only");
Assert.IsNotNull(statements2, "Expected a non empty body");
Assert.AreEqual(1, statements2.Count(), "Expected a body with 1 statement only");
var statement1 = statements1.First();
var statement2 = statements2.First();
Assert.IsNotNull(statement1, "Expected one single statement");
Assert.IsInstanceOfType(statement1, typeof(ThrowStatementSyntax), "Expected a throw statement");
Assert.IsNotNull(statement2, "Expected one single statement");
Assert.IsInstanceOfType(statement2, typeof(ThrowStatementSyntax), "Expected a throw statement");
}