public void GetAllMethods()
{
var result = _constrainedParameter.GetAllMethods();
var method = NormalizingMemberInfoFromExpressionUtility.GetMethod((DomainType obj) => obj.Method());
Assert.That(result, Has.Member(method));
Assert.That(result, Is.EquivalentTo(typeof(DomainType).GetMethods(c_allMembers)));
}
public void GetPointcut_StrongContext_ParameterIndex()
{
var advice = NormalizingMemberInfoFromExpressionUtility.GetMethod((DomainType obj) => obj.ParameterIndex(ref _dummy));
var pointcut = CheckPointcut <ArgumentIndexPointcut> (advice);
Assert.That(pointcut.ArgumentType, Is.EqualTo(typeof(string)));
Assert.That(pointcut.Index, Is.EqualTo(1));
}
public void Create_NonGenericMethod()
{
var method = NormalizingMemberInfoFromExpressionUtility.GetMethod((object obj) => obj.Equals(null));
var signature = MethodSignature.Create(method);
Assert.That(signature.ReturnType, Is.SameAs(typeof(bool)));
Assert.That(signature.GenericParameterCount, Is.EqualTo(0));
Assert.That(signature.ParameterTypes, Is.EqualTo(new[] { typeof(object) }));
}
public void IsShadowed_BaseTypeMethod_NotShadowedByItself()
{
var baseDefinition = NormalizingMemberInfoFromExpressionUtility.GetMethod((DomainTypeBase obj) => obj.BaseTypeMethod());
var shadowingCandidates = GetDeclaredMethods(typeof(DomainTypeBase));
var result = _finder.IsShadowed(baseDefinition, shadowingCandidates);
Assert.That(result, Is.False);
}
public void FieldConstant()
{
var template = NormalizingMemberInfoFromExpressionUtility.GetMethod((DomainType o) => o.FieldConstant());
var field = NormalizingMemberInfoFromExpressionUtility.GetField(() => Type.EmptyTypes);
var instance = ReturnMemberInfoViaConstantExpression(template, field);
Assert.That(instance.FieldConstant(), Is.EqualTo(field));
}
public void IsShadowed_VirtualMethodShadowingBaseMethod_NonMatchingSignature()
{
var baseDefinition = NormalizingMemberInfoFromExpressionUtility.GetMethod((DomainTypeBase obj) => obj.VirtualMethodShadowingBaseMethod(7));
var shadowingCandidates = GetDeclaredMethods(typeof(DomainType));
var result = _finder.IsShadowed(baseDefinition, shadowingCandidates);
Assert.That(result, Is.False);
}
public void MethodPointcut()
{
var trueMethod = NormalizingMemberInfoFromExpressionUtility.GetMethod(() => DomainAspect.TruePointcutMethod());
var falseMethod = NormalizingMemberInfoFromExpressionUtility.GetMethod(() => DomainAspect.FalsePointcutMethod());
var joinPoint = ObjectMother.GetJoinPoint();
CheckMatches(new MethodPointcut(trueMethod), joinPoint);
CheckMatchesNot(new MethodPointcut(falseMethod), joinPoint);
}
public void TypeConstant()
{
var template = NormalizingMemberInfoFromExpressionUtility.GetMethod((DomainType o) => o.TypeConstant());
var type = typeof(int);
var instance = ReturnMemberInfoViaConstantExpression(template, type);
Assert.That(instance.TypeConstant(), Is.SameAs(type));
}
public void IsShadowed_OverridingShadowingMethod()
{
var baseDefinition = NormalizingMemberInfoFromExpressionUtility.GetMethod((DomainTypeBaseBase obj) => obj.OverridingShadowingMethod());
var shadowingCandidates = GetDeclaredMethods(typeof(DomainType));
var result = _finder.IsShadowed(baseDefinition, shadowingCandidates);
Assert.That(result, Is.True);
}
public void AddExplicitBaseDefinition_UnrelatedMethod()
{
var unrelatedMethodDefinition = NormalizingMemberInfoFromExpressionUtility.GetMethod((UnrelatedType obj) => obj.VirtualMethod());
Assert.That(
() => _virtualMethod.AddExplicitBaseDefinition(unrelatedMethodDefinition),
Throws.ArgumentException
.With.ArgumentExceptionMessageEqualTo("The overridden method must be from the same type hierarchy.", "overriddenMethodBaseDefinition"));
}
public void AddExplicitBaseDefinition_CannotAddExplicitBaseDefinition()
{
var overriddenMethodDefinition = NormalizingMemberInfoFromExpressionUtility.GetMethod((DomainType obj) => obj.VirtualMethod());
Assert.That(
() => _method.AddExplicitBaseDefinition(overriddenMethodDefinition),
Throws.InstanceOf <NotSupportedException>()
.With.Message.EqualTo("Cannot add an explicit base definition to the non-virtual method 'NonVirtualMethod'."));
}
public void NewDelegate_StaticMethod()
{
var delegateType = typeof(Action);
var staticMethod = NormalizingMemberInfoFromExpressionUtility.GetMethod(() => StaticMethod());
var result = Expression.NewDelegate(delegateType, null, staticMethod);
Assert.That(result.Target, Is.Null);
}
public void GetMemberSignature_Method()
{
var method = NormalizingMemberInfoFromExpressionUtility.GetMethod((DomainType obj) => obj.Method());
var result = MemberSignatureProvider.GetMemberSignature(method);
Assert.That(result, Is.TypeOf <MethodSignature> ());
Assert.That(result.ToString(), Is.EqualTo("System.Double()"));
}
public void SetUp()
{
_interceptedMethod = NormalizingMemberInfoFromExpressionUtility.GetMethod((object o) => o.Equals(null));
_propertyName = "abc";
_interceptor = new WrappingAccessorInterceptor(_interceptedMethod, _propertyName);
_proxyType = MutableTypeObjectMother.Create();
}
public void GetPointcut_AttributeProvider_StrongContext()
{
var advice = NormalizingMemberInfoFromExpressionUtility.GetMethod((DomainType obj) => obj.AttributeAndContext(ref _dummy));
var pointcut = CheckPointcut <AllPointcut> (advice);
Assert.That(pointcut.Pointcuts, Has.Length.EqualTo(2));
Assert.That(pointcut.Pointcuts, Has.Some.TypeOf <TypePointcut>());
Assert.That(pointcut.Pointcuts, Has.Some.TypeOf <MemberNamePointcut>());
}
public void AddExplicitBaseDefinition_IncompatibleSignatures()
{
var differentSignatureMethodDefinition =
NormalizingMemberInfoFromExpressionUtility.GetMethod((DomainType obj) => obj.VirtualMethodWithDifferentSignature(7));
Assert.That(
() => _virtualMethod.AddExplicitBaseDefinition(differentSignatureMethodDefinition),
Throws.ArgumentException
.With.ArgumentExceptionMessageEqualTo("Method signatures must be equal.", "overriddenMethodBaseDefinition"));
}
public void GetBaseDefinition()
{
var baseMethod = NormalizingMemberInfoFromExpressionUtility.GetMethod((DomainType obj) => obj.OverridingMethod());
var rootDefinition = baseMethod.GetBaseDefinition();
Assert.That(rootDefinition, Is.Not.EqualTo(baseMethod));
var method = MutableMethodInfoObjectMother.Create(baseMethod: baseMethod);
Assert.That(method.GetBaseDefinition(), Is.SameAs(rootDefinition));
}
public void InterfaceMethod_AlreadyExplicitlyImplemented()
{
var method = NormalizingMemberInfoFromExpressionUtility.GetMethod((IDomainInterface obj) => obj.ExplicitlyImplemented());
var type = AssembleType <DomainType> (p => p.AddExplicitOverride(method, ctx => Expression.Constant("new explicit impl")));
var instance = Activator.CreateInstance(type);
Assert.That(((IDomainInterface)instance).ExplicitlyImplemented(), Is.EqualTo("new explicit impl"));
}
public void GetOrCreateOverride_UnrelatedDeclaringType()
{
var method = NormalizingMemberInfoFromExpressionUtility.GetMethod((IDisposable obj) => obj.Dispose());
Assert.That(
() => _factory.GetOrCreateOverride(_mutableType, method, out _isNewlyCreated),
Throws.ArgumentException
.With.ArgumentExceptionMessageEqualTo(
"Method is declared by type 'IDisposable' outside of the proxy base class hierarchy.", "overriddenMethod"));
}
public void GetBaseMethod_OverridingOverriddenMethod()
{
var method = NormalizingMemberInfoFromExpressionUtility.GetMethod((DomainType obj) => obj.OverridingOverriddenMethod());
var result = _finder.GetBaseMethod(method);
var expectedMethod = NormalizingMemberInfoFromExpressionUtility.GetMethod((DomainTypeBase obj) => obj.OverridingOverriddenMethod());
Assert.That(result, Is.EqualTo(expectedMethod));
}
public void GetMostDerivedOverride_ShadowingOverridenMethod()
{
var baseDefinition = NormalizingMemberInfoFromExpressionUtility.GetMethod((DomainTypeBaseBase obj) => obj.ShadowingOverridenMethod());
var result = _finder.GetMostDerivedOverride(baseDefinition, _typeToStartSearch);
var expected = NormalizingMemberInfoFromExpressionUtility.GetMethod((DomainTypeBase obj) => obj.ShadowingOverridenMethod());
Assert.That(result, Is.EqualTo(expected));
}
public void NonVirtualBase_ReImplement_BaseNonAccessible()
{
var interfaceMethod = NormalizingMemberInfoFromExpressionUtility.GetMethod((IMyInterface o) => o.Method3());
Assert.That(
() => AssembleType <DomainType> (p => p.GetOrAddImplementation(interfaceMethod).SetBody(ctx => null)),
Throws.InstanceOf <NotSupportedException>()
.With.Message.EqualTo(
"Cannot re-implement interface method 'Method3' because its base implementation on 'DomainType' is not accessible."));
}
public void Modify_Explicit_ExistingOnBase()
{
var interfaceMethod = NormalizingMemberInfoFromExpressionUtility.GetMethod((IBaseInterface obj) => obj.ExplicitlyImplemented());
Assert.That(
() => AssembleType <DomainType> (p => p.GetOrAddImplementation(interfaceMethod)),
Throws.InstanceOf <NotSupportedException>()
.With.Message.EqualTo(
"Cannot re-implement interface method 'ExplicitlyImplemented' because its base implementation on 'DomainTypeBase' is not accessible."));
}
public void TrampolineMethods_MemberInfoEqualityComparer()
{
var method1 = NormalizingMemberInfoFromExpressionUtility.GetMethod((object obj) => obj.ToString());
var method2 = typeof(CodeGenerationContextTest).GetMethod("ToString");
Assert.That(method1, Is.Not.SameAs(method2));
_context.TrampolineMethods.Add(method1, null);
Assert.That(_context.TrampolineMethods.ContainsKey(method2), Is.True);
}
public void IsGenericMethodInstantiation()
{
var nonGenericMethod = ReflectionObjectMother.GetSomeNonGenericMethod();
var genericMethodDefinition = NormalizingMemberInfoFromExpressionUtility.GetGenericMethodDefinition(() => Method <Dev.T, Dev.T>());
var methodInstantiation = NormalizingMemberInfoFromExpressionUtility.GetMethod(() => Method <int, string>());
Assert.That(nonGenericMethod.IsGenericMethodInstantiation(), Is.False);
Assert.That(genericMethodDefinition.IsGenericMethodInstantiation(), Is.False);
Assert.That(methodInstantiation.IsGenericMethodInstantiation(), Is.True);
}
public void GetAttributeFlagsImpl_AbstractCache_Updated_WhenAddingNonAbstractExplicitOverride()
{
var proxyType = MutableTypeObjectMother.Create(baseType: typeof(AbstractTypeBase));
Assert.That(proxyType.IsAbstract, Is.True);
proxyType.AddExplicitOverride(
NormalizingMemberInfoFromExpressionUtility.GetMethod((AbstractTypeBase t) => t.AbstractMethod1()),
c => Expression.Default(c.ReturnType));
Assert.That(proxyType.IsAbstract, Is.False);
}
public void Modify_Implicit()
{
var interfaceMethod = NormalizingMemberInfoFromExpressionUtility.GetMethod((IDomainInterface obj) => obj.Method());
var type = AssembleType <DomainType> (
p => p.GetOrAddImplementation(interfaceMethod)
.SetBody(ctx => ExpressionHelper.StringConcat(ctx.PreviousBody, Expression.Constant(" modified"))));
var instance = (IDomainInterface)Activator.CreateInstance(type);
Assert.That(instance.Method(), Is.EqualTo("DomainType.Method modified"));
}
public void SetUp()
{
_interceptedMethod = NormalizingMemberInfoFromExpressionUtility.GetMethod((object o) => o.Equals(null));
_propertyName = "abc";
_propertyType = typeof(int);
_interceptorPartialMock = MockRepository.GeneratePartialMock <ImplementingAccessorInterceptorBase> (
_interceptedMethod, _propertyName, _propertyType);
_proxyType = MutableTypeObjectMother.Create(typeof(DomainObject));
}
public void Proceed()
{
var instance = new DomainType();
var method = NormalizingMemberInfoFromExpressionUtility.GetMethod((DomainType obj) => obj.Method(""));
var invocation = new FuncContext <DomainType, string, int> (method, instance, "arg", instance.Method);
invocation.Arg1 = "7";
invocation.Proceed();
Assert.That(invocation.ReturnValue, Is.EqualTo(7));
}
public void Initialization()
{
var instance = new DomainType();
var method = NormalizingMemberInfoFromExpressionUtility.GetMethod((DomainType obj) => obj.Method(""));
var invocation = new FuncContext <DomainType, string, int> (method, instance, "arg", instance.Method);
Assert.That(invocation.Instance, Is.SameAs(instance));
Assert.That(invocation.MemberInfo, Is.SameAs(method));
Assert.That(invocation.Arg1, Is.EqualTo("arg"));
}