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"));
}
