C# Kernel.DelegatingSpecimenBuilder类代码示例

        public void ComposeReturnsCorrectResult()
        {
            // Fixture setup
            var targetType = typeof(string);
            var factory = new DelegatingSpecimenBuilder();
            var sut = new TypedBuilderComposer(targetType, factory);
            // Exercise system
            var result = sut.Compose();
            // Verify outcome
            var filter = Assert.IsAssignableFrom<FilteringSpecimenBuilder>(result);

            var orSpec = Assert.IsAssignableFrom<OrRequestSpecification>(filter.Specification);
            Assert.Equal(targetType, orSpec.Specifications.OfType<SeedRequestSpecification>().Single().TargetType);
            Assert.Equal(targetType, orSpec.Specifications.OfType<ExactTypeSpecification>().Single().TargetType);

            var composite = Assert.IsAssignableFrom<CompositeSpecimenBuilder>(filter.Builder);
            var outputGuard = Assert.IsAssignableFrom<NoSpecimenOutputGuard>(composite.Builders.First());
            Assert.IsAssignableFrom<SeedIgnoringRelay>(composite.Builders.Last());

            Assert.Equal(factory, outputGuard.Builder);

            var inverseSpec = Assert.IsAssignableFrom<InverseRequestSpecification>(outputGuard.Specification);
            var seedSpec = Assert.IsAssignableFrom<SeedRequestSpecification>(inverseSpec.Specification);
            Assert.Equal(targetType, seedSpec.TargetType);
            // Teardown
        }

        public void CreateTypedNodeReturnsCorrectResult(Type targetType)
        {
            // Fixture setup
            var factory = new DelegatingSpecimenBuilder();
            // Exercise system
            FilteringSpecimenBuilder actual =
                SpecimenBuilderNodeFactory.CreateTypedNode(
                    targetType,
                    factory);
            // Verify outcome
            var expected = new FilteringSpecimenBuilder(
                new CompositeSpecimenBuilder(
                    new NoSpecimenOutputGuard(
                        factory,
                        new InverseRequestSpecification(
                            new SeedRequestSpecification(
                                targetType))),
                    new SeedIgnoringRelay()),
                new OrRequestSpecification(
                    new SeedRequestSpecification(targetType),
                    new ExactTypeSpecification(targetType)));

            Assert.True(expected.GraphEquals(actual, new NodeComparer()));
            // Teardown
        }

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

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

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

 public void InitializeWithNullSpecificationThrows()
 {
     // Fixture setup
     var dummyBuilder = new DelegatingSpecimenBuilder();
     Action<object, ISpecimenContext> dummyAction = (s, c) => { };
     // Exercise system and verify outcome
     Assert.Throws<ArgumentNullException>(() => new Postprocessor(dummyBuilder, dummyAction, null));
     // Teardown
 }

 public void SutCanBeInitializedWithDoubleAction()
 {
     // Fixture setup
     var dummyBuilder = new DelegatingSpecimenBuilder();
     Action<object, ISpecimenContext> dummyAction = (s, c) => { };
     // Exercise system and verify outcome
     Assert.DoesNotThrow(() => new Postprocessor(dummyBuilder, dummyAction));
     // Teardown
 }

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

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

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

 public void SutIsRecursionGuard()
 {
     // Fixture setup
     // Exercise system
     var dummy = new DelegatingSpecimenBuilder();
     var sut = new OmitOnRecursionGuard(dummy);
     // Verify outcome
     Assert.IsAssignableFrom<RecursionGuard>(sut);
     // Teardown
 }

 public void SutIsSpecimenBuilderComposer()
 {
     // Fixture setup
     var dummyType = typeof(object);
     var dummyBuilder = new DelegatingSpecimenBuilder();
     // Exercise system
     var sut = new TypedBuilderComposer(dummyType, dummyBuilder);
     // Verify outcome
     Assert.IsAssignableFrom<ISpecimenBuilderComposer>(sut);
     // Teardown
 }

 public void SutIsSpecimenBuilder()
 {
     // Fixture setup
     var dummySpecification = new DelegatingRequestSpecification();
     var dummyBuilder = new DelegatingSpecimenBuilder();
     // Exercise system
     var sut = new FilteringSpecimenBuilder(dummyBuilder, dummySpecification);
     // Verify outcome
     Assert.IsAssignableFrom<ISpecimenBuilder>(sut);
     // Teardown
 }

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

 public void SutIsSpecimenBuilder()
 {
     // Fixture setup
     var dummyBuilder = new DelegatingSpecimenBuilder();
     Action<object> dummyAction = s => { };
     // Exercise system
     var sut = new Postprocessor(dummyBuilder, dummyAction);
     // Verify outcome
     Assert.IsAssignableFrom<ISpecimenBuilder>(sut);
     // Teardown
 }