public void GetEmittableField()
{
var field = ReflectionObjectMother.GetSomeField();
var emittableField = ReflectionObjectMother.GetSomeField();
CheckGetEmittable(p => p.GetEmittableField(field), emittableField, emittableField.DeclaringType);
}
public virtual void SetUp()
{
_mockRepository = new MockRepository();
_mutableType = MutableTypeObjectMother.Create();
_nestedTypeCodeGeneratorFactoryMock = _mockRepository.StrictMock <IMutableNestedTypeCodeGeneratorFactory>();
_codeGeneratorMock = _mockRepository.StrictMock <IReflectionEmitCodeGenerator>();
_emittableOperandProviderMock = _mockRepository.StrictMock <IEmittableOperandProvider> ();
_memberEmitterMock = _mockRepository.StrictMock <IMemberEmitter>();
_initializationBuilderMock = _mockRepository.StrictMock <IInitializationBuilder>();
_proxySerializationEnablerMock = _mockRepository.StrictMock <IProxySerializationEnabler>();
_generator = new MutableTypeCodeGenerator(
_mutableType,
_nestedTypeCodeGeneratorFactoryMock,
_codeGeneratorMock,
_emittableOperandProviderMock,
_memberEmitterMock,
_initializationBuilderMock,
_proxySerializationEnablerMock);
_typeBuilderMock = _mockRepository.StrictMock <ITypeBuilder>();
_debugInfoGeneratorMock = _mockRepository.StrictMock <DebugInfoGenerator>();
_fakeInitializationField = ReflectionObjectMother.GetSomeField();
_fakeInitializationMethod = ReflectionObjectMother.GetSomeMethod();
_fakeInitializationMembers = Tuple.Create(_fakeInitializationField, _fakeInitializationMethod);
}
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 Emit_FieldInfo()
{
var field = ReflectionObjectMother.GetSomeField();
var fakeEmittableOperand = MockRepository.GenerateStub <FieldInfo> ();
_emittableOperandProviderStub.Stub(stub => stub.GetEmittableField(field)).Return(fakeEmittableOperand);
_innerILGeneratorMock.Expect(mock => mock.Emit(OpCodes.Ldfld, fakeEmittableOperand));
_decorator.Emit(OpCodes.Ldfld, field);
_innerILGeneratorMock.VerifyAllExpectations();
}
public void Emit_FieldInfo()
{
var field = ReflectionObjectMother.GetSomeField();
var fakeEmittableOperand = new Mock <FieldInfo>().Object;
_emittableOperandProviderStub.Setup(stub => stub.GetEmittableField(field)).Returns(fakeEmittableOperand);
_innerILGeneratorMock.Setup(mock => mock.Emit(OpCodes.Ldfld, fakeEmittableOperand)).Verifiable();
_decorator.Emit(OpCodes.Ldfld, field);
_innerILGeneratorMock.Verify();
}
public void GetFields()
{
Assert.That(_customType.Fields, Is.Not.Null.And.Not.Empty);
var bindingAttr = BindingFlags.NonPublic;
var fakeResult = new[] { ReflectionObjectMother.GetSomeField() };
_memberSelectorMock.Expect(mock => mock.SelectFields(_customType.Fields, bindingAttr, _customType)).Return(fakeResult);
var result = _customType.GetFields(bindingAttr);
_memberSelectorMock.VerifyAllExpectations();
Assert.That(result, Is.EqualTo(fakeResult));
}
public void GetField()
{
Assert.That(_customType.Fields, Is.Not.Null.And.Not.Empty);
var name = "some name";
var bindingAttr = BindingFlags.NonPublic;
var fakeResult = ReflectionObjectMother.GetSomeField();
_memberSelectorMock.Expect(mock => mock.SelectSingleField(_customType.Fields, bindingAttr, name, _customType)).Return(fakeResult);
var resultField = _customType.GetField(name, bindingAttr);
_memberSelectorMock.VerifyAllExpectations();
Assert.That(resultField, Is.SameAs(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 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 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));
}
