public void MixinKindProperty()
{
var c1 = MixinContextObjectMother.Create(mixinKind: MixinKind.Extending);
var c2 = MixinContextObjectMother.Create(mixinKind: MixinKind.Used);
Assert.That(c1.MixinKind, Is.EqualTo(MixinKind.Extending));
Assert.That(c2.MixinKind, Is.EqualTo(MixinKind.Used));
}
public void ExplicitDependencies_Empty()
{
var mixinContext = MixinContextObjectMother.Create(explicitDependencies: Enumerable.Empty <Type> ());
Assert.That(mixinContext.ExplicitDependencies.Count, Is.EqualTo(0));
Assert.That(mixinContext.ExplicitDependencies, Has.No.Member(typeof(IBaseType2)));
Assert.That(mixinContext.ExplicitDependencies, Is.Empty);
}
public void ExplicitMixinDependencies_NonEmpty()
{
var mixinContext = MixinContextObjectMother.Create(explicitDependencies: new[] { typeof(BT6Mixin2), typeof(BT6Mixin3 <>) });
Assert.That(mixinContext.ExplicitDependencies.Count, Is.EqualTo(2));
Assert.That(mixinContext.ExplicitDependencies, Has.Member(typeof(BT6Mixin2)));
Assert.That(mixinContext.ExplicitDependencies, Has.Member(typeof(BT6Mixin3 <>)));
Assert.That(mixinContext.ExplicitDependencies, Is.EquivalentTo(new[] { typeof(BT6Mixin2), typeof(BT6Mixin3 <>) }));
}
public void SetUp()
{
_mcObject = MixinContextObjectMother.Create(mixinType: typeof(object));
_mcString = MixinContextObjectMother.Create(mixinType: typeof(string));
_mcList = MixinContextObjectMother.Create(mixinType: typeof(List <int>));
_mcGeneric = MixinContextObjectMother.Create(mixinType: typeof(DerivedGenericMixin <object>));
_mcDerived = MixinContextObjectMother.Create(mixinType: typeof(DerivedNullMixin));
_collection = new MixinContextCollection(new[] { _mcObject, _mcString, _mcList, _mcDerived });
_genericCollection = new MixinContextCollection(new[] { _mcGeneric });
}
public void ApplyMixinDependencies_NotFound()
{
var originalMixinContext1 = MixinContextObjectMother.Create(mixinType: typeof(object), explicitDependencies: new[] { typeof(int) });
var originalClassContext = ClassContextObjectMother.Create(typeof(NullTarget), originalMixinContext1);
var dependencies = new[] { new MixinDependencySpecification(typeof(string), new[] { typeof(float) }) };
Assert.That(
() => originalClassContext.ApplyMixinDependencies(dependencies),
Throws.InvalidOperationException.With.Message.EqualTo(
"The mixin 'System.String' is not configured for class 'Remotion.Mixins.UnitTests.Core.TestDomain.NullTarget'."));
}
public void Roundtrip_WithPublicVisibility_IntegrationTest()
{
var classContext = new ClassContext(
typeof(BaseType1),
new[] { MixinContextObjectMother.Create() },
Enumerable.Empty <Type>());
var attribute = CreateAttribute(classContext);
var classContext2 = attribute.GetClassContext();
Assert.That(classContext2, Is.EqualTo(classContext));
}
public void Serialize()
{
var context = MixinContextObjectMother.Create();
var serializer = MockRepository.GenerateMock <IMixinContextSerializer> ();
context.Serialize(serializer);
serializer.AssertWasCalled(mock => mock.AddMixinKind(context.MixinKind));
serializer.AssertWasCalled(mock => mock.AddMixinType(context.MixinType));
serializer.AssertWasCalled(mock => mock.AddIntroducedMemberVisibility(context.IntroducedMemberVisibility));
serializer.AssertWasCalled(mock => mock.AddExplicitDependencies(Arg <IEnumerable <Type> > .List.Equal(context.ExplicitDependencies)));
serializer.AssertWasCalled(mock => mock.AddOrigin(context.Origin));
}
public void ApplyAdditionalExplicitDependencies()
{
var context = MixinContextObjectMother.Create(explicitDependencies: new[] { typeof(int), typeof(double) });
var result = context.ApplyAdditionalExplicitDependencies(new[] { typeof(string), typeof(double), typeof(float), typeof(float) });
Assert.That(result.ExplicitDependencies, Is.EquivalentTo(new[] { typeof(int), typeof(double), typeof(string), typeof(float) }));
Assert.That(context.ExplicitDependencies, Is.EquivalentTo(new[] { typeof(int), typeof(double) }));
Assert.That(result.MixinType, Is.SameAs(context.MixinType));
Assert.That(result.MixinKind, Is.EqualTo(context.MixinKind));
Assert.That(result.IntroducedMemberVisibility, Is.EqualTo(context.IntroducedMemberVisibility));
Assert.That(result.Origin, Is.SameAs(context.Origin));
}
public void ApplyMixinDependencies_GenericMixin_Ambiguous()
{
var originalMixinContext1 = MixinContextObjectMother.Create(mixinType: typeof(List <int>), explicitDependencies: new[] { typeof(int) });
var originalMixinContext2 = MixinContextObjectMother.Create(mixinType: typeof(List <string>), explicitDependencies: new[] { typeof(int) });
var originalClassContext = ClassContextObjectMother.Create(typeof(NullTarget), originalMixinContext1, originalMixinContext2);
var dependencies = new[] { new MixinDependencySpecification(typeof(List <>), new[] { typeof(float) }) };
Assert.That(
() => originalClassContext.ApplyMixinDependencies(dependencies),
Throws.InvalidOperationException.With.Message.EqualTo(
"The dependency specification for 'System.Collections.Generic.List`1[T]' applied to class "
+ "'Remotion.Mixins.UnitTests.Core.TestDomain.NullTarget' is ambiguous; matching mixins: "
+ "'System.Collections.Generic.List`1[System.Int32]', 'System.Collections.Generic.List`1[System.String]'."));
}
public void IntegrationTest()
{
var referenceMixinContext1 = MixinContextObjectMother.Create(mixinType: typeof(BT1Mixin1));
var referenceMixinContext2 = MixinContextObjectMother.Create(mixinType: typeof(BT1Mixin2));
var referenceClassContext = new ClassContext(typeof(BaseType1), new[] { referenceMixinContext1, referenceMixinContext2 }, new[] { typeof(DateTime) });
var serializer = new CodeGenerationClassContextSerializer();
referenceClassContext.Serialize(serializer);
var expression = serializer.GetConstructorInvocationExpression();
var compiledExpression = Expression.Lambda <Func <ClassContext> > (expression).Compile();
var result = compiledExpression();
Assert.That(result, Is.EqualTo(referenceClassContext));
}
public void IntegrationTest()
{
var referenceContext = MixinContextObjectMother.Create();
var serializer = new CodeGenerationMixinContextSerializer();
referenceContext.Serialize(serializer);
var expression = serializer.GetConstructorInvocationExpression();
var compiledExpression = Expression.Lambda <Func <MixinContext> > (expression).Compile();
var result = compiledExpression();
Assert.That(result, Is.EqualTo(referenceContext));
Assert.That(result.Origin, Is.EqualTo(referenceContext.Origin));
}
public void Deserialize()
{
var expectedContext = MixinContextObjectMother.Create();
var deserializer = MockRepository.GenerateStrictMock <IMixinContextDeserializer> ();
deserializer.Expect(mock => mock.GetMixinType()).Return(expectedContext.MixinType);
deserializer.Expect(mock => mock.GetMixinKind()).Return(expectedContext.MixinKind);
deserializer.Expect(mock => mock.GetIntroducedMemberVisibility()).Return(expectedContext.IntroducedMemberVisibility);
deserializer.Expect(mock => mock.GetExplicitDependencies()).Return(expectedContext.ExplicitDependencies);
deserializer.Expect(mock => mock.GetOrigin()).Return(expectedContext.Origin);
var context = MixinContext.Deserialize(deserializer);
deserializer.VerifyAllExpectations();
Assert.That(context, Is.EqualTo(expectedContext));
}
public void AddMixins()
{
var mixinContext1 = MixinContextObjectMother.Create(mixinType: typeof(string), origin: MixinContextOriginObjectMother.Create(assembly: GetType().Assembly));
var mixinContext2 = MixinContextObjectMother.Create(mixinType: typeof(object));
_serializer.AddMixins(new[] { mixinContext1, mixinContext2 });
// Check that the chain of serializers correctly sets up the AttributeMixinContextOriginSerializer
var serializedMixinContexts = ((object[])_serializer.Values[1]);
var serializedMixinContext1 = (object[])serializedMixinContexts[1];
var serializedMixinOrigin = (object[])serializedMixinContext1[4];
var serializedMixinOriginAssembly = serializedMixinOrigin[1];
Assert.That(serializedMixinOriginAssembly, Is.EqualTo(GetType().Assembly.FullName));
var deserializer = new AttributeClassContextDeserializer(_serializer.Values);
Assert.That(deserializer.GetMixins().ToArray(), Is.EqualTo(new[] { mixinContext1, mixinContext2 }));
}
public void ApplyMixinDependencies()
{
var originalMixinContext1 = MixinContextObjectMother.Create(mixinType: typeof(string), explicitDependencies: new[] { typeof(int) });
var originalMixinContext2 = MixinContextObjectMother.Create(mixinType: typeof(DateTime), explicitDependencies: new[] { typeof(double) });
var originalMixinContext3 = MixinContextObjectMother.Create(mixinType: typeof(object), explicitDependencies: new[] { typeof(decimal) });
var originalClassContext = ClassContextObjectMother.Create(typeof(NullTarget), originalMixinContext1, originalMixinContext2, originalMixinContext3);
var dependencies =
new[]
{
new MixinDependencySpecification(typeof(string), new[] { typeof(int), typeof(float), typeof(long) }),
new MixinDependencySpecification(typeof(object), new[] { typeof(byte) }),
new MixinDependencySpecification(typeof(string), new[] { typeof(Enum) })
};
var result = originalClassContext.ApplyMixinDependencies(dependencies);
Assert.That(result, Is.Not.EqualTo(originalClassContext));
var expectedResult = new ClassContext(
originalClassContext.Type,
new[]
{
new MixinContext(
originalMixinContext1.MixinKind,
originalMixinContext1.MixinType,
originalMixinContext1.IntroducedMemberVisibility,
new[] { typeof(int), typeof(float), typeof(long), typeof(Enum) },
originalMixinContext1.Origin),
originalMixinContext2,
new MixinContext(
originalMixinContext3.MixinKind,
originalMixinContext3.MixinType,
originalMixinContext3.IntroducedMemberVisibility,
new[] { typeof(decimal), typeof(byte) },
originalMixinContext3.Origin)
},
originalClassContext.ComposedInterfaces);
Assert.That(result, Is.EqualTo(expectedResult));
Assert.That(originalClassContext.Mixins[typeof(string)].ExplicitDependencies, Has.No.Member(typeof(float)), "Original is not changed");
}
public void ApplyMixinDependencies_GenericMixins()
{
var originalMixinContext1 = MixinContextObjectMother.Create(mixinType: typeof(List <>), explicitDependencies: new[] { typeof(int) });
var originalMixinContext2 = MixinContextObjectMother.Create(mixinType: typeof(Dictionary <int, string>), explicitDependencies: new[] { typeof(double) });
var originalClassContext = ClassContextObjectMother.Create(typeof(NullTarget), originalMixinContext1, originalMixinContext2);
var dependencies =
new[]
{
new MixinDependencySpecification(typeof(List <>), new[] { typeof(float) }),
new MixinDependencySpecification(typeof(Dictionary <,>), new[] { typeof(byte) })
};
var result = originalClassContext.ApplyMixinDependencies(dependencies);
var expectedResult = new ClassContext(
originalClassContext.Type,
new[]
{
new MixinContext(
originalMixinContext1.MixinKind,
originalMixinContext1.MixinType,
originalMixinContext1.IntroducedMemberVisibility,
new[] { typeof(int), typeof(float) },
originalMixinContext1.Origin),
new MixinContext(
originalMixinContext2.MixinKind,
originalMixinContext2.MixinType,
originalMixinContext2.IntroducedMemberVisibility,
new[] { typeof(double), typeof(byte) },
originalMixinContext2.Origin)
},
originalClassContext.ComposedInterfaces);
Assert.That(result, Is.EqualTo(expectedResult));
}
private Dictionary <Type, MixinContext> CreateContextDictionary(params Type[] types)
{
return(types.ToDictionary(type => type, type => MixinContextObjectMother.Create(mixinType: type)));
}
private static MixinContext CreateBT2Mixin2Context()
{
return(MixinContextObjectMother.Create(mixinType: typeof(BT1Mixin2)));
}
public void IntroducedMemberVisibility_Public()
{
var context = MixinContextObjectMother.Create(introducedMemberVisibility: MemberVisibility.Public);
Assert.That(context.IntroducedMemberVisibility, Is.EqualTo(MemberVisibility.Public));
}
