public void InitializeWithNullEqualityComparerThrows()
 {
     // Fixture setup
     var dummyBuilder = new DelegatingSpecimenBuilder();
     // Exercise system and verify outcome
     Assert.Throws<ArgumentNullException>(() => new DelegatingRecursionGuard(dummyBuilder, null));
     // Teardown
 }

 public void IndexOfReturnsCorrectResultWhenItemIsNotInNode()
 {
     // Fixture setup
     var item = new DelegatingSpecimenBuilder();
     // Exercise system
     var actual = this.sut.IndexOf(item);
     // Verify outcome
     Assert.Equal(-1, actual);
     // Teardown
 }

 public void SutIsNode()
 {
     // Fixture setup
     var dummyBuilder = new DelegatingSpecimenBuilder();
     // Exercise system
     var sut = new DelegatingRecursionGuard(dummyBuilder);
     // Verify outcome
     Assert.IsAssignableFrom<ISpecimenBuilderNode>(sut);
     // Teardown
 }

 public void TransformReturnsCorrectResult()
 {
     // Fixture setup
     var sut = new ThrowingRecursionBehavior();
     // Exercise system
     var dummyBuilder = new DelegatingSpecimenBuilder();
     var result = sut.Transform(dummyBuilder);
     // Verify outcome
     Assert.IsAssignableFrom<ThrowingRecursionGuard>(result);
     // Teardown
 }

 public void InsertsCorrectlyInsertsItem(int expected)
 {
     // Fixture setup
     var item = new DelegatingSpecimenBuilder();
     // Exercise system
     this.sut.Insert(expected, item);
     // Verify outcome
     var actual = this.sut.IndexOf(item);
     Assert.Equal(expected, actual);
     // Teardown
 }

 public void SutYieldsInjectedBuilder()
 {
     // Fixture setup
     var expected = new DelegatingSpecimenBuilder();
     var sut = new DelegatingRecursionGuard(expected);
     // Exercise system
     // Verify outcome
     Assert.Equal(expected, sut.Single());
     Assert.Equal(expected, ((System.Collections.IEnumerable)sut).Cast<object>().Single());
     // Teardown
 }

 public void AddAddsItemToEndOfNode()
 {
     // Fixture setup
     var item = new DelegatingSpecimenBuilder();
     var expected = this.FindMarkedNode().Concat(new[] { item });
     // Exercise system
     this.sut.Add(item);
     // Verify outcome
     Assert.True(expected.SequenceEqual(this.sut));
     // Teardown
 }

 public void TransformResultCorrectlyDecoratesInput()
 {
     // Fixture setup
     var sut = new OmitOnRecursionBehavior();
     var expectedBuilder = new DelegatingSpecimenBuilder();
     // Exercise system
     var result = sut.Transform(expectedBuilder);
     // Verify outcome
     var guard = Assert.IsAssignableFrom<RecursionGuard>(result);
     Assert.Equal(expectedBuilder, guard.Builder);
     // Teardown
 }

 public void TransformReturnsCorrectResult()
 {
     // Fixture setup
     var sut = new TracingBehavior();
     var builder = new DelegatingSpecimenBuilder();
     // Exercise system
     var result = sut.Transform(builder);
     // Verify outcome
     var tw = Assert.IsAssignableFrom<TraceWriter>(result);
     Assert.Equal(builder, tw.Tracer.Builder);
     // Teardown
 }

 public void AddRaisesGraphChanged()
 {
     // Fixture setup
     var verified = false;
     this.sut.GraphChanged += (s, e) => verified = s != null && e != null;
     // Exercise system
     var dummyItem = new DelegatingSpecimenBuilder();
     this.sut.Add(dummyItem);
     // Verify outcome
     Assert.True(verified);
     // Teardown
 }

 public void ComparerIsCorrect()
 {
     // Fixture setup
     var dummyBuilder = new DelegatingSpecimenBuilder();
     var expected = new DelegatingEqualityComparer();
     var sut = new DelegatingRecursionGuard(dummyBuilder, expected);
     // Exercise system
     IEqualityComparer actual = sut.Comparer;
     // Verify outcome
     Assert.Equal(expected, actual);
     // Teardown
 }

 public void TransformReturnsCorrectResultForDefaultRecursionDepth()
 {
     // Fixture setup
     var sut = new OmitOnRecursionBehavior();
     // Exercise system
     var dummyBuilder = new DelegatingSpecimenBuilder();
     var result = sut.Transform(dummyBuilder);
     // Verify outcome
     var rg = Assert.IsAssignableFrom<RecursionGuard>(result);
     Assert.IsAssignableFrom<OmitOnRecursionHandler>(rg.RecursionHandler);
     Assert.Equal(1, rg.RecursionDepth);
     // Teardown
 }

 public void ComposeRetainsHandler()
 {
     // Fixture setup
     var dummyBuilder = new DelegatingSpecimenBuilder();
     var expected = new DelegatingRecursionHandler();
     var dummyComparer = new DelegatingEqualityComparer();
     var sut = new RecursionGuard(dummyBuilder, expected, dummyComparer);
     // Exercise system
     var actual = sut.Compose(new ISpecimenBuilder[0]);
     // Verify outcome
     var rg = Assert.IsAssignableFrom<RecursionGuard>(actual);
     Assert.Equal(expected, rg.RecursionHandler);
     // Teardown
 }

 public void TransformReturnsCorrectResultForSpecificRecursionDepth()
 {
     // Fixture setup
     const int explicitRecursionDepth = 2;
     var sut = new NullRecursionBehavior(explicitRecursionDepth);
     // Exercise system
     var dummyBuilder = new DelegatingSpecimenBuilder();
     var result = sut.Transform(dummyBuilder);
     // Verify outcome
     var rg = Assert.IsAssignableFrom<RecursionGuard>(result);
     Assert.IsAssignableFrom<NullRecursionHandler>(rg.RecursionHandler);
     Assert.Equal(explicitRecursionDepth, rg.RecursionDepth);
     // Teardown
 }

        public void SingleParameterDoWillInvokeMethodWithCorrectParameter(
            int expected)
        {
            // Fixture setup
            var builder = new DelegatingSpecimenBuilder();
            builder.OnCreate = (r, c) => expected;

            var verified = false;
            var mock = new CommandMock<int>();
            mock.OnCommand = x => verified = expected == x;
            // Exercise system
            builder.Do((int i) => mock.Command(i));
            // Verify outcome
            Assert.True(verified, "Mock wasn't verified.");
            // Teardown
        }

        public void CreateAnonymousOnSpecimenBuilderComposerReturnsCorrectResult()
        {
            // Fixture setup
            var expectedResult = new DateTime(2010, 5, 31, 14, 52, 19);
            var specimenBuilder = new DelegatingSpecimenBuilder();
            specimenBuilder.OnCreate = (r, c) =>
            {
                Assert.NotNull(c);
                Assert.Equal(new SeededRequest(typeof(DateTime), default(DateTime)), r);
                return expectedResult;
            };

            ISpecimenBuilder composer = new DelegatingComposer { OnCreate = specimenBuilder.OnCreate };
            // Exercise system
            var result = composer.Create<DateTime>();
            // Verify outcome
            Assert.Equal(expectedResult, result);
            // Teardown
        }

 public void ComposeReturnsCorrectResult()
 {
     // Fixture setup
     var dummyBuilder = new DelegatingSpecimenBuilder();
     var dummyHandler = new DelegatingRecursionHandler();
     var dummyComparer = new DelegatingEqualityComparer();
     var sut = new RecursionGuard(dummyBuilder, dummyHandler, dummyComparer);
     // Exercise system
     var expectedBuilders = new[]
     {
         new DelegatingSpecimenBuilder(),
         new DelegatingSpecimenBuilder(),
         new DelegatingSpecimenBuilder()
     };
     var actual = sut.Compose(expectedBuilders);
     // Verify outcome
     var rg = Assert.IsAssignableFrom<RecursionGuard>(actual);
     var composite = Assert.IsAssignableFrom<CompositeSpecimenBuilder>(rg.Builder);
     Assert.True(expectedBuilders.SequenceEqual(composite));
     // Teardown
 }

        public void BuildAndCreateOnUnregisteredAbstractionWillInvokeResidueCollectorWithCorrectType()
        {
            // Fixture setup
            var residueCollector = new DelegatingSpecimenBuilder();
            residueCollector.OnCreate = (r, c) =>
            {
                Assert.Equal(typeof(AbstractType), r);
                return new ConcreteType();
            };

            var sut = new Fixture();
            sut.ResidueCollectors.Add(residueCollector);
            // Exercise system
            sut.Build<PropertyHolder<AbstractType>>().Create();
            // Verify outcome (done by callback)
            // Teardown
        }

 public void SettingRepeatCountWillCorrectlyUpdateMany()
 {
     // Fixture setup
     var dummyBuilder = new DelegatingSpecimenBuilder();
     var many = new MultipleRelay();
     var sut = new Fixture(dummyBuilder, many);
     // Exercise system
     sut.RepeatCount = 26;
     // Verify outcome
     Assert.Equal(sut.RepeatCount, many.Count);
     // Teardown
 }

 public void ResidueCollectorsIsStable()
 {
     // Fixture setup
     var sut = new Fixture();
     var builder = new DelegatingSpecimenBuilder();
     // Exercise system
     sut.ResidueCollectors.Add(builder);
     // Verify outcome
     Assert.Contains(builder, sut.ResidueCollectors);
     // Teardown
 }