public void TargetTypeIsTheSameAsRegisteredTypeWhenOnlyTargetTypeIsSpecified()
        {
            // Arrange
            var targetType = typeof(string);
            var sut        = new FreezingCustomization(targetType);

            // Act & assert
            Assert.Equal(sut.TargetType, sut.RegisteredType);
        }
        public void TargetTypeIsTheSameAsRegisteredTypeWhenOnlyTargetTypeIsSpecified()
        {
            // Fixture setup
            var targetType = typeof(string);
            var sut        = new FreezingCustomization(targetType);

            // Exercise system and verify outcome
            Assert.Equal(sut.TargetType, sut.RegisteredType);
            // Teardown
        }
        public void CustomizeNullFixtureThrows()
        {
            // Arrange
            var dummyType = typeof(object);
            var sut       = new FreezingCustomization(dummyType);

            // Act & assert
            Assert.Throws <ArgumentNullException>(() =>
                                                  sut.Customize(null));
        }
        public void SutIsCustomization()
        {
            // Arrange
            var dummyType = typeof(object);
            // Act
            var sut = new FreezingCustomization(dummyType);

            // Assert
            Assert.IsAssignableFrom <ICustomization>(sut);
        }
        public void SutIsCustomization()
        {
            // Fixture setup
            var dummyType = typeof(object);
            // Exercise system
            var sut = new FreezingCustomization(dummyType);

            // Verify outcome
            Assert.IsAssignableFrom <ICustomization>(sut);
            // Teardown
        }
        public void CustomizeNullFixtureThrows()
        {
            // Fixture setup
            var dummyType = typeof(object);
            var sut       = new FreezingCustomization(dummyType);

            // Exercise system and verify outcome
            Assert.Throws <ArgumentNullException>(() =>
                                                  sut.Customize(null));
            // Teardown
        }
        public void TargetTypeAndRegisteredTypeAreCorrect()
        {
            // Arrange
            var targetType     = typeof(string);
            var registeredType = typeof(object);
            var sut            = new FreezingCustomization(targetType, registeredType);

            // Act & assert
            Assert.Equal(targetType, sut.TargetType);
            Assert.Equal(registeredType, sut.RegisteredType);
        }
        public void TargetTypeIsCorrect()
        {
            // Arrange
            var expectedType = typeof(string);
            var sut          = new FreezingCustomization(expectedType);
            // Act
            Type result = sut.TargetType;

            // Assert
            Assert.Equal(expectedType, result);
        }
        public void TargetTypeAndRegisteredTypeAreCorrect()
        {
            // Fixture setup
            var targetType     = typeof(string);
            var registeredType = typeof(object);
            var sut            = new FreezingCustomization(targetType, registeredType);

            // Exercise system and verify outcome
            Assert.Equal(targetType, sut.TargetType);
            Assert.Equal(registeredType, sut.RegisteredType);
            // Teardown
        }
        public void TargetTypeIsCorrect()
        {
            // Fixture setup
            var expectedType = typeof(string);
            var sut          = new FreezingCustomization(expectedType);
            // Exercise system
            Type result = sut.TargetType;

            // Verify outcome
            Assert.Equal(expectedType, result);
            // Teardown
        }
        public void RegisteredTypeIsCorrect()
        {
            // Arrange
            var targetType     = typeof(string);
            var registeredType = typeof(object);
            var sut            = new FreezingCustomization(targetType, registeredType);
            // Act
            Type result = sut.RegisteredType;

            // Assert
            Assert.Equal(registeredType, result);
        }
 public override IEnumerable<object[]> GetData(System.Reflection.MethodInfo methodUnderTest, Type[] parameterTypes)
 {
     var specimens = new List<object>();
     foreach (var p in methodUnderTest.GetParameters())
     {
         CustomizeFixture(p);
         if (p.ParameterType.GetInterfaces().Any(t => t.IsGenericType && t.GetGenericTypeDefinition() == typeof(IMock<>)))
         {
             var freeze = new FreezingCustomization(p.ParameterType, p.ParameterType);
             this.Fixture.Customize(freeze);
         }
         var specimen = Resolve(p);
         specimens.Add(specimen);
     }
     return new[] { specimens.ToArray() };
 }
        public void CustomizeWithRegisteredTypeCorrectlyCustomizesFixture()
        {
            // Arrange
            var targetType     = typeof(int);
            var registeredType = typeof(object);
            var fixture        = new Fixture();
            var sut            = new FreezingCustomization(targetType, registeredType);

            // Act
            sut.Customize(fixture);
            // Assert
            object i1 = fixture.Create <int>();
            object i2 = fixture.Create <object>();

            Assert.Equal(i1, i2);
        }
        public void CustomizeCorrectlyCustomizesFixture()
        {
            // Arrange
            var targetType = typeof(int);
            var fixture    = new Fixture();

            var sut = new FreezingCustomization(targetType);

            // Act
            sut.Customize(fixture);
            // Assert
            var i1 = fixture.Create <int>();
            var i2 = fixture.Create <int>();

            Assert.Equal(i1, i2);
        }
        public void CustomizeWithRegisteredTypeCorrectlyCustomizesFixture()
        {
            // Fixture setup
            var targetType     = typeof(int);
            var registeredType = typeof(object);
            var fixture        = new Fixture();
            var sut            = new FreezingCustomization(targetType, registeredType);

            // Exercise system
            sut.Customize(fixture);
            // Verify outcome
            object i1 = fixture.Create <int>();
            object i2 = fixture.Create <object>();

            Assert.Equal(i1, i2);
            // Teardown
        }
Esempio n. 16
0
        public void CustomizeCorrectlyCustomizesFixture()
        {
            // Fixture setup
            var targetType = typeof(int);
            var fixture    = new Fixture();

            var sut = new FreezingCustomization(targetType);

            // Exercise system
            sut.Customize(fixture);
            // Verify outcome
            var i1 = fixture.CreateAnonymous <int>();
            var i2 = fixture.CreateAnonymous <int>();

            Assert.Equal(i1, i2);
            // Teardown
        }