public override void TearDown() { if (!_classEmitter.HasBeenBuilt) { _classEmitter.BuildType(); } base.TearDown(); }
public void ForceUnsignedFalse() { var classEmitter = new CustomClassEmitter(Scope, "ForceUnsignedFalse", typeof(object), Type.EmptyTypes, TypeAttributes.Public, false); Type t = classEmitter.BuildType(); Assert.That(StrongNameUtil.IsAssemblySigned(t.Assembly), Is.True); }
public void CreateMethod_CopyParametersAndReturnTypeOutRef() { var classEmitter = new CustomClassEmitter(Scope, "CreateMethod_CopyParametersAndReturnTypeOutRef", typeof(object)); var method = classEmitter.CreateMethod( "MethodWithOutRef", MethodAttributes.Public, typeof(ClassWithAllKindsOfMembers).GetMethod("MethodWithOutRef")); method.AddStatement(new AssignStatement(new IndirectReference(method.ArgumentReferences[0]), NullExpression.Instance)); method.ImplementByReturningDefault(); object instance = Activator.CreateInstance(classEmitter.BuildType()); MethodInfo builtMethod = instance.GetType().GetMethod("MethodWithOutRef"); Assert.That(builtMethod.ReturnType, Is.EqualTo(typeof(void))); ParameterInfo[] parameters = builtMethod.GetParameters(); Assert.That(parameters.Length, Is.EqualTo(2)); Assert.That(parameters[0].ParameterType, Is.EqualTo(typeof(string).MakeByRefType())); Assert.That(parameters[0].ParameterType.IsByRef, Is.True); Assert.That(parameters[0].IsOut, Is.True); Assert.That(parameters[0].IsIn, Is.False); Assert.That(parameters[1].ParameterType, Is.EqualTo(typeof(int).MakeByRefType())); Assert.That(parameters[1].ParameterType.IsByRef, Is.True); Assert.That(parameters[1].IsOut, Is.False); Assert.That(parameters[1].IsIn, Is.False); var arguments = new object[] { "foo", 5 }; builtMethod.Invoke(instance, arguments); Assert.That(arguments[0], Is.EqualTo(null)); Assert.That(arguments[1], Is.EqualTo(5)); }
public void OverrideGenericMethod_WithConstraint_ModifiedByClosedGenericClass() { Type baseType = typeof(GenericClassWithGenericMethod <IConvertible, List <string>, int, object, IConvertible, List <List <IConvertible[]> > >); var classEmitter = new CustomClassEmitter( Scope, "OverrideGenericMethod_WithConstraint_ModifiedByClosedGenericClass", baseType, Type.EmptyTypes, TypeAttributes.Public | TypeAttributes.Class, false); MethodInfo baseMethod = baseType.GetMethod("GenericMethod"); var methodEmitter = classEmitter.CreateMethodOverride(baseMethod); methodEmitter.ImplementByBaseCall(baseMethod); Type builtType = classEmitter.BuildType(); var instance = (GenericClassWithGenericMethod <IConvertible, List <string>, int, object, IConvertible, List <List <IConvertible[]> > >) Activator.CreateInstance(builtType); string result = instance.GenericMethod(1, new List <int[]> (), new List <List <IConvertible[]> > ()); Assert.That(result, Is.EqualTo("1, System.Collections.Generic.List`1[System.Int32[]], System.Collections.Generic.List`1[System.Collections.Generic.List`1[" + "System.IConvertible[]]]")); }
public void OverridingSimpleMembersOfOpenGenericClass() { CustomClassEmitter classEmitter = new CustomClassEmitter(Scope, "OverridingSimpleMembersOfOpenGenericClass", typeof(GenericClassWithAllKindsOfMembers <>), Type.EmptyTypes, TypeAttributes.Public | TypeAttributes.Class, false); MethodInfo baseMethod = typeof(GenericClassWithAllKindsOfMembers <>).GetMethod("Method"); var overriddenMethod = classEmitter.CreateMethodOverride(baseMethod); overriddenMethod.ImplementByBaseCall(baseMethod); PropertyInfo baseProperty = typeof(GenericClassWithAllKindsOfMembers <>).GetProperty("Property"); CustomPropertyEmitter overriddenProperty = classEmitter.CreatePropertyOverride(baseProperty); overriddenProperty.GetMethod = classEmitter.CreateMethodOverride(baseProperty.GetGetMethod()); overriddenProperty.GetMethod.ImplementByBaseCall(baseProperty.GetGetMethod()); EventInfo baseEvent = typeof(GenericClassWithAllKindsOfMembers <>).GetEvent("Event"); CustomEventEmitter overriddenEvent = classEmitter.CreateEventOverride(baseEvent); overriddenEvent.AddMethod = classEmitter.CreateMethodOverride(baseEvent.GetAddMethod()); overriddenEvent.AddMethod.ImplementByBaseCall(baseEvent.GetAddMethod()); overriddenEvent.RemoveMethod = classEmitter.CreateMethodOverride(baseEvent.GetRemoveMethod()); overriddenEvent.RemoveMethod.ImplementByBaseCall(baseEvent.GetRemoveMethod()); Type builtType = classEmitter.BuildType(); GenericClassWithAllKindsOfMembers <int> instance = (GenericClassWithAllKindsOfMembers <int>)Activator.CreateInstance(builtType.MakeGenericType(typeof(int))); instance.Method(5); Assert.That(instance.Property, Is.EqualTo(0)); instance.Event += delegate { return(0); }; instance.Event -= delegate { return(0); }; }
public void CreateDefaultConstructor() { var classEmitter = new CustomClassEmitter(Scope, "CreateDefaultConstructor", typeof(object)); classEmitter.CreateDefaultConstructor(); Activator.CreateInstance(classEmitter.BuildType()); }
public void CreateFullNamedMethodOverride_ProtectedMethod() { var classEmitter = new CustomClassEmitter(Scope, "CreateFullNamedMethodOverride_ProtectedMethod", typeof(ClassWithProtectedVirtualMethod), new[] { typeof(IMarkerInterface) }, TypeAttributes.Public | TypeAttributes.Class, false); var toStringMethod = classEmitter.CreateFullNamedMethodOverride(typeof(ClassWithProtectedVirtualMethod).GetMethod( "GetSecret", BindingFlags.NonPublic | BindingFlags.Instance)); toStringMethod.AddStatement(new ReturnStatement(new ConstReference("P0wned!"))); Type builtType = classEmitter.BuildType(); MethodInfo method = builtType.GetMethod("GetSecret", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly); Assert.That(method, Is.Null); method = builtType.GetMethod(typeof(ClassWithProtectedVirtualMethod).FullName + ".GetSecret", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly); Assert.That(method, Is.Not.Null); Assert.That(method.IsFamily, Is.True); Assert.That(method.IsVirtual, Is.True); Assert.That(method.IsFinal, Is.True); var instance = (ClassWithProtectedVirtualMethod)Activator.CreateInstance(builtType); Assert.That(method.Invoke(instance, null), Is.EqualTo("P0wned!")); }
public Type BuildType() { Type builtType = _emitter.BuildType(); builtType.GetField(_invocationHandlerField.Reference.Name).SetValue(null, _invocationHandler); return(builtType); }
public void HasBeenBuilt() { var classEmitter = new CustomClassEmitter(Scope, "HasBeenBuilt", typeof(ClassEmitterTest)); Assert.That(classEmitter.HasBeenBuilt, Is.False); classEmitter.BuildType(); Assert.That(classEmitter.HasBeenBuilt, Is.True); }
public void CreateStaticField_WithAttributes() { var classEmitter = new CustomClassEmitter(Scope, "CreateStaticField_WithAttributes", typeof(object)); classEmitter.CreateStaticField("_test", typeof(string), FieldAttributes.Private); Type t = classEmitter.BuildType(); Assert.That(t.GetField("_test", BindingFlags.NonPublic | BindingFlags.Static).Attributes, Is.EqualTo(FieldAttributes.Static | FieldAttributes.Private)); }
public void CreateProperty() { var classEmitter = new CustomClassEmitter(Scope, "CreateProperty", typeof(object)); CustomPropertyEmitter property = classEmitter.CreateProperty("Check", PropertyKind.Instance, typeof(string), Type.EmptyTypes, PropertyAttributes.None); property.CreateGetMethod().AddStatement(new ReturnStatement(new ConstReference("4711"))); object instance = Activator.CreateInstance(classEmitter.BuildType()); Assert.That(instance.GetType().GetProperty("Check").GetValue(instance, null), Is.EqualTo("4711")); }
public void CreateStaticMethod() { var classEmitter = new CustomClassEmitter(Scope, "CreateStaticMethod", typeof(object)); var method = classEmitter.CreateMethod("Check", MethodAttributes.Public | MethodAttributes.Static, typeof(string), new Type[0]); method.AddStatement(new ReturnStatement(new ConstReference("stat"))); Type t = classEmitter.BuildType(); Assert.That(t.GetMethod("Check").Invoke(null, null), Is.EqualTo("stat")); }
public void CreateMethod() { var classEmitter = new CustomClassEmitter(Scope, "CreateMethod", typeof(object)); var method = classEmitter.CreateMethod("Check", MethodAttributes.Public, typeof(string), new Type[0]); method.AddStatement(new ReturnStatement(new ConstReference("ret"))); object instance = Activator.CreateInstance(classEmitter.BuildType()); Assert.That(instance.GetType().GetMethod("Check").Invoke(instance, null), Is.EqualTo("ret")); }
public void DeriveFromClosedGenericTypeWithConstraints() { Type baseType = typeof(GenericClassWithConstraints <ICloneable, List <string>, int, object, ICloneable, List <List <ICloneable[]> > >); CustomClassEmitter classEmitter = new CustomClassEmitter(Scope, "DeriveFromClosedGenericTypeWithConstraints", baseType, Type.EmptyTypes, TypeAttributes.Public | TypeAttributes.Class, false); Type builtType = classEmitter.BuildType(); Assert.That(builtType.ContainsGenericParameters, Is.False); Assert.That(builtType.BaseType.ContainsGenericParameters, Is.False); Assert.That(builtType.BaseType, Is.EqualTo(typeof(GenericClassWithConstraints <ICloneable, List <string>, int, object, ICloneable, List <List <ICloneable[]> > >))); }
public void PropertyNamePreservedOnOverride() { var classEmitter = new CustomClassEmitter(Scope, "PropertyNamePreservedOnOverride", typeof(ClassWithAllKindsOfMembers), Type.EmptyTypes, TypeAttributes.Public | TypeAttributes.Class, false); CustomPropertyEmitter property = classEmitter.CreatePropertyOverride(typeof(ClassWithAllKindsOfMembers).GetProperty("Property", _declaredInstanceBindingFlags)); Assert.That(property.PropertyBuilder.Name, Is.EqualTo("Property")); classEmitter.BuildType(); }
public void EmitSimpleClass() { var classEmitter = new CustomClassEmitter(Scope, "SimpleClass", typeof(ClassEmitterTest), new[] { typeof(IMarkerInterface) }, TypeAttributes.Public | TypeAttributes.Class, false); Type builtType = classEmitter.BuildType(); Assert.That(builtType.FullName, Is.EqualTo("SimpleClass")); Assert.That(builtType.BaseType, Is.EqualTo(typeof(ClassEmitterTest))); Assert.That(typeof(IMarkerInterface).IsAssignableFrom(builtType), Is.True); Assert.That(builtType.IsClass, Is.True); Assert.That(builtType.IsPublic, Is.True); }
public void GetPublicMethodWrapper() { var classEmitter = new CustomClassEmitter(Scope, "GetPublicMethodWrapper", typeof(ClassWithProtectedMethod)); classEmitter.GetPublicMethodWrapper(typeof(ClassWithProtectedMethod).GetMethod("GetSecret", _declaredInstanceBindingFlags)); object instance = Activator.CreateInstance(classEmitter.BuildType()); MethodInfo publicWrapper = instance.GetType().GetMethod("__wrap__GetSecret"); Assert.That(publicWrapper, Is.Not.Null); Assert.That(publicWrapper.Invoke(instance, null), Is.EqualTo("The secret is to be more provocative and interesting than anything else in [the] environment.")); }
public void CreateTypeConstructorCreateStaticField() { var classEmitter = new CustomClassEmitter(Scope, "CreateTypeConstructorCreateStaticField", typeof(object)); FieldReference field = classEmitter.CreateStaticField("s_test", typeof(string)); classEmitter.CreateTypeConstructor().CodeBuilder .AddStatement(new AssignStatement(field, (new ConstReference("Yay").ToExpression()))) .AddStatement(new ReturnStatement()); Type t = classEmitter.BuildType(); Assert.That(t.GetField("s_test").GetValue(null), Is.EqualTo("Yay")); }
public void SaveAssemblyUnsigned() { ModuleScope scope = new ModuleScope(true); CustomClassEmitter emitter = new CustomClassEmitter(scope, "UnsignedType", typeof(object), Type.EmptyTypes, TypeAttributes.Public, true); emitter.BuildType(); string[] paths = AssemblySaver.SaveAssemblies(scope); Assert.That(paths.Length, Is.EqualTo(1)); Assert.That(paths[0], Is.EqualTo(Path.Combine(Environment.CurrentDirectory, scope.WeakNamedModuleName))); File.Delete(paths[0]); File.Delete(paths[0].Replace(".dll", ".pdb")); }
public void CreateEvent() { var classEmitter = new CustomClassEmitter(Scope, "CreateEvent", typeof(object)); CustomEventEmitter eventEmitter = classEmitter.CreateEvent("Eve", EventKind.Instance, typeof(Func <string>)); eventEmitter.AddMethod.AddStatement(new ReturnStatement()); eventEmitter.RemoveMethod.AddStatement(new ReturnStatement()); object instance = Activator.CreateInstance(classEmitter.BuildType()); Assert.That(instance.GetType().GetEvent("Eve"), Is.Not.Null); }
public void GetPublicMethodWrapper_HasAttribute() { var classEmitter = new CustomClassEmitter(Scope, "GetPublicMethodWrapper_HasAttribute", typeof(ClassWithProtectedMethod)); classEmitter.GetPublicMethodWrapper(typeof(ClassWithProtectedMethod).GetMethod("GetSecret", _declaredInstanceBindingFlags)); object instance = Activator.CreateInstance(classEmitter.BuildType()); MethodInfo publicWrapper = instance.GetType().GetMethod("__wrap__GetSecret"); var attribute = AttributeUtility.GetCustomAttribute <GeneratedMethodWrapperAttribute> (publicWrapper, false); Assert.That(attribute, Is.Not.Null); }
public void DeriveFromOpenGenericTypeWithConstraints() { Type baseType = typeof(GenericClassWithConstraints <, , , , ,>); CustomClassEmitter classEmitter = new CustomClassEmitter(Scope, "DeriveFromOpenGenericTypeWithConstraints", baseType, Type.EmptyTypes, TypeAttributes.Public | TypeAttributes.Class, false); Type builtType = classEmitter.BuildType(); Assert.That(builtType.ContainsGenericParameters, Is.True); Type[] typeParameters = builtType.GetGenericArguments(); Assert.That(typeParameters.Length, Is.EqualTo(6)); Assert.That(builtType.BaseType.ContainsGenericParameters, Is.True); Assert.That(builtType.BaseType.GetGenericArguments()[0], Is.EqualTo(typeParameters[0])); }
public void CreatePublicInterfaceMethodImplementation() { var classEmitter = new CustomClassEmitter(Scope, "CreatePublicInterfaceMethodImplementation", typeof(object), new[] { typeof(ICloneable) }, TypeAttributes.Public | TypeAttributes.Class, false); var cloneMethod = classEmitter.CreatePublicInterfaceMethodImplementation(typeof(ICloneable).GetMethod("Clone")); cloneMethod.AddStatement(new ReturnStatement(new ConstReference("P0wned!"))); Type builtType = classEmitter.BuildType(); object instance = Activator.CreateInstance(builtType); Assert.That(((ICloneable)instance).Clone(), Is.EqualTo("P0wned!")); }
public void AddCustomAttribute() { var classEmitter = new CustomClassEmitter(Scope, "AddCustomAttribute", typeof(object), Type.EmptyTypes, TypeAttributes.Public, true); classEmitter.AddCustomAttribute(new CustomAttributeBuilder(typeof(SimpleAttribute).GetConstructor(Type.EmptyTypes), new object[0], typeof(SimpleAttribute).GetFields(), new object[] { "value" })); Type builtType = classEmitter.BuildType(); var attributes = (SimpleAttribute[])builtType.GetCustomAttributes(typeof(SimpleAttribute), false); Assert.That(attributes.Length, Is.EqualTo(1)); Assert.That(attributes[0].S, Is.EqualTo("value")); }
public void CreateConstructorCreateField() { var classEmitter = new CustomClassEmitter(Scope, "CreateConstructorCreateField", typeof(object)); FieldReference field = classEmitter.CreateField("_test", typeof(string)); ConstructorEmitter constructor = classEmitter.CreateConstructor(new[] { typeof(string), typeof(int) }); constructor.CodeBuilder.InvokeBaseConstructor(); constructor.CodeBuilder .AddStatement(new AssignStatement(field, new ArgumentReference(typeof(string), 1).ToExpression())) .AddStatement(new ReturnStatement()); object instance = Activator.CreateInstance(classEmitter.BuildType(), "bla", 0); Assert.That(instance.GetType().GetField("_test").GetValue(instance), Is.EqualTo("bla")); }
public void PropertyNameIsNotChangedOnPublicInterfaceImplementation() { var classEmitter = new CustomClassEmitter(Scope, "PropertyNameIsNotChangedOnPublicInterfaceImplementation", typeof(object), new[] { typeof(IInterfaceWithProperty) }, TypeAttributes.Public | TypeAttributes.Class, false); CustomPropertyEmitter property = classEmitter.CreatePublicInterfacePropertyImplementation( typeof(IInterfaceWithProperty).GetProperty("Property", _declaredInstanceBindingFlags)); Assert.That(property.PropertyBuilder.Name, Is.EqualTo("Property")); property.SetMethod = classEmitter.CreateInterfaceMethodImplementation( typeof(IInterfaceWithProperty).GetMethod("set_Property", _declaredInstanceBindingFlags)); property.SetMethod.AddStatement(new ReturnStatement()); classEmitter.BuildType(); }
public void CreateIndexedPropertyOverride() { var classEmitter = new CustomClassEmitter(Scope, "CreateIndexedPropertyOverride", typeof(ClassWithAllKindsOfMembers), Type.EmptyTypes, TypeAttributes.Public | TypeAttributes.Class, false); PropertyInfo baseProperty = typeof(ClassWithAllKindsOfMembers).GetProperty("Item", _declaredInstanceBindingFlags); CustomPropertyEmitter property = classEmitter.CreatePropertyOverride(baseProperty); property.CreateGetMethod().ImplementByBaseCall(baseProperty.GetGetMethod()); property.CreateSetMethod().ImplementByBaseCall(baseProperty.GetSetMethod()); Type builtType = classEmitter.BuildType(); var instance = (ClassWithAllKindsOfMembers)Activator.CreateInstance(builtType); Assert.That(instance[17], Is.EqualTo("17")); instance[18] = "foo"; }
public void OverrideConstrainedGenericMethod() { CustomClassEmitter classEmitter = new CustomClassEmitter(Scope, "OverrideConstrainedGenericMethod", typeof(ClassWithConstrainedGenericMethod), Type.EmptyTypes, TypeAttributes.Public | TypeAttributes.Class, false); MethodInfo baseMethod = typeof(ClassWithConstrainedGenericMethod).GetMethod("GenericMethod"); var methodEmitter = classEmitter.CreateMethodOverride(baseMethod); methodEmitter.ImplementByBaseCall(baseMethod); Type builtType = classEmitter.BuildType(); ClassWithConstrainedGenericMethod instance = (ClassWithConstrainedGenericMethod)Activator.CreateInstance(builtType); string result = instance.GenericMethod("1", 2, "2"); Assert.That(result, Is.EqualTo("1, 2, 2")); }
public void GetPublicMethodWrapper_Cached() { var classEmitter = new CustomClassEmitter(Scope, "GetPublicMethodWrapper_Cached", typeof(ClassWithProtectedMethod)); MethodInfo emitter1 = classEmitter.GetPublicMethodWrapper(typeof(ClassWithProtectedMethod).GetMethod("GetSecret", _declaredInstanceBindingFlags)); MethodInfo emitter2 = classEmitter.GetPublicMethodWrapper(typeof(ClassWithProtectedMethod).GetMethod("GetSecret", _declaredInstanceBindingFlags)); Assert.That(emitter2, Is.SameAs(emitter1)); MethodInfo emitter3 = classEmitter.GetPublicMethodWrapper(typeof(object).GetMethod("Finalize", _declaredInstanceBindingFlags)); Assert.That(emitter3, Is.Not.SameAs(emitter1)); classEmitter.BuildType(); }
public void MethodNameAndVisibilityArePreservedOnOverride() { var classEmitter = new CustomClassEmitter(Scope, "MethodNameAndVisibilityArePreservedOnOverride", typeof(ClassWithAllKindsOfMembers), new[] { typeof(IMarkerInterface) }, TypeAttributes.Public | TypeAttributes.Class, false); var toStringMethod = classEmitter.CreateMethodOverride(typeof(object).GetMethod("ToString", _declaredInstanceBindingFlags)); toStringMethod.AddStatement(new ReturnStatement(new ConstReference("P0wned!"))); var finalizeMethod = classEmitter.CreateMethodOverride(typeof(object).GetMethod("Finalize", _declaredInstanceBindingFlags)); finalizeMethod.AddStatement(new ReturnStatement()); var getterMethod = classEmitter.CreateMethodOverride(typeof(ClassWithAllKindsOfMembers).GetMethod("get_Property", _declaredInstanceBindingFlags)); getterMethod.AddStatement(new ReturnStatement()); Type builtType = classEmitter.BuildType(); MethodInfo overriddenToString = builtType.GetMethod("ToString", _declaredInstanceBindingFlags); Assert.That(overriddenToString.Name, Is.EqualTo("ToString")); Assert.That(overriddenToString.IsPublic, Is.True); Assert.That(overriddenToString.IsFinal, Is.False); Assert.That(overriddenToString.IsStatic, Is.False); Assert.That(overriddenToString.IsSpecialName, Is.False); Assert.That(overriddenToString.Attributes & MethodAttributes.ReuseSlot, Is.EqualTo(MethodAttributes.ReuseSlot)); MethodInfo overriddenFinalize = builtType.GetMethod("Finalize", _declaredInstanceBindingFlags); Assert.That(overriddenFinalize.Name, Is.EqualTo("Finalize")); Assert.That(overriddenFinalize.IsPublic, Is.False); Assert.That(overriddenFinalize.IsFamily, Is.True); Assert.That(overriddenFinalize.IsStatic, Is.False); Assert.That(overriddenFinalize.IsSpecialName, Is.False); Assert.That(overriddenToString.Attributes & MethodAttributes.ReuseSlot, Is.EqualTo(MethodAttributes.ReuseSlot)); MethodInfo overriddenGetter = builtType.GetMethod("get_Property", _declaredInstanceBindingFlags); Assert.That(overriddenGetter.Name, Is.EqualTo("get_Property")); Assert.That(overriddenGetter.IsPublic, Is.True); Assert.That(overriddenGetter.IsStatic, Is.False); Assert.That(overriddenGetter.IsSpecialName, Is.True); Assert.That(overriddenGetter.Attributes & MethodAttributes.ReuseSlot, Is.EqualTo(MethodAttributes.ReuseSlot)); }