public void BaseMethodWithoutOverride()
{
var baseMethod = NormalizingMemberInfoFromExpressionUtility.GetMethod <DomainTypeBase> (x => x.BaseMethod());
var type = AssembleType <DomainType> (
proxyType =>
{
var mutableMethod = proxyType.GetOrAddOverride(baseMethod);
Assert.That(mutableMethod.BaseMethod, Is.EqualTo(baseMethod));
Assert.That(mutableMethod.AddedExplicitBaseDefinitions, Is.Empty);
CheckBodyOfAddedOverride(baseMethod, mutableMethod);
mutableMethod.SetBody(ctx => ExpressionHelper.StringConcat(ctx.PreviousBody, Expression.Constant(" made mutable")));
Assert.That(proxyType.GetOrAddOverride(baseMethod), Is.SameAs(mutableMethod));
});
var implicitOverride = type.GetMethod(baseMethod.Name);
Assert.That(implicitOverride.DeclaringType, Is.SameAs(type));
var instance = (DomainType)Activator.CreateInstance(type);
var result = implicitOverride.Invoke(instance, null);
Assert.That(result, Is.EqualTo("Base made mutable"));
Assert.That(instance.BaseMethod(), Is.EqualTo("Base made mutable"));
}
public void MakeSerializable_SerializableInterfaceType()
{
var proxyType = MutableTypeObjectMother.Create(typeof(SerializableInterfaceType), attributes: TypeAttributes.Serializable);
_enabler.MakeSerializable(proxyType, _participantConfigurationID, _assembledTypeIdentifierProviderStub.Object, _typeID);
Assert.That(proxyType.AddedInterfaces, Is.Empty);
Assert.That(proxyType.AddedMethods, Has.Count.EqualTo(1));
var baseMethod = NormalizingMemberInfoFromExpressionUtility.GetMethod((SerializableInterfaceType o) => o.GetObjectData(null, new StreamingContext()));
var method = proxyType.AddedMethods.Single();
var serializationInfo = method.ParameterExpressions[0];
var expectedBody = Expression.Block(
Expression.Call(new ThisExpression(proxyType), new NonVirtualCallMethodInfoAdapter(baseMethod), method.ParameterExpressions.Cast <Expression>()),
Expression.Block(
Expression.Call(serializationInfo, "SetType", Type.EmptyTypes, Expression.Constant(typeof(ObjectWithDeserializationConstructorProxy))),
Expression.Call(
serializationInfo,
"AddValue",
Type.EmptyTypes,
Expression.Constant("<tp>participantConfigurationID"),
Expression.Constant(_participantConfigurationID)),
Expression.Call(serializationInfo, "AddValue", Type.EmptyTypes, Expression.Constant("<tp>assembledTypeIDData"), _assembledTypeIDData)));
ExpressionTreeComparer.CheckAreEqualTrees(expectedBody, method.Body);
}
public void Static()
{
var type = AssembleType <DomainType> (
proxyType =>
{
var staticField = NormalizingMemberInfoFromExpressionUtility.GetField(() => DomainType.StaticDelegateField);
var accessorAttributes = MethodAttributes.Private | MethodAttributes.Static;
var method = proxyType.AddMethod(
"StaticMethod",
accessorAttributes,
typeof(void),
new[] { new ParameterDeclaration(typeof(Action), "handler") },
ctx => Expression.Assign(Expression.Field(null, staticField), ctx.Parameters.Single()));
proxyType.AddEvent("StaticEvent", EventAttributes.SpecialName, addMethod: method, removeMethod: method);
});
var event_ = type.GetEvent("StaticEvent", BindingFlags.NonPublic | BindingFlags.Static);
Assertion.IsNotNull(event_);
Assert.That(event_.Attributes, Is.EqualTo(EventAttributes.SpecialName));
Assert.That(DomainType.StaticDelegateField, Is.Null);
var handler = new Action(() => { });
// event_.AddEventHandler(null, handler) // Does not work because add method is private.
event_.GetAddMethod(true).Invoke(null, new object[] { handler });
Assert.That(DomainType.StaticDelegateField, Is.SameAs(handler));
}
public void ModifyingNonVirtualAndStaticAndFinalMethods_Throws()
{
var nonVirtualMethod = NormalizingMemberInfoFromExpressionUtility.GetMethod((DomainType obj) => obj.PublicMethod());
var staticMethod = NormalizingMemberInfoFromExpressionUtility.GetMethod(() => DomainType.PublicStaticMethod());
var finalMethod = NormalizingMemberInfoFromExpressionUtility.GetMethod((DomainType obj) => obj.FinalMethod());
var type = AssembleType <DomainType> (
proxyType =>
{
var message = "Only virtual methods can be overridden.";
Assert.That(
() => proxyType.GetOrAddOverride(nonVirtualMethod),
Throws.TypeOf <ArgumentException>().With.Message.StartsWith(message));
Assert.That(
() => proxyType.GetOrAddOverride(staticMethod),
Throws.TypeOf <ArgumentException>().With.Message.StartsWith(message));
Assert.That(
() => proxyType.GetOrAddOverride(finalMethod),
Throws.TypeOf <NotSupportedException>().With.Message.EqualTo("Cannot override final method 'DomainType.FinalMethod'."));
});
var instance = (DomainType)Activator.CreateInstance(type);
Assert.That(instance.PublicMethod(), Is.EqualTo(12));
var method = type.GetMethod("PublicStaticMethod", BindingFlags.Public | BindingFlags.Static | BindingFlags.FlattenHierarchy);
Assert.That(method.Invoke(null, null), Is.EqualTo(13));
}
public override void SetUp()
{
base.SetUp();
_signedType = typeof(int);
_unsignedType = CreateUnsignedType(TypeAttributes.Class, typeof(object));
_signedInterfaceType = typeof(IMarkerInterface);
_unsignedInterfaceType = CreateUnsignedType(TypeAttributes.Interface | TypeAttributes.Abstract, baseType: null);
_signedDelegateType = typeof(Action);
_unsignedDelegateType = typeof(Action <>).MakeGenericType(_unsignedType);
var attributeCtor = NormalizingMemberInfoFromExpressionUtility.GetConstructor(() => new AbcAttribute(null));
_signedAttribute = new CustomAttributeDeclaration(attributeCtor, new object[] { _signedType });
_unsignedAttribute = new CustomAttributeDeclaration(attributeCtor, new object[] { _unsignedType });
_signedField = NormalizingMemberInfoFromExpressionUtility.GetField(() => DomainType.Field);
_unsignedField = _unsignedType.GetField("field");
_signedCtor = NormalizingMemberInfoFromExpressionUtility.GetConstructor(() => new DomainType());
_unsignedCtor = _unsignedType.GetConstructors().Single();
_signedMethod = NormalizingMemberInfoFromExpressionUtility.GetMethod(() => DomainType.Method());
_unsignedMethod = _unsignedType.GetMethod("method");
_signedVarArgsMethod = typeof(DomainType).GetMethod("VarArgsMethod");
_unsignedVarArgsMethod = _unsignedType.GetMethod("varargs");
}
private IPipeline CreatePipeline()
{
var field = NormalizingMemberInfoFromExpressionUtility.GetField((DomainType obj) => obj.String);
var participant = CreateParticipant(
proxyType =>
{
Assert.That(proxyType.Initialization.Expressions, Is.Empty);
proxyType.AddInitialization(
ctx =>
{
Assert.That(ctx.IsStatic, Is.False);
var fieldExpr = Expression.Field(ctx.This, field);
return(Expression.Assign(
fieldExpr,
ExpressionHelper.StringConcat(
fieldExpr,
Expression.Condition(
Expression.Equal(ctx.InitializationSemantics, Expression.Constant(InitializationSemantics.Construction)),
Expression.Constant("construction"),
Expression.Constant(" deserialization")))));
});
Assert.That(proxyType.Initialization.Expressions, Is.Not.Empty);
});
return(CreatePipeline(new[] { participant }));
}
public override void SetUp()
{
base.SetUp();
_invokeLambda = NormalizingMemberInfoFromExpressionUtility.GetMethod((DomainType obj) => obj.InvokeLambda(7));
_returnLambda = NormalizingMemberInfoFromExpressionUtility.GetMethod((DomainType obj) => obj.ReturnLambda(7));
}
public void Initialization()
{
var constructor = NormalizingMemberInfoFromExpressionUtility.GetConstructor(() => new DomainAttribute((ValueType)null));
var property = NormalizingMemberInfoFromExpressionUtility.GetProperty((DomainAttribute obj) => obj.Property);
var field = NormalizingMemberInfoFromExpressionUtility.GetField((DomainAttribute obj) => obj.Field);
var declaration = new CustomAttributeDeclaration(
constructor,
new object[] { 7 },
new NamedArgumentDeclaration(property, 7),
new NamedArgumentDeclaration(field, "value"));
Assert.That(declaration.Type, Is.SameAs(typeof(DomainAttribute)));
Assert.That(declaration.Constructor, Is.SameAs(constructor));
Assert.That(declaration.ConstructorArguments, Is.EqualTo(new[] { 7 }));
var actualNamedArguments = declaration.NamedArguments.Select(na => new { na.MemberInfo, na.Value });
var expectedNamedArguments =
new[]
{
new { MemberInfo = (MemberInfo)property, Value = (object)7 },
new { MemberInfo = (MemberInfo)field, Value = (object)"value" }
};
Assert.That(actualNamedArguments, Is.EqualTo(expectedNamedArguments));
}
public void Initialization_MemberDeclaringTypesAreAssignable()
{
var constructor = NormalizingMemberInfoFromExpressionUtility.GetConstructor(() => new DomainAttribute());
var property = typeof(DomainAttribute).GetProperty("Property");
new CustomAttributeDeclaration(constructor, new object[0], new NamedArgumentDeclaration(property, 7));
}
public void CreateMethod_ImplicitOverride()
{
var fakeOverridenMethod = NormalizingMemberInfoFromExpressionUtility.GetMethod((B obj) => obj.OverrideHierarchy(7));
_relatedMethodFinderMock
.Setup(mock => mock.GetMostDerivedVirtualMethod("Method", new MethodSignature(typeof(int), Type.EmptyTypes, 0), _mutableType.BaseType))
.Returns(fakeOverridenMethod)
.Verifiable();
Func <MethodBodyCreationContext, Expression> bodyProvider = ctx =>
{
Assert.That(ctx.HasBaseMethod, Is.True);
Assert.That(ctx.BaseMethod, Is.SameAs(fakeOverridenMethod));
return(Expression.Default(typeof(int)));
};
var method = CallCreateMethod(
_mutableType,
"Method",
MethodAttributes.Public | MethodAttributes.Virtual,
typeof(int),
ParameterDeclaration.None,
bodyProvider);
_relatedMethodFinderMock.Verify();
Assert.That(method.BaseMethod, Is.EqualTo(fakeOverridenMethod));
Assert.That(method.GetBaseDefinition(), Is.EqualTo(fakeOverridenMethod.GetBaseDefinition()));
}
public void Initialization_InvalidMemberDeclaringType()
{
var constructor = NormalizingMemberInfoFromExpressionUtility.GetConstructor(() => new DomainAttribute());
var property = NormalizingMemberInfoFromExpressionUtility.GetProperty((DerivedAttribute attr) => attr.PropertyInDerivedType);
new CustomAttributeDeclaration(constructor, new object[0], new NamedArgumentDeclaration(property, 7));
}
public void WriteOnly_Public_Instance()
{
var type = AssembleType <DomainType> (
proxyType =>
{
var field = NormalizingMemberInfoFromExpressionUtility.GetField((DomainType o) => o.PublicField);
var setMethod = proxyType.AddMethod(
"InstanceSetMethod",
MethodAttributes.Public,
typeof(void),
new[] { new ParameterDeclaration(typeof(string), "value") },
ctx => Expression.Assign(Expression.Field(ctx.This, field), ctx.Parameters[0]));
proxyType.AddProperty("InstanceProperty", PropertyAttributes.None, getMethod: null, setMethod: setMethod);
});
var nonExistingStaticProperty = type.GetProperty("InstanceProperty", BindingFlags.Public | BindingFlags.Static);
Assert.That(nonExistingStaticProperty, Is.Null);
var property = type.GetProperty("InstanceProperty", BindingFlags.Public | BindingFlags.Instance);
CheckSignature(property, CallingConventions.HasThis | CallingConventions.Standard);
var instance = (DomainType)Activator.CreateInstance(type);
property.SetValue(instance, "test", null);
Assert.That(instance.PublicField, Is.EqualTo("test"));
}
public void OverrideExisting_AddCustomAttribute()
{
var type = AssembleType <DomainType> (
proxyType =>
{
var existingProperty = NormalizingMemberInfoFromExpressionUtility.GetProperty((DomainType obj) => obj.ExistingProperty);
var getMethod = proxyType.GetOrAddOverride(existingProperty.GetGetMethod());
var setMethod = proxyType.GetOrAddOverride(existingProperty.GetSetMethod());
var property = proxyType.AddProperty(existingProperty.Name, PropertyAttributes.None, getMethod, setMethod);
var attributeCtor = NormalizingMemberInfoFromExpressionUtility.GetConstructor(() => new AbcAttribute(""));
var customAttributes = new CustomAttributeDeclaration(attributeCtor, new object[] { "derived" });
property.AddCustomAttribute(customAttributes);
});
var newProperty = type.GetProperty("ExistingProperty");
var instance = (DomainType)Activator.CreateInstance(type);
Assert.That(instance.ExistingProperty, Is.Null);
Assert.That(newProperty.GetValue(instance, null), Is.Null);
newProperty.SetValue(instance, "Test", null);
Assert.That(instance.ExistingProperty, Is.EqualTo("Test"));
Assert.That(newProperty.GetValue(instance, null), Is.EqualTo("Test"));
var attributeArgs = Attribute.GetCustomAttributes(newProperty, inherit: true).Cast <AbcAttribute>().Select(a => a.Arg);
Assert.That(attributeArgs, Is.EquivalentTo(new[] { "base", "derived" }));
}
public void IndexParameters()
{
var type = AssembleType <DomainType> (
proxyType =>
{
var field = NormalizingMemberInfoFromExpressionUtility.GetField((DomainType o) => o.PublicField);
proxyType.AddProperty(
"Property",
typeof(string),
new[] { new ParameterDeclaration(typeof(string), "index0"), new ParameterDeclaration(typeof(string), "index1") },
MethodAttributes.Public,
getBodyProvider: ctx =>
{
Assert.That(ctx.ReturnType, Is.SameAs(typeof(string)));
Assert.That(ctx.Parameters.Count, Is.EqualTo(2));
return(ExpressionHelper.StringConcat(ctx.Parameters[0], ctx.Parameters[1]));
},
setBodyProvider: ctx =>
{
Assert.That(ctx.ReturnType, Is.SameAs(typeof(void)));
Assert.That(ctx.Parameters.Count, Is.EqualTo(3));
var value = ExpressionHelper.StringConcat(ExpressionHelper.StringConcat(ctx.Parameters[0], ctx.Parameters[1]), ctx.Parameters[2]);
return(Expression.Assign(Expression.Field(ctx.This, field), value));
});
});
var property = type.GetProperty("Property");
var instance = (DomainType)Activator.CreateInstance(type);
Assert.That(property.GetValue(instance, new object[] { "a ", "b" }), Is.EqualTo("a b"));
property.SetValue(instance, "value", new object[] { "a ", "b " });
Assert.That(instance.PublicField, Is.EqualTo("a b value"));
}
public void GenericParameters()
{
var method1 = NormalizingMemberInfoFromExpressionUtility.GetMethod((DomainType o) => o.ReferenceType());
var method2 = NormalizingMemberInfoFromExpressionUtility.GetMethod((DomainType o) => o.ValueType());
var method3 = NormalizingMemberInfoFromExpressionUtility.GetGenericMethodDefinition((DomainType o) => o.Unconstrained <Dev.T>());
var method4 = NormalizingMemberInfoFromExpressionUtility.GetGenericMethodDefinition((DomainType o) => o.ReferenceTypeConstraint <Dev.T>());
var method5 = NormalizingMemberInfoFromExpressionUtility.GetGenericMethodDefinition((DomainType o) => o.NotNuallableValueTypeConstraint <int>());
var method6 = NormalizingMemberInfoFromExpressionUtility.GetGenericMethodDefinition((DomainType o) => o.ClassBaseTypeConstraint <DomainType>());
var type = AssembleType <DomainType> (
proxyType =>
{
proxyType.GetOrAddOverride(method1).SetBody(ctx => Expression.Default(typeof(string)));
proxyType.GetOrAddOverride(method2).SetBody(ctx => Expression.Default(typeof(int)));
proxyType.GetOrAddOverride(method3).SetBody(ctx => Expression.Default(ctx.GenericParameters[0]));
proxyType.GetOrAddOverride(method4).SetBody(ctx => Expression.Default(ctx.GenericParameters[0]));
proxyType.GetOrAddOverride(method5).SetBody(ctx => Expression.Default(ctx.GenericParameters[0]));
proxyType.GetOrAddOverride(method6).SetBody(ctx => Expression.Default(ctx.GenericParameters[0]));
});
var instance = (DomainType)Activator.CreateInstance(type);
Assert.That(instance.ReferenceType(), Is.Null);
Assert.That(instance.Unconstrained <string>(), Is.Null);
Assert.That(instance.ReferenceTypeConstraint <string>(), Is.Null);
Assert.That(instance.NotNuallableValueTypeConstraint <int>(), Is.EqualTo(0));
Assert.That(instance.ClassBaseTypeConstraint <DomainType>(), Is.Null);
}
private CustomAttributeDeclaration CreateMultipleAttribute(string value)
{
var constructor = NormalizingMemberInfoFromExpressionUtility.GetConstructor(() => new MultipleAttribute());
var field = NormalizingMemberInfoFromExpressionUtility.GetField((MultipleAttribute obj) => obj.String);
return(new CustomAttributeDeclaration(constructor, new object[0], new NamedArgumentDeclaration(field, value)));
}
public override void Participate(object id, IProxyTypeAssemblyContext proxyTypeAssemblyContext)
{
var constructor = NormalizingMemberInfoFromExpressionUtility.GetConstructor(() => new ModifiedAssembledTypeAttribute());
var attribute = new CustomAttributeDeclaration(constructor, new object[0]);
proxyTypeAssemblyContext.ProxyType.AddCustomAttribute(attribute);
}
public void ComputeMapping_AddedInterface_NotFullyImplemented_AllowPartial()
{
_mutableType.AddInterface(typeof(IDisposable));
var interfaceMethod = NormalizingMemberInfoFromExpressionUtility.GetMethod((IDisposable obj) => obj.Dispose());
CallComputeMappingAndCheckResult(_mutableType, typeof(IDisposable), Tuple.Create(interfaceMethod, (MethodInfo)null));
}
public void ReImplement()
{
var interfaceMethod = NormalizingMemberInfoFromExpressionUtility.GetMethod((IInterfaceWithMethod o) => o.Method());
var type = AssembleType <DomainTypeWithMethod> (
proxyType =>
{
proxyType.AddInterface(typeof(IInterfaceWithMethod));
var mutableMethod = AddEquivalentMethod(
proxyType,
interfaceMethod,
MethodAttributes.Public | MethodAttributes.Virtual | MethodAttributes.NewSlot,
ctx =>
{
Assert.That(ctx.HasBaseMethod, Is.False);
return(Expression.Constant("new implementation"));
});
Assert.That(mutableMethod.BaseMethod, Is.Null);
Assert.That(mutableMethod.GetBaseDefinition(), Is.EqualTo(mutableMethod));
});
var instance = (DomainTypeWithMethod)Activator.CreateInstance(type);
Assert.That(instance.Method(), Is.EqualTo("original implementation"));
Assert.That(((IInterfaceWithMethod)instance).Method(), Is.EqualTo("new implementation"));
}
public void ComputeMapping_ExistingInterface()
{
var implicitImplementation1 = NormalizingMemberInfoFromExpressionUtility.GetMethod((DomainType obj) => obj.Method11());
var implicitImplementation2 = NormalizingMemberInfoFromExpressionUtility.GetMethod((DomainType obj) => obj.Method12());
var explicitImplementation = _mutableType.AddMethod("ExplicitImpl", MethodAttributes.Virtual);
explicitImplementation.AddExplicitBaseDefinition(_existingInterfaceMethod2);
_interfaceMapProviderMock
.Setup(mock => mock.Get(typeof(IExistingInterface)))
.Returns(
new InterfaceMapping
{
InterfaceType = typeof(IExistingInterface),
InterfaceMethods = new[] { _existingInterfaceMethod1, _existingInterfaceMethod2 },
TargetMethods = new[] { implicitImplementation1, implicitImplementation2 }
})
.Verifiable();
CallComputeMappingAndCheckResult(
_mutableType,
typeof(IExistingInterface),
Tuple.Create(_existingInterfaceMethod1, implicitImplementation1),
Tuple.Create(_existingInterfaceMethod2, (MethodInfo)explicitImplementation));
}
public void CreateBody_BuildsCorrectBody_UsingAbstractTemplateMembers()
{
var accessorImplementationMethod =
NormalizingMemberInfoFromExpressionUtility.GetGenericMethodDefinition((PropertyAccessor a) => a.SetValue <object> (null));
var arguments = new Expression[] { Expression.Parameter(typeof(int), "param") };
var ctx = new MethodBodyModificationContext(_proxyType, false, new ParameterExpression[0], Type.EmptyTypes, typeof(int), null, null);
_interceptorPartialMock
.Stub(stub => PrivateInvoke.GetNonPublicProperty(stub, "AccessorImplementationMethod"))
.Return(accessorImplementationMethod);
_interceptorPartialMock
.Stub(stub => PrivateInvoke.InvokeNonPublicMethod(stub, "GetArguments", Arg <MethodBaseBodyContextBase> .Is.Anything))
.WhenCalled(mi => Assert.That(mi.Arguments[0], Is.SameAs(ctx)))
.Return(arguments);
var result = (Expression)PrivateInvoke.InvokeNonPublicMethod(_interceptorPartialMock, "CreateBody", ctx);
var expectedbody =
Expression.Call(
Expression.Call(
Expression.Property(
new ThisExpression(_proxyType),
typeof(DomainObject).GetProperty("Properties", BindingFlags.Instance | BindingFlags.NonPublic)),
"get_Item",
null,
Expression.Constant("abc")),
"SetValue",
new[] { typeof(int) },
arguments);
ExpressionTreeComparer.CheckAreEqualTrees(expectedbody, result);
}
public void NoBase_Implement()
{
var interfaceMethod = NormalizingMemberInfoFromExpressionUtility.GetMethod((IAddedInterface o) => o.AddedMethod());
var type = AssembleType <DomainType> (
p =>
{
p.AddInterface(typeof(IAddedInterface));
var method = p.GetOrAddImplementation(interfaceMethod);
Assert.That(method, Is.SameAs(p.GetOrAddImplementation(interfaceMethod)));
method.SetBody(
ctx =>
{
Assert.That(ctx.HasBaseMethod, Is.False);
Assert.That(ctx.HasPreviousBody, Is.False);
return(Expression.Constant("added"));
});
});
var instance = (IAddedInterface)Activator.CreateInstance(type);
Assert.That(instance.AddedMethod(), Is.EqualTo("added"));
}
public void GetAdviceBuilders_Inheriting()
{
var method = NormalizingMemberInfoFromExpressionUtility.GetMethod((DomainType obj) => obj.InheritMethod());
var baseMethod = NormalizingMemberInfoFromExpressionUtility.GetMethod((DomainTypeBase obj) => obj.InheritMethod());
_customAttributeDataHelperMock
.Stub(x => x.AllowsMultiple(Arg <ICustomAttributeData> .Is.Anything))
.Return(true).Repeat.Any();
_customAttributeDataHelperMock
.Stub(x => x.IsAspectAttribute(Arg <ICustomAttributeData> .Is.Anything))
.Return(true).Repeat.Any();
_customAttributeDataHelperMock
.Expect(x => x.IsInheriting(Arg <ICustomAttributeData> .Matches(y => y.Constructor.DeclaringType == typeof(InheritingAttribute))))
.Return(true);
_customAttributeDataHelperMock
.Expect(x => x.IsInheriting(Arg <ICustomAttributeData> .Matches(y => y.Constructor.DeclaringType == typeof(NotInheritingAttribute))))
.Return(false);
_attributeDeclarationProviderMock
.Expect(x => x.GetAdviceBuilders(Arg <ICustomAttributeData> .Matches(y => y.Constructor.DeclaringType == typeof(InheritingAttribute))))
.Return(new[] { _fakeAdviceBuilder1 });
var result = _provider.GetAdviceBuilders(method, new[] { method, baseMethod }).ToArray();
_customAttributeDataHelperMock.VerifyAllExpectations();
_attributeDeclarationProviderMock.VerifyAllExpectations();
Assert.That(result, Is.EquivalentTo(new[] { _fakeAdviceBuilder1 }));
}
public void VirtualBase_Overrides()
{
var interfaceMethod = NormalizingMemberInfoFromExpressionUtility.GetMethod((IMyInterface o) => o.Method1());
var baseMethod = NormalizingMemberInfoFromExpressionUtility.GetMethod((DomainType o) => o.Method1());
var type = AssembleType <DomainType> (
p =>
{
var method = p.GetOrAddImplementation(interfaceMethod);
Assert.That(method, Is.SameAs(p.GetOrAddImplementation(interfaceMethod)));
method.SetBody(ctx =>
{
Assert.That(ctx.BaseMethod, Is.EqualTo(baseMethod));
Assert.That(ctx.DeclaringType.AddedInterfaces, Is.Empty);
return(ExpressionHelper.StringConcat(ctx.PreviousBody, Expression.Constant(" override")));
});
});
var overrideMethod = GetDeclaredMethod(type, "Method1");
Assert.That(overrideMethod.Attributes.IsSet(MethodAttributes.VtableLayoutMask, MethodAttributes.ReuseSlot), Is.True);
var instance = (DomainType)Activator.CreateInstance(type);
var result1 = instance.Method1();
var result2 = instance.As <IMyInterface>().Method1();
Assert.That(result1, Is.EqualTo("1 override"));
Assert.That(result2, Is.EqualTo("1 override"));
}
public void Implement_InvalidCandidates()
{
var interfaceMethod1 = NormalizingMemberInfoFromExpressionUtility.GetMethod((IInvalidCandidates obj) => obj.NonPublicCandidate());
var interfaceMethod2 = NormalizingMemberInfoFromExpressionUtility.GetMethod((IInvalidCandidates obj) => obj.NonVirtualCandidate());
AssembleType <DomainType> (
proxyType =>
{
proxyType.AddMethod(
"NonPublicCandidate", MethodAttributes.Assembly | MethodAttributes.Virtual, typeof(void), ParameterDeclaration.None, ctx => Expression.Empty());
proxyType.AddMethod("NonVirtualCandidate", MethodAttributes.Public, typeof(void), ParameterDeclaration.None, ctx => Expression.Empty());
proxyType.AddInterface(typeof(IInvalidCandidates));
var messageFormat = "Interface method '{0}' cannot be implemented because a method with equal name and signature already exists. "
+ "Use AddExplicitOverride to create an explicit implementation.";
Assert.That(
() => proxyType.GetOrAddImplementation(interfaceMethod1),
Throws.InvalidOperationException.With.Message.EqualTo(string.Format(messageFormat, interfaceMethod1.Name)));
Assert.That(
() => proxyType.GetOrAddImplementation(interfaceMethod2),
Throws.InvalidOperationException.With.Message.EqualTo(string.Format(messageFormat, interfaceMethod2.Name)));
// Implement the interface, otherwise the type is invalid and cannot be generated.
proxyType.AddExplicitOverride(interfaceMethod1, ctx => Expression.Empty());
proxyType.AddExplicitOverride(interfaceMethod2, ctx => Expression.Empty());
});
}
public void NonVirtualBase_ReImplements_AndCallsBase()
{
var interfaceMethod = NormalizingMemberInfoFromExpressionUtility.GetMethod((IMyInterface o) => o.Method2());
var type = AssembleType <DomainType> (
p =>
{
var method = p.GetOrAddImplementation(interfaceMethod);
Assert.That(method, Is.SameAs(p.GetOrAddImplementation(interfaceMethod)));
method.SetBody(ctx =>
{
Assert.That(ctx.HasBaseMethod, Is.False);
Assert.That(p.AddedInterfaces, Is.EqualTo(new[] { typeof(IMyInterface) }));
return(ExpressionHelper.StringConcat(ctx.PreviousBody, Expression.Constant(" re-implementation")));
});
});
var reImplementMethod = GetDeclaredMethod(type, "Method2");
Assert.That(reImplementMethod.Attributes.IsSet(MethodAttributes.NewSlot), Is.True);
var instance = (DomainType)Activator.CreateInstance(type);
var result1 = instance.Method2();
var result2 = instance.As <IMyInterface>().Method2();
Assert.That(result1, Is.EqualTo("2"));
Assert.That(result2, Is.EqualTo("2 re-implementation"));
}
public void Override_UsingAccesssors()
{
var dummyRaiseMethod = NormalizingMemberInfoFromExpressionUtility.GetMethod((DomainType o) => o.DummyRaiseMethod(7));
var type = AssembleType <DomainType> (
proxyType =>
{
var existingEvent = proxyType.GetEvent("ExistingEvent");
var addMethod = proxyType.GetOrAddOverride(existingEvent.GetAddMethod());
var removeMethod = proxyType.GetOrAddOverride(existingEvent.GetRemoveMethod());
Assert.That(existingEvent.GetRaiseMethod(true), Is.Null);
var raiseMethod = proxyType.GetOrAddOverride(dummyRaiseMethod);
proxyType.AddEvent(existingEvent.Name, EventAttributes.None, addMethod, removeMethod, raiseMethod);
});
var newEvent = type.GetEvent("ExistingEvent", BindingFlags.Public | BindingFlags.Instance);
Assertion.IsNotNull(newEvent);
var instance = (DomainType)Activator.CreateInstance(type);
Assert.That(instance.AddCalled, Is.False);
Assert.That(instance.RemoveCalled, Is.False);
newEvent.AddEventHandler(instance, null);
Assert.That(instance.AddCalled, Is.True);
newEvent.RemoveEventHandler(instance, null);
Assert.That(instance.RemoveCalled, Is.True);
var newRaiseMethod = type.GetMethod("DummyRaiseMethod");
Assert.That(newEvent.GetRaiseMethod(), Is.SameAs(newRaiseMethod));
}
public void GetMostDerivedVirtualMethod_NonVirtualMethod()
{
var method = NormalizingMemberInfoFromExpressionUtility.GetMethod((DomainType obj) => obj.NonVirtualMethod());
var result = _finder.GetMostDerivedVirtualMethod(method.Name, _methodSignature, _typeToStartSearch);
Assert.That(result, Is.Null);
}
public void ProxyIsBaseTypeOfNewClass()
{
// public class Proxy : DomainType {
// public override string Method () { return base.Method() + " Proxy"; }
// }
// public class ProxyProxy : Proxy {
// public override string Method () { return base.Method() + " ProxyProxy"; }
// }
var method = NormalizingMemberInfoFromExpressionUtility.GetMethod((DomainType o) => o.Method());
string newClassName = null;
var type = AssembleType <DomainType> (
typeContext =>
{
var proxy = typeContext.ProxyType;
proxy.GetOrAddOverride(method).SetBody(ctx => ExpressionHelper.StringConcat(ctx.PreviousBody, Expression.Constant(" Proxy")));
var proxyProxy = typeContext.CreateAddtionalProxyType(new object(), proxy);
proxyProxy.GetOrAddOverride(method).SetBody(ctx => ExpressionHelper.StringConcat(ctx.PreviousBody, Expression.Constant(" ProxyProxy")));
newClassName = proxyProxy.FullName;
});
var proxyProxyType = type.Assembly.GetType(newClassName, throwOnError: true);
var proxyInstance = (DomainType)Activator.CreateInstance(type);
var proxyProxyInstance = (DomainType)Activator.CreateInstance(proxyProxyType);
Assert.That(proxyInstance.Method(), Is.EqualTo("DomainType Proxy"));
Assert.That(proxyProxyInstance.Method(), Is.EqualTo("DomainType Proxy ProxyProxy"));
}
public void BaseMethod_GenericMethod()
{
var baseMethod = NormalizingMemberInfoFromExpressionUtility.GetGenericMethodDefinition((DomainType obj) => obj.GenericMethod <Dev.T> (null));
var type = AssembleType <DomainType> (
proxyType =>
{
var mutableMethod = proxyType.GetOrAddOverride(baseMethod);
Assert.That(mutableMethod.BaseMethod, Is.SameAs(baseMethod));
Assert.That(mutableMethod.IsGenericMethodDefinition, Is.True);
var mutableGenericParameter = mutableMethod.MutableGenericParameters.Single();
Assert.That(mutableGenericParameter.Name, Is.EqualTo("TPar"));
Assert.That(mutableGenericParameter.GenericParameterAttributes, Is.EqualTo(GenericParameterAttributes.None));
Assert.That(mutableGenericParameter.GetGenericParameterConstraints(), Is.Empty);
mutableMethod.SetBody(ctx => ExpressionHelper.StringConcat(ctx.PreviousBody, Expression.Constant(" made mutable")));
});
var method = GetDeclaredMethod(type, "GenericMethod");
Assert.That(method.GetBaseDefinition(), Is.SameAs(baseMethod));
Assert.That(method.IsGenericMethodDefinition, Is.True);
var genericParameter = method.GetGenericArguments().Single();
Assert.That(genericParameter.Name, Is.EqualTo("TPar"));
Assert.That(genericParameter.GenericParameterAttributes, Is.EqualTo(GenericParameterAttributes.None));
Assert.That(genericParameter.GetGenericParameterConstraints(), Is.EqualTo(new[] { typeof(object) }), "Why object and not empty?");
var instance = (DomainType)Activator.CreateInstance(type);
Assert.That(instance.GenericMethod("doesn't matter"), Is.EqualTo("DomainType String made mutable"));
}
