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));
}
