public void EventOverrides() { TargetClassDefinition targetClass = DefinitionObjectMother.GetActiveTargetClassDefinition(typeof(BaseType1)); MixinDefinition mixin1 = targetClass.Mixins[typeof(BT1Mixin1)]; MixinDefinition mixin2 = targetClass.Mixins[typeof(BT1Mixin2)]; EventInfo baseEvent1 = typeof(BaseType1).GetEvent("VirtualEvent"); EventInfo baseEvent2 = typeof(BaseType1).GetEvent("ExplicitEvent"); EventInfo mixinEvent1 = typeof(BT1Mixin1).GetEvent("VirtualEvent"); EventDefinition overridden = targetClass.Events[baseEvent1]; Assert.That(overridden.Overrides.ContainsKey(typeof(BT1Mixin1)), Is.True); EventDefinition overrider = overridden.Overrides[typeof(BT1Mixin1)]; Assert.That(mixin1.Events[mixinEvent1], Is.SameAs(overrider)); Assert.That(overrider.Base, Is.Not.Null); Assert.That(overrider.Base, Is.SameAs(overridden)); Assert.That(overrider.RemoveMethod.Base, Is.SameAs(overridden.RemoveMethod)); Assert.That(overrider.AddMethod.Base, Is.SameAs(overridden.AddMethod)); EventDefinition notOverridden = targetClass.Events[baseEvent2]; Assert.That(notOverridden.Overrides.Count, Is.EqualTo(0)); Assert.That(overridden.Overrides.ContainsKey(typeof(BT1Mixin2)), Is.True); overrider = overridden.Overrides[typeof(BT1Mixin2)]; Assert.That(new List <MemberDefinitionBase> (mixin2.GetAllOverrides()).Contains(overrider), Is.True); Assert.That(overrider.Base, Is.SameAs(overridden)); Assert.That(overrider.AddMethod.Base, Is.SameAs(overridden.AddMethod)); Assert.That(overrider.RemoveMethod.Base, Is.SameAs(overridden.RemoveMethod)); }
public void MethodOverrides() { TargetClassDefinition targetClass = DefinitionObjectMother.GetActiveTargetClassDefinition(typeof(BaseType1)); MixinDefinition mixin1 = targetClass.Mixins[typeof(BT1Mixin1)]; MixinDefinition mixin2 = targetClass.Mixins[typeof(BT1Mixin2)]; Assert.That(mixin1.HasOverriddenMembers(), Is.False); Assert.That(mixin2.HasOverriddenMembers(), Is.False); Assert.That(targetClass.HasOverriddenMembers(), Is.True); MethodInfo baseMethod1 = typeof(BaseType1).GetMethod("VirtualMethod", new Type[0]); MethodInfo baseMethod2 = typeof(BaseType1).GetMethod("VirtualMethod", new[] { typeof(string) }); MethodInfo mixinMethod1 = typeof(BT1Mixin1).GetMethod("VirtualMethod", new Type[0]); MethodDefinition overridden = targetClass.Methods[baseMethod1]; Assert.That(overridden.Overrides.ContainsKey(typeof(BT1Mixin1)), Is.True); MethodDefinition overrider = overridden.Overrides[typeof(BT1Mixin1)]; Assert.That(mixin1.Methods[mixinMethod1], Is.SameAs(overrider)); Assert.That(overrider.Base, Is.Not.Null); Assert.That(overrider.Base, Is.SameAs(overridden)); MethodDefinition notOverridden = targetClass.Methods[baseMethod2]; Assert.That(notOverridden.Overrides.Count, Is.EqualTo(0)); Assert.That(overridden.Overrides.ContainsKey(typeof(BT1Mixin2)), Is.True); overrider = overridden.Overrides[typeof(BT1Mixin2)]; Assert.That(new List <MemberDefinitionBase> (mixin2.GetAllOverrides()).Contains(overrider), Is.True); Assert.That(overrider.Base, Is.SameAs(overridden)); }
public void PropertyOverrides() { TargetClassDefinition targetClass = DefinitionObjectMother.GetActiveTargetClassDefinition(typeof(BaseType1)); MixinDefinition mixin1 = targetClass.Mixins[typeof(BT1Mixin1)]; MixinDefinition mixin2 = targetClass.Mixins[typeof(BT1Mixin2)]; PropertyInfo baseProperty1 = typeof(BaseType1).GetProperty("VirtualProperty"); PropertyInfo baseProperty2 = typeof(BaseType1).GetProperty("Item", new[] { typeof(string) }); PropertyInfo mixinProperty1 = typeof(BT1Mixin1).GetProperty("VirtualProperty"); PropertyDefinition overridden = targetClass.Properties[baseProperty1]; Assert.That(overridden.Overrides.ContainsKey(typeof(BT1Mixin1)), Is.True); PropertyDefinition overrider = overridden.Overrides[typeof(BT1Mixin1)]; Assert.That(mixin1.Properties[mixinProperty1], Is.SameAs(overrider)); Assert.That(overrider.Base, Is.Not.Null); Assert.That(overrider.Base, Is.SameAs(overridden)); Assert.That(overrider.SetMethod.Base, Is.SameAs(overridden.SetMethod)); PropertyDefinition notOverridden = targetClass.Properties[baseProperty2]; Assert.That(notOverridden.Overrides.Count, Is.EqualTo(0)); Assert.That(overridden.Overrides.ContainsKey(typeof(BT1Mixin2)), Is.True); overrider = overridden.Overrides[typeof(BT1Mixin2)]; Assert.That(new List <MemberDefinitionBase> (mixin2.GetAllOverrides()).Contains(overrider), Is.True); Assert.That(overrider.Base, Is.SameAs(overridden)); Assert.That(overrider.GetMethod.Base, Is.SameAs(overridden.GetMethod)); }
public void ComposedInterfacesAndDependenciesForFace() { TargetClassDefinition bt3 = DefinitionObjectMother.BuildUnvalidatedDefinition(typeof(BaseType3), typeof(BT3Mixin4), typeof(Bt3Mixin7TargetCall)); MixinDefinition m4 = bt3.Mixins[typeof(BT3Mixin4)]; MixinDefinition m7 = bt3.Mixins[typeof(Bt3Mixin7TargetCall)]; TargetCallDependencyDefinition d1 = m7.TargetCallDependencies[typeof(ICBaseType3BT3Mixin4)]; Assert.That(d1.GetImplementer(), Is.Null); Assert.That(d1.FullName, Is.EqualTo("Remotion.Mixins.UnitTests.Core.TestDomain.ICBaseType3BT3Mixin4")); Assert.That(d1.Parent, Is.SameAs(m7)); Assert.That(d1.IsAggregate, Is.True); Assert.That(d1.AggregatedDependencies[typeof(ICBaseType3)].IsAggregate, Is.True); Assert.That(d1.AggregatedDependencies[typeof(ICBaseType3)] .AggregatedDependencies[typeof(IBaseType31)].IsAggregate, Is.False); Assert.That(d1.AggregatedDependencies[typeof(ICBaseType3)] .AggregatedDependencies[typeof(IBaseType31)].GetImplementer(), Is.SameAs(bt3)); Assert.That(d1.AggregatedDependencies[typeof(IBT3Mixin4)].IsAggregate, Is.False); Assert.That(d1.AggregatedDependencies[typeof(IBT3Mixin4)].GetImplementer(), Is.SameAs(m4)); Assert.That(d1.AggregatedDependencies[typeof(IBT3Mixin4)].Aggregator, Is.SameAs(d1)); Assert.That(bt3.RequiredTargetCallTypes[typeof(ICBaseType3)].IsEmptyInterface, Is.True); Assert.That(bt3.RequiredTargetCallTypes[typeof(ICBaseType3)].IsAggregatorInterface, Is.True); Assert.That(bt3.RequiredTargetCallTypes.ContainsKey(typeof(ICBaseType3BT3Mixin4)), Is.True); Assert.That(bt3.RequiredTargetCallTypes.ContainsKey(typeof(ICBaseType3)), Is.True); Assert.That(bt3.RequiredTargetCallTypes.ContainsKey(typeof(IBaseType31)), Is.True); Assert.That(bt3.RequiredTargetCallTypes.ContainsKey(typeof(IBT3Mixin4)), Is.True); }
public void IndirectNextCallDependencies() { TargetClassDefinition targetClass = DefinitionObjectMother.GetActiveTargetClassDefinition(typeof(ClassImplementingIndirectRequirements)); MixinDefinition mixin = targetClass.Mixins[typeof(MixinWithIndirectRequirements)]; Assert.That(mixin, Is.Not.Null); Assert.That(targetClass.RequiredNextCallTypes.ContainsKey(typeof(IIndirectBaseAggregator)), Is.True); Assert.That(targetClass.RequiredNextCallTypes[typeof(IIndirectBaseAggregator)].IsAggregatorInterface, Is.True); Assert.That(targetClass.RequiredNextCallTypes.ContainsKey(typeof(IIndirectRequirement1)), Is.True); Assert.That(targetClass.RequiredNextCallTypes[typeof(IIndirectRequirement1)].IsAggregatorInterface, Is.False); Assert.That(targetClass.RequiredNextCallTypes.ContainsKey(typeof(IIndirectRequirementBase1)), Is.True); Assert.That(targetClass.RequiredNextCallTypes[typeof(IIndirectRequirementBase1)].IsAggregatorInterface, Is.False); Assert.That(targetClass.RequiredNextCallTypes.ContainsKey(typeof(IIndirectRequirement2)), Is.False); Assert.That(targetClass.RequiredNextCallTypes.ContainsKey(typeof(IIndirectRequirementBase2)), Is.False); Assert.That(targetClass.RequiredNextCallTypes.ContainsKey(typeof(IIndirectRequirement3)), Is.True); Assert.That(targetClass.RequiredNextCallTypes[typeof(IIndirectRequirement3)].IsAggregatorInterface, Is.True); Assert.That(targetClass.RequiredNextCallTypes.ContainsKey(typeof(IIndirectRequirementBase3)), Is.True); Assert.That(targetClass.RequiredNextCallTypes[typeof(IIndirectRequirementBase3)].IsAggregatorInterface, Is.False); Assert.That(targetClass.RequiredNextCallTypes[typeof(IIndirectRequirementBase3)].IsEmptyInterface, Is.False); Assert.That(mixin.NextCallDependencies.ContainsKey(typeof(IIndirectBaseAggregator)), Is.True); Assert.That(mixin.NextCallDependencies.ContainsKey(typeof(IIndirectRequirement1)), Is.True); Assert.That(mixin.NextCallDependencies.ContainsKey(typeof(IIndirectRequirement2)), Is.False); Assert.That(mixin.NextCallDependencies.ContainsKey(typeof(IIndirectRequirement3)), Is.True); Assert.That(mixin.NextCallDependencies.ContainsKey(typeof(IIndirectRequirementBase1)), Is.True); Assert.That(mixin.NextCallDependencies.ContainsKey(typeof(IIndirectRequirementBase2)), Is.False); Assert.That(mixin.NextCallDependencies.ContainsKey(typeof(IIndirectRequirementBase3)), Is.True); }
private void LoadAspects() { XmlNodeList aspects = _node.SelectNodes("aspect"); foreach (XmlNode node in aspects) { String name = GetRequiredAttribute(node, "name"); AspectDefinition aspect = new AspectDefinition(LexicalInfo.Empty, name); Configuration.Aspects.Add(aspect); XmlNode singleType = node.SelectSingleNode("for/singletype"); aspect.TargetType = new TargetTypeDefinition(); aspect.TargetType.SingleType = CreateTypeReference(singleType); XmlNodeList mixins = node.SelectNodes("mixin"); foreach (XmlNode inner in mixins) { MixinDefinition def = new MixinDefinition(LexicalInfo.Empty); def.TypeReference = CreateTypeReference(inner); aspect.Mixins.Add(def); } XmlNodeList pointcuts = node.SelectNodes("pointcut"); foreach (XmlNode inner in pointcuts) { PointCutDefinition def = CreatePointCutDefinition(inner); aspect.PointCuts.Add(def); } } }
public void ParsingAspectWithAFewMixinDeclarations() { AspectParser parser = CreateParser( "aspect XPTO for MyNamespace.MyType \r\n" + "" + " include MyNamespace.Type1 in MyAssembly1 " + " include MyNamespace.Type2 in MyAssembly2 " + " include MyNamespace.Type3 in MyAssembly3 " + "" + "" + "end"); EngineConfiguration conf = parser.Parse(); AspectDefinition def = conf.Aspects[0]; Assert.AreEqual(3, def.Mixins.Count); MixinDefinition typeName = def.Mixins[0]; Assert.AreEqual(TargetTypeEnum.Type, typeName.TypeReference.TargetType); Assert.AreEqual("MyNamespace.Type1", typeName.TypeReference.TypeName); Assert.AreEqual("MyAssembly1", typeName.TypeReference.AssemblyReference.AssemblyName); typeName = def.Mixins[1]; Assert.AreEqual(TargetTypeEnum.Type, typeName.TypeReference.TargetType); Assert.AreEqual("MyNamespace.Type2", typeName.TypeReference.TypeName); Assert.AreEqual("MyAssembly2", typeName.TypeReference.AssemblyReference.AssemblyName); typeName = def.Mixins[2]; Assert.AreEqual(TargetTypeEnum.Type, typeName.TypeReference.TargetType); Assert.AreEqual("MyNamespace.Type3", typeName.TypeReference.TypeName); Assert.AreEqual("MyAssembly3", typeName.TypeReference.AssemblyReference.AssemblyName); }
public void MixinsIntroduceAttributes() { TargetClassDefinition bt1 = DefinitionObjectMother.GetActiveTargetClassDefinition(typeof(BaseType1)); Assert.That(bt1.CustomAttributes.Count, Is.EqualTo(2)); Assert.That(bt1.CustomAttributes.ContainsKey(typeof(BT1Attribute)), Is.True); Assert.That(bt1.CustomAttributes.ContainsKey(typeof(DefaultMemberAttribute)), Is.True); MixinDefinition mixin1 = bt1.Mixins[typeof(BT1Mixin1)]; Assert.That(mixin1.CustomAttributes.Count, Is.EqualTo(1)); Assert.That(mixin1.CustomAttributes.ContainsKey(typeof(BT1M1Attribute)), Is.True); Assert.That(mixin1.AttributeIntroductions.Count, Is.EqualTo(1)); Assert.That(mixin1.AttributeIntroductions.ContainsKey(typeof(BT1M1Attribute)), Is.True); MixinDefinition mixin2 = bt1.Mixins[typeof(BT1Mixin2)]; Assert.That(mixin2.CustomAttributes.Count, Is.EqualTo(0)); Assert.That(mixin2.AttributeIntroductions.Count, Is.EqualTo(0)); Assert.That(bt1.ReceivedAttributes.Count, Is.EqualTo(1)); Assert.That(bt1.ReceivedAttributes[0].Attribute, Is.SameAs(mixin1.CustomAttributes[0])); Assert.That(bt1.ReceivedAttributes[0], Is.SameAs(mixin1.AttributeIntroductions[0])); Assert.That(bt1.ReceivedAttributes[0].Parent, Is.SameAs(mixin1)); Assert.That(bt1.ReceivedAttributes[0].FullName, Is.EqualTo(mixin1.CustomAttributes[0].FullName)); Assert.That(bt1.ReceivedAttributes[0].AttributeType, Is.EqualTo(mixin1.CustomAttributes[0].AttributeType)); }
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)); }
protected void include( AspectDefinition aspect ) //throws RecognitionException, TokenStreamException { Token i = null; TypeReference tr = null; MixinDefinition md; try { // for error handling i = LT(1); match(INCLUDE); md = new MixinDefinition(ToLexicalInfo(i)); tr = type_name_or_ref(); md.TypeReference = tr; aspect.Mixins.Add(md); } catch (RecognitionException ex) { reportError(ex); consume(); consumeUntil(tokenSet_10_); } }
public void ComposedInterfacesAndDependenciesForBase() { TargetClassDefinition bt3 = DefinitionObjectMother.BuildUnvalidatedDefinition(typeof(BaseType3), typeof(BT3Mixin4), typeof(BT3Mixin7Base)); MixinDefinition m4 = bt3.Mixins[typeof(BT3Mixin4)]; MixinDefinition m7 = bt3.Mixins[typeof(BT3Mixin7Base)]; NextCallDependencyDefinition d2 = m7.NextCallDependencies[typeof(ICBaseType3BT3Mixin4)]; Assert.That(d2.GetImplementer(), Is.Null); Assert.That(d2.IsAggregate, Is.True); Assert.That(d2.AggregatedDependencies[typeof(ICBaseType3)].IsAggregate, Is.True); Assert.That(d2.AggregatedDependencies[typeof(ICBaseType3)].Parent, Is.SameAs(d2)); Assert.That(d2.AggregatedDependencies[typeof(ICBaseType3)] .AggregatedDependencies[typeof(IBaseType31)].IsAggregate, Is.False); Assert.That(d2.AggregatedDependencies[typeof(ICBaseType3)] .AggregatedDependencies[typeof(IBaseType31)].GetImplementer(), Is.SameAs(bt3)); Assert.That(d2.AggregatedDependencies[typeof(IBT3Mixin4)].IsAggregate, Is.False); Assert.That(d2.AggregatedDependencies[typeof(IBT3Mixin4)].GetImplementer(), Is.SameAs(m4)); Assert.That(d2.AggregatedDependencies[typeof(IBT3Mixin4)].Aggregator, Is.SameAs(d2)); Assert.That(bt3.RequiredNextCallTypes[typeof(ICBaseType3)].IsEmptyInterface, Is.True); Assert.That(bt3.RequiredNextCallTypes[typeof(ICBaseType3)].IsAggregatorInterface, Is.True); Assert.That(bt3.RequiredNextCallTypes.ContainsKey(typeof(ICBaseType3BT3Mixin4)), Is.True); Assert.That(bt3.RequiredNextCallTypes.ContainsKey(typeof(ICBaseType3)), Is.True); Assert.That(bt3.RequiredNextCallTypes.ContainsKey(typeof(IBaseType31)), Is.True); Assert.That(bt3.RequiredNextCallTypes.ContainsKey(typeof(IBT3Mixin4)), Is.True); }
public void DuckTypingBaseInterface() { using (MixinConfiguration.BuildFromActive().ForClass <BaseTypeWithDuckBaseMixin> ().Clear().AddMixins(typeof(DuckBaseMixin)).EnterScope()) { TargetClassDefinition targetClass = DefinitionObjectMother.GetActiveTargetClassDefinition(typeof(BaseTypeWithDuckBaseMixin)); Assert.That(targetClass.Mixins.ContainsKey(typeof(DuckBaseMixin)), Is.True); MixinDefinition mixin = targetClass.Mixins[typeof(DuckBaseMixin)]; Assert.That(targetClass.RequiredNextCallTypes.ContainsKey(typeof(IDuckBaseRequirements)), Is.True); CheckAllRequiringEntities( targetClass.RequiredNextCallTypes[typeof(IDuckBaseRequirements)], mixin); Assert.That(mixin.NextCallDependencies.ContainsKey(typeof(IDuckBaseRequirements)), Is.True); Assert.That(mixin.NextCallDependencies[typeof(IDuckBaseRequirements)].GetImplementer(), Is.SameAs(targetClass)); Assert.That(mixin.NextCallDependencies[typeof(IDuckBaseRequirements)].Depender, Is.SameAs(mixin)); Assert.That(mixin.NextCallDependencies[typeof(IDuckBaseRequirements)].Aggregator, Is.Null); Assert.That(mixin.NextCallDependencies[typeof(IDuckBaseRequirements)].AggregatedDependencies.Count, Is.EqualTo(0)); Assert.That(mixin.NextCallDependencies[typeof(IDuckBaseRequirements)].RequiredType, Is.SameAs(targetClass.RequiredNextCallTypes[typeof(IDuckBaseRequirements)])); Assert.That(targetClass.RequiredNextCallTypes[typeof(IDuckBaseRequirements)].Methods.Count, Is.EqualTo(2)); Assert.That(targetClass.RequiredNextCallTypes[typeof(IDuckBaseRequirements)].Methods[0].InterfaceMethod, Is.SameAs(typeof(IDuckBaseRequirements).GetMethod("MethodImplementedOnBase"))); Assert.That(targetClass.RequiredNextCallTypes[typeof(IDuckBaseRequirements)].Methods[0].ImplementingMethod, Is.SameAs(targetClass.Methods[typeof(BaseTypeWithDuckBaseMixin).GetMethod("MethodImplementedOnBase")])); } }
public void GenericMixinsAreClosed() { MixinDefinition def = DefinitionObjectMother.BuildUnvalidatedDefinition(typeof(BaseType3), typeof(BT3Mixin3 <,>)) .GetMixinByConfiguredType(typeof(BT3Mixin3 <,>)); Assert.That(def.Type.IsGenericTypeDefinition, Is.False); }
public void CopyAttributes_OnClass() { using (MixinConfiguration.BuildFromActive().ForClass <NullTarget> ().Clear().AddMixins(typeof(MixinIndirectlyAddingAttribute)).EnterScope()) { MixinDefinition definition = DefinitionObjectMother.GetActiveTargetClassDefinition(typeof(NullTarget)).Mixins[typeof(MixinIndirectlyAddingAttribute)]; Assert.That(definition.CustomAttributes.ContainsKey(typeof(CopyCustomAttributesAttribute)), Is.False); Assert.That(definition.CustomAttributes.ContainsKey(typeof(AttributeWithParameters)), Is.True); var attributes = new List <AttributeDefinition> (definition.CustomAttributes[typeof(AttributeWithParameters)]); Assert.That(attributes.Count, Is.EqualTo(1)); Assert.That(attributes[0].IsCopyTemplate, Is.True); Assert.That(attributes[0].AttributeType, Is.EqualTo(typeof(AttributeWithParameters))); Assert.That( attributes[0].Data.Constructor, Is.EqualTo(typeof(AttributeWithParameters).GetConstructor(new[] { typeof(int), typeof(string) }))); Assert.That(attributes[0].DeclaringDefinition, Is.EqualTo(definition)); Assert.That(attributes[0].Data.ConstructorArguments.Count, Is.EqualTo(2)); Assert.That(attributes[0].Data.ConstructorArguments[0], Is.EqualTo(1)); Assert.That(attributes[0].Data.ConstructorArguments[1], Is.EqualTo("bla")); var namedArgumentData = attributes[0].Data.NamedArguments.Select(n => new { n.MemberInfo, n.Value }).ToArray(); var expectedNamedArgumentData = new[] { new { MemberInfo = (MemberInfo)typeof(AttributeWithParameters).GetField("Field"), Value = (object)5 }, new { MemberInfo = (MemberInfo)typeof(AttributeWithParameters).GetProperty("Property"), Value = (object)4 } }; Assert.That(namedArgumentData, Is.EquivalentTo(expectedNamedArgumentData)); } }
private static void AssertEngineConfiguration(AspectEngine engine) { Assert.IsNotNull(engine); Assert.IsNotNull(engine.Configuration); Assert.AreEqual(1, engine.Configuration.Imports.Count); Assert.AreEqual(1, engine.Configuration.Mixins.Count); Assert.AreEqual(1, engine.Configuration.Interceptors.Count); Assert.AreEqual(1, engine.Configuration.Aspects.Count); AspectDefinition aspect = engine.Configuration.Aspects[0]; Assert.AreEqual("McBrother", aspect.Name); Assert.AreEqual(typeof(DummyCustomer), aspect.TargetType.SingleType.ResolvedType); Assert.AreEqual(1, aspect.Mixins.Count); MixinDefinition mixin = aspect.Mixins[0]; Assert.AreEqual(typeof(DummyMixin), mixin.TypeReference.ResolvedType); Assert.AreEqual(1, aspect.PointCuts.Count); PointCutDefinition pointcut = aspect.PointCuts[0]; Assert.AreEqual(AllMethodSignature.Instance, pointcut.Method); Assert.AreEqual(1, pointcut.Advices.Count); InterceptorDefinition advice = pointcut.Advices[0]; Assert.AreEqual(typeof(DummyInterceptor), advice.TypeReference.ResolvedType); }
public void MultipleAttributesOnMembers() { TargetClassDefinition bt1 = DefinitionObjectMother.BuildUnvalidatedDefinition(typeof(BaseTypeWithAllowMultiple), typeof(MixinAddingAllowMultipleToClassAndMember), typeof(MixinAddingAllowMultipleToClassAndMember2)); MethodDefinition member = bt1.Methods[typeof(BaseTypeWithAllowMultiple).GetMethod("Foo")]; Assert.That(member.CustomAttributes.Count, Is.EqualTo(1)); Assert.That(member.Overrides.Count, Is.EqualTo(2)); Assert.That(member.ReceivedAttributes.Count, Is.EqualTo(2)); MixinDefinition mixin1 = bt1.Mixins[typeof(MixinAddingAllowMultipleToClassAndMember)]; MethodDefinition mixinMember1 = mixin1.Methods[typeof(MixinAddingAllowMultipleToClassAndMember).GetMethod("Foo")]; Assert.That(mixinMember1.CustomAttributes.Count, Is.EqualTo(1)); MixinDefinition mixin2 = bt1.Mixins[typeof(MixinAddingAllowMultipleToClassAndMember2)]; MethodDefinition mixinMember2 = mixin2.Methods[typeof(MixinAddingAllowMultipleToClassAndMember).GetMethod("Foo")]; Assert.That(mixinMember2.CustomAttributes.Count, Is.EqualTo(1)); Assert.That(member.ReceivedAttributes.ContainsKey(typeof(MultiAttribute)), Is.True); Assert.That(member.ReceivedAttributes.GetItemCount(typeof(MultiAttribute)), Is.EqualTo(2)); List <AttributeDefinition> attributes = new List <AttributeIntroductionDefinition> (member.ReceivedAttributes[typeof(MultiAttribute)]) .ConvertAll <AttributeDefinition> (delegate(AttributeIntroductionDefinition intro) { return(intro.Attribute); }); Assert.That(attributes, Is.EquivalentTo(new AttributeDefinition[] { mixinMember1.CustomAttributes[0], mixinMember2.CustomAttributes[0] })); }
public void Dependencies() { MixinDefinition bt3Mixin1 = DefinitionObjectMother.GetActiveTargetClassDefinition(typeof(BaseType3)).Mixins[typeof(BT3Mixin1)]; Assert.That(bt3Mixin1.TargetCallDependencies.ContainsKey(typeof(IBaseType31)), Is.True); Assert.That(bt3Mixin1.TargetCallDependencies.Count, Is.EqualTo(1)); Assert.That(bt3Mixin1.NextCallDependencies.ContainsKey(typeof(IBaseType31)), Is.True); Assert.That(bt3Mixin1.NextCallDependencies.Count, Is.EqualTo(1)); MixinDefinition bt3Mixin2 = DefinitionObjectMother.GetActiveTargetClassDefinition(typeof(BaseType3)).Mixins[typeof(BT3Mixin2)]; Assert.That(bt3Mixin2.TargetCallDependencies.ContainsKey(typeof(IBaseType32)), Is.True); Assert.That(bt3Mixin2.TargetCallDependencies.Count, Is.EqualTo(1)); Assert.That(bt3Mixin2.NextCallDependencies.Count, Is.EqualTo(0)); MixinDefinition bt3Mixin6 = DefinitionObjectMother.GetActiveTargetClassDefinition(typeof(BaseType3)).GetMixinByConfiguredType(typeof(BT3Mixin6 <,>)); Assert.That(bt3Mixin6.TargetCallDependencies.ContainsKey(typeof(IBaseType31)), Is.True); Assert.That(bt3Mixin6.TargetCallDependencies.ContainsKey(typeof(IBaseType32)), Is.True); Assert.That(bt3Mixin6.TargetCallDependencies.ContainsKey(typeof(IBaseType33)), Is.True); Assert.That(bt3Mixin6.TargetCallDependencies.ContainsKey(typeof(IBT3Mixin4)), Is.True); Assert.That(bt3Mixin6.TargetCallDependencies.ContainsKey(typeof(IBaseType34)), Is.False); Assert.That(bt3Mixin6.TargetCallDependencies[typeof(IBaseType31)].IsAggregate, Is.False); Assert.That(bt3Mixin6.TargetCallDependencies[typeof(IBT3Mixin4)].IsAggregate, Is.False); Assert.That(bt3Mixin6.TargetCallDependencies[typeof(IBaseType31)].AggregatedDependencies.Count, Is.EqualTo(0)); Assert.That(bt3Mixin6.TargetCallDependencies[typeof(IBT3Mixin4)].RequiredType.RequiringDependencies.ContainsKey( bt3Mixin6.TargetCallDependencies[typeof(IBT3Mixin4)]), Is.True); Assert.That(bt3Mixin6.TargetCallDependencies[typeof(IBT3Mixin4)].Aggregator, Is.Null); Assert.That(bt3Mixin6.TargetCallDependencies[typeof(IBaseType31)].RequiredType, Is.SameAs(bt3Mixin6.TargetClass.RequiredTargetCallTypes[typeof(IBaseType31)])); Assert.That(bt3Mixin6.TargetCallDependencies[typeof(IBaseType32)].GetImplementer(), Is.SameAs(bt3Mixin6.TargetClass)); Assert.That(bt3Mixin6.TargetCallDependencies[typeof(IBT3Mixin4)].GetImplementer(), Is.SameAs(bt3Mixin6.TargetClass.Mixins[typeof(BT3Mixin4)])); Assert.That(bt3Mixin6.NextCallDependencies.ContainsKey(typeof(IBaseType34)), Is.True); Assert.That(bt3Mixin6.NextCallDependencies.ContainsKey(typeof(IBT3Mixin4)), Is.True); Assert.That(bt3Mixin6.NextCallDependencies.ContainsKey(typeof(IBaseType31)), Is.False); Assert.That(bt3Mixin6.NextCallDependencies.ContainsKey(typeof(IBaseType32)), Is.False); Assert.IsTrue(bt3Mixin6.NextCallDependencies.ContainsKey(typeof(IBaseType33)), "indirect dependency"); Assert.That(bt3Mixin6.NextCallDependencies[typeof(IBaseType34)].RequiredType, Is.SameAs(bt3Mixin6.TargetClass.RequiredNextCallTypes[typeof(IBaseType34)])); Assert.That(bt3Mixin6.NextCallDependencies[typeof(IBaseType34)].GetImplementer(), Is.SameAs(bt3Mixin6.TargetClass)); Assert.That(bt3Mixin6.NextCallDependencies[typeof(IBT3Mixin4)].GetImplementer(), Is.SameAs(bt3Mixin6.TargetClass.Mixins[typeof(BT3Mixin4)])); Assert.That(bt3Mixin6.NextCallDependencies[typeof(IBT3Mixin4)].IsAggregate, Is.False); Assert.That(bt3Mixin6.NextCallDependencies[typeof(IBT3Mixin4)].IsAggregate, Is.False); Assert.That(bt3Mixin6.NextCallDependencies[typeof(IBT3Mixin4)].AggregatedDependencies.Count, Is.EqualTo(0)); Assert.That(bt3Mixin6.NextCallDependencies[typeof(IBT3Mixin4)].RequiredType.RequiringDependencies.ContainsKey( bt3Mixin6.NextCallDependencies[typeof(IBT3Mixin4)]), Is.True); Assert.That(bt3Mixin6.NextCallDependencies[typeof(IBT3Mixin4)].Aggregator, Is.Null); }
public void GenericMixinsAreSetToConstraintOrBaseType() { MixinDefinition def = DefinitionObjectMother.BuildUnvalidatedDefinition(typeof(BaseType3), typeof(BT3Mixin3 <,>)) .GetMixinByConfiguredType(typeof(BT3Mixin3 <,>)); Assert.That(def.Type.GetGenericArguments()[0], Is.EqualTo(typeof(BaseType3))); Assert.That(def.Type.GetGenericArguments()[1], Is.EqualTo(typeof(IBaseType33))); }
public void AcceptsAlphabeticOrdering_False() { using (MixinConfiguration.BuildNew().ForClass <NullTarget> ().AddMixin <NullMixin> ().EnterScope()) { MixinDefinition accepter = DefinitionObjectMother.GetActiveTargetClassDefinition(typeof(NullTarget)).Mixins[typeof(NullMixin)]; Assert.That(accepter.AcceptsAlphabeticOrdering, Is.False); } }
public void MixinKind_Used() { using (MixinConfiguration.BuildNew().ForClass <NullTarget> ().AddMixin <NullMixin> ().OfKind(MixinKind.Used).EnterScope()) { MixinDefinition mixin = DefinitionObjectMother.GetActiveTargetClassDefinition(typeof(NullTarget)).Mixins[typeof(NullMixin)]; Assert.That(mixin.MixinKind, Is.EqualTo(MixinKind.Used)); } }
public void NotOverriddenAbstractMixinMethodSucceeds() { TargetClassDefinition bt1 = DefinitionObjectMother.BuildUnvalidatedDefinition(typeof(BaseType1), typeof(MixinWithAbstractMembers)); MixinDefinition mixin = bt1.Mixins[typeof(MixinWithAbstractMembers)]; MethodDefinition method = mixin.Methods[typeof(MixinWithAbstractMembers).GetMethod("AbstractMethod", BindingFlags.Instance | BindingFlags.NonPublic)]; Assert.That(method.Overrides.Count, Is.EqualTo(0)); }
public static MixinDependencyDefinition CreateMixinDependencyDefinition(MixinDefinition definition) { ArgumentUtility.CheckNotNull("definition", definition); var mixinDependency = new MixinDependencyDefinition(new RequiredMixinTypeDefinition(definition.TargetClass, typeof(IBaseType2)), definition, null); PrivateInvoke.InvokeNonPublicMethod(definition.MixinDependencies, "Add", mixinDependency); return(mixinDependency); }
public void CopyNonInheritedAttributesFromSelf_DosntIntroduceDuplicates() { using (MixinConfiguration.BuildFromActive().ForClass <NullTarget> ().Clear().AddMixins(typeof(MixinIndirectlyAddingInheritedAttributeFromSelf)).EnterScope()) { MixinDefinition definition = DefinitionObjectMother.GetActiveTargetClassDefinition(typeof(NullTarget)).Mixins[typeof(MixinIndirectlyAddingInheritedAttributeFromSelf)]; Assert.That(definition.CustomAttributes.ContainsKey(typeof(AttributeWithParameters)), Is.True); Assert.That(new List <AttributeDefinition> (definition.CustomAttributes[typeof(AttributeWithParameters)]).Count, Is.EqualTo(1)); } }
public void CopyNonInheritedAttributesFromSelf() { using (MixinConfiguration.BuildFromActive().ForClass <NullTarget> ().Clear().AddMixins(typeof(MixinIndirectlyAddingNonInheritedAttributeFromSelf)).EnterScope()) { MixinDefinition definition = DefinitionObjectMother.GetActiveTargetClassDefinition(typeof(NullTarget)).Mixins[typeof(MixinIndirectlyAddingNonInheritedAttributeFromSelf)]; Assert.That(definition.CustomAttributes.ContainsKey(typeof(CopyCustomAttributesAttribute)), Is.False); Assert.That(definition.CustomAttributes.ContainsKey(typeof(NonInheritableAttribute)), Is.True); } }
public InterfaceIntroductionDefinitionBuilder(MixinDefinition mixin, MemberVisibility defaultVisibility) { _mixin = mixin; _defaultVisibility = defaultVisibility; _nonIntroducedInterfaces = new HashSet <Type> { typeof(ISerializable), typeof(IDeserializationCallback), typeof(IInitializableMixin) }; AnalyzeNonIntroducedInterfaces(); }
private MixinDefinition CreateMixinDefinition(MixinContext mixinContext) { Type mixinType = TargetClass.MixinTypeCloser.GetClosedMixinType(mixinContext.MixinType); bool acceptsAlphabeticOrdering = AcceptsAlphabeticOrdering(mixinType); var mixin = new MixinDefinition(mixinContext.MixinKind, mixinType, TargetClass, acceptsAlphabeticOrdering); TargetClass.Mixins.Add(mixin); return(mixin); }
private void CheckSomeRequiringMixin(RequirementDefinitionBase requirement, MixinDefinition expectedRequiringMixin) { ArgumentUtility.CheckNotNull("requirement", requirement); ArgumentUtility.CheckNotNull("expectedRequiringMixin", expectedRequiringMixin); var requirers = requirement.GetRequiringEntityDescription().Split(new[] { ", " }, StringSplitOptions.None); Assert.That(requirers, Has.Member("mixin '" + expectedRequiringMixin.FullName + "'")); }
private Expression GetMixinReference(MixinDefinition mixin, Type concreteMixinType) { // (ConcreteMixinType) __this.__extensions[mixin.MixinIndex] return(Expression.Convert( Expression.ArrayAccess( Expression.Field(_thisField, _targetTypeForNextCall.ExtensionsField), Expression.Constant(mixin.MixinIndex)), concreteMixinType)); }
public static MixinDefinition CreateMixinDefinition(TargetClassDefinition targetClassDefinition, Type mixinType, bool acceptsAlphabeticOrdering = true) { ArgumentUtility.CheckNotNull("targetClassDefinition", targetClassDefinition); ArgumentUtility.CheckNotNull("mixinType", mixinType); var mixinDefinition = new MixinDefinition(MixinKind.Used, mixinType, targetClassDefinition, acceptsAlphabeticOrdering); PrivateInvoke.InvokeNonPublicMethod(targetClassDefinition.Mixins, "Add", mixinDefinition); return(mixinDefinition); }
public static MixinDependencyDefinition CreateMixinDependencyDefinition(MixinDefinition from, MixinDefinition to) { ArgumentUtility.CheckNotNull("from", from); ArgumentUtility.CheckNotNull("to", to); var mixinDependency = new MixinDependencyDefinition(new RequiredMixinTypeDefinition(from.TargetClass, to.Type), from, null); PrivateInvoke.InvokeNonPublicMethod(from.MixinDependencies, "Add", mixinDependency); return(mixinDependency); }
public void SetUp() { _remotionReflector = new Reflectors.OldMixinDependenciesReflector (); var mixinConfiguration = MixinConfiguration.BuildNew () .ForClass<TargetClass1> () .AddMixin<Mixin1> () .BuildConfiguration (); _targetClassDefinition = TargetClassDefinitionUtility.GetConfiguration (typeof (TargetClass1), mixinConfiguration); _mixinDefinition = _targetClassDefinition.GetMixinByConfiguredType (typeof (Mixin1)); }
public void SetUp() { _remotionReflector = new Reflectors.NewMixinDependenciesReflector (); var mixinConfiguration = MixinConfiguration.BuildNew () .ForClass<TargetClass1> () .AddMixin<Mixin1> () .BuildConfiguration (); _targetClassDefinition = TargetClassDefinitionFactory.CreateTargetClassDefinition (mixinConfiguration.ClassContexts.First ()); _mixinDefinition = _targetClassDefinition.GetMixinByConfiguredType (typeof (Mixin1)); }
public override void OnMixinDefinition(MixinDefinition mixin) { Push( Document.CreateNode(XmlNodeType.Element, "mixin", null) ); SerializeTypeReference(mixin.TypeReference); Pop(); }
public virtual void OnMixinDefinition(MixinDefinition mixin) { OnTypeReferenceDefinition(mixin.TypeReference); }
public void SetUp() { _remotionReflector = new Reflectors.Net4_5SupportReflector ().Initialize("."); var mixinConfiguration = MixinConfiguration.BuildNew () .ForClass<TargetClass1> () .AddMixin<Mixin1> () .BuildConfiguration (); _targetClassDefinition = TargetClassDefinitionFactory.CreateAndValidate (mixinConfiguration.ClassContexts.First ()); _mixinDefinition = _targetClassDefinition.GetMixinByConfiguredType (typeof (Mixin1)); }