public void SetUp()
{
_proxy = MutableTypeObjectMother.Create();
_addedCtor = _proxy.AddConstructor();
_tracker = new ProxyTypeModificationTracker(_proxy, new[] { _addedCtor.Body });
}
public static MutableConstructorInfo AddConstructor(
this MutableType mutableType,
MethodAttributes attributes = MethodAttributes.Public,
IEnumerable <ParameterDeclaration> parameters = null,
Func <ConstructorBodyCreationContext, Expression> bodyProvider = null)
{
parameters = parameters ?? ParameterDeclaration.None;
bodyProvider = bodyProvider ?? (ctx => Expression.Empty());
return(mutableType.AddConstructor(attributes, parameters, bodyProvider));
}
private MutableConstructorInfo AddConstructor(
MutableType nextCallProxy, MutableType concreteTarget, Expression thisField, Expression depthField)
{
return(nextCallProxy.AddConstructor(
MethodAttributes.Public,
new[] { new ParameterDeclaration(concreteTarget, "this"), new ParameterDeclaration(typeof(int), "depth") },
ctx =>
Expression.Block(
ctx.CallBaseConstructor(),
Expression.Assign(thisField, ctx.Parameters[0]),
Expression.Assign(depthField, ctx.Parameters[1]))));
}
public void DefineTypeFacets()
{
var typeInitializer = _mutableType.AddTypeInitializer(ctx => Expression.Empty());
var instanceInitialization = ExpressionTreeObjectMother.GetSomeExpression();
_mutableType.AddInitialization(ctx => instanceInitialization);
var customAttribute = CustomAttributeDeclarationObjectMother.Create();
_mutableType.AddCustomAttribute(customAttribute);
var @interface = typeof(IDisposable);
_mutableType.AddInterface(@interface);
var field = _mutableType.AddField();
var constructor = _mutableType.AddConstructor();
var method = _mutableType.AddMethod();
var property = _mutableType.AddProperty();
var event_ = _mutableType.AddEvent();
using (_mockRepository.Ordered())
{
var context = PopulateContext(_generator, 2);
_typeBuilderMock.Expect(mock => mock.SetParent(_mutableType.BaseType));
_memberEmitterMock.Expect(mock => mock.AddConstructor(context, typeInitializer));
_initializationBuilderMock.Expect(mock => mock.CreateInitializationMembers(_mutableType)).Return(_fakeInitializationMembers);
_proxySerializationEnablerMock.Expect(mock => mock.MakeSerializable(_mutableType, _fakeInitializationMethod));
_typeBuilderMock.Expect(mock => mock.SetCustomAttribute(customAttribute));
_typeBuilderMock.Expect(mock => mock.AddInterfaceImplementation(@interface));
_memberEmitterMock.Expect(mock => mock.AddField(context, field));
_initializationBuilderMock.Expect(
mock => mock.WireConstructorWithInitialization(constructor, _fakeInitializationMembers, _proxySerializationEnablerMock));
_memberEmitterMock.Expect(mock => mock.AddConstructor(context, constructor));
_memberEmitterMock.Expect(mock => mock.AddMethod(context, method));
SetupExpectationsForAccessors(_memberEmitterMock, _mutableType.AddedMethods.Except(new[] { method }));
_memberEmitterMock.Expect(mock => mock.AddProperty(context, property));
_memberEmitterMock.Expect(mock => mock.AddEvent(context, event_));
}
_mockRepository.ReplayAll();
_generator.DefineTypeFacets();
_mockRepository.VerifyAll();
}
public void CreateConstructor_ThrowsIfAlreadyExists()
{
_mutableType.AddConstructor(parameters: ParameterDeclaration.None);
Func <ConstructorBodyCreationContext, Expression> bodyProvider = ctx => Expression.Empty();
Assert.That(
() => _factory.CreateConstructor(_mutableType, 0, ParameterDeclarationObjectMother.CreateMultiple(2), bodyProvider),
Throws.Nothing);
Assert.That(
() =>
_factory.CreateConstructor(_mutableType, MethodAttributes.Static, ParameterDeclaration.None, bodyProvider),
Throws.Nothing);
Assert.That(
() => _factory.CreateConstructor(_mutableType, 0, ParameterDeclaration.None, bodyProvider),
Throws.InvalidOperationException.With.Message.EqualTo("Constructor with equal signature already exists."));
}
private static MutableConstructorInfo CopyConstructor(MutableType proxyType, MethodAttributes attributes, ConstructorInfo constructor)
{
var parameters = constructor.GetParameters().Select(p => new ParameterDeclaration(p.ParameterType, p.Name, p.Attributes));
return(proxyType.AddConstructor(attributes, parameters, ctx => ctx.CallBaseConstructor(ctx.Parameters)));
}