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 static MethodOnTypeInstantiation Create(TypeInstantiation declaringType = null, MethodInfo method = null)
{
declaringType = declaringType ?? TypeInstantiationObjectMother.Create();
method = method ?? ReflectionObjectMother.GetSomeMethod();
return(new MethodOnTypeInstantiation(declaringType, method));
}
public void SelectSingleMethod()
{
var methods =
new[]
{
CreateMethodStub("Method1", MethodAttributes.Assembly),
CreateMethodStub("This method is filtered because of its name", MethodAttributes.Family),
CreateMethodStub("Method1", MethodAttributes.Public)
};
var bindingFlags = (BindingFlags)1;
var typesOrNull = new[] { typeof(int), typeof(string) };
var modifiersOrNull = new[] { new ParameterModifier(2) };
_bindingFlagsEvaluatorMock.Expect(mock => mock.HasRightAttributes(methods[0].Attributes, bindingFlags)).Return(false);
_bindingFlagsEvaluatorMock.Expect(mock => mock.HasRightAttributes(methods[2].Attributes, bindingFlags)).Return(true);
var binderMock = MockRepository.GenerateStrictMock <Binder>();
var fakeResult = ReflectionObjectMother.GetSomeMethod();
binderMock
.Expect(mock => mock.SelectMethod(bindingFlags, new MethodBase[] { methods[2] }, typesOrNull, modifiersOrNull))
.Return(fakeResult);
var result = _selector.SelectSingleMethod(methods, binderMock, bindingFlags, "Method1", _someDeclaringType, typesOrNull, modifiersOrNull);
_bindingFlagsEvaluatorMock.VerifyAllExpectations();
binderMock.VerifyAllExpectations();
Assert.That(result, Is.SameAs(fakeResult));
}
public void GetEmittableMethod()
{
var method = ReflectionObjectMother.GetSomeMethod();
var emittableMethod = ReflectionObjectMother.GetSomeNonGenericMethod();
CheckGetEmittable(p => p.GetEmittableMethod(method), emittableMethod, emittableMethod.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 SelectSingleMethod()
{
var methods =
new[]
{
CreateMethodStub("Method1", MethodAttributes.Assembly),
CreateMethodStub("This method is filtered because of its name", MethodAttributes.Family),
CreateMethodStub("Method1", MethodAttributes.Public)
};
var bindingFlags = (BindingFlags)1;
var typesOrNull = new[] { typeof(int), typeof(string) };
var modifiersOrNull = new[] { new ParameterModifier(2) };
_bindingFlagsEvaluatorMock.Setup(mock => mock.HasRightAttributes(methods[0].Attributes, bindingFlags)).Returns(false).Verifiable();
_bindingFlagsEvaluatorMock.Setup(mock => mock.HasRightAttributes(methods[2].Attributes, bindingFlags)).Returns(true).Verifiable();
var binderMock = new Mock <Binder> (MockBehavior.Strict);
var fakeResult = ReflectionObjectMother.GetSomeMethod();
binderMock
.Setup(mock => mock.SelectMethod(bindingFlags, It.Is <MethodBase[]> (param => param.SequenceEqual(new MethodBase[] { methods[2] })), typesOrNull, modifiersOrNull))
.Returns(fakeResult)
.Verifiable();
var result = _selector.SelectSingleMethod(methods, binderMock.Object, bindingFlags, "Method1", _someDeclaringType, typesOrNull, modifiersOrNull);
_bindingFlagsEvaluatorMock.Verify();
binderMock.Verify();
Assert.That(result, Is.SameAs(fakeResult));
}
public void IsRunetimeMethodInfo()
{
var runtimeMethod = ReflectionObjectMother.GetSomeMethod();
var customMethod = CustomMethodInfoObjectMother.Create();
Assert.That(runtimeMethod.IsRuntimeMethodInfo(), Is.True);
Assert.That(customMethod.IsRuntimeMethodInfo(), Is.False);
}
public void Adapt_Method()
{
var method = ReflectionObjectMother.GetSomeMethod();
var adapter = NonVirtualCallMethodInfoAdapter.Adapt(method);
Assert.That(adapter.AdaptedMethod, Is.SameAs(method));
}
public void GetEmittableMethod_MethodBuilder()
{
var method = ReflectionObjectMother.GetSomeMethod();
var emittableMethod = ReflectionEmitObjectMother.CreateMethodBuilder();
Assert.That(emittableMethod.GetGenericArguments(), Is.Null);
_innerMock.Stub(stub => stub.GetEmittableMethod(method)).Return(emittableMethod);
_typeAnalyzerMock.Stub(stub => stub.IsStrongNamed(emittableMethod.DeclaringType)).Return(true);
Assert.That(() => _decorator.GetEmittableMethod(method), Throws.Nothing);
}
public void SetUp()
{
_declaringType = MutableTypeObjectMother.Create();
_isStatic = BooleanObjectMother.GetRandomBoolean();
_parameters = new[] { Expression.Parameter(typeof(string)) };
_genericParameters = new[] { ReflectionObjectMother.GetSomeGenericParameter() };
_returnType = ReflectionObjectMother.GetSomeType();
_baseMethod = ReflectionObjectMother.GetSomeMethod();
_context = new TestableMethodBodyContextBase(
_declaringType, _isStatic, _parameters.AsOneTime(), _genericParameters.AsOneTime(), _returnType, _baseMethod);
}
public void GetMethods()
{
Assert.That(_customType.Methods, Is.Not.Null.And.Not.Empty);
var bindingAttr = BindingFlags.NonPublic;
var fakeResult = new[] { ReflectionObjectMother.GetSomeMethod() };
_memberSelectorMock.Expect(mock => mock.SelectMethods(_customType.Methods, bindingAttr, _customType)).Return(fakeResult);
var result = _customType.GetMethods(bindingAttr);
_memberSelectorMock.VerifyAllExpectations();
Assert.That(result, Is.EqualTo(fakeResult));
}
public void Emit_MethodInfo()
{
var method = ReflectionObjectMother.GetSomeMethod();
var fakeEmittableOperand = MockRepository.GenerateStub <MethodInfo> ();
_emittableOperandProviderStub.Stub(stub => stub.GetEmittableMethod(method)).Return(fakeEmittableOperand);
_innerILGeneratorMock.Expect(mock => mock.Emit(OpCodes.Call, fakeEmittableOperand));
_decorator.Emit(OpCodes.Call, method);
_innerILGeneratorMock.VerifyAllExpectations();
}
public void Emit_MethodInfo()
{
var method = ReflectionObjectMother.GetSomeMethod();
var fakeEmittableOperand = new Mock <MethodInfo>().Object;
_emittableOperandProviderStub.Setup(stub => stub.GetEmittableMethod(method)).Returns(fakeEmittableOperand);
_innerILGeneratorMock.Setup(mock => mock.Emit(OpCodes.Call, fakeEmittableOperand)).Verifiable();
_decorator.Emit(OpCodes.Call, method);
_innerILGeneratorMock.Verify();
}
public void AddExplicitOverride()
{
var method = ReflectionObjectMother.GetSomeMethod();
Func <MethodBodyCreationContext, Expression> bodyProvider = ctx => null;
var fakeMethod = MutableMethodInfoObjectMother.Create();
_mutableMemberFactoryMock.Expect(mock => mock.CreateExplicitOverride(_mutableType, method, bodyProvider)).Return(fakeMethod);
var result = _mutableType.AddExplicitOverride(method, bodyProvider);
Assert.That(result, Is.SameAs(fakeMethod));
Assert.That(_mutableType.AddedMethods, Is.EqualTo(new[] { result }));
}
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 GetEmittableMethod_GenericArguments()
{
var method = ReflectionObjectMother.GetSomeMethod();
var emittableMethod = NormalizingMemberInfoFromExpressionUtility.GetMethod(() => GenericMethod <int>());
_innerMock.Setup(stub => stub.GetEmittableMethod(method)).Returns(emittableMethod);
_typeAnalyzerMock.Setup(mock => mock.IsStrongNamed(emittableMethod.DeclaringType)).Returns(true).Verifiable();
_typeAnalyzerMock.Setup(mock => mock.IsStrongNamed(typeof(int))).Returns(true).Verifiable();
var result = _decorator.GetEmittableMethod(method);
_typeAnalyzerMock.Verify();
Assert.That(result, Is.SameAs(emittableMethod));
}
private void CheckExplicitOverrideAction(Action testedAction, MethodInfo overriddenMethod, MutableMethodInfo overridingMethod)
{
var fakeOverriddenMethod = ReflectionObjectMother.GetSomeMethod();
var fakeOverridingMethod = ReflectionObjectMother.GetSomeMethod();
_emittableOperandProviderMock.Setup(mock => mock.GetEmittableMethod(overriddenMethod)).Returns(fakeOverriddenMethod).Verifiable();
_emittableOperandProviderMock.Setup(mock => mock.GetEmittableMethod(overridingMethod)).Returns(fakeOverridingMethod).Verifiable();
_typeBuilderMock.Setup(mock => mock.DefineMethodOverride(fakeOverridingMethod, fakeOverriddenMethod)).Verifiable();
testedAction();
_emittableOperandProviderMock.Verify();
_typeBuilderMock.Verify();
}
public void Emit_MethodInfo_BaseCallMethodInfo_TurnsCallvirt_IntoCall()
{
var method = ReflectionObjectMother.GetSomeMethod();
var fakeEmittableOperand = MockRepository.GenerateStub <MethodInfo> ();
_emittableOperandProviderStub.Stub(stub => stub.GetEmittableMethod(method)).Return(fakeEmittableOperand);
_innerILGeneratorMock.Expect(mock => mock.Emit(OpCodes.Call, fakeEmittableOperand));
var baseAdaptedMethod = new NonVirtualCallMethodInfoAdapter(method);
_decorator.Emit(OpCodes.Callvirt, baseAdaptedMethod);
_innerILGeneratorMock.VerifyAllExpectations();
}
public void Emit_MethodInfo_BaseCallMethodInfo_TurnsCallvirt_IntoCall()
{
var method = ReflectionObjectMother.GetSomeMethod();
var fakeEmittableOperand = new Mock <MethodInfo>().Object;
_emittableOperandProviderStub.Setup(stub => stub.GetEmittableMethod(method)).Returns(fakeEmittableOperand);
_innerILGeneratorMock.Setup(mock => mock.Emit(OpCodes.Call, fakeEmittableOperand)).Verifiable();
var baseAdaptedMethod = new NonVirtualCallMethodInfoAdapter(method);
_decorator.Emit(OpCodes.Callvirt, baseAdaptedMethod);
_innerILGeneratorMock.Verify();
}
public void SetUp()
{
_declaringType = MutableTypeObjectMother.Create();
_isStatic = BooleanObjectMother.GetRandomBoolean();
_parameters = new[] { Expression.Parameter(typeof(int)), Expression.Parameter(typeof(object)) };
_baseMethod = ReflectionObjectMother.GetSomeMethod();
_genericParameters = new[] { ReflectionObjectMother.GetSomeGenericParameter() };
_returnType = ReflectionObjectMother.GetSomeType();
_previousBody = Expression.Block(_parameters[0], _parameters[1]);
_context = new MethodBodyModificationContext(
_declaringType, _isStatic, _parameters.AsOneTime(), _genericParameters.AsOneTime(), _returnType, _baseMethod, _previousBody);
_contextWithoutPreviousBody = new MethodBodyModificationContext(
_declaringType, _isStatic, _parameters, _genericParameters, _returnType, _baseMethod, null);
}
public void GetOrAddOverride_RetrievesExistingOverride()
{
var baseMethod = ReflectionObjectMother.GetSomeMethod();
var fakeOverride = MutableMethodInfoObjectMother.Create();
var isNewlyCreated = false;
_mutableMemberFactoryMock
.Setup(mock => mock.GetOrCreateOverride(_mutableType, baseMethod, out isNewlyCreated))
.Returns(fakeOverride)
.Verifiable();
var result = _mutableType.GetOrAddOverride(baseMethod);
Assert.That(result, Is.SameAs(fakeOverride));
Assert.That(_mutableType.AddedMethods, Has.No.Member(result));
}
public void GetBaseDefinition_ForStandardMethodInfo_Cached()
{
var standardMethodInfoMock = MockRepository.GenerateStrictMock <MethodInfo>();
var fakeMethodDefinition = ReflectionObjectMother.GetSomeMethod();
standardMethodInfoMock.Expect(mock => mock.GetBaseDefinition()).Return(fakeMethodDefinition).Repeat.Once();
var result1 = MethodBaseDefinitionCache.GetBaseDefinition(standardMethodInfoMock);
var result2 = MethodBaseDefinitionCache.GetBaseDefinition(standardMethodInfoMock);
standardMethodInfoMock.VerifyAllExpectations();
Assert.That(result1, Is.SameAs(fakeMethodDefinition));
Assert.That(result2, Is.SameAs(fakeMethodDefinition));
}
public void EmitCall_MethodInfo_BaseCallMethodInfo()
{
var method = ReflectionObjectMother.GetSomeMethod();
var optionalParameterTypes = new[] { ReflectionObjectMother.GetSomeType() };
var fakeEmittableOperand = MockRepository.GenerateStub <MethodInfo> ();
_emittableOperandProviderStub.Stub(stub => stub.GetEmittableMethod(method)).Return(fakeEmittableOperand);
_innerILGeneratorMock.Expect(mock => mock.EmitCall(OpCodes.Call, fakeEmittableOperand, optionalParameterTypes));
var baseAdaptedMethod = new NonVirtualCallMethodInfoAdapter(method);
_decorator.EmitCall(OpCodes.Call, baseAdaptedMethod, optionalParameterTypes);
_innerILGeneratorMock.VerifyAllExpectations();
}
public void GetBaseDefinition_ForStandardMethodInfo_Cached()
{
var standardMethodInfoMock = new Mock <MethodInfo> (MockBehavior.Strict);
var fakeMethodDefinition = ReflectionObjectMother.GetSomeMethod();
standardMethodInfoMock.Setup(mock => mock.GetBaseDefinition()).Returns(fakeMethodDefinition).Verifiable();
var result1 = MethodBaseDefinitionCache.GetBaseDefinition(standardMethodInfoMock.Object);
var result2 = MethodBaseDefinitionCache.GetBaseDefinition(standardMethodInfoMock.Object);
standardMethodInfoMock.Verify();
Assert.That(result1, Is.SameAs(fakeMethodDefinition));
Assert.That(result2, Is.SameAs(fakeMethodDefinition));
}
public void GetEmittableMethod_MethodBuilder()
{
var method = ReflectionObjectMother.GetSomeMethod();
var emittableMethod = ReflectionEmitObjectMother.CreateMethodBuilder();
#if NETFRAMEWORK
// MethodBuilder in .NET Framework returns null for non-generic types.
// MethodInfo returns empty, same as MethodInfo and MethodBuilder do in .NET 5.
Assert.That(emittableMethod.GetGenericArguments(), Is.Null);
#else
Assert.That(emittableMethod.GetGenericArguments(), Is.Empty);
#endif
_innerMock.Setup(stub => stub.GetEmittableMethod(method)).Returns(emittableMethod);
_typeAnalyzerMock.Setup(stub => stub.IsStrongNamed(emittableMethod.DeclaringType)).Returns(true);
Assert.That(() => _decorator.GetEmittableMethod(method), Throws.Nothing);
}
public void SetUp()
{
var identifier = new ConcreteMixinTypeIdentifier(typeof(object), new HashSet <MethodInfo> (), new HashSet <MethodInfo> ());
_nonPublicMethod = ReflectionObjectMother.GetSomeNonPublicMethod();
_publicMethod = ReflectionObjectMother.GetSomePublicMethod();
_wrapperOrInterfaceMethod = ReflectionObjectMother.GetSomeMethod();
_concreteMixinType = new ConcreteMixinType(
identifier,
typeof(object),
typeof(IServiceProvider),
new Dictionary <MethodInfo, MethodInfo> {
{ _nonPublicMethod, _wrapperOrInterfaceMethod }
},
new Dictionary <MethodInfo, MethodInfo> {
{ _nonPublicMethod, _wrapperOrInterfaceMethod }
});
}
public void GetOrAddImplementation_RetrievesExistingImplementation()
{
var interfaceMethod = ReflectionObjectMother.GetSomeMethod();
var fakeImplementation = MutableMethodInfoObjectMother.Create();
_mutableMemberFactoryMock
.Expect(
mock => mock.GetOrCreateImplementation(
Arg.Is(_mutableType),
Arg.Is(interfaceMethod),
out Arg <bool> .Out(false).Dummy))
.Return(fakeImplementation);
var result = _mutableType.GetOrAddImplementation(interfaceMethod);
Assert.That(result, Is.SameAs(fakeImplementation));
Assert.That(_mutableType.AddedMethods, Has.No.Member(result));
}
public void GetOrAddOverride_RetrievesExistingOverride()
{
var baseMethod = ReflectionObjectMother.GetSomeMethod();
var fakeOverride = MutableMethodInfoObjectMother.Create();
_mutableMemberFactoryMock
.Expect(
mock => mock.GetOrCreateOverride(
Arg.Is(_mutableType),
Arg.Is(baseMethod),
out Arg <bool> .Out(false).Dummy))
.Return(fakeOverride);
var result = _mutableType.GetOrAddOverride(baseMethod);
Assert.That(result, Is.SameAs(fakeOverride));
Assert.That(_mutableType.AddedMethods, Has.No.Member(result));
}
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 GetOrAddImplementation_RetrievesExistingImplementation()
{
var interfaceMethod = ReflectionObjectMother.GetSomeMethod();
var fakeImplementation = MutableMethodInfoObjectMother.Create();
var isNewlyCreated = false;
_mutableMemberFactoryMock
.Setup(
mock => mock.GetOrCreateImplementation(
_mutableType,
interfaceMethod,
out isNewlyCreated))
.Returns(fakeImplementation)
.Verifiable();
var result = _mutableType.GetOrAddImplementation(interfaceMethod);
Assert.That(result, Is.SameAs(fakeImplementation));
Assert.That(_mutableType.AddedMethods, Has.No.Member(result));
}