public void AddMixinToClass_WithoutOrigin() { var mockRepository = new MockRepository(); var builder = mockRepository.StrictMock <MixinConfigurationBuilder> ((MixinConfiguration)null); var targetType = typeof(object); var mixinType = typeof(string); var explicitDependencies = new[] { typeof(int) }; var suppressedMixins = new[] { typeof(double) }; var expectedOrigin = MixinContextOrigin.CreateForMethod(MethodBase.GetCurrentMethod()); builder .Expect( mock => mock.AddMixinToClass( MixinKind.Extending, targetType, mixinType, MemberVisibility.Private, explicitDependencies, suppressedMixins, expectedOrigin)) .Return(builder); mockRepository.ReplayAll(); var returnedBuilder = builder.AddMixinToClass( MixinKind.Extending, targetType, mixinType, MemberVisibility.Private, explicitDependencies, suppressedMixins); mockRepository.VerifyAll(); Assert.That(returnedBuilder, Is.SameAs(builder)); }
public void GetHashCode_EqualObjects() { var origin1 = new MixinContextOrigin("some kind", GetType().Assembly, "some location"); var origin2 = new MixinContextOrigin("some kind", GetType().Assembly, "some location"); Assert.That(origin1.GetHashCode(), Is.EqualTo(origin2.GetHashCode())); }
public MixinContextBuilder EnsureMixin(Type mixinType) { ArgumentUtility.CheckNotNull("mixinType", mixinType); var origin = MixinContextOrigin.CreateForStackFrame(new StackFrame(1)); return(EnsureMixin(mixinType, origin)); }
/// <summary> /// Adds the given mixin to the given target type with a number of explicit dependencies and suppressed mixins. This is a shortcut /// method for calling <see cref="ForClass"/>, <see cref="ClassContextBuilder.AddMixin(System.Type,Remotion.Mixins.Context.MixinContextOrigin)"/>, /// <see cref="MixinContextBuilder.WithDependencies"/>, and <see cref="MixinContextBuilder.ReplaceMixins"/> in a row. /// </summary> /// <param name="mixinKind">The kind of relationship the mixin has with its target class.</param> /// <param name="targetType">The target type to add a mixin for.</param> /// <param name="mixinType">The mixin type to add.</param> /// <param name="introducedMemberVisibility">The default visibility to be used for introduced members.</param> /// <param name="explicitDependencies">The explicit dependencies of the mixin in the context of the target type.</param> /// <param name="suppressedMixins">The mixins suppressed by this mixin in the context of the target type.</param> /// <param name="origin">A <see cref="MixinContextOrigin"/> object describing where the mixin configuration originates from.</param> public virtual MixinConfigurationBuilder AddMixinToClass( MixinKind mixinKind, Type targetType, Type mixinType, MemberVisibility introducedMemberVisibility, IEnumerable <Type> explicitDependencies, IEnumerable <Type> suppressedMixins, MixinContextOrigin origin) { ArgumentUtility.CheckNotNull("targetType", targetType); ArgumentUtility.CheckNotNull("mixinType", mixinType); ArgumentUtility.CheckNotNull("explicitDependencies", explicitDependencies); ArgumentUtility.CheckNotNull("suppressedMixins", suppressedMixins); ArgumentUtility.CheckNotNull("origin", origin); MixinContextBuilder mixinContextBuilder = AddMixinToClass(targetType, mixinType, origin); mixinContextBuilder .OfKind(mixinKind) .WithDependencies(explicitDependencies.ToArray()) .WithIntroducedMemberVisibility(introducedMemberVisibility) .ReplaceMixins(suppressedMixins.ToArray()); return(this); }
public void CreateForMethod() { var origin = MixinContextOrigin.CreateForMethod(MethodBase.GetCurrentMethod()); Assert.That(origin.Kind, Is.EqualTo("Method")); Assert.That(origin.Assembly, Is.EqualTo(GetType().Assembly)); Assert.That(origin.Location, Is.EqualTo("Void CreateForMethod(), declaring type: Remotion.Mixins.UnitTests.Core.Context.MixinContextOriginTest")); }
public void CreateForCustomAttribute_OnAssembly() { var origin = MixinContextOrigin.CreateForCustomAttribute(new MixAttribute(typeof(object), typeof(NullMixin)), _someAssembly); Assert.That(origin.Kind, Is.EqualTo("MixAttribute")); Assert.That(origin.Assembly, Is.EqualTo(_someAssembly)); Assert.That(origin.Location, Is.EqualTo("assembly")); }
public void CreateForCustomAttribute_OnMemberInfo() { var origin = MixinContextOrigin.CreateForCustomAttribute(new UsesAttribute(typeof(NullMixin)), typeof(MixinContextOriginTest)); Assert.That(origin.Kind, Is.EqualTo("UsesAttribute")); Assert.That(origin.Assembly, Is.EqualTo(typeof(MixinContextOriginTest).Assembly)); Assert.That(origin.Location, Is.EqualTo("Remotion.Mixins.UnitTests.Core.Context.MixinContextOriginTest")); }
public void Equals_True() { var origin1 = new MixinContextOrigin("some kind", GetType().Assembly, "some location"); var origin2 = new MixinContextOrigin("some kind", GetType().Assembly, "some location"); Assert.That(origin1.Equals(origin2), Is.True); Assert.That(origin1.Equals((object)origin2), Is.True); }
public ClassContextBuilder EnsureMixins(params Type[] mixinTypes) { ArgumentUtility.CheckNotNullOrEmpty("mixinTypes", mixinTypes); var origin = MixinContextOrigin.CreateForStackFrame(new StackFrame(1)); return(EnsureMixins(origin, mixinTypes)); }
public void Origin() { ClassContext context = MixinConfiguration.ActiveConfiguration.GetContext(typeof(TargetClassForGlobalMix)); var expectedOrigin = new MixinContextOrigin("MixAttribute", typeof(TargetClassForGlobalMix).Assembly, "assembly"); Assert.That(context.Mixins[typeof(MixinForGlobalMix)].Origin, Is.EqualTo(expectedOrigin)); }
public void SetUp() { _mockRepository = new MockRepository(); _parentBuilderMock = _mockRepository.StrictMock <ClassContextBuilder> (typeof(object)); _origin = MixinContextOriginObjectMother.Create(); _mixinBuilder = new MixinContextBuilder(_parentBuilderMock, typeof(BT2Mixin1), _origin); }
private Expression CreateOriginExpression(MixinContextOrigin origin) { var serializer = new ExpressionMixinContextOriginSerializer(); origin.Serialize(serializer); return(serializer.CreateNewExpression()); }
public void AddOrigin(MixinContextOrigin origin) { ArgumentUtility.CheckNotNull("origin", origin); var originSerializer = new CodeGenerationMixinContextOriginSerializer(); origin.Serialize(originSerializer); _constructorArguments[4] = originSerializer.GetConstructorInvocationExpression(); }
public void CreateForStackFrame() { var stackFrame = GetCallerStackFrame(); var origin = MixinContextOrigin.CreateForStackFrame(stackFrame); Assert.That(origin.Kind, Is.EqualTo("Method")); Assert.That(origin.Assembly, Is.EqualTo(GetType().Assembly)); Assert.That(origin.Location, Is.EqualTo("Void CreateForStackFrame(), declaring type: Remotion.Mixins.UnitTests.Core.Context.MixinContextOriginTest")); }
public void Apply(MixinConfigurationBuilder configurationBuilder, Assembly attributeTarget) { ArgumentUtility.CheckNotNull("configurationBuilder", configurationBuilder); ArgumentUtility.CheckNotNull("attributeTarget", attributeTarget); var origin = MixinContextOrigin.CreateForCustomAttribute(this, attributeTarget); Apply(configurationBuilder, MixinKind, TargetType, MixinType, origin); }
public void AddOrigin(MixinContextOrigin origin) { ArgumentUtility.CheckNotNull("origin", origin); var originSerializer = CreateMixinContextOriginSerializer(); origin.Serialize(originSerializer); Values[4] = originSerializer.Values; }
public void EnsureMixins_Generic3_WithoutOrigin() { var expectedOrigin = MixinContextOrigin.CreateForMethod(MethodBase.GetCurrentMethod()); _classBuilderMock.Expect(mock => mock.EnsureMixins <BT2Mixin1, BT3Mixin1, BT3Mixin2> (expectedOrigin)).Return(_classBuilderMock); _mockRepository.Replay(_classBuilderMock); Assert.That(_classBuilderMock.EnsureMixins <BT2Mixin1, BT3Mixin1, BT3Mixin2> (), Is.SameAs(_classBuilderMock)); _mockRepository.Verify(_classBuilderMock); }
public void AddMixin_NonGeneric_WithoutOrigin() { var expectedOrigin = MixinContextOrigin.CreateForMethod(MethodBase.GetCurrentMethod()); _classBuilderMock.Expect(mock => mock.AddMixin(typeof(BT2Mixin1), expectedOrigin)).Return(_mixinBuilderMock); _mockRepository.Replay(_classBuilderMock); Assert.That(_classBuilderMock.AddMixin(typeof(BT2Mixin1)), Is.SameAs(_mixinBuilderMock)); _mockRepository.Verify(_classBuilderMock); }
public void Apply(MixinConfigurationBuilder configurationBuilder, Type attributeTarget) { ArgumentUtility.CheckNotNull("configurationBuilder", configurationBuilder); ArgumentUtility.CheckNotNull("attributeTarget", attributeTarget); Type mixinType = CloseOverMixinTypeArguments(attributeTarget); var origin = MixinContextOrigin.CreateForCustomAttribute(this, attributeTarget); Apply(configurationBuilder, MixinKind.Extending, TargetType, mixinType, origin); }
public new void ToString() { var origin = new MixinContextOrigin("SomeKind", _someAssembly, "some location"); var expectedCodeBase = _someAssembly.CodeBase; var expected = string.Format( "SomeKind, Location: 'some location' (Assembly: 'Remotion.Mixins.UnitTests', code base: {0})", expectedCodeBase); Assert.That(origin.ToString(), Is.EqualTo(expected)); }
/// <summary> /// Ensures that the given types are configured as mixins for the <see cref="TargetType"/>, adding them if necessary. The mixins will not be /// added if they has been taken over from the parent context (unless <see cref="Clear"/> was called); if added, they will override corresponding /// mixins inherited from a base type. /// </summary> /// <param name="origin">A <see cref="MixinContextOrigin"/> object describing where the mixin configuration originates from.</param> /// <param name="mixinTypes">The mixin types to collect.</param> /// <returns>This object for further configuration of the <see cref="TargetType"/>.</returns> public virtual ClassContextBuilder EnsureMixins(MixinContextOrigin origin, params Type[] mixinTypes) { ArgumentUtility.CheckNotNullOrEmpty("mixinTypes", mixinTypes); ArgumentUtility.CheckNotNull("origin", origin); foreach (Type mixinType in mixinTypes) { EnsureMixin(mixinType, origin); } return(this); }
public void AddOrderedMixins_Generic2_WithoutOrigin() { var expectedOrigin = MixinContextOrigin.CreateForMethod(MethodBase.GetCurrentMethod()); _classBuilderMock.Expect(mock => mock.AddOrderedMixins <BT2Mixin1, BT3Mixin1> (expectedOrigin)).Return(_classBuilderMock); _mockRepository.ReplayAll(); var result = _classBuilderMock.AddOrderedMixins <BT2Mixin1, BT3Mixin1>(); _mockRepository.VerifyAll(); Assert.That(result, Is.SameAs(_classBuilderMock)); }
public void Origin() { var configuration = new DeclarativeConfigurationBuilder(null).AddType(typeof(User)).BuildConfiguration(); var context = configuration.GetContext(typeof(User)); var mixinContext = context.Mixins.Single(); var expectedOrigin = new MixinContextOrigin( "UsesAttribute", typeof(User).Assembly, "Remotion.Mixins.UnitTests.Core.Context.DeclarativeConfigurationBuilder_IntegrationTests.UsesAnalysisTest+User"); Assert.That(mixinContext.Origin, Is.EqualTo(expectedOrigin)); }
/// <summary> /// Ensures that the given type is configured as a mixin for the <see cref="TargetType"/>, adding it if necessary. The mixin will not be /// added if it has been taken over from the parent context (unless <see cref="Clear"/> was called); if added, it will override corresponding /// mixins inherited from a base type. /// </summary> /// <param name="mixinType">The mixin type to collect.</param> /// <param name="origin">A <see cref="MixinContextOrigin"/> object describing where the mixin configuration originates from.</param> /// <returns>This object for further configuration of the <see cref="TargetType"/>.</returns> public virtual MixinContextBuilder EnsureMixin(Type mixinType, MixinContextOrigin origin) { ArgumentUtility.CheckNotNull("mixinType", mixinType); ArgumentUtility.CheckNotNull("origin", origin); MixinContextBuilder builder; if (!_mixinContextBuilders.TryGetValue(mixinType, out builder)) { builder = AddMixin(mixinType, origin); } return(builder); }
private static ClassContext CreateClassContext(Type classType, Type[] persistentMixins) { var mixinContexts = persistentMixins.Select( t => new MixinContext( MixinKind.Extending, t, MemberVisibility.Private, Enumerable.Empty <Type>(), MixinContextOrigin.CreateForMethod(MethodBase.GetCurrentMethod()))); return(new ClassContext(classType, mixinContexts, Enumerable.Empty <Type> ())); }
public static MixinContext Create( MixinKind mixinKind = MixinKind.Extending, Type mixinType = null, MemberVisibility introducedMemberVisibility = MemberVisibility.Private, IEnumerable <Type> explicitDependencies = null, MixinContextOrigin origin = null) { return(new MixinContext( mixinKind, mixinType ?? typeof(UnspecifiedType), introducedMemberVisibility, explicitDependencies ?? new[] { typeof(object), typeof(string) }, origin ?? MixinContextOriginObjectMother.Create())); }
public void Deserialize() { var deserializerStub = MockRepository.GenerateStub <IMixinContextOriginDeserializer> (); deserializerStub.Stub(stub => stub.GetKind()).Return("SomeKind"); deserializerStub.Stub(stub => stub.GetAssembly()).Return(_someAssembly); deserializerStub.Stub(stub => stub.GetLocation()).Return("some location"); var origin = MixinContextOrigin.Deserialize(deserializerStub); Assert.That(origin.Kind, Is.EqualTo("SomeKind")); Assert.That(origin.Assembly, Is.EqualTo(_someAssembly)); Assert.That(origin.Location, Is.EqualTo("some location")); }
public void Serialize() { var origin = new MixinContextOrigin("SomeKind", _someAssembly, "some location"); var serializerMock = MockRepository.GenerateStrictMock <IMixinContextOriginSerializer>(); serializerMock.Expect(mock => mock.AddKind(origin.Kind)); serializerMock.Expect(mock => mock.AddAssembly(origin.Assembly)); serializerMock.Expect(mock => mock.AddLocation(origin.Location)); origin.Serialize(serializerMock); serializerMock.VerifyAllExpectations(); }
public void IntegrationTest() { var someAssembly = GetType().Assembly; var referenceContextOrigin = new MixinContextOrigin("some kind", someAssembly, "some location"); var serializer = new CodeGenerationMixinContextOriginSerializer(); referenceContextOrigin.Serialize(serializer); var expression = serializer.GetConstructorInvocationExpression(); var compiledExpression = Expression.Lambda <Func <MixinContextOrigin> > (expression).Compile(); var result = compiledExpression(); Assert.That(result, Is.EqualTo(referenceContextOrigin)); }
public MixinConfigurationBuilder AddMixinToClass( MixinKind mixinKind, Type targetType, Type mixinType, MemberVisibility introducedMemberVisibility, IEnumerable <Type> explicitDependencies, IEnumerable <Type> suppressedMixins) { ArgumentUtility.CheckNotNull("targetType", targetType); ArgumentUtility.CheckNotNull("mixinType", mixinType); ArgumentUtility.CheckNotNull("explicitDependencies", explicitDependencies); ArgumentUtility.CheckNotNull("suppressedMixins", suppressedMixins); var origin = MixinContextOrigin.CreateForStackFrame(new StackFrame(1)); return(AddMixinToClass(mixinKind, targetType, mixinType, introducedMemberVisibility, explicitDependencies, suppressedMixins, origin)); }