public void AddMapping(MutableMethodInfo mappedMethod, MethodInfo emittableMethod)
{
ArgumentUtility.CheckNotNull("mappedMethod", mappedMethod);
ArgumentUtility.CheckNotNull("emittableMethod", emittableMethod);
AddMapping(_mappedMethods, mappedMethod, emittableMethod);
}
public void AddMethod(CodeGenerationContext context, MutableMethodInfo method)
{
ArgumentUtility.CheckNotNull("context", context);
ArgumentUtility.CheckNotNull("method", method);
var methodBuilder = context.TypeBuilder.DefineMethod(method.Name, method.Attributes);
methodBuilder.RegisterWith(context.EmittableOperandProvider, method);
context.MethodBuilders.Add(method, methodBuilder);
// Generic parameters must be defined before the signature as generic parameters may be used in the signature.
DefineGenericParameters(context, methodBuilder, method);
methodBuilder.SetReturnType(method.ReturnType);
methodBuilder.SetParameters(GetParameterTypes(method));
DefineParameter(methodBuilder, method.MutableReturnParameter);
DefineParameters(methodBuilder, method);
DefineCustomAttributes(methodBuilder, method);
if (!method.IsAbstract)
{
var bodyBuildAction = CreateBodyBuildAction(context, methodBuilder, method.ParameterExpressions, method.Body);
context.PostDeclarationsActionManager.AddAction(bodyBuildAction);
}
var explicitOverrideAction = CreateExplicitOverrideBuildAction(context, method);
context.PostDeclarationsActionManager.AddAction(explicitOverrideAction);
}
public IStorage AddMemberInfo(MutableMethodInfo mutableMethod)
{
ArgumentUtility.CheckNotNull("mutableMethod", mutableMethod);
Assertion.IsNotNull(mutableMethod.DeclaringType);
var mutableType = (MutableType)mutableMethod.DeclaringType;
IStorage storage;
Func <ThisExpression, Expression> initializationProvider;
var property = mutableMethod.UnderlyingSystemMethodInfo.GetRelatedPropertyInfo();
if (property != null)
{
storage = AddStaticStorage(mutableType, typeof(PropertyInfo), mutableMethod.Name);
initializationProvider = thisExpression => _contextArgumentExpressionBuilder.CreatePropertyInfoInitExpression(property);
}
else
{
storage = AddStaticStorage(mutableType, typeof(MethodInfo), mutableMethod.Name);
initializationProvider = expr => _contextArgumentExpressionBuilder.CreateMethodInfoInitExpression(mutableMethod);
}
mutableType.AddTypeInitialization(ctx => CreateAssignExpression(storage, initializationProvider, ctx));
return(storage);
}
public void RegisterWith(IEmittableOperandProvider emittableOperandProvider, MutableMethodInfo method)
{
ArgumentUtility.CheckNotNull("emittableOperandProvider", emittableOperandProvider);
ArgumentUtility.CheckNotNull("method", method);
emittableOperandProvider.AddMapping(method, _methodBuilder);
}
public Expression CopyMethodBody(MutableMethodInfo otherMethod, params Expression[] arguments)
{
ArgumentUtility.CheckNotNull("otherMethod", otherMethod);
ArgumentUtility.CheckNotNull("arguments", arguments);
return(CopyMethodBody(otherMethod, (IEnumerable <Expression>)arguments));
}
public void SetUp()
{
_declaringType = MutableTypeObjectMother.Create(baseType: typeof(DomainType));
_method = MutableMethodInfoObjectMother.Create(_declaringType, "NonVirtualMethod");
_virtualMethod = MutableMethodInfoObjectMother.Create(_declaringType, attributes: MethodAttributes.Virtual);
}
public MutablePropertyInfo CreateProperty(
MutableType declaringType, string name, PropertyAttributes attributes, MutableMethodInfo getMethod, MutableMethodInfo setMethod)
{
ArgumentUtility.CheckNotNull("declaringType", declaringType);
ArgumentUtility.CheckNotNullOrEmpty("name", name);
// Get method may be null.
// Set method may be null.
MemberAttributesUtility.ValidateAttributes("properties", MemberAttributesUtility.InvalidPropertyAttributes, attributes, "attributes");
if (getMethod == null && setMethod == null)
{
throw new ArgumentException("Property must have at least one accessor.", "getMethod");
}
var readWriteProperty = getMethod != null && setMethod != null;
if (readWriteProperty && getMethod.IsStatic != setMethod.IsStatic)
{
throw new ArgumentException("Accessor methods must be both either static or non-static.", "getMethod");
}
if (getMethod != null && !ReferenceEquals(getMethod.DeclaringType, declaringType))
{
throw new ArgumentException("Get method is not declared on the current type.", "getMethod");
}
if (setMethod != null && !ReferenceEquals(setMethod.DeclaringType, declaringType))
{
throw new ArgumentException("Set method is not declared on the current type.", "setMethod");
}
if (getMethod != null && getMethod.ReturnType == typeof(void))
{
throw new ArgumentException("Get accessor must be a non-void method.", "getMethod");
}
if (setMethod != null && setMethod.ReturnType != typeof(void))
{
throw new ArgumentException("Set accessor must have return type void.", "setMethod");
}
var getSignature = getMethod != null ? new PropertySignature(getMethod.ReturnType, getMethod.GetParameters().Select(p => p.ParameterType)) : null;
var setParameters = setMethod != null?setMethod.GetParameters().Select(p => p.ParameterType).ToList() : null;
var setSignature = setMethod != null ? new PropertySignature(setParameters.Last(), setParameters.Take(setParameters.Count - 1)) : null;
if (readWriteProperty && !getSignature.Equals(setSignature))
{
throw new ArgumentException("Get and set accessor methods must have a matching signature.", "setMethod");
}
var signature = getSignature ?? setSignature;
if (declaringType.AddedProperties.Any(p => p.Name == name && PropertySignature.Create(p).Equals(signature)))
{
throw new InvalidOperationException("Property with equal name and signature already exists.");
}
return(new MutablePropertyInfo(declaringType, name, attributes, getMethod, setMethod));
}
public MethodExecutionExpression(MutableMethodInfo method)
{
_method = method;
_body = Call(
new ThisExpression(method.DeclaringType),
NonVirtualCallMethodInfoAdapter.Adapt(method.UnderlyingSystemMethodInfo),
method.ParameterExpressions.Cast <Expression>());
}
public static MethodExecutionExpression Adapt(MutableMethodInfo method)
{
var instance = new ThisExpression(method.DeclaringType);
var baseMethod = NonVirtualCallMethodInfoAdapter.Adapt(method.UnderlyingSystemMethodInfo);
var parameters = method.ParameterExpressions.Cast <Expression>();
var body = Call(instance, baseMethod, parameters);
return(new MethodExecutionExpression(method, body));
}
public MutableEventInfo CreateEvent(
MutableType declaringType,
string name,
EventAttributes attributes,
MutableMethodInfo addMethod,
MutableMethodInfo removeMethod,
MutableMethodInfo raiseMethod)
{
return(_eventFactory.CreateEvent(declaringType, name, attributes, addMethod, removeMethod, raiseMethod));
}
public void SetUp()
{
_declaringType = MutableTypeObjectMother.Create();
_name = "Property";
_attributes = (PropertyAttributes)7;
_type = ReflectionObjectMother.GetSomeType();
_indexParameters = ParameterDeclarationObjectMother.CreateMultiple(2);
_getMethod = MutableMethodInfoObjectMother.Create(returnType: _type, parameters: _indexParameters);
_setMethod =
MutableMethodInfoObjectMother.Create(parameters: _indexParameters.Concat(new[] { ParameterDeclarationObjectMother.Create(_type) }));
_property = new MutablePropertyInfo(_declaringType, _name, _attributes, _getMethod, _setMethod);
}
public static MutableEventInfo Create(
MutableType declaringType = null,
string name = "UnspecifiedEvent",
EventAttributes attributes = EventAttributes.None,
MutableMethodInfo addMethod = null,
MutableMethodInfo removeMethod = null,
MutableMethodInfo raiseMethod = null)
{
Assertion.IsTrue(addMethod != null && removeMethod != null);
declaringType = declaringType ?? MutableTypeObjectMother.Create();
return(new MutableEventInfo(declaringType, name, attributes, addMethod, removeMethod, raiseMethod));
}
private void CheckBodyOfAddedOverride(MethodInfo baseMethod, MutableMethodInfo mutableMethod)
{
Assert.That(mutableMethod.Body, Is.InstanceOf <MethodCallExpression>());
var methodCallExpression = (MethodCallExpression)mutableMethod.Body;
Assert.That(methodCallExpression.Object, Is.TypeOf <ThisExpression>());
var thisExpression = ((ThisExpression)methodCallExpression.Object);
Assert.That(thisExpression.Type, Is.SameAs(mutableMethod.DeclaringType));
Assert.That(methodCallExpression.Method, Is.TypeOf <NonVirtualCallMethodInfoAdapter> ());
Assert.That(((NonVirtualCallMethodInfoAdapter)methodCallExpression.Method).AdaptedMethod, Is.EqualTo(baseMethod));
}
public void SetUp()
{
_delegateProviderMock = new Mock <IDelegateProvider> (MockBehavior.Strict);
_provider = new EmittableOperandProvider(_delegateProviderMock.Object);
_mutableType = MutableTypeObjectMother.Create();
_mutableGenericParameter = MutableGenericParameterObjectMother.Create();
_mutableField = MutableFieldInfoObjectMother.Create();
_mutableConstructor = MutableConstructorInfoObjectMother.Create();
_mutableMethod = MutableMethodInfoObjectMother.Create();
_emittableType = ReflectionObjectMother.GetSomeType();
}
private IMutableMember ImplementEventOverride(EventDefinition @event)
{
MutableMethodInfo addMethodOverride = null, removeMethodOverride = null;
if (@event.AddMethod.Overrides.Count > 0)
{
addMethodOverride = ImplementMethodOverride(@event.AddMethod);
}
if (@event.RemoveMethod.Overrides.Count > 0)
{
removeMethodOverride = ImplementMethodOverride(@event.RemoveMethod);
}
return(_concreteTarget.AddEvent(@event.Name, EventAttributes.None, addMethodOverride, removeMethodOverride));
}
public static MutablePropertyInfo Create(
MutableType declaringType = null,
string name = "UnspecifiedProperty",
PropertyAttributes attributes = PropertyAttributes.None,
MutableMethodInfo getMethod = null,
MutableMethodInfo setMethod = null)
{
declaringType = declaringType ?? MutableTypeObjectMother.Create();
if (getMethod == null && setMethod == null)
{
getMethod = MutableMethodInfoObjectMother.Create(declaringType, "Getter", returnType: typeof(int));
}
return(new MutablePropertyInfo(declaringType, name, attributes, getMethod, setMethod));
}
public static MutablePropertyInfo AddProperty2(
this MutableType mutableType,
string name = null,
PropertyAttributes attributes = PropertyAttributes.None,
MutableMethodInfo getMethod = null,
MutableMethodInfo setMethod = null)
{
name = name ?? "Property_" + ++s_counter;
if (getMethod == null && setMethod == null)
{
getMethod = MutableMethodInfoObjectMother.Create(mutableType, "Getter", returnType: typeof(int));
}
return(mutableType.AddProperty(name, attributes, getMethod, setMethod));
}
private IMutableMember ImplementPropertyOverride(PropertyDefinition property)
{
MutableMethodInfo getMethodOverride = null, setMethodOverride = null;
if (property.GetMethod != null && property.GetMethod.Overrides.Count > 0)
{
getMethodOverride = ImplementMethodOverride(property.GetMethod);
}
if (property.SetMethod != null && property.SetMethod.Overrides.Count > 0)
{
setMethodOverride = ImplementMethodOverride(property.SetMethod);
}
return(_concreteTarget.AddProperty(property.Name, PropertyAttributes.None, getMethodOverride, setMethodOverride));
}
public MutablePropertyInfo CreateProperty(
MutableType declaringType,
string name,
Type type,
IEnumerable <ParameterDeclaration> indexParameters,
MethodAttributes accessorAttributes,
Func <MethodBodyCreationContext, Expression> getBodyProvider,
Func <MethodBodyCreationContext, Expression> setBodyProvider)
{
ArgumentUtility.CheckNotNull("declaringType", declaringType);
ArgumentUtility.CheckNotNullOrEmpty("name", name);
ArgumentUtility.CheckNotNull("type", type);
ArgumentUtility.CheckNotNull("indexParameters", indexParameters);
// Get body provider may be null.
// Set body provider may be null.
MemberAttributesUtility.ValidateAttributes(
"property accessor methods", MemberAttributesUtility.InvalidMethodAttributes, accessorAttributes, "accessorAttributes");
if (getBodyProvider == null && setBodyProvider == null)
{
throw new ArgumentException("At least one accessor body provider must be specified.", "getBodyProvider");
}
var indexParams = indexParameters.ToList();
var signature = new PropertySignature(type, indexParams.Select(pd => pd.Type));
if (declaringType.AddedProperties.Any(p => p.Name == name && PropertySignature.Create(p).Equals(signature)))
{
throw new InvalidOperationException("Property with equal name and signature already exists.");
}
var attributes = accessorAttributes | MethodAttributes.SpecialName;
MutableMethodInfo getMethod = null, setMethod = null;
if (getBodyProvider != null)
{
getMethod = CreateAccessor(declaringType, "get_" + name, attributes, type, indexParams, getBodyProvider);
}
if (setBodyProvider != null)
{
var setterParams = indexParams.Concat(new[] { new ParameterDeclaration(type, "value") });
setMethod = CreateAccessor(declaringType, "set_" + name, attributes, typeof(void), setterParams, setBodyProvider);
}
return(new MutablePropertyInfo(declaringType, name, PropertyAttributes.None, getMethod, setMethod));
}
public static MutableEventInfo AddEvent2(
this MutableType mutableType,
string name = null,
EventAttributes attributes = EventAttributes.None,
MutableMethodInfo addMethod = null,
MutableMethodInfo removeMethod = null,
MutableMethodInfo raiseMethod = null)
{
name = name ?? "Event_" + ++s_counter;
var handlerMethod = addMethod ?? removeMethod;
var handlerType = handlerMethod != null?handlerMethod.GetParameters().Single().ParameterType : typeof(Action);
addMethod = addMethod ?? MutableMethodInfoObjectMother.Create(mutableType, "Adder", parameters: new[] { ParameterDeclarationObjectMother.Create(handlerType) });
removeMethod = removeMethod ?? MutableMethodInfoObjectMother.Create(mutableType, "Adder", parameters: new[] { ParameterDeclarationObjectMother.Create(handlerType) });
return(mutableType.AddEvent(name, attributes, addMethod, removeMethod, raiseMethod));
}
public void GetNonVirtualCallTrampoline()
{
int i;
var method = NormalizingMemberInfoFromExpressionUtility.GetMethod((DomainType obj) => obj.Abc(out i, 0.7));
MutableMethodInfo mutableMethod = null;
_memberEmitterMock
.Setup(mock => mock.AddMethod(_context, It.IsAny <MutableMethodInfo>()))
.Callback((CodeGenerationContext context, MutableMethodInfo methodArg) => mutableMethod = methodArg)
.Verifiable();
var result = _provider.GetNonVirtualCallTrampoline(_context, method);
_memberEmitterMock.Verify();
Assert.That(result, Is.SameAs(mutableMethod));
Assert.That(_mutableType.AddedMethods, Has.Member(result));
var name = "Remotion.TypePipe.UnitTests.CodeGeneration.ReflectionEmit.MethodTrampolineProviderTest+DomainType.Abc_NonVirtualCallTrampoline";
Assert.That(result.Name, Is.EqualTo(name));
Assert.That(result.Attributes, Is.EqualTo(MethodAttributes.Private));
Assert.That(result.ReturnType, Is.SameAs(typeof(string)));
var parameters = result.GetParameters().Select(p => new { p.ParameterType, p.Name, p.Attributes });
var expectedParameters = new[]
{
new { ParameterType = typeof(int).MakeByRefType(), Name = "i", Attributes = ParameterAttributes.Out },
new { ParameterType = typeof(double), Name = "d", Attributes = ParameterAttributes.None }
};
Assert.That(parameters, Is.EqualTo(expectedParameters));
Assert.That(result.GetBaseDefinition(), Is.SameAs(result));
Assert.That(result.IsGenericMethod, Is.False);
Assert.That(result.IsGenericMethodDefinition, Is.False);
Assert.That(result.ContainsGenericParameters, Is.False);
Assert.That(mutableMethod.Body, Is.InstanceOf <MethodCallExpression>());
var methodCallExpression = ((MethodCallExpression)mutableMethod.Body);
Assert.That(methodCallExpression.Object, Is.TypeOf <ThisExpression>().And.Property("Type").SameAs(_mutableType));
Assert.That(methodCallExpression.Method, Is.TypeOf <NonVirtualCallMethodInfoAdapter>().And.Property("AdaptedMethod").SameAs(method));
Assert.That(methodCallExpression.Arguments, Is.EqualTo(mutableMethod.ParameterExpressions));
}
public MutableEventInfo CreateEvent(
MutableType declaringType,
string name,
Type handlerType,
MethodAttributes accessorAttributes,
Func <MethodBodyCreationContext, Expression> addBodyProvider,
Func <MethodBodyCreationContext, Expression> removeBodyProvider,
Func <MethodBodyCreationContext, Expression> raiseBodyProvider)
{
ArgumentUtility.CheckNotNull("declaringType", declaringType);
ArgumentUtility.CheckNotNullOrEmpty("name", name);
ArgumentUtility.CheckNotNullAndTypeIsAssignableFrom("handlerType", handlerType, typeof(Delegate));
ArgumentUtility.CheckNotNull("addBodyProvider", addBodyProvider);
ArgumentUtility.CheckNotNull("removeBodyProvider", removeBodyProvider);
// Raise body provider may be null.
MemberAttributesUtility.ValidateAttributes(
"event accessor methods", MemberAttributesUtility.InvalidMethodAttributes, accessorAttributes, "accessorAttributes");
var signature = new EventSignature(handlerType);
if (declaringType.AddedEvents.Any(e => e.Name == name && EventSignature.Create(e).Equals(signature)))
{
throw new InvalidOperationException("Event with equal name and signature already exists.");
}
var attributes = accessorAttributes | MethodAttributes.SpecialName;
var addRemoveParameters = new[] { new ParameterDeclaration(handlerType, "handler") };
var addMethod = CreateAccessor(declaringType, "add_" + name, attributes, typeof(void), addRemoveParameters, addBodyProvider);
var removeMethod = CreateAccessor(declaringType, "remove_" + name, attributes, typeof(void), addRemoveParameters, removeBodyProvider);
MutableMethodInfo raiseMethod = null;
if (raiseBodyProvider != null)
{
var invokeMethod = GetInvokeMethod(handlerType);
var raiseParameters = invokeMethod.GetParameters().Select(p => new ParameterDeclaration(p.ParameterType, p.Name, p.Attributes));
raiseMethod = CreateAccessor(declaringType, "raise_" + name, attributes, invokeMethod.ReturnType, raiseParameters, raiseBodyProvider);
}
return(new MutableEventInfo(declaringType, name, EventAttributes.None, addMethod, removeMethod, raiseMethod));
}
public Expression CopyMethodBody(MutableMethodInfo otherMethod, IEnumerable <Expression> arguments)
{
ArgumentUtility.CheckNotNull("otherMethod", otherMethod);
ArgumentUtility.CheckNotNull("arguments", arguments);
// ReSharper disable PossibleUnintendedReferenceComparison
if (otherMethod.DeclaringType != _declaringType)
// ReSharper restore PossibleUnintendedReferenceComparison
{
var message = string.Format("The specified method is declared by a different type '{0}'.", otherMethod.DeclaringType);
throw new ArgumentException(message, "otherMethod");
}
if (IsStatic && !otherMethod.IsStatic)
{
throw new ArgumentException("The body of an instance method cannot be copied into a static method.", "otherMethod");
}
return(BodyContextUtility.ReplaceParameters(otherMethod.ParameterExpressions, otherMethod.Body, arguments));
}
public void Initialization()
{
var declaringType = MutableTypeObjectMother.Create();
var name = "abc";
var attributes = (MethodAttributes)7 | MethodAttributes.Virtual;
var returnType = ReflectionObjectMother.GetSomeType();
var parameters = ParameterDeclarationObjectMother.CreateMultiple(2);
var baseMethod = ReflectionObjectMother.GetSomeVirtualMethod();
var body = ExpressionTreeObjectMother.GetSomeExpression(returnType);
var method = new MutableMethodInfo(
declaringType, name, attributes, new MutableGenericParameter[0], returnType, parameters.AsOneTime(), baseMethod, body);
Assert.That(method.DeclaringType, Is.SameAs(declaringType));
Assert.That(method.MutableDeclaringType, Is.SameAs(declaringType));
Assert.That(method.Name, Is.EqualTo(name));
Assert.That(method.Attributes, Is.EqualTo(attributes));
Assert.That(method.IsGenericMethod, Is.False);
CustomParameterInfoTest.CheckParameter(method.ReturnParameter, method, -1, null, returnType, ParameterAttributes.None);
Assert.That(method.MutableReturnParameter, Is.SameAs(method.ReturnParameter));
var actualParameters = method.GetParameters();
Assert.That(actualParameters, Has.Length.EqualTo(2));
CustomParameterInfoTest.CheckParameter(actualParameters[0], method, 0, parameters[0].Name, parameters[0].Type, parameters[0].Attributes);
CustomParameterInfoTest.CheckParameter(actualParameters[1], method, 1, parameters[1].Name, parameters[1].Type, parameters[1].Attributes);
Assert.That(method.MutableParameters, Is.EqualTo(actualParameters));
var paramExpressions = method.ParameterExpressions;
Assert.That(paramExpressions, Has.Count.EqualTo(2));
Assert.That(paramExpressions[0], Has.Property("Name").EqualTo(parameters[0].Name).And.Property("Type").SameAs(parameters[0].Type));
Assert.That(paramExpressions[1], Has.Property("Name").EqualTo(parameters[1].Name).And.Property("Type").SameAs(parameters[1].Type));
Assert.That(method.BaseMethod, Is.SameAs(baseMethod));
Assert.That(method.Body, Is.SameAs(body));
}
public void SetUp()
{
_declaringType = MutableTypeObjectMother.Create();
_name = "Event";
_attributes = (EventAttributes)7;
_argumentType = ReflectionObjectMother.GetSomeType();
_returnType = ReflectionObjectMother.GetSomeOtherType();
_handlerType = typeof(Func <,>).MakeGenericType(_argumentType, _returnType);
_addMethod = MutableMethodInfoObjectMother.Create(
attributes: MethodAttributes.Public,
returnType: typeof(void),
parameters: new[] { new ParameterDeclaration(_handlerType, "handler") });
_removeMethod = MutableMethodInfoObjectMother.Create(
attributes: MethodAttributes.Public,
returnType: typeof(void),
parameters: new[] { new ParameterDeclaration(_handlerType, "handler") });
_raiseMethod = MutableMethodInfoObjectMother.Create(
attributes: MethodAttributes.Public,
returnType: _returnType,
parameters: new[] { new ParameterDeclaration(_argumentType, "") });
_event = new MutableEventInfo(_declaringType, _name, _attributes, _addMethod, _removeMethod, _raiseMethod);
}
private void ImplementIntroducedProperty(Expression implementer, PropertyIntroductionDefinition introducedProperty)
{
var interfaceProperty = introducedProperty.InterfaceMember;
var implementingProperty = introducedProperty.ImplementingMember;
var visibility = introducedProperty.Visibility;
MutableMethodInfo getMethod = null, setMethod = null;
if (introducedProperty.IntroducesGetMethod)
{
getMethod = ImplementIntroducedMethod(implementer, interfaceProperty.GetGetMethod(), implementingProperty.GetMethod, visibility);
}
if (introducedProperty.IntroducesSetMethod)
{
setMethod = ImplementIntroducedMethod(implementer, interfaceProperty.GetSetMethod(), implementingProperty.SetMethod, visibility);
}
var name = GetIntroducedMemberName(visibility, interfaceProperty);
var property = _concreteTarget.AddProperty(name, PropertyAttributes.None, getMethod, setMethod);
_attributeGenerator.AddIntroducedMemberAttribute(property, interfaceProperty, implementingProperty);
_attributeGenerator.ReplicateAttributes(implementingProperty, property);
}
public MethodInfo GetGeneratedMethod(MutableMethodInfo mutableMethod)
{
return((MethodInfo)GetGeneratedMember(mutableMethod));
}
private void CheckExplicitOverrideAction(Action testedAction, MethodInfo overriddenMethod, MutableMethodInfo overridingMethod)
{
_emittableOperandProviderMock.BackToRecord();
_typeBuilderMock.BackToRecord();
var fakeOverriddenMethod = ReflectionObjectMother.GetSomeMethod();
var fakeOverridingMethod = ReflectionObjectMother.GetSomeMethod();
_emittableOperandProviderMock.Expect(mock => mock.GetEmittableMethod(overriddenMethod)).Return(fakeOverriddenMethod);
_emittableOperandProviderMock.Expect(mock => mock.GetEmittableMethod(overridingMethod)).Return(fakeOverridingMethod);
_typeBuilderMock.Expect(mock => mock.DefineMethodOverride(fakeOverridingMethod, fakeOverriddenMethod));
_emittableOperandProviderMock.Replay();
_typeBuilderMock.Replay();
testedAction();
_emittableOperandProviderMock.VerifyAllExpectations();
_typeBuilderMock.VerifyAllExpectations();
}
public MutablePropertyInfo CreateProperty(
MutableType declaringType, string name, PropertyAttributes attributes, MutableMethodInfo getMethod, MutableMethodInfo setMethod)
{
return(_propertyFactory.CreateProperty(declaringType, name, attributes, getMethod, setMethod));
}
public void AddMapping(MutableMethodInfo mappedMethod, MethodInfo emittableMethod)
{
_emittableOperandProvider.AddMapping(mappedMethod, emittableMethod);
}
