public void SetBody()
{
var declaringType = MutableTypeObjectMother.Create();
var attribtes = MethodAttributes.Virtual; // Methods which have a base method must be virtual.
var returnType = typeof(object);
var parameters = ParameterDeclarationObjectMother.CreateMultiple(2);
var baseMethod = ReflectionObjectMother.GetSomeVirtualMethod(); // Base method must be virtual.
var genericParameters = new[] { MutableGenericParameterObjectMother.Create() };
var method = MutableMethodInfoObjectMother.Create(
declaringType, "Method", attribtes, returnType, parameters, baseMethod, genericParameters: genericParameters);
var fakeBody = ExpressionTreeObjectMother.GetSomeExpression(typeof(int));
Func <MethodBodyModificationContext, Expression> bodyProvider = ctx =>
{
Assert.That(ctx.DeclaringType, Is.SameAs(declaringType));
Assert.That(ctx.IsStatic, Is.False);
Assert.That(ctx.Parameters, Is.EqualTo(method.ParameterExpressions).And.Not.Empty);
Assert.That(ctx.GenericParameters, Is.EqualTo(genericParameters));
Assert.That(ctx.ReturnType, Is.SameAs(returnType));
Assert.That(ctx.BaseMethod, Is.SameAs(baseMethod));
Assert.That(ctx.PreviousBody, Is.SameAs(method.Body));
return(fakeBody);
};
method.SetBody(bodyProvider);
var expectedBody = Expression.Convert(fakeBody, returnType);
ExpressionTreeComparer.CheckAreEqualTrees(expectedBody, method.Body);
}
public void GetAllXXX_UsesAllBindingFlagsToRetrieveMembers()
{
var fields = _baseTypeConstraint.GetFields(c_allMembers);
var methods = _baseTypeConstraint.GetMethods(c_allMembers);
var properties = _baseTypeConstraint.GetProperties(c_allMembers);
var events = _baseTypeConstraint.GetEvents(c_allMembers);
var baseMemberSelectorMock = new Mock <IMemberSelector> (MockBehavior.Strict);
var baseTypeConstraint = CustomTypeObjectMother.Create(
baseMemberSelectorMock.Object, fields: fields, methods: methods, properties: properties, events: events);
baseMemberSelectorMock.Setup(mock => mock.SelectFields(fields, c_allMembers, baseTypeConstraint)).Returns(fields).Verifiable();
// Note: GetMethods is optimized for retrieving all the methods; so there is no memberSelectorMock call.
baseMemberSelectorMock.Setup(mock => mock.SelectProperties(properties, c_allMembers, baseTypeConstraint)).Returns(properties).Verifiable();
baseMemberSelectorMock.Setup(mock => mock.SelectEvents(events, c_allMembers, baseTypeConstraint)).Returns(events).Verifiable();
var parameter = MutableGenericParameterObjectMother.Create(constraints: new[] { baseTypeConstraint, _interfaceConstraint });
Assert.That(parameter.GetAllFields(), Is.EqualTo(fields));
Assert.That(parameter.GetAllMethods(), Is.EqualTo(methods));
Assert.That(parameter.GetAllProperties(), Is.EqualTo(properties));
Assert.That(parameter.GetAllEvents(), Is.EqualTo(events));
baseMemberSelectorMock.Verify(mock => mock.SelectMethods(It.IsAny <IEnumerable <ConstructorInfo> >(), It.IsAny <BindingFlags>(), It.IsAny <Type>()), Times.Never());
baseMemberSelectorMock.Verify();
}
public void GetAllXXX_UsesAllBindingFlagsToRetrieveMembers()
{
var fields = _baseTypeConstraint.GetFields(c_allMembers);
var methods = _baseTypeConstraint.GetMethods(c_allMembers);
var properties = _baseTypeConstraint.GetProperties(c_allMembers);
var events = _baseTypeConstraint.GetEvents(c_allMembers);
var baseMemberSelectorMock = MockRepository.GenerateStrictMock <IMemberSelector>();
var baseTypeConstraint = CustomTypeObjectMother.Create(
baseMemberSelectorMock, fields: fields, methods: methods, properties: properties, events: events);
baseMemberSelectorMock.Expect(mock => mock.SelectFields(fields, c_allMembers, baseTypeConstraint)).Return(fields);
// Note: GetMethods is optimized for retrieving all the methods; so there is no memberSelectorMock call.
baseMemberSelectorMock.Expect(mock => mock.SelectProperties(properties, c_allMembers, baseTypeConstraint)).Return(properties);
baseMemberSelectorMock.Expect(mock => mock.SelectEvents(events, c_allMembers, baseTypeConstraint)).Return(events);
var parameter = MutableGenericParameterObjectMother.Create(constraints: new[] { baseTypeConstraint, _interfaceConstraint });
Assert.That(parameter.GetAllFields(), Is.EqualTo(fields));
Assert.That(parameter.GetAllMethods(), Is.EqualTo(methods));
Assert.That(parameter.GetAllProperties(), Is.EqualTo(properties));
Assert.That(parameter.GetAllEvents(), Is.EqualTo(events));
baseMemberSelectorMock.AssertWasNotCalled(
mock => mock.SelectMethods(Arg <IEnumerable <ConstructorInfo> > .Is.Anything, Arg <BindingFlags> .Is.Anything, Arg <Type> .Is.Anything));
baseMemberSelectorMock.VerifyAllExpectations();
}
public void AppendTypeString_CallsBase_ForUninitializedGenericParam()
{
var uninitializedGenericParam = MutableGenericParameterObjectMother.Create(position: 7);
_builder.AppendTypeString(_sb1, uninitializedGenericParam);
Assert.That(() => _originalBuilder.AppendTypeString(_sb2, uninitializedGenericParam), Throws.Exception);
Assert.That(_sb1.ToString(), Is.EqualTo("[7]"));
}
public void GetAllConstructors_NewConstraint()
{
var parameter = MutableGenericParameterObjectMother.Create(genericParameterAttributes: GenericParameterAttributes.DefaultConstructorConstraint);
var result = parameter.GetConstructors(c_allMembers).Single();
Assert.That(result, Is.TypeOf <GenericParameterDefaultConstructor>());
Assert.That(result.DeclaringType, Is.SameAs(parameter));
}
public void DelegatingMembers()
{
var emittableOperandProvider = new Mock <IEmittableOperandProvider>();
var genericParameter = MutableGenericParameterObjectMother.Create();
var helper = new DecoratorTestHelper <IGenericTypeParameterBuilder> (_decorator, _innerMock);
helper.CheckDelegation(d => d.RegisterWith(emittableOperandProvider.Object, genericParameter));
helper.CheckDelegation(d => d.SetGenericParameterAttributes((GenericParameterAttributes)7));
}
public void SetGenericParameterConstraints_BaseConstraintConflicts_WithNotNullableValueTypeConstraint()
{
var parameter = MutableGenericParameterObjectMother.Create(genericParameterAttributes: GenericParameterAttributes.NotNullableValueTypeConstraint);
Assert.That(
() => parameter.SetGenericParameterConstraints(new[] { ReflectionObjectMother.GetSomeSubclassableType() }),
Throws.ArgumentException
.With.ArgumentExceptionMessageEqualTo(
"A generic parameter cannot have a base constraint if the NotNullableValueTypeConstraint flag is set.", "constraints"));
}
public void AppendTypeString_CallsBase_ForInitializedGenericParam()
{
var initializedGenericParam = MutableGenericParameterObjectMother.Create();
initializedGenericParam.InitializeDeclaringMember(MutableMethodInfoObjectMother.Create());
_builder.AppendTypeString(_sb1, initializedGenericParam);
_originalBuilder.AppendTypeString(_sb2, initializedGenericParam);
Assert.That(_sb1.ToString(), Is.EqualTo(_sb2.ToString()));
}
private MutableMethodInfo CreateFakeGenericMethod()
{
var genericParameter = MutableGenericParameterObjectMother.Create(position: 0);
return(MutableMethodInfoObjectMother.Create(
_mutableType,
attributes: MethodAttributes.Virtual,
genericParameters: new[] { genericParameter },
returnType: genericParameter,
parameters: new[] { ParameterDeclarationObjectMother.Create(typeof(int)), ParameterDeclarationObjectMother.Create(genericParameter) }));
}
public void SetUp()
{
_typeParameter = MutableGenericParameterObjectMother.Create();
_parameter = CustomParameterInfoObjectMother.Create();
_genericMethodDefinition = CustomMethodInfoObjectMother.Create(parameters: new[] { _parameter }, typeArguments: new[] { _typeParameter });
_typeArgument = CustomTypeObjectMother.Create();
var info = new MethodInstantiationInfo(_genericMethodDefinition, new[] { _typeArgument });
_instantiation = new MethodInstantiation(info);
}
public void Initialization_GenericMethodDefinition()
{
var genericParameters = MutableGenericParameterObjectMother.CreateMultiple(2);
var method = MutableMethodInfoObjectMother.Create(genericParameters: genericParameters);
Assert.That(method.IsGenericMethod, Is.True);
Assert.That(method.IsGenericMethodDefinition, Is.True);
Assert.That(method.MutableGenericParameters, Is.EqualTo(genericParameters));
var genParas = method.GetGenericArguments();
Assert.That(genParas, Is.EqualTo(genericParameters));
Assert.That(genParas, Has.All.Matches <Type> (g => g.DeclaringMethod == method));
}
public void SetUp()
{
_position = 7;
_name = "_parameter";
_namespace = "namespace";
_genericParameterAttributes = (GenericParameterAttributes)7;
_parameter = new MutableGenericParameter(_position, _name, _namespace, _genericParameterAttributes);
_baseTypeConstraint = typeof(DomainType);
_interfaceConstraint = ReflectionObjectMother.GetSomeInterfaceType();
_constrainedParameter = MutableGenericParameterObjectMother.Create(constraints: new[] { _baseTypeConstraint, _interfaceConstraint }.AsOneTime());
}
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();
}
public void IsAssignableFromFast_GenericParameterConstraints()
{
var genericParameter1 = MutableGenericParameterObjectMother.Create(constraints: new[] { typeof(IDisposable) });
var genericParameter2 = MutableGenericParameterObjectMother.Create(constraints: new[] { typeof(TypeExtensionsTest) });
var genericParameter3 = MutableGenericParameterObjectMother.Create(constraints: new[] { typeof(IDisposable) });
Assert.That(typeof(object).IsTypePipeAssignableFrom(genericParameter1), Is.True);
Assert.That(typeof(TypeExtensionsTest).IsTypePipeAssignableFrom(genericParameter1), Is.False);
Assert.That(typeof(TypeExtensionsTest).IsTypePipeAssignableFrom(genericParameter2), Is.True);
Assert.That(typeof(IDisposable).IsTypePipeAssignableFrom(genericParameter1), Is.True);
Assert.That(typeof(IDisposable).IsTypePipeAssignableFrom(genericParameter2), Is.False);
Assert.That(genericParameter1.IsTypePipeAssignableFrom(typeof(object)), Is.False);
Assert.That(genericParameter1.IsTypePipeAssignableFrom(typeof(IDisposable)), Is.False);
Assert.That(genericParameter1.IsTypePipeAssignableFrom(genericParameter1), Is.True);
Assert.That(genericParameter1.IsTypePipeAssignableFrom(genericParameter2), Is.False);
Assert.That(genericParameter1.IsTypePipeAssignableFrom(genericParameter3), Is.False);
}
public void AddMethod_GenericMethodDefinition()
{
var baseTypeConstraint = typeof(DomainType);
var interfaceConstraint = typeof(IDisposable);
Assert.That(baseTypeConstraint.GetInterfaces(), Is.Not.Empty);
Assert.That(baseTypeConstraint.GetInterfaces(), Has.No.Member(interfaceConstraint));
var genericParameter = MutableGenericParameterObjectMother.Create(
name: "TParam",
genericParameterAttributes: (GenericParameterAttributes)7,
constraints: new[] { baseTypeConstraint, interfaceConstraint });
var method = MutableMethodInfoObjectMother.Create(
genericParameters: new[] { genericParameter },
returnType: genericParameter,
parameters: new[] { ParameterDeclarationObjectMother.Create(genericParameter, "genericParam") });
var methodBuilderMock = new Mock <IMethodBuilder> (MockBehavior.Strict);
_typeBuilderMock.Setup(mock => mock.DefineMethod(method.Name, method.Attributes)).Returns(methodBuilderMock.Object);
methodBuilderMock.Setup(mock => mock.RegisterWith(_emittableOperandProviderMock.Object, method));
var genericParameterBuilderMock = new Mock <IGenericTypeParameterBuilder> (MockBehavior.Strict);
methodBuilderMock.Setup(mock => mock.DefineGenericParameters(new[] { "TParam" })).Returns(new[] { genericParameterBuilderMock.Object }).Verifiable();
genericParameterBuilderMock.Setup(mock => mock.RegisterWith(_emittableOperandProviderMock.Object, genericParameter)).Verifiable();
genericParameterBuilderMock.Setup(mock => mock.SetGenericParameterAttributes((GenericParameterAttributes)7)).Verifiable();
genericParameterBuilderMock.Setup(mock => mock.SetBaseTypeConstraint(baseTypeConstraint)).Verifiable();
genericParameterBuilderMock.Setup(mock => mock.SetInterfaceConstraints(new[] { interfaceConstraint })).Verifiable();
SetupDefineCustomAttribute(genericParameterBuilderMock, genericParameter);
methodBuilderMock.Setup(mock => mock.SetReturnType(genericParameter)).Verifiable();
methodBuilderMock.Setup(mock => mock.SetParameters(new Type[] { genericParameter })).Verifiable();
SetupDefineParameter(methodBuilderMock, 0, null, ParameterAttributes.None);
SetupDefineParameter(methodBuilderMock, 1, "genericParam", ParameterAttributes.None);
_emitter.AddMethod(_context, method);
methodBuilderMock.Verify();
genericParameterBuilderMock.Verify();
}
public void DelegatingMembers()
{
var mappedType = MutableTypeObjectMother.Create();
var mappedGenericParameter = MutableGenericParameterObjectMother.Create();
var mappedField = MutableFieldInfoObjectMother.Create();
var mappedConstructor = MutableConstructorInfoObjectMother.Create();
var mappedMethod = MutableMethodInfoObjectMother.Create();
var emittableType = ReflectionObjectMother.GetSomeType();
var emittableGenericParameter = ReflectionObjectMother.GetSomeGenericParameter();
var emittableField = ReflectionObjectMother.GetSomeField();
var emittableConstructor = ReflectionObjectMother.GetSomeConstructor();
var emittableMethod = ReflectionObjectMother.GetSomeMethod();
var helper = new DecoratorTestHelper <IEmittableOperandProvider> (_decorator, _innerMock);
helper.CheckDelegation(d => d.AddMapping(mappedType, emittableType));
helper.CheckDelegation(d => d.AddMapping(mappedGenericParameter, emittableGenericParameter));
helper.CheckDelegation(d => d.AddMapping(mappedField, emittableField));
helper.CheckDelegation(d => d.AddMapping(mappedConstructor, emittableConstructor));
helper.CheckDelegation(d => d.AddMapping(mappedMethod, emittableMethod));
}
public void SetGenericParameterConstraints_BaseConstraintConflicts_WithNotNullableValueTypeConstraint()
{
var parameter = MutableGenericParameterObjectMother.Create(genericParameterAttributes: GenericParameterAttributes.NotNullableValueTypeConstraint);
parameter.SetGenericParameterConstraints(new[] { ReflectionObjectMother.GetSomeSubclassableType() });
}
public void SetUp()
{
_declaringType = MutableGenericParameterObjectMother.Create();
_constructor = new GenericParameterDefaultConstructor(_declaringType);
}
public void Initialization_ValueType()
{
var parameter = MutableGenericParameterObjectMother.Create(genericParameterAttributes: GenericParameterAttributes.NotNullableValueTypeConstraint);
Assert.That(parameter.BaseType, Is.SameAs(typeof(ValueType)));
}
public void GetEmittableMethod_MethodInstantiation_OnCustomType()
{
var genericMethodDefinition = MutableMethodInfoObjectMother.Create(genericParameters: new[] { MutableGenericParameterObjectMother.Create() });
var emittableGenericMethodDefinition = typeof(Enumerable).GetMethod("Empty");
_provider.AddMapping(genericMethodDefinition, emittableGenericMethodDefinition);
var instantiation = genericMethodDefinition.MakeTypePipeGenericMethod(_emittableType);
Assert.That(instantiation, Is.TypeOf <MethodInstantiation>());
var result = _provider.GetEmittableMethod(instantiation);
Assert.That(result, Is.Not.InstanceOf <CustomMethodInfo>());
var emittableGenericArgument = result.GetGenericArguments().Single();
Assert.That(emittableGenericArgument, Is.SameAs(_emittableType));
}
