public void MixinContext()
{
ClassContext baseContext = new ClassContextBuilder(typeof(string)).AddMixin <DateTime>().WithDependency <int>().BuildClassContext();
ClassContext inheritor = ClassContextObjectMother.Create(typeof(double)).InheritFrom(new[] { baseContext });
Assert.That(inheritor.Mixins[typeof(DateTime)], Is.EqualTo(baseContext.Mixins[typeof(DateTime)]));
}
public void ParentMembers()
{
_mockRepository.BackToRecordAll();
var r1 = new ClassContextBuilder(new MixinConfigurationBuilder(null), typeof(object));
var r2 = new MixinConfiguration();
var r3 = _mockRepository.StrictMock <IDisposable> ();
using (_mockRepository.Ordered())
{
_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(_classBuilder.ForClass <object> (), Is.SameAs(r1));
Assert.That(_classBuilder.ForClass <string> (), Is.SameAs(r1));
Assert.That(_classBuilder.BuildConfiguration(), Is.SameAs(r2));
Assert.That(_classBuilder.EnterScope(), Is.SameAs(r3));
_mockRepository.VerifyAll();
}
public void SetUp()
{
_classContextBuilderWithParent = new ClassContextBuilder(typeof(NullTarget));
_classContextBuilderWithParent.AddMixin(typeof(NullMixin2));
_parentContextWithBuilder = ClassContextObjectMother.Create(typeof(NullTarget), typeof(NullMixin));
_classContextBuilderWithIndirectParent = new ClassContextBuilder(typeof(DerivedNullTarget));
_classContextBuilderWithoutParent = new ClassContextBuilder(typeof(BaseType4));
_classContextBuilderWithParent.AddMixin(typeof(BT4Mixin1));
_buildersWithParentContexts = new Dictionary <Type, Tuple <ClassContextBuilder, ClassContext> > ();
_buildersWithParentContexts.Add(_classContextBuilderWithParent.TargetType, Tuple.Create(_classContextBuilderWithParent, _parentContextWithBuilder));
_buildersWithParentContexts.Add(_classContextBuilderWithoutParent.TargetType, Tuple.Create(_classContextBuilderWithoutParent, (ClassContext)null));
_parentContextWithoutBuilder = ClassContextObjectMother.Create(typeof(BaseType1));
_parentContexts = new ClassContextCollection(_parentContextWithoutBuilder, _parentContextWithBuilder);
_inheritancePolicyMock = MockRepository.GenerateMock <IMixinInheritancePolicy> ();
_inheritedContext = ClassContextObjectMother.Create(typeof(object), typeof(NullMixin));
var classContextBuilders = new[] { _classContextBuilderWithoutParent, _classContextBuilderWithIndirectParent, _classContextBuilderWithParent };
_builder = new InheritanceResolvingClassContextBuilder(classContextBuilders, _parentContexts, _inheritancePolicyMock);
}
public void SetUp()
{
_mockRepository = new MockRepository();
_parentBuilderMock = _mockRepository.StrictMock <ClassContextBuilder> (typeof(object));
_origin = MixinContextOriginObjectMother.Create();
_mixinBuilder = new MixinContextBuilder(_parentBuilderMock, typeof(BT2Mixin1), _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 ForClass_Twice()
{
var builder = new MixinConfigurationBuilder(null);
ClassContextBuilder classBuilder = builder.ForClass(typeof(BaseType1));
ClassContextBuilder classBuilder2 = builder.ForClass(typeof(BaseType1));
Assert.That(classBuilder2, Is.SameAs(classBuilder));
}
public void BaseAndDerivedMixin_CanBeInherited_DifferentOrder()
{
ClassContext baseContext = new ClassContextBuilder(typeof(string)).AddMixin <DerivedNullMixin> ().AddMixin <NullMixin> ().BuildClassContext();
ClassContext inheritor = ClassContextObjectMother.Create(typeof(double)).InheritFrom(new[] { baseContext });
Assert.That(inheritor.Mixins.Count, Is.EqualTo(2));
Assert.That(inheritor.Mixins.ContainsKey(typeof(NullMixin)), Is.True);
Assert.That(inheritor.Mixins.ContainsKey(typeof(DerivedNullMixin)), Is.True);
}
public void FailsIfInterfaceMixinDependencyNotFulfilled()
{
ClassContext context = new ClassContextBuilder(typeof(TargetClassWithAdditionalDependencies)).AddMixin <MixinWithAdditionalInterfaceDependency> ().WithDependency <IMixinWithAdditionalClassDependency> ().BuildClassContext();
TargetClassDefinition definition = TargetClassDefinitionFactory.CreateWithoutValidation(context);
var log = Validator.Validate(definition.Mixins[typeof(MixinWithAdditionalInterfaceDependency)]);
Assert.That(HasFailure("Remotion.Mixins.Validation.Rules.DefaultMixinDependencyRules.DependencyMustBeSatisfiedByAnotherMixin", log), Is.True);
}
public void ForClass_Generic()
{
var builder = new MixinConfigurationBuilder(null);
ClassContextBuilder classBuilder = builder.ForClass <BaseType1> ();
Assert.That(classBuilder.TargetType, Is.SameAs(typeof(BaseType1)));
Assert.That(classBuilder.Parent, Is.SameAs(builder));
Assert.That(builder.ClassContextBuilders, Has.Member(classBuilder));
}
public void ExistingMixin_OverridesInherited()
{
ClassContext baseContext = new ClassContextBuilder(typeof(string)).AddMixin <DateTime>().WithDependency <int>().BuildClassContext();
ClassContext inheritor = new ClassContextBuilder(typeof(double)).AddMixin <DateTime>().WithDependency <decimal>().BuildClassContext().InheritFrom(new[] { baseContext }); // ignores inherited DateTime because DateTime already exists
Assert.That(inheritor.Mixins.Count, Is.EqualTo(1));
Assert.That(inheritor.Mixins.ContainsKey(typeof(DateTime)), Is.True);
Assert.That(inheritor.Mixins[typeof(DateTime)].ExplicitDependencies, Has.No.Member(typeof(int)));
Assert.That(inheritor.Mixins[typeof(DateTime)].ExplicitDependencies, Has.Member(typeof(decimal)));
}
public void SpecializeWithTypeArguments()
{
ClassContext original = new ClassContextBuilder(typeof(List <>)).AddMixin <BT1Mixin1>().WithDependency <IBaseType2>().BuildClassContext();
ClassContext specialized = original.SpecializeWithTypeArguments(new[] { typeof(int) });
Assert.That(specialized, Is.Not.Null);
Assert.That(specialized.Type, Is.EqualTo(typeof(List <int>)));
Assert.That(specialized.Mixins.ContainsKey(typeof(BT1Mixin1)), Is.True);
Assert.That(specialized.Mixins[typeof(BT1Mixin1)].ExplicitDependencies, Has.Member(typeof(IBaseType2)));
}
public void SpecializedGenericMixin_OverridesInherited()
{
ClassContext baseContext = new ClassContextBuilder(typeof(string)).AddMixin(typeof(GenericMixinWithVirtualMethod <>)).WithDependency <int>().BuildClassContext();
ClassContext inheritor = new ClassContextBuilder(typeof(double)).AddMixin <GenericMixinWithVirtualMethod <object> >().WithDependency <decimal>().BuildClassContext().InheritFrom(new[] { baseContext });
Assert.That(inheritor.Mixins.Count, Is.EqualTo(1));
Assert.That(inheritor.Mixins.ContainsKey(typeof(GenericMixinWithVirtualMethod <>)), Is.False);
Assert.That(inheritor.Mixins.ContainsKey(typeof(GenericMixinWithVirtualMethod <object>)), Is.True);
Assert.That(inheritor.Mixins[typeof(GenericMixinWithVirtualMethod <object>)].ExplicitDependencies, Has.No.Member(typeof(int)));
Assert.That(inheritor.Mixins[typeof(GenericMixinWithVirtualMethod <object>)].ExplicitDependencies, Has.Member(typeof(decimal)));
}
public void ComposedInterfaces()
{
ClassContext baseContext = new ClassContextBuilder(typeof(string))
.AddComposedInterface(typeof(object))
.AddComposedInterface(typeof(int))
.BuildClassContext();
ClassContext inheritor = ClassContextObjectMother.Create(typeof(double)).InheritFrom(new[] { baseContext });
Assert.That(inheritor.ComposedInterfaces.Count, Is.EqualTo(2));
Assert.That(inheritor.ComposedInterfaces, Is.EquivalentTo(inheritor.ComposedInterfaces));
}
public void Apply()
{
var attribute = new ComposedInterfaceAttribute(typeof(string));
ClassContextBuilder classBuilderMock = _mockRepository.StrictMock <ClassContextBuilder> (_configurationBuilderMock, typeof(string));
_configurationBuilderMock.Expect(mock => mock.ForClass(typeof(string))).Return(classBuilderMock);
classBuilderMock.Expect(mock => mock.AddComposedInterface(typeof(IServiceProvider))).Return(classBuilderMock);
_mockRepository.ReplayAll();
attribute.Apply(_configurationBuilderMock, typeof(IServiceProvider));
_mockRepository.VerifyAll();
}
public void FromClassContext_MixinKinds()
{
ClassContext context = new ClassContextBuilder(typeof(int))
.AddComposedInterface(typeof(uint))
.AddMixin(typeof(string)).OfKind(MixinKind.Extending)
.AddMixin(typeof(double)).OfKind(MixinKind.Used)
.BuildClassContext();
ConcreteMixedTypeAttribute attribute = CreateAttribute(context);
var deserializer = new AttributeClassContextDeserializer(attribute.ClassContextData);
Assert.That(ClassContext.Deserialize(deserializer), Is.EqualTo(context));
}
public void BuildConfiguration()
{
_builder.AddType(typeof(User));
_builder.AddType(typeof(Extender));
_builder.AddType(typeof(IComposedInterface));
MixinConfiguration configuration = _builder.BuildConfiguration();
ClassContext c1 = new ClassContextBuilder(typeof(User)).AddMixin(typeof(NullMixin)).OfKind(MixinKind.Used).BuildClassContext();
ClassContext c2 = new ClassContextBuilder(typeof(NullTarget))
.AddMixin(typeof(Extender)).AddComposedInterface(typeof(IComposedInterface)).BuildClassContext();
Assert.That(configuration.ClassContexts, Is.EquivalentTo(new object[] { c1, c2, _globalClassContext }));
}
public void BuildConfiguration_WithParentConfiguration()
{
MixinConfiguration parentConfiguration = MixinConfiguration.BuildNew().ForClass <int>().AddMixin <string>().BuildConfiguration();
var builder = new DeclarativeConfigurationBuilder(parentConfiguration);
builder.AddType(typeof(User));
MixinConfiguration configuration = builder.BuildConfiguration();
ClassContext c1 = new ClassContextBuilder(typeof(User)).AddMixin(typeof(NullMixin)).OfKind(MixinKind.Used).BuildClassContext();
Assert.That(configuration.ClassContexts,
Is.EquivalentTo(new object[] { c1, parentConfiguration.GetContext(typeof(int)), _globalClassContext }));
}
public void BuildContext_ReplaceParentContext()
{
var classContextBuilder = new ClassContextBuilder(_parentBuilderMock, typeof(BaseType2));
classContextBuilder.Clear().AddMixins <BT1Mixin1, BT1Mixin2> ();
var parentContext = ClassContextObjectMother.Create(typeof(BaseType2), typeof(BT2Mixin1));
ClassContext builtContext = classContextBuilder.BuildClassContext(new[] { parentContext });
Assert.That(builtContext.Mixins.Count, Is.EqualTo(2));
Assert.That(builtContext.Mixins.ContainsKey(typeof(BT1Mixin1)), Is.True);
Assert.That(builtContext.Mixins.ContainsKey(typeof(BT1Mixin2)), Is.True);
}
public void GetClassContextComplex()
{
ClassContext context = new ClassContextBuilder(typeof(int))
.AddMixin(typeof(double))
.AddComposedInterface(typeof(uint))
.AddMixin(typeof(string)).WithDependency(typeof(bool))
.BuildClassContext();
ConcreteMixedTypeAttribute attribute = CreateAttribute(context);
ClassContext regeneratedContext = attribute.GetClassContext();
Assert.That(context, Is.EqualTo(regeneratedContext));
Assert.That(context, Is.Not.SameAs(regeneratedContext));
}
public void Initialization_Standalone()
{
var classBuilder = new ClassContextBuilder(typeof(BaseType2));
Assert.That(classBuilder.TargetType, Is.SameAs(typeof(BaseType2)));
Assert.That(classBuilder.Parent, Is.Not.Null);
Assert.That(_classBuilder.MixinContextBuilders, Is.Empty);
Assert.That(_classBuilder.ComposedInterfaces.ToArray(), Is.Empty);
ClassContext classContext = _classBuilder.BuildClassContext(new ClassContext[0]);
Assert.That(classContext.Mixins.Count, Is.EqualTo(0));
Assert.That(classContext.ComposedInterfaces.Count, Is.EqualTo(0));
}
public void GetClassContext_MixinKinds()
{
ClassContext context = new ClassContextBuilder(typeof(int))
.AddComposedInterface(typeof(uint))
.AddMixin(typeof(string)).OfKind(MixinKind.Extending)
.AddMixin(typeof(double)).OfKind(MixinKind.Used)
.BuildClassContext();
ConcreteMixedTypeAttribute attribute = CreateAttribute(context);
ClassContext regeneratedContext = attribute.GetClassContext();
Assert.That(regeneratedContext.Mixins[typeof(string)].MixinKind, Is.EqualTo(MixinKind.Extending));
Assert.That(regeneratedContext.Mixins[typeof(double)].MixinKind, Is.EqualTo(MixinKind.Used));
}
public void InheritFrom_LeavesExistingData()
{
ClassContext baseContext = new ClassContextBuilder(typeof(string))
.AddMixin(typeof(DateTime))
.AddComposedInterface(typeof(object))
.BuildClassContext();
ClassContext inheritor = new ClassContextBuilder(typeof(double))
.AddMixin(typeof(string))
.AddComposedInterface(typeof(int)).BuildClassContext().InheritFrom(new[] { baseContext });
Assert.That(inheritor.Mixins.Count, Is.EqualTo(2));
Assert.That(inheritor.ComposedInterfaces.Count, Is.EqualTo(2));
}
public void FromClassContextComplex()
{
ClassContext context = new ClassContextBuilder(typeof(int))
.AddComposedInterface(typeof(uint))
.AddMixin(typeof(string)).WithDependency(typeof(bool))
.AddMixin(typeof(double)).WithDependency(typeof(int))
.BuildClassContext();
ConcreteMixedTypeAttribute attribute = CreateAttribute(context);
var deserializer = new AttributeClassContextDeserializer(attribute.ClassContextData);
Assert.That(ClassContext.Deserialize(deserializer), Is.EqualTo(context));
}
public void Clear()
{
var classBuilder = new ClassContextBuilder(_parentBuilderMock, typeof(BaseType1));
classBuilder.AddMixin <BT1Mixin2> ();
classBuilder.AddComposedInterface <IBaseType31> ();
Assert.That(classBuilder.MixinContextBuilders, Is.Not.Empty);
Assert.That(classBuilder.ComposedInterfaces, Is.Not.Empty);
Assert.That(classBuilder.SuppressInheritance, Is.False);
Assert.That(classBuilder.Clear(), Is.SameAs(classBuilder));
Assert.That(classBuilder.MixinContextBuilders, Is.Empty);
Assert.That(classBuilder.ComposedInterfaces.ToArray(), Is.Empty);
Assert.That(classBuilder.SuppressInheritance, Is.True);
}
public void BuildContext_Suppression()
{
var classContextBuilder = new ClassContextBuilder(_parentBuilderMock, typeof(BaseType2));
classContextBuilder.AddMixins <BT1Mixin1, BT1Mixin2> ();
classContextBuilder.SuppressMixins(typeof(IBT1Mixin1), typeof(BT5Mixin1), typeof(BT3Mixin3 <,>));
var inheritedContext = ClassContextObjectMother.Create(typeof(BaseType2), typeof(BT3Mixin1), typeof(BT3Mixin3 <IBaseType33, IBaseType33>));
var parentContext = ClassContextObjectMother.Create(typeof(BaseType2), typeof(BT5Mixin1), typeof(BT5Mixin2));
ClassContext builtContext = classContextBuilder.BuildClassContext(new[] { inheritedContext, parentContext });
Assert.That(builtContext.Mixins.Count, Is.EqualTo(3));
Assert.That(builtContext.Mixins.ContainsKey(typeof(BT3Mixin1)), Is.True);
Assert.That(builtContext.Mixins.ContainsKey(typeof(BT5Mixin2)), Is.True);
Assert.That(builtContext.Mixins.ContainsKey(typeof(BT1Mixin2)), Is.True);
}
public void GetClassContext_Dependencies()
{
ClassContext context = new ClassContextBuilder(typeof(int))
.AddMixin(typeof(object)).OfKind(MixinKind.Extending).WithDependencies(typeof(double), typeof(bool))
.AddMixin(typeof(string)).OfKind(MixinKind.Extending).WithDependencies(typeof(bool))
.AddMixin(typeof(int)).OfKind(MixinKind.Extending)
.BuildClassContext();
ConcreteMixedTypeAttribute attribute = CreateAttribute(context);
ClassContext regeneratedContext = attribute.GetClassContext();
Assert.That(regeneratedContext.Mixins.Count, Is.EqualTo(3));
Assert.That(regeneratedContext.Mixins[typeof(object)].ExplicitDependencies, Is.EqualTo(new object[] { typeof(double), typeof(bool) }));
Assert.That(regeneratedContext.Mixins[typeof(string)].ExplicitDependencies, Is.EqualTo(new object[] { typeof(bool) }));
Assert.That(regeneratedContext.Mixins[typeof(int)].ExplicitDependencies, Is.Empty);
}
public void BuildContext_SuppressedInheritance()
{
ClassContext inheritedContext = new ClassContextBuilder(typeof(BaseType2))
.AddMixin(typeof(BT3Mixin1))
.AddComposedInterface(typeof(BT1Mixin2))
.BuildClassContext();
_classBuilder.Clear();
_classBuilder.AddMixins <BT1Mixin1, BT1Mixin2> ();
_classBuilder.AddComposedInterfaces <IBT6Mixin1, IBT6Mixin2> ();
ClassContext builtContext = _classBuilder.BuildClassContext(new[] { inheritedContext });
Assert.That(builtContext.Mixins.Count, Is.EqualTo(2));
Assert.That(builtContext.Mixins.ContainsKey(typeof(BT1Mixin1)), Is.True);
Assert.That(builtContext.Mixins.ContainsKey(typeof(BT1Mixin2)), Is.True);
Assert.That(builtContext.ComposedInterfaces.Count, Is.EqualTo(2));
Assert.That(builtContext.ComposedInterfaces, Has.Member(typeof(IBT6Mixin1)));
Assert.That(builtContext.ComposedInterfaces, Has.Member(typeof(IBT6Mixin2)));
}
private Type[] GetMixinTypes(ClassContextBuilder classBuilder)
{
return(classBuilder.MixinContextBuilders.Select(mcb => mcb.MixinType).ToArray());
}
public void InheritedUnspecializedDerivedGenericMixin_Throws()
{
ClassContext baseContext = new ClassContextBuilder(typeof(string)).AddMixin(typeof(DerivedGenericMixin <>)).WithDependency <int>().BuildClassContext();
new ClassContextBuilder(typeof(double)).AddMixin(typeof(GenericMixinWithVirtualMethod <>)).WithDependency <decimal>().BuildClassContext().InheritFrom(new[] { baseContext });
}
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();
}
