public void GotoLabel()
{
var provider = new ReflectionProvider();
var assemblyBuilder = new EmitAssemblyBuilder("TestAssembly");
var typeBuilder = assemblyBuilder.DefineType("", "TestClass");
var method = typeBuilder.DefineMethod("Foo", typeof(string));
var variable = method.Il.DeclareLocal(typeof(int));
var label = method.Il.DefineLabel();
method.Il.Emit(Ldc_I4_0);
method.Il.Emit(Stloc, variable);
method.Il.MarkLabel(label);
method.Il.Emit(Ldloc, variable);
method.Il.Emit(Ldc_I4_1);
method.Il.Emit(Add);
method.Il.Emit(Dup);
method.Il.Emit(Stloc, variable);
method.Il.Emit(Ldc_I4_5);
method.Il.Emit(Blt, label);
method.Il.Emit(Ldloc, variable);
method.Il.Emit(Ret);
var type = provider.Compile(assemblyBuilder).GetType("TestClass");
var instance = Activator.CreateInstance(type);
var methodInfo = type.GetMethod("Foo");
var result = (int)methodInfo.Invoke(instance, null);
Assert.AreEqual(5, result);
}
public void GotoLabel()
{
var provider = new ReflectionProvider();
var assemblyBuilder = new EmitAssemblyBuilder("TestAssembly");
var typeBuilder = assemblyBuilder.DefineType("", "TestClass");
var method = typeBuilder.DefineMethod("Foo", typeof(string));
var variable = method.Il.DeclareLocal(typeof(int));
var label = method.Il.DefineLabel();
method.Il.Emit(Ldc_I4_0);
method.Il.Emit(Stloc, variable);
method.Il.MarkLabel(label);
method.Il.Emit(Ldloc, variable);
method.Il.Emit(Ldc_I4_1);
method.Il.Emit(Add);
method.Il.Emit(Dup);
method.Il.Emit(Stloc, variable);
method.Il.Emit(Ldc_I4_5);
method.Il.Emit(Blt, label);
method.Il.Emit(Ldloc, variable);
method.Il.Emit(Ret);
var type = provider.Compile(assemblyBuilder).GetType("TestClass");
var instance = Activator.CreateInstance(type);
var methodInfo = type.GetMethod("Foo");
var result = (int)methodInfo.Invoke(instance, null);
Assert.AreEqual(5, result);
}
public ActionResult Index()
{
ViewBag.Message = "Risultato di chiamate a dll: ";
ViewBag.Message += ReflectionProvider.getInstance().callMetodoByName("ClassLibrary1", "Class1", "prova");
ViewBag.Message += ReflectionProvider.getInstance().callMetodoByName("ClassLibrary2", "Class1", "prova");
return(View());
//return Redirect("default.htm");
}
public ActionResult About()
{
ViewBag.Message = "Risultato di chiamate a dll: ";
ViewBag.Message += ReflectionProvider.getInstance().callMetodoByName("ClassLibrary1", "Class1", "prova");
ViewBag.Message += ReflectionProvider.getInstance().callMetodoByName("ClassLibrary2", "Class2", "prova");
return(View());
}
public void OneAttributeReturned_When_OneAttributeExists()
{
// Act
var reflectionProvider = new ReflectionProvider();
var actualAttributes = reflectionProvider.GetCustomAttributes(GetType().GetMethods()[0]);
// Assert
Assert.That(actualAttributes.ToList().Count, Is.EqualTo(1));
}
public void ClassExtendsBaseType()
{
var provider = new ReflectionProvider();
var assemblyBuilder = new EmitAssemblyBuilder("TestAssembly");
var typeBuilder = assemblyBuilder.DefineType("", "TestClass", baseType: typeof(CustomBaseType));
var method = typeBuilder.DefineMethod("Foo", typeof(void), EmitVisibility.Public, isStatic: true);
method.Il.Emit(EmitOpCodes.Ret);
var type = provider.Compile(assemblyBuilder).GetType("TestClass");
Assert.IsTrue(typeof(CustomBaseType).IsAssignableFrom(type));
}
public void ClassExtendsBaseType()
{
var provider = new ReflectionProvider();
var assemblyBuilder = new EmitAssemblyBuilder("TestAssembly");
var typeBuilder = assemblyBuilder.DefineType("", "TestClass", baseType: typeof(CustomBaseType));
var method = typeBuilder.DefineMethod("Foo", typeof(void), EmitVisibility.Public, isStatic: true);
method.Il.Emit(EmitOpCodes.Ret);
var type = provider.Compile(assemblyBuilder).GetType("TestClass");
Assert.IsTrue(typeof(CustomBaseType).IsAssignableFrom(type));
}
public void CorrectMethodsReturned()
{
// Arrange
var expectedMethods = GetType().GetMethods();
// Act
var reflectionProvider = new ReflectionProvider();
var actualMethod = reflectionProvider.GetMethods(GetType());
// Assert
Assert.That(actualMethod.FirstOrDefault()?.Name, Is.EqualTo(expectedMethods.FirstOrDefault()?.Name));
}
public void CorrectAssemblyReturned()
{
// Arrange
var expectedAssembly = Assembly.GetExecutingAssembly();
// Act
var reflectionProvider = new ReflectionProvider();
var actualAssembly = reflectionProvider.GetAssemblyFromFile(expectedAssembly.Location);
// Assert
Assert.That(actualAssembly, Is.EqualTo(expectedAssembly));
}
public void CorrectAttributeReturned_When_OneAttributeExists()
{
// Arrange
var expectedAttributes = GetType().GetMethods()[0].GetCustomAttributes();
// Act
var reflectionProvider = new ReflectionProvider();
var actualAttributes = reflectionProvider.GetCustomAttributes(GetType().GetMethods()[0]);
// Assert
Assert.That(actualAttributes.First().GetType().Name, Is.EqualTo(expectedAttributes.First().GetType().Name));
}
public void CorrectTypesReturned()
{
// Arrange
var expectedAssemblyTypes = Assembly.GetExecutingAssembly().GetTypes();
// Act
var reflectionProvider = new ReflectionProvider();
var actualAssemblyTypes = reflectionProvider.GetTypes(Assembly.GetExecutingAssembly());
// Assert
Assert.That(actualAssemblyTypes, Is.EquivalentTo(expectedAssemblyTypes));
}
public void CorrectFullNameTypeReturned()
{
// Arrange
var expectedTypeFullName = GetType().FullName;
// Act
var reflectionProvider = new ReflectionProvider();
var actualTypeFullName = reflectionProvider.GetTypeFullName(GetType());
// Assert
Assert.That(actualTypeFullName, Is.EqualTo(expectedTypeFullName));
}
public void CorrectReflectedTypeFullNameReturned()
{
// Arrange
var expectedMethodName = GetType().GetMethods().FirstOrDefault()?.ReflectedType.FullName;
// Act
var reflectionProvider = new ReflectionProvider();
var actualMethodName = reflectionProvider.GetMethodReflectedTypeFullName(GetType().GetMethods().FirstOrDefault());
// Assert
Assert.That(actualMethodName, Is.EqualTo(expectedMethodName));
}
public void ProtectedMethodIsProtected()
{
var provider = new ReflectionProvider();
var assemblyBuilder = new EmitAssemblyBuilder("TestAssembly");
var typeBuilder = assemblyBuilder.DefineType("", "TestClass");
var method = typeBuilder.DefineMethod("Foo", typeof(void), EmitVisibility.Protected);
method.Il.Emit(EmitOpCodes.Ret);
var type = provider.Compile(assemblyBuilder).GetType("TestClass");
var methodInfo = type.GetMethod("Foo", BindingFlags.NonPublic | BindingFlags.Instance);
Assert.IsTrue((methodInfo.Attributes & MethodAttributes.Family) == MethodAttributes.Family);
}
public void StaticFieldIsStatic()
{
var provider = new ReflectionProvider();
var assemblyBuilder = new EmitAssemblyBuilder("TestAssembly");
var typeBuilder = assemblyBuilder.DefineType("", "TestClass");
typeBuilder.DefineField("foo", typeof(string), isStatic: true);
var type = provider.Compile(assemblyBuilder).GetType("TestClass");
var field = type.GetField("foo");
Assert.IsTrue(field.IsStatic);
}
public void InternalMethodIsInternal()
{
var provider = new ReflectionProvider();
var assemblyBuilder = new EmitAssemblyBuilder("TestAssembly");
var typeBuilder = assemblyBuilder.DefineType("", "TestClass");
var method = typeBuilder.DefineMethod("Foo", typeof(void), EmitVisibility.Internal);
method.Il.Emit(EmitOpCodes.Ret);
var type = provider.Compile(assemblyBuilder).GetType("TestClass");
var methodInfo = type.GetMethod("Foo", BindingFlags.NonPublic | BindingFlags.Instance);
Assert.IsTrue((methodInfo.Attributes & MethodAttributes.Assembly) == MethodAttributes.Assembly);
}
public void StaticMethodIsStatic()
{
var provider = new ReflectionProvider();
var assemblyBuilder = new EmitAssemblyBuilder("TestAssembly");
var typeBuilder = assemblyBuilder.DefineType("", "TestClass");
var method = typeBuilder.DefineMethod("Foo", typeof(void), EmitVisibility.Public, isStatic: true);
method.Il.Emit(EmitOpCodes.Ret);
var type = provider.Compile(assemblyBuilder).GetType("TestClass");
var methodInfo = type.GetMethod("Foo");
Assert.IsTrue(methodInfo.IsStatic);
}
public MetadataContext()
{
ReflectionProvider reflectionProvider = new ReflectionProvider();
_propertyProviders.DefaultValue = reflectionProvider;
_propertyProviders.Changed += TypeRegistryChanged;
_methodProviders.DefaultValue = reflectionProvider;
_methodProviders.Register(typeof(DataRow), NullProviders.MethodProvider);
_methodProviders.Register(typeof(DataTable), NullProviders.MethodProvider);
_methodProviders.Register(typeof(Hashtable), NullProviders.MethodProvider);
_methodProviders.Changed += TypeRegistryChanged;
_comparers.Changed += TypeRegistryChanged;
}
public void SetAndGetValueFromField()
{
var provider = new ReflectionProvider();
var assemblyBuilder = new EmitAssemblyBuilder("TestAssembly");
var typeBuilder = assemblyBuilder.DefineType("", "TestClass");
typeBuilder.DefineField("foo", typeof(string));
var type = provider.Compile(assemblyBuilder).GetType("TestClass");
var instance = Activator.CreateInstance(type);
var field = type.GetField("foo");
Assert.IsNull(field.GetValue(instance));
field.SetValue(instance, "bar");
Assert.AreEqual("bar", field.GetValue(instance));
}
public void MethodReturnsString()
{
var provider = new ReflectionProvider();
var assemblyBuilder = new EmitAssemblyBuilder("TestAssembly");
var typeBuilder = assemblyBuilder.DefineType("", "TestClass");
var method = typeBuilder.DefineMethod("Foo", typeof(string));
method.Il.Emit(EmitOpCodes.Ldstr, "bar");
method.Il.Emit(EmitOpCodes.Ret);
var type = provider.Compile(assemblyBuilder).GetType("TestClass");
var instance = Activator.CreateInstance(type);
var methodInfo = type.GetMethod("Foo");
var result = (string)methodInfo.Invoke(instance, null);
Assert.AreEqual("bar", result);
}
private MethodInfo CreateMethod(Action <EmitBlockStatement> ilGenerator, Type baseType = null, Action <EmitMethodBuilder> methodInstrumenter = null)
{
var provider = new ReflectionProvider();
var assemblyBuilder = new EmitAssemblyBuilder("MethodAssembly");
var typeBuilder = assemblyBuilder.DefineType("", "Method");
var method = typeBuilder.DefineMethod("Foo", typeof(object), isStatic: true);
methodInstrumenter?.Invoke(method);
var block = method.Body;
ilGenerator(block);
var assembly = provider.Compile(assemblyBuilder);
var type = assembly.GetType(typeBuilder.FullName);
var methodInfo = type.GetMethod("Foo");
return(methodInfo);
}
public void MethodReturnsString()
{
var provider = new ReflectionProvider();
var assemblyBuilder = new EmitAssemblyBuilder("TestAssembly");
var typeBuilder = assemblyBuilder.DefineType("", "TestClass");
var method = typeBuilder.DefineMethod("Foo", typeof(string));
method.Il.Emit(EmitOpCodes.Ldstr, "bar");
method.Il.Emit(EmitOpCodes.Ret);
var type = provider.Compile(assemblyBuilder).GetType("TestClass");
var instance = Activator.CreateInstance(type);
var methodInfo = type.GetMethod("Foo");
var result = (string)methodInfo.Invoke(instance, null);
Assert.AreEqual("bar", result);
}
public void DeclareVariable()
{
var provider = new ReflectionProvider();
var assemblyBuilder = new EmitAssemblyBuilder("TestAssembly");
var typeBuilder = assemblyBuilder.DefineType("", "TestClass");
var method = typeBuilder.DefineMethod("Foo", typeof(string));
var variable = method.Il.DeclareLocal(typeof(string));
method.Il.Emit(Ldstr, "bar");
method.Il.Emit(Stloc, variable);
method.Il.Emit(Ldloc, variable);
method.Il.Emit(Ret);
var type = provider.Compile(assemblyBuilder).GetType("TestClass");
var instance = Activator.CreateInstance(type);
var methodInfo = type.GetMethod("Foo");
var result = (string)methodInfo.Invoke(instance, null);
Assert.AreEqual("bar", result);
}
private static DataContext CreateDefault()
{
var functions = BuiltInFunctions.GetFunctions().ToImmutableList();
var aggregates = BuiltInAggregates.GetAggregates().ToImmutableList();
var reflectionProvider = new ReflectionProvider();
var propertyProviders = ImmutableDictionary.Create <Type, IPropertyProvider>()
.Add(typeof(object), reflectionProvider);
var methodProviders = ImmutableDictionary.Create <Type, IMethodProvider>()
.Add(typeof(object), reflectionProvider);
var comparers = ImmutableDictionary.Create <Type, IComparer>();
return(new DataContext(ImmutableList.Create <TableSymbol>(),
ImmutableList.Create <TableRelation>(),
functions,
aggregates,
ImmutableList.Create <VariableSymbol>(),
propertyProviders,
methodProviders,
comparers));
}
public void DeclareVariable()
{
var provider = new ReflectionProvider();
var assemblyBuilder = new EmitAssemblyBuilder("TestAssembly");
var typeBuilder = assemblyBuilder.DefineType("", "TestClass");
var method = typeBuilder.DefineMethod("Foo", typeof(string));
var variable = method.Il.DeclareLocal(typeof(string));
method.Il.Emit(Ldstr, "bar");
method.Il.Emit(Stloc, variable);
method.Il.Emit(Ldloc, variable);
method.Il.Emit(Ret);
var type = provider.Compile(assemblyBuilder).GetType("TestClass");
var instance = Activator.CreateInstance(type);
var methodInfo = type.GetMethod("Foo");
var result = (string)methodInfo.Invoke(instance, null);
Assert.AreEqual("bar", result);
}
public void SetAndGetValueFromField()
{
var provider = new ReflectionProvider();
var assemblyBuilder = new EmitAssemblyBuilder("TestAssembly");
var typeBuilder = assemblyBuilder.DefineType("", "TestClass");
typeBuilder.DefineField("foo", typeof(string));
var type = provider.Compile(assemblyBuilder).GetType("TestClass");
var instance = Activator.CreateInstance(type);
var field = type.GetField("foo");
Assert.IsNull(field.GetValue(instance));
field.SetValue(instance, "bar");
Assert.AreEqual("bar", field.GetValue(instance));
}
public void GivenATypeWithoutTheDesiredAttributeWhenHasAttributeIsCalled()
{
var reflectionProvider = new ReflectionProvider();
_returnedObject = reflectionProvider.Construct(typeof (Tests));
}
public void StaticFieldIsStatic()
{
var provider = new ReflectionProvider();
var assemblyBuilder = new EmitAssemblyBuilder("TestAssembly");
var typeBuilder = assemblyBuilder.DefineType("", "TestClass");
typeBuilder.DefineField("foo", typeof(string), isStatic: true);
var type = provider.Compile(assemblyBuilder).GetType("TestClass");
var field = type.GetField("foo");
Assert.IsTrue(field.IsStatic);
}
public void StaticMethodIsStatic()
{
var provider = new ReflectionProvider();
var assemblyBuilder = new EmitAssemblyBuilder("TestAssembly");
var typeBuilder = assemblyBuilder.DefineType("", "TestClass");
var method = typeBuilder.DefineMethod("Foo", typeof(void), EmitVisibility.Public, isStatic: true);
method.Il.Emit(EmitOpCodes.Ret);
var type = provider.Compile(assemblyBuilder).GetType("TestClass");
var methodInfo = type.GetMethod("Foo");
Assert.IsTrue(methodInfo.IsStatic);
}
private MethodInfo CreateMethod(Action<EmitBlockStatement> ilGenerator, Type baseType = null, Action<EmitMethodBuilder> methodInstrumenter = null)
{
var provider = new ReflectionProvider();
var assemblyBuilder = new EmitAssemblyBuilder("MethodAssembly");
var typeBuilder = assemblyBuilder.DefineType("", "Method");
var method = typeBuilder.DefineMethod("Foo", typeof(object), isStatic: true);
methodInstrumenter?.Invoke(method);
var block = method.Body;
ilGenerator(block);
var assembly = provider.Compile(assemblyBuilder);
var type = assembly.GetType(typeBuilder.FullName);
var methodInfo = type.GetMethod("Foo");
return methodInfo;
}
public void GivenATypeWithoutTheDesiredAttributeWhenHasAttributeIsCalled()
{
var reflectionProvider = new ReflectionProvider();
_returnedValue = reflectionProvider.HasAttribute(typeof(StandardTests), typeof(BDDTestFixtureAttribute), false);
}
