public void SetCustomAttribute() { var attributeCtor = NormalizingMemberInfoFromExpressionUtility.GetConstructor(() => new AbcAttribute(null)); var property = NormalizingMemberInfoFromExpressionUtility.GetProperty((AbcAttribute obj) => obj.StringProperty); var field = NormalizingMemberInfoFromExpressionUtility.GetField((AbcAttribute obj) => obj.IntField); var wasCalled = false; Action <CustomAttributeBuilder> setCustomAttributeMethod = customAttributeBuilder => { wasCalled = true; Assert.That(customAttributeBuilder, Is.Not.Null); CheckCustomAttributeBuilder( customAttributeBuilder, attributeCtor, new object[] { typeof(int) }, new[] { property }, new object[] { "def" }, new[] { field }, new object[] { 8 }); }; var adapterBasePartialMock = MockRepository.GeneratePartialMock <BuilderAdapterBase> (setCustomAttributeMethod); var declaration = new CustomAttributeDeclaration( attributeCtor, new object[] { typeof(int) }, new NamedArgumentDeclaration(property, "def"), new NamedArgumentDeclaration(field, 8)); adapterBasePartialMock.SetCustomAttribute(declaration); Assert.That(wasCalled, Is.True); }
public void IndexParameters() { var type = AssembleType <DomainType> ( proxyType => { var field = NormalizingMemberInfoFromExpressionUtility.GetField((DomainType o) => o.PublicField); proxyType.AddProperty( "Property", typeof(string), new[] { new ParameterDeclaration(typeof(string), "index0"), new ParameterDeclaration(typeof(string), "index1") }, MethodAttributes.Public, getBodyProvider: ctx => { Assert.That(ctx.ReturnType, Is.SameAs(typeof(string))); Assert.That(ctx.Parameters.Count, Is.EqualTo(2)); return(ExpressionHelper.StringConcat(ctx.Parameters[0], ctx.Parameters[1])); }, setBodyProvider: ctx => { Assert.That(ctx.ReturnType, Is.SameAs(typeof(void))); Assert.That(ctx.Parameters.Count, Is.EqualTo(3)); var value = ExpressionHelper.StringConcat(ExpressionHelper.StringConcat(ctx.Parameters[0], ctx.Parameters[1]), ctx.Parameters[2]); return(Expression.Assign(Expression.Field(ctx.This, field), value)); }); }); var property = type.GetProperty("Property"); var instance = (DomainType)Activator.CreateInstance(type); Assert.That(property.GetValue(instance, new object[] { "a ", "b" }), Is.EqualTo("a b")); property.SetValue(instance, "value", new object[] { "a ", "b " }); Assert.That(instance.PublicField, Is.EqualTo("a b value")); }
public override void SetUp() { base.SetUp(); _signedType = typeof(int); _unsignedType = CreateUnsignedType(TypeAttributes.Class, typeof(object)); _signedInterfaceType = typeof(IMarkerInterface); _unsignedInterfaceType = CreateUnsignedType(TypeAttributes.Interface | TypeAttributes.Abstract, baseType: null); _signedDelegateType = typeof(Action); _unsignedDelegateType = typeof(Action <>).MakeGenericType(_unsignedType); var attributeCtor = NormalizingMemberInfoFromExpressionUtility.GetConstructor(() => new AbcAttribute(null)); _signedAttribute = new CustomAttributeDeclaration(attributeCtor, new object[] { _signedType }); _unsignedAttribute = new CustomAttributeDeclaration(attributeCtor, new object[] { _unsignedType }); _signedField = NormalizingMemberInfoFromExpressionUtility.GetField(() => DomainType.Field); _unsignedField = _unsignedType.GetField("field"); _signedCtor = NormalizingMemberInfoFromExpressionUtility.GetConstructor(() => new DomainType()); _unsignedCtor = _unsignedType.GetConstructors().Single(); _signedMethod = NormalizingMemberInfoFromExpressionUtility.GetMethod(() => DomainType.Method()); _unsignedMethod = _unsignedType.GetMethod("method"); _signedVarArgsMethod = typeof(DomainType).GetMethod("VarArgsMethod"); _unsignedVarArgsMethod = _unsignedType.GetMethod("varargs"); }
public void AccessMembers() { var overriddenMethod = NormalizingMemberInfoFromExpressionUtility.GetGenericMethodDefinition((DomainType o) => o.GenericMethod <Constraint> (null, "")); var field = NormalizingMemberInfoFromExpressionUtility.GetField((Constraint o) => o.Field); var method = NormalizingMemberInfoFromExpressionUtility.GetMethod((Constraint o) => o.Method("")); var property = NormalizingMemberInfoFromExpressionUtility.GetProperty((Constraint o) => o.Property); var type = AssembleType <DomainType> (p => p.GetOrAddOverride(overriddenMethod).SetBody(ctx => { var parameter = ctx.Parameters[0]; var variable = Expression.Variable(typeof(string)); // TODO 5480: Remove conversion and inline. var castedParameter = Expression.Convert(parameter, typeof(Constraint)); return(Expression.Block( new[] { variable }, Expression.Assign(variable, Expression.Call(castedParameter, method, ctx.Parameters[1])), Expression.Assign(Expression.Field(castedParameter, field), variable), Expression.Assign(Expression.Property(castedParameter, property), Expression.Field(castedParameter, field)), Expression.Property(castedParameter, property))); })); var instance = (DomainType)Activator.CreateInstance(type); var arg = new Constraint(); var result = instance.GenericMethod(arg, "abc"); Assert.That(arg.Field, Is.EqualTo("method: abc")); Assert.That(arg.Property, Is.EqualTo("method: abc")); Assert.That(result, Is.EqualTo("method: abc")); }
public void Static() { var type = AssembleType <DomainType> ( proxyType => { var staticField = NormalizingMemberInfoFromExpressionUtility.GetField(() => DomainType.StaticDelegateField); var accessorAttributes = MethodAttributes.Private | MethodAttributes.Static; var method = proxyType.AddMethod( "StaticMethod", accessorAttributes, typeof(void), new[] { new ParameterDeclaration(typeof(Action), "handler") }, ctx => Expression.Assign(Expression.Field(null, staticField), ctx.Parameters.Single())); proxyType.AddEvent("StaticEvent", EventAttributes.SpecialName, addMethod: method, removeMethod: method); }); var event_ = type.GetEvent("StaticEvent", BindingFlags.NonPublic | BindingFlags.Static); Assertion.IsNotNull(event_); Assert.That(event_.Attributes, Is.EqualTo(EventAttributes.SpecialName)); Assert.That(DomainType.StaticDelegateField, Is.Null); var handler = new Action(() => { }); // event_.AddEventHandler(null, handler) // Does not work because add method is private. event_.GetAddMethod(true).Invoke(null, new object[] { handler }); Assert.That(DomainType.StaticDelegateField, Is.SameAs(handler)); }
public void WriteOnly_Public_Instance() { var type = AssembleType <DomainType> ( proxyType => { var field = NormalizingMemberInfoFromExpressionUtility.GetField((DomainType o) => o.PublicField); var setMethod = proxyType.AddMethod( "InstanceSetMethod", MethodAttributes.Public, typeof(void), new[] { new ParameterDeclaration(typeof(string), "value") }, ctx => Expression.Assign(Expression.Field(ctx.This, field), ctx.Parameters[0])); proxyType.AddProperty("InstanceProperty", PropertyAttributes.None, getMethod: null, setMethod: setMethod); }); var nonExistingStaticProperty = type.GetProperty("InstanceProperty", BindingFlags.Public | BindingFlags.Static); Assert.That(nonExistingStaticProperty, Is.Null); var property = type.GetProperty("InstanceProperty", BindingFlags.Public | BindingFlags.Instance); CheckSignature(property, CallingConventions.HasThis | CallingConventions.Standard); var instance = (DomainType)Activator.CreateInstance(type); property.SetValue(instance, "test", null); Assert.That(instance.PublicField, Is.EqualTo("test")); }
public void CreateAspectInitExpression_NamedArrayArgument() { var namedArgumentMock = MockRepository.GenerateStrictMock <ICustomAttributeNamedArgument> (); var arrayField = NormalizingMemberInfoFromExpressionUtility.GetField((DomainAspect obj) => obj.FieldArrayArg); namedArgumentMock.Expect(x => x.MemberInfo).Return(arrayField); namedArgumentMock.Expect(x => x.MemberType).Return(arrayField.FieldType); namedArgumentMock.Expect(x => x.Value).Return(new object[] { "str", 7 }); SetupConstructionMock(namedArguments: new[] { namedArgumentMock }); var result = _initializationExpressionHelper.CreateAspectInitExpression(_constructionMock); var assignment = (MemberAssignment)result.Bindings[0]; Assert.That(assignment.Expression, Is.InstanceOf <NewArrayExpression> ().With.Property("Type").EqualTo(typeof(object[]))); var newArrayExpression = (NewArrayExpression)assignment.Expression; Assert.That(newArrayExpression.Expressions, Has.Count.EqualTo(2)); Assert.That(newArrayExpression.Expressions[0], Is.InstanceOf <ConstantExpression> ().With.Property("Type").EqualTo(typeof(object))); var expression1 = (ConstantExpression)newArrayExpression.Expressions[0]; Assert.That(expression1, Has.Property("Value").EqualTo("str")); Assert.That(expression1, Is.InstanceOf <ConstantExpression> ().With.Property("Type").EqualTo(typeof(object))); var expression2 = (ConstantExpression)newArrayExpression.Expressions[1]; Assert.That(expression2, Has.Property("Value").EqualTo(7)); Assert.That(expression2, Is.InstanceOf <ConstantExpression> ().With.Property("Type").EqualTo(typeof(object))); }
public void CreateAspectInitExpression_NamedElementArgument() { var namedFieldArgumentMock = MockRepository.GenerateStrictMock <ICustomAttributeNamedArgument> (); var namedPropertyArgumentMock = MockRepository.GenerateStrictMock <ICustomAttributeNamedArgument> (); var field = NormalizingMemberInfoFromExpressionUtility.GetField((DomainAspect obj) => obj.FieldElementArg); var property = NormalizingMemberInfoFromExpressionUtility.GetProperty((DomainAspect obj) => obj.PropertyElementArg); namedFieldArgumentMock.Expect(x => x.MemberInfo).Return(field); namedFieldArgumentMock.Expect(x => x.MemberType).Return(field.FieldType); namedFieldArgumentMock.Expect(x => x.Value).Return("field"); namedPropertyArgumentMock.Expect(x => x.MemberInfo).Return(property); namedPropertyArgumentMock.Expect(x => x.MemberType).Return(property.PropertyType); namedPropertyArgumentMock.Expect(x => x.Value).Return("prop"); SetupConstructionMock(namedArguments: new[] { namedFieldArgumentMock, namedPropertyArgumentMock }); var result = _initializationExpressionHelper.CreateAspectInitExpression(_constructionMock); Assert.That(result.Bindings, Has.Count.EqualTo(2)); var assignment1 = (MemberAssignment)result.Bindings[0]; Assert.That(assignment1.Member, Is.EqualTo(field)); Assert.That(assignment1.Expression, Is.TypeOf <ConstantExpression> ().With.Property("Value").EqualTo("field")); var assignment2 = (MemberAssignment)result.Bindings[1]; Assert.That(assignment2.Member, Is.EqualTo(property)); Assert.That(assignment2.Expression, Is.TypeOf <ConstantExpression> ().With.Property("Value").EqualTo("prop")); }
private CustomAttributeDeclaration CreateMultipleAttribute(string value) { var constructor = NormalizingMemberInfoFromExpressionUtility.GetConstructor(() => new MultipleAttribute()); var field = NormalizingMemberInfoFromExpressionUtility.GetField((MultipleAttribute obj) => obj.String); return(new CustomAttributeDeclaration(constructor, new object[0], new NamedArgumentDeclaration(field, value))); }
public void Initialization() { var constructor = NormalizingMemberInfoFromExpressionUtility.GetConstructor(() => new DomainAttribute((ValueType)null)); var property = NormalizingMemberInfoFromExpressionUtility.GetProperty((DomainAttribute obj) => obj.Property); var field = NormalizingMemberInfoFromExpressionUtility.GetField((DomainAttribute obj) => obj.Field); var declaration = new CustomAttributeDeclaration( constructor, new object[] { 7 }, new NamedArgumentDeclaration(property, 7), new NamedArgumentDeclaration(field, "value")); Assert.That(declaration.Type, Is.SameAs(typeof(DomainAttribute))); Assert.That(declaration.Constructor, Is.SameAs(constructor)); Assert.That(declaration.ConstructorArguments, Is.EqualTo(new[] { 7 })); var actualNamedArguments = declaration.NamedArguments.Select(na => new { na.MemberInfo, na.Value }); var expectedNamedArguments = new[] { new { MemberInfo = (MemberInfo)property, Value = (object)7 }, new { MemberInfo = (MemberInfo)field, Value = (object)"value" } }; Assert.That(actualNamedArguments, Is.EqualTo(expectedNamedArguments)); }
public void Create() { var field = NormalizingMemberInfoFromExpressionUtility.GetField(() => Type.EmptyTypes); var signature = FieldSignature.Create(field); Assert.That(signature.FieldType, Is.SameAs(typeof(Type[]))); }
private IPipeline CreatePipeline() { var field = NormalizingMemberInfoFromExpressionUtility.GetField((DomainType obj) => obj.String); var participant = CreateParticipant( proxyType => { Assert.That(proxyType.Initialization.Expressions, Is.Empty); proxyType.AddInitialization( ctx => { Assert.That(ctx.IsStatic, Is.False); var fieldExpr = Expression.Field(ctx.This, field); return(Expression.Assign( fieldExpr, ExpressionHelper.StringConcat( fieldExpr, Expression.Condition( Expression.Equal(ctx.InitializationSemantics, Expression.Constant(InitializationSemantics.Construction)), Expression.Constant("construction"), Expression.Constant(" deserialization"))))); }); Assert.That(proxyType.Initialization.Expressions, Is.Not.Empty); }); return(CreatePipeline(new[] { participant })); }
public void ExistingField() { var field = NormalizingMemberInfoFromExpressionUtility.GetField(() => DomainType.StaticField); Assert.That(DomainType.StaticField, Is.Null); var type = AssembleType <DomainType> ( proxyType => { Assert.That(proxyType.TypeInitializer, Is.Null); Assert.That(proxyType.MutableTypeInitializer, Is.Null); var initializationExpression = Expression.Assign(Expression.Field(null, field), Expression.Constant("abc")); var typeInitializer = proxyType.AddTypeInitializer( ctx => { Assert.That(ctx.IsStatic, Is.True); return(initializationExpression); }); Assert.That(proxyType.TypeInitializer, Is.SameAs(typeInitializer)); Assert.That(proxyType.MutableTypeInitializer, Is.SameAs(typeInitializer)); Assert.That(proxyType.AddedConstructors, Has.No.Member(typeInitializer)); }); RuntimeHelpers.RunClassConstructor(type.TypeHandle); Assert.That(DomainType.StaticField, Is.EqualTo("abc")); }
public void GetFieldSignature() { var field = NormalizingMemberInfoFromExpressionUtility.GetField((DomainType obj) => obj.Field); var result = SignatureDebugStringGenerator.GetFieldSignature(field); Assert.That(result, Is.EqualTo("IEnumerable`1[DomainType] Field")); }
public void GetMemberSignature_Field() { var method = NormalizingMemberInfoFromExpressionUtility.GetField((DomainType obj) => obj.Field); var result = MemberSignatureProvider.GetMemberSignature(method); Assert.That(result, Is.TypeOf <FieldSignature> ()); }
public void GetField_Instance() { var member = NormalizingMemberInfoFromExpressionUtility.GetField((DomainType obj) => obj.InstanceField); var expected = typeof(DomainType).GetField("InstanceField"); Assert.That(member, Is.EqualTo(expected)); }
public void GetField_Static() { var member = NormalizingMemberInfoFromExpressionUtility.GetField(() => DomainType.StaticField); var expected = typeof(DomainType).GetField("StaticField"); Assert.That(member, Is.EqualTo(expected)); }
public void Initialization_Field_MustNotBeStatic() { var staticField = NormalizingMemberInfoFromExpressionUtility.GetField(() => StaticField); Assert.That( () => new NamedArgumentDeclaration(staticField, ""), Throws.ArgumentException .With.ArgumentExceptionMessageEqualTo("Field 'StaticField' is not an instance field.", "fieldInfo")); }
public void FieldConstant() { var template = NormalizingMemberInfoFromExpressionUtility.GetMethod((DomainType o) => o.FieldConstant()); var field = NormalizingMemberInfoFromExpressionUtility.GetField(() => Type.EmptyTypes); var instance = ReturnMemberInfoViaConstantExpression(template, field); Assert.That(instance.FieldConstant(), Is.EqualTo(field)); }
public void Initialization_Fied_MustBePublic() { var privateField = NormalizingMemberInfoFromExpressionUtility.GetField(() => _privateFied); Assert.That( () => new NamedArgumentDeclaration(privateField, ""), Throws.ArgumentException .With.ArgumentExceptionMessageEqualTo("Field '_privateFied' is not public.", "fieldInfo")); }
public void GetAllFields() { var result = _constrainedParameter.GetAllFields(); var field = NormalizingMemberInfoFromExpressionUtility.GetField((DomainType obj) => obj.Field); Assert.That(result, Has.Member(field)); Assert.That(result, Is.EquivalentTo(typeof(DomainType).GetFields(c_allMembers))); }
public void GetSerializableFieldMapping_Filtering() { var field1 = NormalizingMemberInfoFromExpressionUtility.GetField(() => StaticField); var field2 = NormalizingMemberInfoFromExpressionUtility.GetField(() => InstanceField); var field3 = NormalizingMemberInfoFromExpressionUtility.GetField(() => NonSerializedField); var result = _finder.GetSerializableFieldMapping(new[] { field1, field2, field3 }); Assert.That(result, Is.EqualTo(new[] { Tuple.Create("<tp>InstanceField", field2) })); }
public void SetUp() { _mutableType = MutableTypeObjectMother.Create(typeof(DomainType)); _publicField = NormalizingMemberInfoFromExpressionUtility.GetField((DomainType obj) => obj.PublicField); _publicMethod = NormalizingMemberInfoFromExpressionUtility.GetMethod((DomainType obj) => obj.PublicMethod(0)); _publicMethodWithOverloadEmpty = NormalizingMemberInfoFromExpressionUtility.GetMethod((DomainType obj) => obj.PublicMethodWithOverload()); _publicMethodWithOverloadInt = NormalizingMemberInfoFromExpressionUtility.GetMethod((DomainType obj) => obj.PublicMethodWithOverload(1)); _publicProperty = NormalizingMemberInfoFromExpressionUtility.GetProperty((DomainType obj) => obj.PublicProperty); _publicPropertyWithIndexParameter = typeof(DomainType).GetProperty("Item"); }
public void Initialization_Complex() { var namedArgument = CustomAttributeNamedArgument(MethodBase.GetCurrentMethod()); var result = new CustomAttributeNamedArgumentAdapter(namedArgument); var member = NormalizingMemberInfoFromExpressionUtility.GetField((DomainAttribute obj) => obj.Field); Assert.That(result.MemberInfo, Is.EqualTo(member)); Assert.That(result.MemberType, Is.EqualTo(typeof(object))); Assert.That(result.Value, Is.EqualTo(new object[] { "s", 7, null, typeof(double), MyEnum.B, new[] { 4, 5 } })); }
public void MultipleParticipants() { var field = NormalizingMemberInfoFromExpressionUtility.GetField(() => DomainType.StaticField); var fieldExpr = Expression.Field(null, field); var type = AssembleType <DomainType> ( p => p.AddTypeInitializer(ctx => Expression.Assign(fieldExpr, ExpressionHelper.StringConcat(fieldExpr, Expression.Constant("abc")))), p => p.MutableTypeInitializer.SetBody( ctx => Expression.Block( ctx.PreviousBody, Expression.Assign(fieldExpr, ExpressionHelper.StringConcat(fieldExpr, Expression.Constant("def")))))); RuntimeHelpers.RunClassConstructor(type.TypeHandle); Assert.That(DomainType.StaticField, Is.EqualTo("abcdef")); }
public virtual void GetCustomAttributes_AttributeInstantiation() { var field = NormalizingMemberInfoFromExpressionUtility.GetField((DomainAttribute obj) => obj.Field); var property = NormalizingMemberInfoFromExpressionUtility.GetProperty((DomainAttribute obj) => obj.Property); var attr = CreateAttribute <DomainAttribute> ( new object[] { new object[] { "ctorArg", 7, null, typeof(double), MyEnum.B, new[] { 1, 2 } } }, new NamedArgumentDeclaration(field, "named arg"), new NamedArgumentDeclaration(property, new object[] { "named arg", 8, typeof(int), MyEnum.C, new[] { 3, 4 } })); var mutableInfo = CreateMutableInfo(attr); var attributes = mutableInfo.GetCustomAttributes(typeof(DomainAttribute), false); var attribute = (DomainAttribute)attributes.Single(); Assert.That(attribute.CtorArg, Is.EqualTo(new object[] { "ctorArg", 7, null, typeof(double), MyEnum.B, new[] { 1, 2 } })); Assert.That(attribute.Field, Is.EqualTo("named arg")); Assert.That(attribute.Property, Is.EqualTo(new object[] { "named arg", 8, typeof(int), MyEnum.C, new[] { 3, 4 } })); }
public void PropertiesCreateNewInstances() { var constructor = NormalizingMemberInfoFromExpressionUtility.GetConstructor(() => new DomainAttribute((object)null)); var field = NormalizingMemberInfoFromExpressionUtility.GetField((DomainAttribute obj) => obj.ObjectField); var declaration = new CustomAttributeDeclaration( constructor, new object[] { new object[] { 1, new[] { 2, 3 } } }, new NamedArgumentDeclaration(field, new object[] { new[] { 4 }, 5, 6 })); Assert.That(declaration.ConstructorArguments, Is.Not.SameAs(declaration.ConstructorArguments)); Assert.That(declaration.ConstructorArguments.Single(), Is.Not.SameAs(declaration.ConstructorArguments.Single())); Assert.That(((object[])declaration.ConstructorArguments.Single())[1], Is.Not.SameAs(((object[])declaration.ConstructorArguments.Single())[1])); Assert.That(declaration.NamedArguments, Is.Not.SameAs(declaration.NamedArguments)); Assert.That(declaration.NamedArguments.Single().Value, Is.Not.SameAs(declaration.NamedArguments.Single())); Assert.That(((object[])declaration.NamedArguments.Single().Value)[0], Is.Not.SameAs(((object[])declaration.NamedArguments.Single().Value)[0])); }
public void AddRemove() { var type = AssembleType <DomainType> ( proxyType => { var addField = NormalizingMemberInfoFromExpressionUtility.GetField((DomainType obj) => obj.AddCalled); var removeField = NormalizingMemberInfoFromExpressionUtility.GetField((DomainType obj) => obj.RemoveCalled); proxyType.AddEvent( "Event", typeof(Func <int, string, long>), MethodAttributes.Public, addBodyProvider: ctx => { Assert.That(ctx.Parameters.Single().Type, Is.SameAs(typeof(Func <int, string, long>))); return(Expression.Assign(Expression.Field(ctx.This, addField), Expression.Constant(true))); }, removeBodyProvider: ctx => { Assert.That(ctx.Parameters.Single().Type, Is.SameAs(typeof(Func <int, string, long>))); return(Expression.Assign(Expression.Field(ctx.This, removeField), Expression.Constant(true))); }, raiseBodyProvider: ctx => { Assert.That(ctx.Parameters.Select(p => p.Type), Is.EqualTo(new[] { typeof(int), typeof(string) })); Assert.That(ctx.ReturnType, Is.SameAs(typeof(long))); return(Expression.Constant(7L)); }); }); var event_ = type.GetEvent("Event"); var instance = (DomainType)Activator.CreateInstance(type); event_.AddEventHandler(instance, null); Assert.That(instance.AddCalled, Is.True); event_.RemoveEventHandler(instance, null); Assert.That(instance.RemoveCalled, Is.True); var result = instance.Invoke <long> (event_.GetRaiseMethod(), 0, ""); Assert.That(result, Is.EqualTo(7L)); }
public void SetCustomAttribute() { var attributeCtor = NormalizingMemberInfoFromExpressionUtility.GetConstructor(() => new AbcAttribute(null)); var field = NormalizingMemberInfoFromExpressionUtility.GetField((AbcAttribute obj) => obj.TypeField); var type = ReflectionObjectMother.GetSomeType(); var ctorArg = new object[] { 7, new object[] { "7", type } }; var declaration = new CustomAttributeDeclaration(attributeCtor, new object[] { ctorArg }, new NamedArgumentDeclaration(field, type)); var emittableType = ReflectionObjectMother.GetSomeOtherType(); _operandProvider.Setup(mock => mock.GetEmittableType(type)).Returns(emittableType).Verifiable(); _innerMock .Setup(mock => mock.SetCustomAttribute(It.IsAny <CustomAttributeDeclaration>())) .Callback( (CustomAttributeDeclaration customAttributeDeclaration) => { var emittableDeclaration = (ICustomAttributeData)customAttributeDeclaration; Assert.That(emittableDeclaration, Is.Not.SameAs(declaration)); Assert.That(emittableDeclaration.Constructor, Is.SameAs(attributeCtor)); Assert.That(emittableDeclaration.ConstructorArguments, Has.Count.EqualTo(1)); Assert.That( emittableDeclaration.ConstructorArguments.Single(), Is.EqualTo(new object[] { 7, new object[] { "7", emittableType } })); Assert.That(emittableDeclaration.NamedArguments, Has.Count.EqualTo(1)); var namedArgument = emittableDeclaration.NamedArguments.Single(); Assert.That(namedArgument.MemberInfo, Is.EqualTo(field)); Assert.That(namedArgument.Value, Is.SameAs(emittableType)); }) .Verifiable(); _decorator.SetCustomAttribute(declaration); _operandProvider.Verify(); _operandProvider.Verify(mock => mock.GetEmittableType(type), Times.Exactly(2)); _innerMock.Verify(); }
public void MethodUsingBaseMembers() { var type = AssembleType <DomainType> ( proxyType => { var baseField = NormalizingMemberInfoFromExpressionUtility.GetField((DomainType obj) => obj.ExistingField); var baseMethod = NormalizingMemberInfoFromExpressionUtility.GetMethod((DomainType obj) => obj.ExistingMethod()); proxyType.AddMethod( "AddedMethod", MethodAttributes.Public, typeof(string), ParameterDeclaration.None, ctx => Expression.Block( Expression.Assign(Expression.Field(ctx.This, baseField), Expression.Constant("blah")), Expression.Call(ctx.This, baseMethod))); }); var addedMethod = type.GetMethod("AddedMethod"); var instance = Activator.CreateInstance(type); var result = addedMethod.Invoke(instance, null); Assert.That(result, Is.EqualTo("blah")); }