public void GetEmittableConstructor()
{
var constructor = ReflectionObjectMother.GetSomeConstructor();
var emittableConstructor = ReflectionObjectMother.GetSomeConstructor();
CheckGetEmittable(p => p.GetEmittableConstructor(constructor), emittableConstructor, emittableConstructor.DeclaringType);
}
public void SetUp()
{
_memberSelectorMock = MockRepository.GenerateStrictMock <IMemberSelector>();
_name = "TypeName";
_namespace = "MyNamespace";
_attributes = (TypeAttributes)7;
_customType = new TestableCustomType(
_name,
_namespace,
_attributes,
genericTypeDefinition: null,
typeArguments: Type.EmptyTypes)
{
NestedTypes = new[] { ReflectionObjectMother.GetSomeType() },
Interfaces = new[] { typeof(IDisposable) },
Fields = new[] { ReflectionObjectMother.GetSomeField() },
Constructors = new[] { ReflectionObjectMother.GetSomeConstructor() },
Methods = new[] { ReflectionObjectMother.GetSomeMethod() },
Properties = new[] { ReflectionObjectMother.GetSomeProperty() },
Events = new[] { ReflectionObjectMother.GetSomeEvent() }
};
_customType.SetMemberSelector(_memberSelectorMock);
_typeArgument = ReflectionObjectMother.GetSomeType();
_genericTypeUnderlyingDefinition = typeof(IList <>);
_genericType = CustomTypeObjectMother.Create(
name: "GenericType`1", genericTypeDefinition: _genericTypeUnderlyingDefinition, typeArguments: new[] { _typeArgument });
_typeParameter = ReflectionObjectMother.GetSomeGenericParameter();
_genericTypeDefinition = CustomTypeObjectMother.Create(name: "GenericTypeDefinition`1", typeArguments: new[] { _typeParameter });
}
public void IsDeserializationConstructor()
{
var ctor1 = NormalizingMemberInfoFromExpressionUtility.GetConstructor(() => new SerializableInterfaceType(null, new StreamingContext()));
var ctor2 = ReflectionObjectMother.GetSomeConstructor();
Assert.That(_enabler.IsDeserializationConstructor(ctor1), Is.True);
Assert.That(_enabler.IsDeserializationConstructor(ctor2), Is.False);
}
public void Adapt_Constructor()
{
var ctor = ReflectionObjectMother.GetSomeConstructor();
var adapter = NonVirtualCallMethodInfoAdapter.Adapt(ctor);
Assert.That(adapter.AdaptedMethod, Is.TypeOf <ConstructorAsMethodInfoAdapter>());
var constructorAsMethodInfoAdapter = (ConstructorAsMethodInfoAdapter)adapter.AdaptedMethod;
Assert.That(constructorAsMethodInfoAdapter.AdaptedConstructor, Is.SameAs(ctor));
}
public void Emit_ConstructorInfo()
{
var constructor = ReflectionObjectMother.GetSomeConstructor();
var fakeEmittableOperand = MockRepository.GenerateStub <ConstructorInfo>();
_emittableOperandProviderStub.Stub(stub => stub.GetEmittableConstructor(constructor)).Return(fakeEmittableOperand);
_innerILGeneratorMock.Expect(mock => mock.Emit(OpCodes.Call, fakeEmittableOperand));
_decorator.Emit(OpCodes.Call, constructor);
_innerILGeneratorMock.VerifyAllExpectations();
}
public void Emit_ConstructorInfo()
{
var constructor = ReflectionObjectMother.GetSomeConstructor();
var fakeEmittableOperand = new Mock <ConstructorInfo>().Object;
_emittableOperandProviderStub.Setup(stub => stub.GetEmittableConstructor(constructor)).Returns(fakeEmittableOperand);
_innerILGeneratorMock.Setup(mock => mock.Emit(OpCodes.Call, fakeEmittableOperand)).Verifiable();
_decorator.Emit(OpCodes.Call, constructor);
_innerILGeneratorMock.Verify();
}
public void GetConstructors()
{
Assert.That(_customType.Constructors, Is.Not.Null.And.Not.Empty);
var bindingAttr = BindingFlags.NonPublic;
var fakeResult = new[] { ReflectionObjectMother.GetSomeConstructor() };
_memberSelectorMock.Expect(mock => mock.SelectMethods(_customType.Constructors, bindingAttr, _customType)).Return(fakeResult);
var result = _customType.GetConstructors(bindingAttr);
_memberSelectorMock.VerifyAllExpectations();
Assert.That(result, Is.EqualTo(fakeResult));
}
public void GetEmittableXXX_RuntimeInfos()
{
var type = ReflectionObjectMother.GetSomeType();
var genericParameter = ReflectionObjectMother.GetSomeGenericParameter();
var field = ReflectionObjectMother.GetSomeField();
var ctor = ReflectionObjectMother.GetSomeConstructor();
var method = ReflectionObjectMother.GetSomeMethod();
Assert.That(_provider.GetEmittableType(type), Is.SameAs(type));
Assert.That(_provider.GetEmittableType(genericParameter), Is.SameAs(genericParameter));
Assert.That(_provider.GetEmittableField(field), Is.SameAs(field));
Assert.That(_provider.GetEmittableConstructor(ctor), Is.SameAs(ctor));
Assert.That(_provider.GetEmittableMethod(method), Is.SameAs(method));
}
public void EmitCall_MethodInfo_BaseConstructorMethodInfo_EmptyOptionalParameters()
{
var constructor = ReflectionObjectMother.GetSomeConstructor();
var fakeEmittableOperand = MockRepository.GenerateStub <ConstructorInfo> ();
_emittableOperandProviderStub.Stub(stub => stub.GetEmittableConstructor(constructor)).Return(fakeEmittableOperand);
_innerILGeneratorMock.Expect(mock => mock.Emit(OpCodes.Call, fakeEmittableOperand));
var constructorAsMethodInfoAdapter = new ConstructorAsMethodInfoAdapter(constructor);
_decorator.EmitCall(OpCodes.Call, constructorAsMethodInfoAdapter, Type.EmptyTypes);
_innerILGeneratorMock.VerifyAllExpectations();
}
public void EmitCall_MethodInfo_BaseConstructorMethodInfo_NullOptionalParameters()
{
var constructor = ReflectionObjectMother.GetSomeConstructor();
var fakeEmittableOperand = new Mock <ConstructorInfo>().Object;
_emittableOperandProviderStub.Setup(stub => stub.GetEmittableConstructor(constructor)).Returns(fakeEmittableOperand);
_innerILGeneratorMock.Setup(mock => mock.Emit(OpCodes.Call, fakeEmittableOperand)).Verifiable();
var constructorAsMethodInfoAdapter = new ConstructorAsMethodInfoAdapter(constructor);
_decorator.EmitCall(OpCodes.Call, constructorAsMethodInfoAdapter, null);
_innerILGeneratorMock.Verify();
}
public void GetEmittableXXX_Mutable()
{
var emittableType = ReflectionObjectMother.GetSomeType();
var emittableGenericParameter = ReflectionObjectMother.GetSomeGenericParameter();
var emittableField = ReflectionObjectMother.GetSomeField();
var emittableConstructor = ReflectionObjectMother.GetSomeConstructor();
var emittableMethod = ReflectionObjectMother.GetSomeMethod();
_provider.AddMapping(_mutableType, emittableType);
_provider.AddMapping(_mutableGenericParameter, emittableGenericParameter);
_provider.AddMapping(_mutableField, emittableField);
_provider.AddMapping(_mutableConstructor, emittableConstructor);
_provider.AddMapping(_mutableMethod, emittableMethod);
Assert.That(_provider.GetEmittableType(_mutableType), Is.SameAs(emittableType));
Assert.That(_provider.GetEmittableType(_mutableGenericParameter), Is.SameAs(emittableGenericParameter));
Assert.That(_provider.GetEmittableField(_mutableField), Is.SameAs(emittableField));
Assert.That(_provider.GetEmittableConstructor(_mutableConstructor), Is.SameAs(emittableConstructor));
Assert.That(_provider.GetEmittableMethod(_mutableMethod), Is.SameAs(emittableMethod));
}
public void GetConstructorImpl(Binder inputBinder, Binder expectedBinder)
{
Assert.That(_customType.Constructors, Is.Not.Null.And.Not.Empty);
var callingConvention = CallingConventions.Any;
var bindingAttr = BindingFlags.NonPublic;
var typesOrNull = new[] { ReflectionObjectMother.GetSomeType() };
var modifiersOrNull = new[] { new ParameterModifier(1) };
var fakeResult = ReflectionObjectMother.GetSomeConstructor();
_memberSelectorMock
.Setup(mock => mock.SelectSingleMethod(_customType.Constructors, expectedBinder, bindingAttr, null, _customType, typesOrNull, modifiersOrNull))
.Returns(fakeResult)
.Verifiable();
var arguments = new object[] { bindingAttr, inputBinder, callingConvention, typesOrNull, modifiersOrNull };
var result = (ConstructorInfo)PrivateInvoke.InvokeNonPublicMethod(_customType, "GetConstructorImpl", arguments);
_memberSelectorMock.Verify();
Assert.That(result, Is.SameAs(fakeResult));
}
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 SelectSingleMethod_ForConstructors_NameIsNotConsidered()
{
var constructors = new[] { CreateConstructorStub(MethodAttributes.Assembly), CreateConstructorStub(MethodAttributes.Family) };
var bindingFlags = (BindingFlags)1;
var typesOrNull = new[] { typeof(int), typeof(string) };
var modifiersOrNull = new[] { new ParameterModifier(2) };
_bindingFlagsEvaluatorMock.Expect(mock => mock.HasRightAttributes(constructors[0].Attributes, bindingFlags)).Return(false);
_bindingFlagsEvaluatorMock.Expect(mock => mock.HasRightAttributes(constructors[1].Attributes, bindingFlags)).Return(true);
var binderMock = MockRepository.GenerateStrictMock <Binder>();
var fakeResult = ReflectionObjectMother.GetSomeConstructor();
binderMock
.Expect(mock => mock.SelectMethod(bindingFlags, new MethodBase[] { constructors[1] }, typesOrNull, modifiersOrNull))
.Return(fakeResult);
var result = _selector.SelectSingleMethod(constructors, binderMock, bindingFlags, null, _someDeclaringType, typesOrNull, modifiersOrNull);
_bindingFlagsEvaluatorMock.VerifyAllExpectations();
binderMock.VerifyAllExpectations();
Assert.That(result, Is.SameAs(fakeResult));
}
public void SelectSingleMethod_ForConstructors_NameIsNotConsidered()
{
var constructors = new[] { CreateConstructorStub(MethodAttributes.Assembly), CreateConstructorStub(MethodAttributes.Family) };
var bindingFlags = (BindingFlags)1;
var typesOrNull = new[] { typeof(int), typeof(string) };
var modifiersOrNull = new[] { new ParameterModifier(2) };
_bindingFlagsEvaluatorMock.Setup(mock => mock.HasRightAttributes(constructors[0].Attributes, bindingFlags)).Returns(false).Verifiable();
_bindingFlagsEvaluatorMock.Setup(mock => mock.HasRightAttributes(constructors[1].Attributes, bindingFlags)).Returns(true).Verifiable();
var binderMock = new Mock <Binder> (MockBehavior.Strict);
var fakeResult = ReflectionObjectMother.GetSomeConstructor();
binderMock
.Setup(mock => mock.SelectMethod(bindingFlags, It.Is <MethodBase[]> (param => param.SequenceEqual(new MethodBase[] { constructors[1] })), typesOrNull, modifiersOrNull))
.Returns(fakeResult)
.Verifiable();
var result = _selector.SelectSingleMethod(constructors, binderMock.Object, bindingFlags, null, _someDeclaringType, typesOrNull, modifiersOrNull);
_bindingFlagsEvaluatorMock.Verify();
binderMock.Verify();
Assert.That(result, Is.SameAs(fakeResult));
}
public void SetUp()
{
var adaptedConstructor = ReflectionObjectMother.GetSomeConstructor();
_adapter = new ConstructorAsMethodInfoAdapter(adaptedConstructor);
}