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