public void SetUp()
{
_mockRepository = new MockRepository();
_parentBuilderMock = _mockRepository.StrictMock <ClassContextBuilder> (typeof(object));
_origin = MixinContextOriginObjectMother.Create();
_mixinBuilder = new MixinContextBuilder(_parentBuilderMock, typeof(BT2Mixin1), _origin);
}
public void AddMixin_NonGeneric()
{
var origin = MixinContextOriginObjectMother.Create();
MixinContextBuilder mixinBuilder = _classBuilder.AddMixin(typeof(BT2Mixin1), origin);
Assert.That(mixinBuilder.MixinType, Is.SameAs(typeof(BT2Mixin1)));
Assert.That(mixinBuilder.Parent, Is.SameAs(_classBuilder));
Assert.That(mixinBuilder.Origin, Is.SameAs(origin));
Assert.That(_classBuilder.MixinContextBuilders, Has.Member(mixinBuilder));
}
public void EnsureMixin_Generic()
{
var origin = MixinContextOriginObjectMother.Create();
_classBuilderMock.Expect(mock => mock.EnsureMixin <BT2Mixin1> (origin)).CallOriginalMethod(OriginalCallOptions.CreateExpectation);
_classBuilderMock.Expect(mock => mock.EnsureMixin(typeof(BT2Mixin1), origin)).Return(_mixinBuilderMock);
_mockRepository.Replay(_classBuilderMock);
Assert.That(_classBuilderMock.EnsureMixin <BT2Mixin1> (origin), Is.SameAs(_mixinBuilderMock));
_mockRepository.Verify(_classBuilderMock);
}
public void GetHashCode_Equal()
{
var c1a = new MixinContext(
MixinKind.Extending,
typeof(BT6Mixin1),
MemberVisibility.Private,
new[] { typeof(BT6Mixin2), typeof(BT6Mixin3 <>) },
MixinContextOriginObjectMother.Create());
var c1b = new MixinContext(
MixinKind.Extending,
typeof(BT6Mixin1),
MemberVisibility.Private,
new[] { typeof(BT6Mixin2), typeof(BT6Mixin3 <>) },
MixinContextOriginObjectMother.Create());
var c1WithDifferentDependencyOrder = new MixinContext(
MixinKind.Extending,
typeof(BT6Mixin1),
MemberVisibility.Private,
new[] { typeof(BT6Mixin3 <>), typeof(BT6Mixin2) },
MixinContextOriginObjectMother.Create());
var c1WithDifferentOrigin = new MixinContext(
MixinKind.Extending,
typeof(BT6Mixin1),
MemberVisibility.Private,
new[] { typeof(BT6Mixin2), typeof(BT6Mixin3 <>) },
MixinContextOriginObjectMother.Create(kind: "some different kind"));
var c2a = new MixinContext(
MixinKind.Extending, typeof(BT6Mixin1), MemberVisibility.Private, Enumerable.Empty <Type>(), MixinContextOriginObjectMother.Create());
var c2b = new MixinContext(
MixinKind.Extending, typeof(BT6Mixin1), MemberVisibility.Private, Enumerable.Empty <Type>(), MixinContextOriginObjectMother.Create());
var c3a = new MixinContext(
MixinKind.Used,
typeof(BT6Mixin1),
MemberVisibility.Public,
new[] { typeof(BT6Mixin3 <>), typeof(BT6Mixin2) },
MixinContextOriginObjectMother.Create());
var c3b = new MixinContext(
MixinKind.Used,
typeof(BT6Mixin1),
MemberVisibility.Public,
new[] { typeof(BT6Mixin3 <>), typeof(BT6Mixin2) },
MixinContextOriginObjectMother.Create());
Assert.That(c1b.GetHashCode(), Is.EqualTo(c1a.GetHashCode()));
Assert.That(c1WithDifferentDependencyOrder.GetHashCode(), Is.EqualTo(c1a.GetHashCode()));
Assert.That(c1WithDifferentOrigin.Origin, Is.Not.EqualTo(c1a.Origin));
Assert.That(c1WithDifferentOrigin.GetHashCode(), Is.EqualTo(c1a.GetHashCode()));
Assert.That(c2b.GetHashCode(), Is.EqualTo(c2a.GetHashCode()));
Assert.That(c3b.GetHashCode(), Is.EqualTo(c3a.GetHashCode()));
}
public void AddMixins_Generic3()
{
var origin = MixinContextOriginObjectMother.Create();
_classBuilderMock.Expect(mock => mock.AddMixins <BT2Mixin1, BT3Mixin1, BT3Mixin2> (origin))
.CallOriginalMethod(OriginalCallOptions.CreateExpectation);
_classBuilderMock.Expect(mock => mock.AddMixins(origin, typeof(BT2Mixin1), typeof(BT3Mixin1), typeof(BT3Mixin2))).Return(_classBuilderMock);
_mockRepository.Replay(_classBuilderMock);
Assert.That(_classBuilderMock.AddMixins <BT2Mixin1, BT3Mixin1, BT3Mixin2> (origin), Is.SameAs(_classBuilderMock));
_mockRepository.Verify(_classBuilderMock);
}
public void Equals_False()
{
var origin = MixinContextOriginObjectMother.Create();
var c1 = new MixinContext(
MixinKind.Extending, typeof(BT6Mixin1), MemberVisibility.Private, new[] { typeof(BT6Mixin2), typeof(BT6Mixin3 <>) }, origin);
var c2 = new MixinContext(MixinKind.Extending, typeof(BT6Mixin1), MemberVisibility.Private, new[] { typeof(BT6Mixin3 <>) }, origin);
var c3 = new MixinContext(MixinKind.Extending, typeof(BT6Mixin2), MemberVisibility.Private, new[] { typeof(BT6Mixin3 <>) }, origin);
var c4 = new MixinContext(MixinKind.Used, typeof(BT6Mixin2), MemberVisibility.Private, new[] { typeof(BT6Mixin3 <>) }, origin);
var c5 = new MixinContext(MixinKind.Used, typeof(BT6Mixin2), MemberVisibility.Public, new[] { typeof(BT6Mixin3 <>) }, origin);
Assert.That(c2, Is.Not.EqualTo(c1));
Assert.That(c3, Is.Not.EqualTo(c2));
Assert.That(c4, Is.Not.EqualTo(c3));
Assert.That(c5, Is.Not.EqualTo(c4));
}
public void AddOrderedMixins_Generic2()
{
var origin = MixinContextOriginObjectMother.Create();
Assert.That(_classBuilder.AddOrderedMixins <BT2Mixin1, BT3Mixin1> (origin), Is.SameAs(_classBuilder));
var mixinBuilders = new List <MixinContextBuilder> (_classBuilder.MixinContextBuilders);
Assert.That(mixinBuilders.Count, Is.EqualTo(2));
Assert.That(mixinBuilders[0].MixinType, Is.SameAs(typeof(BT2Mixin1)));
Assert.That(mixinBuilders[0].Origin, Is.SameAs(origin));
Assert.That(mixinBuilders[0].Dependencies, Is.Empty);
Assert.That(mixinBuilders[1].MixinType, Is.SameAs(typeof(BT3Mixin1)));
Assert.That(mixinBuilders[1].Origin, Is.SameAs(origin));
Assert.That(mixinBuilders[1].Dependencies, Is.EquivalentTo(new object[] { typeof(BT2Mixin1) }));
}
public void AddOrigin()
{
var mixinContextOrigin = MixinContextOriginObjectMother.Create(assembly: GetType().Assembly);
_serializer.AddOrigin(mixinContextOrigin);
// Check that the chain of serializers correctly sets up the FlatMixinContextOriginSerializer
var serializedMixinOrigin = (object[])_serializer.Values[4];
var serializedMixinOriginAssembly = serializedMixinOrigin[1];
Assert.That(serializedMixinOriginAssembly, Is.EqualTo(GetType().Assembly.FullName));
var deserializer = new FlatMixinContextDeserializer(_serializer.Values);
Assert.That(deserializer.GetOrigin(), Is.EqualTo(mixinContextOrigin));
}
public void EnsureMixin_NonGeneric()
{
var origin = MixinContextOriginObjectMother.Create();
MixinContextBuilder builder = _classBuilder.EnsureMixin(typeof(BT2Mixin1), origin);
Assert.That(builder.MixinType, Is.EqualTo(typeof(BT2Mixin1)));
Assert.That(builder.Origin, Is.EqualTo(origin));
Type[] mixinTypes = GetMixinTypes();
Assert.That(mixinTypes, Is.EquivalentTo(new object[] { typeof(BT2Mixin1) }));
var otherOrigin = MixinContextOriginObjectMother.Create("some other kind");
Assert.That(_classBuilder.EnsureMixin(typeof(BT2Mixin1), otherOrigin), Is.SameAs(builder));
Type[] mixinTypesAfterSecondEnsureMixin = GetMixinTypes();
Assert.That(mixinTypesAfterSecondEnsureMixin, Is.EquivalentTo(new object[] { typeof(BT2Mixin1) }));
Assert.That(builder.Origin, Is.EqualTo(origin));
}
public void SetUp()
{
_mockRepository = new MockRepository();
_parentBuilderMock = _mockRepository.StrictMock <MixinConfigurationBuilder> ((MixinConfiguration)null);
_classBuilder = new ClassContextBuilder(_parentBuilderMock, typeof(BaseType2));
_classBuilderMock = _mockRepository.StrictMock <ClassContextBuilder> (_parentBuilderMock, typeof(BaseType2));
_mixinBuilderMock = _mockRepository.StrictMock <MixinContextBuilder> (_classBuilderMock, typeof(BT2Mixin1), MixinContextOriginObjectMother.Create());
}
public void ParentMembers()
{
_mockRepository.BackToRecordAll();
var suppressionRuleStub = MockRepository.GenerateStub <IMixinSuppressionRule> ();
var r1 = new ClassContextBuilder(new MixinConfigurationBuilder(null), typeof(object));
var r2 = new MixinConfiguration();
var r3 = _mockRepository.StrictMock <IDisposable> ();
var r4 = new MixinContextBuilder(r1, typeof(BT1Mixin1), _origin);
var r5 = ClassContextObjectMother.Create(typeof(object));
var origin = MixinContextOriginObjectMother.Create();
IEnumerable <ClassContext> inheritedContexts = new ClassContext[0];
var expectedInferredOrigin = MixinContextOrigin.CreateForMethod(MethodBase.GetCurrentMethod());
using (_mockRepository.Ordered())
{
_parentBuilderMock.Expect(mock => mock.Clear()).Return(r1);
_parentBuilderMock.Expect(mock => mock.AddMixin(typeof(object), origin)).Return(r4);
_parentBuilderMock.Expect(mock => mock.AddMixin(typeof(object), expectedInferredOrigin)).Return(r4);
_parentBuilderMock.Expect(mock => mock.AddMixin <string> (origin)).Return(r4);
_parentBuilderMock.Expect(mock => mock.AddMixin <string> (expectedInferredOrigin)).Return(r4);
_parentBuilderMock.Expect(mock => mock.AddMixins(origin, typeof(BT1Mixin1), typeof(BT1Mixin2))).Return(r1);
_parentBuilderMock.Expect(mock => mock.AddMixins(expectedInferredOrigin, typeof(BT1Mixin1), typeof(BT1Mixin2))).Return(r1);
_parentBuilderMock.Expect(mock => mock.AddMixins <BT1Mixin1, BT1Mixin2> (origin)).Return(r1);
_parentBuilderMock.Expect(mock => mock.AddMixins <BT1Mixin1, BT1Mixin2> (expectedInferredOrigin)).Return(r1);
_parentBuilderMock.Expect(mock => mock.AddMixins <BT1Mixin1, BT1Mixin2, BT3Mixin1> (origin)).Return(r1);
_parentBuilderMock.Expect(mock => mock.AddMixins <BT1Mixin1, BT1Mixin2, BT3Mixin1> (expectedInferredOrigin)).Return(r1);
_parentBuilderMock.Expect(mock => mock.AddOrderedMixins(origin, typeof(BT1Mixin1), typeof(BT1Mixin2))).Return(r1);
_parentBuilderMock.Expect(mock => mock.AddOrderedMixins(expectedInferredOrigin, typeof(BT1Mixin1), typeof(BT1Mixin2))).Return(r1);
_parentBuilderMock.Expect(mock => mock.AddOrderedMixins <BT1Mixin1, BT1Mixin2> (origin)).Return(r1);
_parentBuilderMock.Expect(mock => mock.AddOrderedMixins <BT1Mixin1, BT1Mixin2> (expectedInferredOrigin)).Return(r1);
_parentBuilderMock.Expect(mock => mock.AddOrderedMixins <BT1Mixin1, BT1Mixin2, BT3Mixin1> (origin)).Return(r1);
_parentBuilderMock.Expect(mock => mock.AddOrderedMixins <BT1Mixin1, BT1Mixin2, BT3Mixin1> (expectedInferredOrigin)).Return(r1);
_parentBuilderMock.Expect(mock => mock.EnsureMixin(typeof(object), origin)).Return(r4);
_parentBuilderMock.Expect(mock => mock.EnsureMixin(typeof(object), expectedInferredOrigin)).Return(r4);
_parentBuilderMock.Expect(mock => mock.EnsureMixin <string> (origin)).Return(r4);
_parentBuilderMock.Expect(mock => mock.EnsureMixin <string> (expectedInferredOrigin)).Return(r4);
_parentBuilderMock.Expect(mock => mock.EnsureMixins(origin, typeof(BT1Mixin1), typeof(BT1Mixin2))).Return(r1);
_parentBuilderMock.Expect(mock => mock.EnsureMixins(expectedInferredOrigin, typeof(BT1Mixin1), typeof(BT1Mixin2))).Return(r1);
_parentBuilderMock.Expect(mock => mock.EnsureMixins <BT1Mixin1, BT1Mixin2> (origin)).Return(r1);
_parentBuilderMock.Expect(mock => mock.EnsureMixins <BT1Mixin1, BT1Mixin2> (expectedInferredOrigin)).Return(r1);
_parentBuilderMock.Expect(mock => mock.EnsureMixins <BT1Mixin1, BT1Mixin2, BT3Mixin1> (origin)).Return(r1);
_parentBuilderMock.Expect(mock => mock.EnsureMixins <BT1Mixin1, BT1Mixin2, BT3Mixin1> (expectedInferredOrigin)).Return(r1);
_parentBuilderMock.Expect(mock => mock.AddComposedInterface(typeof(IBT6Mixin1))).Return(r1);
_parentBuilderMock.Expect(mock => mock.AddComposedInterface <IBT6Mixin1>()).Return(r1);
_parentBuilderMock.Expect(mock => mock.AddComposedInterfaces(typeof(IBT6Mixin1), typeof(IBT6Mixin2))).Return(r1);
_parentBuilderMock.Expect(mock => mock.AddComposedInterfaces <IBT6Mixin1, IBT6Mixin2> ()).Return(r1);
_parentBuilderMock.Expect(mock => mock.AddComposedInterfaces <IBT6Mixin1, IBT6Mixin2, IBT6Mixin3> ()).Return(r1);
_parentBuilderMock.Expect(mock => mock.AddComposedInterfaces <IBT6Mixin1, IBT6Mixin2, IBT6Mixin3> ()).Return(r1);
_parentBuilderMock.Expect(mock => mock.SuppressMixin(suppressionRuleStub)).Return(r1);
_parentBuilderMock.Expect(mock => mock.SuppressMixin(typeof(object))).Return(r1);
_parentBuilderMock.Expect(mock => mock.SuppressMixin <string> ()).Return(r1);
_parentBuilderMock.Expect(mock => mock.SuppressMixins(typeof(BT1Mixin1), typeof(BT1Mixin2))).Return(r1);
_parentBuilderMock.Expect(mock => mock.SuppressMixins <BT1Mixin1, BT1Mixin2> ()).Return(r1);
_parentBuilderMock.Expect(mock => mock.SuppressMixins <BT1Mixin1, BT1Mixin2, BT3Mixin1> ()).Return(r1);
_parentBuilderMock.Expect(mock => mock.AddMixinDependency(typeof(BT1Mixin1), typeof(BT1Mixin2))).Return(r1);
_parentBuilderMock.Expect(mock => mock.AddMixinDependency <BT1Mixin1, BT1Mixin2> ()).Return(r1);
_parentBuilderMock.Expect(mock => mock.BuildClassContext(inheritedContexts)).Return(r5);
_parentBuilderMock.Expect(mock => mock.BuildClassContext()).Return(r5);
_parentBuilderMock.Expect(mock => mock.ForClass <object> ()).Return(r1);
_parentBuilderMock.Expect(mock => mock.ForClass <string> ()).Return(r1);
_parentBuilderMock.Expect(mock => mock.BuildConfiguration()).Return(r2);
_parentBuilderMock.Expect(mock => mock.EnterScope()).Return(r3);
}
_mockRepository.ReplayAll();
Assert.That(_mixinBuilder.Clear(), Is.SameAs(r1));
Assert.That(_mixinBuilder.AddMixin(typeof(object), origin), Is.SameAs(r4));
Assert.That(_mixinBuilder.AddMixin(typeof(object)), Is.SameAs(r4));
Assert.That(_mixinBuilder.AddMixin <string> (origin), Is.SameAs(r4));
Assert.That(_mixinBuilder.AddMixin <string> (), Is.SameAs(r4));
Assert.That(_mixinBuilder.AddMixins(origin, typeof(BT1Mixin1), typeof(BT1Mixin2)), Is.SameAs(r1));
Assert.That(_mixinBuilder.AddMixins(typeof(BT1Mixin1), typeof(BT1Mixin2)), Is.SameAs(r1));
Assert.That(_mixinBuilder.AddMixins <BT1Mixin1, BT1Mixin2> (origin), Is.SameAs(r1));
Assert.That(_mixinBuilder.AddMixins <BT1Mixin1, BT1Mixin2> (), Is.SameAs(r1));
Assert.That(_mixinBuilder.AddMixins <BT1Mixin1, BT1Mixin2, BT3Mixin1> (origin), Is.SameAs(r1));
Assert.That(_mixinBuilder.AddMixins <BT1Mixin1, BT1Mixin2, BT3Mixin1> (), Is.SameAs(r1));
Assert.That(_mixinBuilder.AddOrderedMixins(origin, typeof(BT1Mixin1), typeof(BT1Mixin2)), Is.SameAs(r1));
Assert.That(_mixinBuilder.AddOrderedMixins(typeof(BT1Mixin1), typeof(BT1Mixin2)), Is.SameAs(r1));
Assert.That(_mixinBuilder.AddOrderedMixins <BT1Mixin1, BT1Mixin2> (origin), Is.SameAs(r1));
Assert.That(_mixinBuilder.AddOrderedMixins <BT1Mixin1, BT1Mixin2> (), Is.SameAs(r1));
Assert.That(_mixinBuilder.AddOrderedMixins <BT1Mixin1, BT1Mixin2, BT3Mixin1> (origin), Is.SameAs(r1));
Assert.That(_mixinBuilder.AddOrderedMixins <BT1Mixin1, BT1Mixin2, BT3Mixin1> (), Is.SameAs(r1));
Assert.That(_mixinBuilder.EnsureMixin(typeof(object), origin), Is.SameAs(r4));
Assert.That(_mixinBuilder.EnsureMixin(typeof(object)), Is.SameAs(r4));
Assert.That(_mixinBuilder.EnsureMixin <string> (origin), Is.SameAs(r4));
Assert.That(_mixinBuilder.EnsureMixin <string> (), Is.SameAs(r4));
Assert.That(_mixinBuilder.EnsureMixins(origin, typeof(BT1Mixin1), typeof(BT1Mixin2)), Is.SameAs(r1));
Assert.That(_mixinBuilder.EnsureMixins(typeof(BT1Mixin1), typeof(BT1Mixin2)), Is.SameAs(r1));
Assert.That(_mixinBuilder.EnsureMixins <BT1Mixin1, BT1Mixin2> (origin), Is.SameAs(r1));
Assert.That(_mixinBuilder.EnsureMixins <BT1Mixin1, BT1Mixin2> (), Is.SameAs(r1));
Assert.That(_mixinBuilder.EnsureMixins <BT1Mixin1, BT1Mixin2, BT3Mixin1> (origin), Is.SameAs(r1));
Assert.That(_mixinBuilder.EnsureMixins <BT1Mixin1, BT1Mixin2, BT3Mixin1> (), Is.SameAs(r1));
Assert.That(_mixinBuilder.AddComposedInterface(typeof(IBT6Mixin1)), Is.SameAs(r1));
Assert.That(_mixinBuilder.AddComposedInterface <IBT6Mixin1> (), Is.SameAs(r1));
Assert.That(_mixinBuilder.AddComposedInterfaces(typeof(IBT6Mixin1), typeof(IBT6Mixin2)), Is.SameAs(r1));
Assert.That(_mixinBuilder.AddComposedInterfaces <IBT6Mixin1, IBT6Mixin2> (), Is.SameAs(r1));
Assert.That(_mixinBuilder.AddComposedInterfaces <IBT6Mixin1, IBT6Mixin2, IBT6Mixin3> (), Is.SameAs(r1));
Assert.That(_mixinBuilder.AddComposedInterfaces <IBT6Mixin1, IBT6Mixin2, IBT6Mixin3> (), Is.SameAs(r1));
Assert.That(_mixinBuilder.SuppressMixin(suppressionRuleStub), Is.SameAs(r1));
Assert.That(_mixinBuilder.SuppressMixin(typeof(object)), Is.SameAs(r1));
Assert.That(_mixinBuilder.SuppressMixin <string> (), Is.SameAs(r1));
Assert.That(_mixinBuilder.SuppressMixins(typeof(BT1Mixin1), typeof(BT1Mixin2)), Is.SameAs(r1));
Assert.That(_mixinBuilder.SuppressMixins <BT1Mixin1, BT1Mixin2> (), Is.SameAs(r1));
Assert.That(_mixinBuilder.SuppressMixins <BT1Mixin1, BT1Mixin2, BT3Mixin1> (), Is.SameAs(r1));
Assert.That(_mixinBuilder.AddMixinDependency(typeof(BT1Mixin1), typeof(BT1Mixin2)), Is.SameAs(r1));
Assert.That(_mixinBuilder.AddMixinDependency <BT1Mixin1, BT1Mixin2> (), Is.SameAs(r1));
Assert.That(_mixinBuilder.BuildClassContext(inheritedContexts), Is.SameAs(r5));
Assert.That(_mixinBuilder.BuildClassContext(), Is.SameAs(r5));
Assert.That(_mixinBuilder.ForClass <object> (), Is.SameAs(r1));
Assert.That(_mixinBuilder.ForClass <string> (), Is.SameAs(r1));
Assert.That(_mixinBuilder.BuildConfiguration(), Is.SameAs(r2));
Assert.That(_mixinBuilder.EnterScope(), Is.SameAs(r3));
_mockRepository.VerifyAll();
}
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 SetUp()
{
_mixinContextOrigin = MixinContextOriginObjectMother.Create();
}
