public IEnumerable <RequiredMethodDefinition> CreateRequiredMethodDefinitions(RequirementDefinitionBase requirement)
{
ArgumentUtility.CheckNotNull("requirement", requirement);
Assertion.IsTrue(requirement.Type.IsInterface);
InterfaceIntroductionDefinition introduction = requirement.TargetClass.ReceivedInterfaces[requirement.Type];
foreach (EventIntroductionDefinition eventIntroduction in introduction.IntroducedEvents)
{
yield return(new RequiredMethodDefinition(requirement, eventIntroduction.InterfaceMember.GetAddMethod(), eventIntroduction.ImplementingMember.AddMethod));
yield return(new RequiredMethodDefinition(requirement, eventIntroduction.InterfaceMember.GetRemoveMethod(), eventIntroduction.ImplementingMember.RemoveMethod));
}
foreach (PropertyIntroductionDefinition propertyIntroduction in introduction.IntroducedProperties)
{
var getMethod = propertyIntroduction.InterfaceMember.GetGetMethod();
if (getMethod != null)
{
yield return(new RequiredMethodDefinition(requirement, getMethod, propertyIntroduction.ImplementingMember.GetMethod));
}
var setMethod = propertyIntroduction.InterfaceMember.GetSetMethod();
if (setMethod != null)
{
yield return(new RequiredMethodDefinition(requirement, setMethod, propertyIntroduction.ImplementingMember.SetMethod));
}
}
foreach (MethodIntroductionDefinition methodIntroduction in introduction.IntroducedMethods)
{
yield return(new RequiredMethodDefinition(requirement, methodIntroduction.InterfaceMember, methodIntroduction.ImplementingMember));
}
}
public void IntroducedMembers()
{
TargetClassDefinition targetClass = DefinitionObjectMother.GetActiveTargetClassDefinition(typeof(BaseType1));
MixinDefinition mixin1 = targetClass.Mixins[typeof(BT1Mixin1)];
InterfaceIntroductionDefinition introducedInterface = mixin1.InterfaceIntroductions[typeof(IBT1Mixin1)];
Assert.That(introducedInterface.IntroducedMethods.ContainsKey(typeof(IBT1Mixin1).GetMethod("IntroducedMethod")), Is.True);
Assert.That(introducedInterface.IntroducedProperties.ContainsKey(typeof(IBT1Mixin1).GetProperty("IntroducedProperty")), Is.True);
Assert.That(introducedInterface.IntroducedEvents.ContainsKey(typeof(IBT1Mixin1).GetEvent("IntroducedEvent")), Is.True);
MethodIntroductionDefinition method = introducedInterface.IntroducedMethods[typeof(IBT1Mixin1).GetMethod("IntroducedMethod")];
Assert.That(method, Is.Not.EqualTo(mixin1.Methods[typeof(BT1Mixin1).GetMethod("IntroducedMethod")]));
Assert.That(method.ImplementingMember, Is.SameAs(mixin1.Methods[typeof(BT1Mixin1).GetMethod("IntroducedMethod")]));
Assert.That(method.DeclaringInterface, Is.SameAs(introducedInterface));
Assert.That(method.Parent, Is.SameAs(introducedInterface));
PropertyIntroductionDefinition property = introducedInterface.IntroducedProperties[typeof(IBT1Mixin1).GetProperty("IntroducedProperty")];
Assert.That(property, Is.Not.EqualTo(mixin1.Properties[typeof(BT1Mixin1).GetProperty("IntroducedProperty")]));
Assert.That(property.ImplementingMember, Is.SameAs(mixin1.Properties[typeof(BT1Mixin1).GetProperty("IntroducedProperty")]));
Assert.That(property.DeclaringInterface, Is.SameAs(introducedInterface));
Assert.That(method.Parent, Is.SameAs(introducedInterface));
EventIntroductionDefinition eventDefinition = introducedInterface.IntroducedEvents[typeof(IBT1Mixin1).GetEvent("IntroducedEvent")];
Assert.That(eventDefinition, Is.Not.EqualTo(mixin1.Events[typeof(BT1Mixin1).GetEvent("IntroducedEvent")]));
Assert.That(eventDefinition.ImplementingMember, Is.SameAs(mixin1.Events[typeof(BT1Mixin1).GetEvent("IntroducedEvent")]));
Assert.That(eventDefinition.DeclaringInterface, Is.SameAs(introducedInterface));
Assert.That(method.Parent, Is.SameAs(introducedInterface));
}
private Expression GetIntroducedInterfaceImplementer(InterfaceIntroductionDefinition introduction)
{
// ((InterfaceType) __extensions[implementerIndex])
return(Expression.Convert(
Expression.ArrayAccess(_extensionsField, Expression.Constant(introduction.Implementer.MixinIndex)),
introduction.InterfaceType));
}
private void AnalyzeIntroducedMembers(InterfaceIntroductionDefinition introducedInterface)
{
MemberImplementationFinder memberFinder = new MemberImplementationFinder(introducedInterface.InterfaceType, _mixin);
var specialMethods = new HashSet <MethodInfo> ();
AnalyzeProperties(introducedInterface, memberFinder, specialMethods);
AnalyzeEvents(introducedInterface, memberFinder, specialMethods);
AnalyzeMethods(introducedInterface, memberFinder, specialMethods);
}
public static InterfaceIntroductionDefinition CreateInterfaceIntroductionDefinition(MixinDefinition definition)
{
ArgumentUtility.CheckNotNull("definition", definition);
var interfaceIntroduction = new InterfaceIntroductionDefinition(typeof(IBT1Mixin1), definition);
PrivateInvoke.InvokeNonPublicMethod(definition.InterfaceIntroductions, "Add", interfaceIntroduction);
return(interfaceIntroduction);
}
public void IntroducesGetMethod()
{
using (MixinConfiguration.BuildFromActive().ForClass <BaseType1> ().Clear().AddMixins(typeof(MixinImplementingFullPropertiesWithPartialIntroduction)).EnterScope())
{
InterfaceIntroductionDefinition introduction = DefinitionObjectMother.GetActiveTargetClassDefinition(typeof(BaseType1)).ReceivedInterfaces[typeof(InterfaceWithPartialProperties)];
PropertyIntroductionDefinition prop1 = introduction.IntroducedProperties[typeof(InterfaceWithPartialProperties).GetProperty("Prop1")];
PropertyIntroductionDefinition prop2 = introduction.IntroducedProperties[typeof(InterfaceWithPartialProperties).GetProperty("Prop2")];
Assert.That(prop1.IntroducesGetMethod, Is.True);
Assert.That(prop1.IntroducesSetMethod, Is.False);
Assert.That(prop2.IntroducesSetMethod, Is.True);
Assert.That(prop2.IntroducesGetMethod, Is.False);
}
}
public void IntroducedInterface()
{
TargetClassDefinition targetClass = DefinitionObjectMother.GetActiveTargetClassDefinition(typeof(BaseType1));
MixinDefinition mixin1 = targetClass.Mixins[typeof(BT1Mixin1)];
Assert.That(mixin1.InterfaceIntroductions.ContainsKey(typeof(IBT1Mixin1)), Is.True);
InterfaceIntroductionDefinition introducedInterface = mixin1.InterfaceIntroductions[typeof(IBT1Mixin1)];
Assert.That(introducedInterface.Parent, Is.SameAs(mixin1));
Assert.That(introducedInterface.Implementer, Is.SameAs(mixin1));
Assert.That(targetClass.ReceivedInterfaces.ContainsKey(typeof(IBT1Mixin1)), Is.True);
Assert.That(introducedInterface, Is.SameAs(targetClass.ReceivedInterfaces[typeof(IBT1Mixin1)]));
Assert.That(introducedInterface.TargetClass, Is.SameAs(targetClass));
}
private void AnalyzeMethods(InterfaceIntroductionDefinition introducedInterface, MemberImplementationFinder memberFinder,
HashSet <MethodInfo> specialMethods)
{
foreach (MethodInfo interfaceMethod in introducedInterface.InterfaceType.GetMethods())
{
if (!specialMethods.Contains(interfaceMethod))
{
MethodDefinition implementer = memberFinder.FindMethodImplementation(interfaceMethod);
CheckMemberImplementationFound(implementer, interfaceMethod);
MemberVisibility visibility = GetVisibility(implementer.MemberInfo);
introducedInterface.IntroducedMethods.Add(new MethodIntroductionDefinition(introducedInterface, interfaceMethod, implementer, visibility));
}
}
}
private void AnalyzeEvents(InterfaceIntroductionDefinition introducedInterface, MemberImplementationFinder memberFinder,
HashSet <MethodInfo> specialMethods)
{
foreach (EventInfo interfaceEvent in introducedInterface.InterfaceType.GetEvents())
{
EventDefinition implementer = memberFinder.FindEventImplementation(interfaceEvent);
CheckMemberImplementationFound(implementer, interfaceEvent);
MemberVisibility visibility = GetVisibility(implementer.MemberInfo);
introducedInterface.IntroducedEvents.Add(new EventIntroductionDefinition(introducedInterface, interfaceEvent, implementer, visibility));
specialMethods.Add(interfaceEvent.GetAddMethod());
specialMethods.Add(interfaceEvent.GetRemoveMethod());
}
}
public void SpecialVisibility()
{
using (MixinConfiguration.BuildNew()
.ForClass <NullTarget> ()
.AddMixin <MixinIntroducingMembersWithDifferentVisibilities> ().WithIntroducedMemberVisibility(MemberVisibility.Private)
.EnterScope())
{
TargetClassDefinition definition = DefinitionObjectMother.GetActiveTargetClassDefinition(typeof(NullTarget));
InterfaceIntroductionDefinition interfaceDefinition = definition.ReceivedInterfaces[typeof(IMixinIntroducingMembersWithDifferentVisibilities)];
Assert.That(interfaceDefinition.IntroducedMethods[typeof(IMixinIntroducingMembersWithDifferentVisibilities).GetMethod("MethodWithPublicVisibility")].Visibility,
Is.EqualTo(MemberVisibility.Public));
Assert.That(interfaceDefinition.IntroducedProperties[typeof(IMixinIntroducingMembersWithDifferentVisibilities).GetProperty("PropertyWithPublicVisibility")].Visibility,
Is.EqualTo(MemberVisibility.Public));
Assert.That(interfaceDefinition.IntroducedEvents[typeof(IMixinIntroducingMembersWithDifferentVisibilities).GetEvent("EventWithPublicVisibility")].Visibility,
Is.EqualTo(MemberVisibility.Public));
}
}
public void Apply(Type implementedInterface)
{
if (_mixin.TargetClass.ReceivedInterfaces.ContainsKey(implementedInterface))
{
MixinDefinition otherIntroducer = _mixin.TargetClass.ReceivedInterfaces[implementedInterface].Implementer;
string message = string.Format(
"Two mixins introduce the same interface {0} to base class {1}: {2} and {3}.",
implementedInterface.FullName,
_mixin.TargetClass.FullName,
otherIntroducer.FullName,
_mixin.FullName);
throw new ConfigurationException(message);
}
InterfaceIntroductionDefinition introducedInterface = new InterfaceIntroductionDefinition(implementedInterface, _mixin);
_mixin.InterfaceIntroductions.Add(introducedInterface);
_mixin.TargetClass.ReceivedInterfaces.Add(introducedInterface);
AnalyzeIntroducedMembers(introducedInterface);
}
private void AnalyzeProperties(InterfaceIntroductionDefinition introducedInterface, MemberImplementationFinder memberFinder,
HashSet <MethodInfo> specialMethods)
{
foreach (PropertyInfo interfaceProperty in introducedInterface.InterfaceType.GetProperties())
{
PropertyDefinition implementer = memberFinder.FindPropertyImplementation(interfaceProperty);
CheckMemberImplementationFound(implementer, interfaceProperty);
MemberVisibility visibility = GetVisibility(implementer.MemberInfo);
introducedInterface.IntroducedProperties.Add(new PropertyIntroductionDefinition(introducedInterface, interfaceProperty, implementer, visibility));
MethodInfo getMethod = interfaceProperty.GetGetMethod();
if (getMethod != null)
{
specialMethods.Add(getMethod);
}
MethodInfo setMethod = interfaceProperty.GetSetMethod();
if (setMethod != null)
{
specialMethods.Add(setMethod);
}
}
}
public void Visit(InterfaceIntroductionDefinition interfaceIntroduction)
{
ArgumentUtility.CheckNotNull("interfaceIntroduction", interfaceIntroduction);
CheckRules(_interfaceIntroductionRules, interfaceIntroduction);
}
public void DefaultConfiguration_EverythingIsVisitedOnce()
{
var activeConfiguration = MixinConfiguration.ActiveConfiguration;
ValidationLogData log;
using (MixinConfiguration.BuildNew().EnterScope())
{
log = activeConfiguration.Validate();
}
var validationResults = log.GetResults();
var visitedDefinitions = new HashSet <IVisitableDefinition>();
foreach (ValidationResult result in validationResults)
{
var definition = result.ValidatedDefinition;
Assert.That(visitedDefinitions.Contains(definition), Is.False, definition.ToString());
visitedDefinitions.Add(definition);
}
TargetClassDefinition bt1 = DefinitionObjectMother.GetActiveTargetClassDefinition(typeof(BaseType1));
AssertVisitedEquivalent(validationResults, bt1);
TargetClassDefinition bt3 = DefinitionObjectMother.GetActiveTargetClassDefinition(typeof(BaseType3));
AssertVisitedEquivalent(validationResults, bt3);
TargetClassDefinition bt6 = DefinitionObjectMother.GetActiveTargetClassDefinition(typeof(BaseType6));
AssertVisitedEquivalent(validationResults, bt6);
TargetClassDefinition btWithAdditionalDependencies =
DefinitionObjectMother.GetActiveTargetClassDefinition(typeof(TargetClassWithAdditionalDependencies));
AssertVisitedEquivalent(validationResults, btWithAdditionalDependencies);
TargetClassDefinition targetWithSuppressAttribute =
DefinitionObjectMother.GetActiveTargetClassDefinition(typeof(TargetClassSuppressingBT1Attribute));
AssertVisitedEquivalent(validationResults, targetWithSuppressAttribute);
TargetClassDefinition targetWithNonIntroducedAttribute =
DefinitionObjectMother.GetActiveTargetClassDefinition(typeof(TargetClassWithMixinNonIntroducingSimpleAttribute));
AssertVisitedEquivalent(validationResults, targetWithSuppressAttribute);
TargetClassDefinition targetClassWinningOverMixinAddingBT1AttributeToMember =
DefinitionObjectMother.GetActiveTargetClassDefinition(typeof(TargetClassWinningOverMixinAddingBT1AttributeToMember));
AssertVisitedEquivalent(validationResults, targetClassWinningOverMixinAddingBT1AttributeToMember);
MixinDefinition bt1m1 = bt1.Mixins[typeof(BT1Mixin1)];
AssertVisitedEquivalent(validationResults, bt1m1);
MixinDefinition bt1m2 = bt1.Mixins[typeof(BT1Mixin2)];
AssertVisitedEquivalent(validationResults, bt1m2);
MixinDefinition bt3m1 = bt3.Mixins[typeof(BT3Mixin1)];
AssertVisitedEquivalent(validationResults, bt3m1);
MixinDefinition bt3m2 = bt3.Mixins[typeof(BT3Mixin2)];
AssertVisitedEquivalent(validationResults, bt3m2);
MixinDefinition bt3m3 = bt3.GetMixinByConfiguredType(typeof(BT3Mixin3 <,>));
AssertVisitedEquivalent(validationResults, bt3m3);
MixinDefinition bt3m4 = bt3.Mixins[typeof(BT3Mixin4)];
AssertVisitedEquivalent(validationResults, bt3m4);
MixinDefinition bt3m5 = bt3.Mixins[typeof(BT3Mixin5)];
AssertVisitedEquivalent(validationResults, bt3m5);
MixinDefinition mixinWithSuppressedAttribute = targetWithSuppressAttribute.Mixins[typeof(MixinAddingBT1Attribute)];
AssertVisitedEquivalent(validationResults, mixinWithSuppressedAttribute);
MixinDefinition mixinWithNonIntroducedAttribute = targetWithNonIntroducedAttribute.Mixins[typeof(MixinNonIntroducingSimpleAttribute)];
AssertVisitedEquivalent(validationResults, mixinWithNonIntroducedAttribute);
MethodDefinition m1 = bt1.Methods[typeof(BaseType1).GetMethod("VirtualMethod", Type.EmptyTypes)];
AssertVisitedEquivalent(validationResults, m1);
MethodDefinition m2 = bt1.Methods[typeof(BaseType1).GetMethod("VirtualMethod", new[] { typeof(string) })];
AssertVisitedEquivalent(validationResults, m2);
MethodDefinition m3 = bt1m1.Methods[typeof(BT1Mixin1).GetMethod("VirtualMethod")];
AssertVisitedEquivalent(validationResults, m3);
MethodDefinition m4 = bt1m1.Methods[typeof(BT1Mixin1).GetMethod("IntroducedMethod")];
AssertVisitedEquivalent(validationResults, m4);
MethodDefinition memberWinningOverMixinAddingAttribute =
targetClassWinningOverMixinAddingBT1AttributeToMember.Methods[
typeof(TargetClassWinningOverMixinAddingBT1AttributeToMember).GetMethod("VirtualMethod")];
AssertVisitedEquivalent(validationResults, memberWinningOverMixinAddingAttribute);
PropertyDefinition p1 = bt1.Properties[typeof(BaseType1).GetProperty("VirtualProperty")];
AssertVisitedEquivalent(validationResults, p1);
MethodDefinition m5 = p1.GetMethod;
AssertVisitedEquivalent(validationResults, m5);
MethodDefinition m6 = p1.SetMethod;
AssertVisitedEquivalent(validationResults, m6);
PropertyDefinition p2 = bt1m1.Properties[typeof(BT1Mixin1).GetProperty("VirtualProperty")];
AssertVisitedEquivalent(validationResults, p2);
EventDefinition e1 = bt1.Events[typeof(BaseType1).GetEvent("VirtualEvent")];
AssertVisitedEquivalent(validationResults, e1);
MethodDefinition m7 = e1.AddMethod;
AssertVisitedEquivalent(validationResults, m7);
MethodDefinition m8 = e1.RemoveMethod;
AssertVisitedEquivalent(validationResults, m8);
EventDefinition e2 = bt1m1.Events[typeof(BT1Mixin1).GetEvent("VirtualEvent")];
AssertVisitedEquivalent(validationResults, e2);
InterfaceIntroductionDefinition i1 = bt1m1.InterfaceIntroductions[typeof(IBT1Mixin1)];
AssertVisitedEquivalent(validationResults, i1);
MethodIntroductionDefinition im1 = i1.IntroducedMethods[typeof(IBT1Mixin1).GetMethod("IntroducedMethod")];
AssertVisitedEquivalent(validationResults, im1);
PropertyIntroductionDefinition im2 = i1.IntroducedProperties[typeof(IBT1Mixin1).GetProperty("IntroducedProperty")];
AssertVisitedEquivalent(validationResults, im2);
EventIntroductionDefinition im3 = i1.IntroducedEvents[typeof(IBT1Mixin1).GetEvent("IntroducedEvent")];
AssertVisitedEquivalent(validationResults, im3);
AttributeDefinition a1 = bt1.CustomAttributes.GetFirstItem(typeof(BT1Attribute));
AssertVisitedEquivalent(validationResults, a1);
AttributeDefinition a2 = bt1m1.CustomAttributes.GetFirstItem(typeof(BT1M1Attribute));
AssertVisitedEquivalent(validationResults, a2);
AttributeDefinition a3 = m1.CustomAttributes.GetFirstItem(typeof(BT1Attribute));
AssertVisitedEquivalent(validationResults, a3);
AttributeDefinition a4 = p1.CustomAttributes.GetFirstItem(typeof(BT1Attribute));
AssertVisitedEquivalent(validationResults, a4);
AttributeDefinition a5 = e1.CustomAttributes.GetFirstItem(typeof(BT1Attribute));
AssertVisitedEquivalent(validationResults, a5);
AttributeDefinition a6 = im1.ImplementingMember.CustomAttributes.GetFirstItem(typeof(BT1M1Attribute));
AssertVisitedEquivalent(validationResults, a6);
AttributeDefinition a7 = im2.ImplementingMember.CustomAttributes.GetFirstItem(typeof(BT1M1Attribute));
AssertVisitedEquivalent(validationResults, a7);
AttributeDefinition a8 = im3.ImplementingMember.CustomAttributes.GetFirstItem(typeof(BT1M1Attribute));
AssertVisitedEquivalent(validationResults, a8);
AttributeIntroductionDefinition ai1 = bt1.ReceivedAttributes.GetFirstItem(typeof(BT1M1Attribute));
AssertVisitedEquivalent(validationResults, ai1);
AttributeIntroductionDefinition ai2 = m1.ReceivedAttributes.GetFirstItem(typeof(BT1M1Attribute));
AssertVisitedEquivalent(validationResults, ai2);
RequiredNextCallTypeDefinition bc1 = bt3.RequiredNextCallTypes[typeof(IBaseType34)];
AssertVisitedEquivalent(validationResults, bc1);
RequiredMethodDefinition bcm1 = bc1.Methods[typeof(IBaseType34).GetMethod("IfcMethod")];
AssertVisitedEquivalent(validationResults, bcm1);
RequiredTargetCallTypeDefinition ft1 = bt3.RequiredTargetCallTypes[typeof(IBaseType32)];
AssertVisitedEquivalent(validationResults, ft1);
RequiredMethodDefinition fm1 = ft1.Methods[typeof(IBaseType32).GetMethod("IfcMethod")];
AssertVisitedEquivalent(validationResults, fm1);
RequiredMixinTypeDefinition rmt1 = btWithAdditionalDependencies.RequiredMixinTypes[typeof(IMixinWithAdditionalClassDependency)];
AssertVisitedEquivalent(validationResults, rmt1);
RequiredMixinTypeDefinition rmt2 = btWithAdditionalDependencies.RequiredMixinTypes[typeof(MixinWithNoAdditionalDependency)];
AssertVisitedEquivalent(validationResults, rmt2);
ComposedInterfaceDependencyDefinition cid1 = bt6.ComposedInterfaceDependencies[typeof(ICBT6Mixin1)];
AssertVisitedEquivalent(validationResults, cid1);
TargetCallDependencyDefinition td1 = bt3m1.TargetCallDependencies[typeof(IBaseType31)];
AssertVisitedEquivalent(validationResults, td1);
NextCallDependencyDefinition bd1 = bt3m1.NextCallDependencies[typeof(IBaseType31)];
AssertVisitedEquivalent(validationResults, bd1);
MixinDependencyDefinition md1 =
btWithAdditionalDependencies.Mixins[typeof(MixinWithAdditionalClassDependency)].MixinDependencies[typeof(MixinWithNoAdditionalDependency)];
AssertVisitedEquivalent(validationResults, md1);
SuppressedAttributeIntroductionDefinition suppressedAttribute1 =
mixinWithSuppressedAttribute.SuppressedAttributeIntroductions.GetFirstItem(typeof(BT1Attribute));
AssertVisitedEquivalent(validationResults, suppressedAttribute1);
NonAttributeIntroductionDefinition nonIntroducedAttribute1 =
mixinWithNonIntroducedAttribute.NonAttributeIntroductions.GetFirstItem(typeof(SimpleAttribute));
AssertVisitedEquivalent(validationResults, nonIntroducedAttribute1);
NonAttributeIntroductionDefinition nonIntroducedAttribute2 = memberWinningOverMixinAddingAttribute.Overrides[0].NonAttributeIntroductions[0];
AssertVisitedEquivalent(validationResults, nonIntroducedAttribute2);
}
