public void SutIsEquatable()
 {
     // Fixture setup
     // Exercise system
     var sut = new SeededRequest(typeof(decimal), 1);
     // Verify outcome
     Assert.IsInstanceOfType(sut, typeof(IEquatable<SeededRequest>));
     // Teardown
 }
 public void SutIsEquatable()
 {
     // Fixture setup
     // Exercise system
     var sut = new SeededRequest(typeof(decimal), 1);
     // Verify outcome
     Assert.IsAssignableFrom<IEquatable<SeededRequest>>(sut);
     // Teardown
 }
 public void SutDoesNotEqualNullSut()
 {
     // Fixture setup
     var sut = new SeededRequest(typeof(TimeSpan), new object());
     SeededRequest other = null;
     // Exercise system
     var result = sut.Equals(other);
     // Verify outcome
     Assert.False(result, "Equals");
     // Teardown
 }
 public void SeedIsCorrect()
 {
     // Fixture setup
     var expectedSeed = "Anonymous value";
     var sut = new SeededRequest(typeof(string), expectedSeed);
     // Exercise system
     var result = sut.Seed;
     // Verify outcome
     Assert.Equal(expectedSeed, result);
     // Teardown
 }
 public void SutDoesNotEqualNullObject()
 {
     // Fixture setup
     var sut = new SeededRequest(typeof(DateTime), new DateTime(103029));
     object other = null;
     // Exercise system
     var result = sut.Equals(other);
     // Verify outcome
     Assert.IsFalse(result, "Equals");
     // Teardown
 }
 public void RequestIsCorrect()
 {
     // Fixture setup
     var expectedRequest = new object();
     var sut = new SeededRequest(expectedRequest, "Anonymous value");
     // Exercise system
     var result = sut.Request;
     // Verify outcome
     Assert.Equal(expectedRequest, result);
     // Teardown
 }
 public void CreateFromSeedWhenContainerCannotSatisfyWrappedRequestWillReturnNull()
 {
     // Fixture setup
     var anonymousSeed = new SeededRequest(typeof(object), new object());
     var unableContainer = new DelegatingSpecimenContainer { OnCreate = r => null };
     var sut = new ValueIgnoringSeedUnwrapper();
     // Exercise system
     var result = sut.Create(anonymousSeed, unableContainer);
     // Verify outcome
     Assert.IsNull(result, "Create");
     // Teardown
 }
 public void IsSatisfiedByReturnsCorrectResult(Type specType, Type seedRequestType, bool expectedResult)
 {
     // Fixture setup
     var sut = new SeedRequestSpecification(specType);
     var dummySeed = new object();
     var seededRequest = new SeededRequest(seedRequestType, dummySeed);
     // Exercise system
     var result = sut.IsSatisfiedBy(seededRequest);
     // Verify outcome
     Assert.Equal(expectedResult, result);
     // Teardown
 }
 public void CreateWithNonStringSeedWillReturnCorrectResult()
 {
     // Fixture setup
     var sut = new StringSeedRelay();
     var nonStringSeed = new SeededRequest(typeof(string), new object());
     // Exercise system
     var dummyContainer = new DelegatingSpecimenContext();
     var result = sut.Create(nonStringSeed, dummyContainer);
     // Verify outcome
     var expectedResult = new NoSpecimen(nonStringSeed);
     Assert.Equal(expectedResult, result);
     // Teardown
 }
 public void CreateWithInvalidSeededRequestReturnsCorrectResult(object request, object seed)
 {
     // Fixture setup
     var sut = new SeededFactory<int>(s => s);
     var seededRequest = new SeededRequest(request, seed);
     // Exercise system
     var dummyContainer = new DelegatingSpecimenContext();
     var result = sut.Create(seededRequest, dummyContainer);
     // Verify outcome
     var expectedResult = new NoSpecimen(seededRequest);
     Assert.Equal(expectedResult, result);
     // Teardown
 }
 public void CreateFromSeedWhenContainerCannotSatisfyWrappedRequestWillReturnNull()
 {
     // Fixture setup
     var anonymousSeed = new SeededRequest(typeof(object), new object());
     var unableContainer = new DelegatingSpecimenContext { OnResolve = r => new NoSpecimen(anonymousSeed) };
     var sut = new SeedIgnoringRelay();
     // Exercise system
     var result = sut.Create(anonymousSeed, unableContainer);
     // Verify outcome
     var expectedResult = new NoSpecimen(anonymousSeed);
     Assert.Equal(expectedResult, result);
     // Teardown
 }
            protected virtual object HandleSeededRequest(
                SeededRequest seededRequest,
                Type seededRequestType,
                ISpecimenContext context)
            {
                if (seededRequestType == typeof(string)
                    && seededRequest.Seed is string)
                {
                    return seededRequest.Seed;
                }

                return TryCreateSpecimen(seededRequestType, context)
                    ?? new NoSpecimen(seededRequest);
            }
        public void CreateWithNonStringRequestSeedWillReturnNull()
        {
            // Fixture setup
            var sut = new StringSeedRelay();
            var nonStringRequestSeed = new SeededRequest(typeof(object), "Anonymous value");
            // Exercise system
            var dummyContainer = new DelegatingSpecimenContext();
            var result = sut.Create(nonStringRequestSeed, dummyContainer);
            // Verify outcome
#pragma warning disable 618
            var expectedResult = new NoSpecimen(nonStringRequestSeed);
#pragma warning restore 618
            Assert.Equal(expectedResult, result);
            // Teardown
        }
        public void CreateFromSeedWhenContainerCanSatisfyWrappedRequestWillReturnCorrectResult()
        {
            // Fixture setup
            var anonymousSeed = new SeededRequest(typeof(object), new object());

            var expectedResult = new object();
            var container = new DelegatingSpecimenContainer { OnCreate = r => expectedResult };

            var sut = new ValueIgnoringSeedUnwrapper();
            // Exercise system
            var result = sut.Create(anonymousSeed, container);
            // Verify outcome
            Assert.AreEqual(expectedResult, result, "Create");
            // Teardown
        }
        public void CreateFromSeedWillCorrectlyInvokeContainer()
        {
            // Fixture setup
            var sut = new SeedIgnoringRelay();
            var seededRequest = new SeededRequest(typeof(int), 1);

            var mockVerified = false;
            var containerMock = new DelegatingSpecimenContext();
            containerMock.OnResolve = r =>
            {
                Assert.Equal(typeof(int), r);
                mockVerified = true;
                return null;
            };
            // Exercise system
            sut.Create(seededRequest, containerMock);
            // Verify outcome
            Assert.True(mockVerified, "Mock verification");
            // Teardown
        }
        public void CreateFromSeedWillCorrectlyInvokeContainer()
        {
            // Fixture setup
            var sut           = new SeedIgnoringRelay();
            var seededRequest = new SeededRequest(typeof(int), 1);

            var mockVerified  = false;
            var containerMock = new DelegatingSpecimenContext();

            containerMock.OnResolve = r =>
            {
                Assert.Equal(typeof(int), r);
                mockVerified = true;
                return(null);
            };
            // Exercise system
            sut.Create(seededRequest, containerMock);
            // Verify outcome
            Assert.True(mockVerified, "Mock verification");
            // Teardown
        }
        public void CreateFromParameterRequestWillCorrectlyInvokeContainer()
        {
            // Fixture setup
            var sut             = new ParameterRequestTranslator();
            var parameterInfo   = typeof(SingleParameterType <string>).GetConstructors().First().GetParameters().First();
            var expectedRequest = new SeededRequest(parameterInfo.ParameterType, parameterInfo.Name);

            var mockVerified  = false;
            var containerMock = new DelegatingSpecimenContainer();

            containerMock.OnCreate = r =>
            {
                Assert.AreEqual(expectedRequest, r, "Create");
                mockVerified = true;
                return(null);
            };
            // Exercise system
            sut.Create(parameterInfo, containerMock);
            // Verify outcome
            Assert.IsTrue(mockVerified, "Mock verification");
            // Teardown
        }
        public void CreateFromParameterRequestWillCorrectlyInvokeContainer()
        {
            // Fixture setup
            var sut             = new PropertyRequestRelay();
            var propertyInfo    = typeof(PropertyHolder <object>).GetProperty("Property");
            var expectedRequest = new SeededRequest(propertyInfo.PropertyType, propertyInfo.Name);

            var mockVerified  = false;
            var containerMock = new DelegatingSpecimenContext();

            containerMock.OnResolve = r =>
            {
                Assert.Equal(expectedRequest, r);
                mockVerified = true;
                return(null);
            };
            // Exercise system
            sut.Create(propertyInfo, containerMock);
            // Verify outcome
            Assert.True(mockVerified, "Mock verification");
            // Teardown
        }
        public void CreateWithCorrectSeedWillReturnCorrectResult()
        {
            // Fixture setup
            var seed = 7m;
            var seededRequest = new SeededRequest(typeof(decimal), seed);
            var expectedResult = 3m;

            Func<decimal, decimal> factoryStub = s => s == seed ? expectedResult : 0m;

            var sut = new SeededFactory<decimal>(factoryStub);
            // Exercise system
            var dummyContext = new DelegatingSpecimenContext();
            var result = sut.Create(seededRequest, dummyContext);
            // Verify outcome
            Assert.Equal(expectedResult, result);
            // Teardown
        }
 public void SutEqualsOtherSutWhenRequestsAreEqualAndSeedsAreNull()
 {
     // Fixture setup
     var request = typeof(WeakReference);
     var sut = new SeededRequest(request, null);
     var other = new SeededRequest(request, null);
     // Exercise system
     var result = sut.Equals(other);
     // Verify outcome
     Assert.True(result, "Equals");
     // Teardown
 }
        public void CreateWithCorrectlyTypedSeededRequestWithNullSeedReturnsCorrectResult()
        {
            // Fixture setup
            var seededRequest = new SeededRequest(typeof(string), null);
            var expectedResult = Guid.NewGuid().ToString();

            Func<string, string> factoryStub = s => s == null ? expectedResult : null;

            var sut = new SeededFactory<string>(factoryStub);
            // Exercise system
            var dummyContext = new DelegatingSpecimenContext();
            var result = sut.Create(seededRequest, dummyContext);
            // Verify outcome
            Assert.Equal(expectedResult, result);
            // Teardown
        }
 public void CreateWithStringSeedWhenContainerCannotCreateStringsWillReturnCorrectResult()
 {
     // Fixture setup
     var sut = new StringSeedRelay();
     var stringSeed = new SeededRequest(typeof(string), "Anonymous value");
     var unableContainer = new DelegatingSpecimenContext { OnResolve = r => new NoSpecimen(stringSeed) };
     // Exercise system
     var result = sut.Create(stringSeed, unableContainer);
     // Verify outcome
     var expectedResult = new NoSpecimen(stringSeed);
     Assert.Equal(expectedResult, result);
     // Teardown
 }
        public void CreateWithStringSeedWhenContainerCanCreateStringsWillReturnCorrectResult()
        {
            // Fixture setup
            var seedString = Guid.NewGuid().ToString();
            var containerString = Guid.NewGuid().ToString();

            var sut = new StringSeedRelay();
            var stringSeed = new SeededRequest(typeof(string), seedString);
            var container = new DelegatingSpecimenContext { OnResolve = r => containerString };
            // Exercise system
            var result = sut.Create(stringSeed, container);
            // Verify outcome
            var expectedString = seedString + containerString;
            Assert.Equal(expectedString, result);
            // Teardown
        }
 public void SutDoesNotEqualOtherObjectWhenSutSeedIsNull()
 {
     // Fixture setup
     var anonymousRequest = string.Empty;
     var sut = new SeededRequest(anonymousRequest, null);
     object other = new SeededRequest(anonymousRequest, 2.9f);
     // Exercise system
     var result = sut.Equals(other);
     // Verify outcome
     Assert.False(result, "Equals");
     // Teardown
 }
        public void CreateFromParameterRequestWillCorrectlyInvokeContainer()
        {
            // Fixture setup
            var sut = new ParameterRequestTranslator();
            var parameterInfo = typeof(SingleParameterType<string>).GetConstructors().First().GetParameters().First();
            var expectedRequest = new SeededRequest(parameterInfo.ParameterType, parameterInfo.Name);

            var mockVerified = false;
            var containerMock = new DelegatingSpecimenContainer();
            containerMock.OnCreate = r =>
            {
                Assert.AreEqual(expectedRequest, r, "Create");
                mockVerified = true;
                return null;
            };
            // Exercise system
            sut.Create(parameterInfo, containerMock);
            // Verify outcome
            Assert.IsTrue(mockVerified, "Mock verification");
            // Teardown
        }
 public void GetHashCodeWillReturnCorrectResult()
 {
     // Fixture setup
     var request = typeof(NetPipeStyleUriParser);
     var value = Missing.Value;
     var sut = new SeededRequest(request, value);
     var expectedHashCode = request.GetHashCode() ^ value.GetHashCode();
     // Exercise system
     var result = sut.GetHashCode();
     // Verify outcome
     Assert.Equal(expectedHashCode, result);
     // Teardown
 }
 public void SutDoesNotEqualOtherSutWhenOtherSeedIsNull()
 {
     // Fixture setup
     var anonymousRequest = typeof(Buffer);
     var sut = new SeededRequest(anonymousRequest, new GopherStyleUriParser());
     var other = new SeededRequest(anonymousRequest, null);
     // Exercise system
     var result = sut.Equals(other);
     // Verify outcome
     Assert.False(result, "Equals");
     // Teardown
 }
        public void CreateFromFieldRequestWillCorrectlyInvokeContainer()
        {
            // Fixture setup
            var sut = new FieldRequestRelay();
            var fieldInfo = typeof(FieldHolder<object>).GetField("Field");
            var expectedRequest = new SeededRequest(fieldInfo.FieldType, fieldInfo.Name);

            var mockVerified = false;
            var containerMock = new DelegatingSpecimenContext();
            containerMock.OnResolve = r => mockVerified = expectedRequest.Equals(r);
            // Exercise system
            sut.Create(fieldInfo, containerMock);
            // Verify outcome
            Assert.True(mockVerified, "Mock verification");
            // Teardown
        }
 public void SutDoesNotEqualOtherObjectWhenRequestsDiffer()
 {
     // Fixture setup
     var anonymousValue = 1;
     var sut = new SeededRequest(new object(), anonymousValue);
     object other = new SeededRequest(typeof(TimeSpan), anonymousValue);
     // Exercise system
     var result = sut.Equals(other);
     // Verify outcome
     Assert.False(result, "Equals");
     // Teardown
 }
 public void SutDoesNotEqualAnonymousObject()
 {
     // Fixture setup
     var sut = new SeededRequest(new object(), "Anonymous value");
     object anonymousObject = new FileStyleUriParser();
     // Exercise system
     var result = sut.Equals(anonymousObject);
     // Verify outcome
     Assert.False(result, "Equals");
     // Teardown
 }
 public void SutEqualsOtherSutWhenRequestsAndSeedEquals()
 {
     // Fixture setup
     var request = typeof(HttpStyleUriParser);
     var seed = new OperatingSystem(PlatformID.WinCE, new Version());
     var sut = new SeededRequest(request, seed);
     var other = new SeededRequest(request, seed);
     // Exercise system
     var result = sut.Equals(other);
     // Verify outcome
     Assert.True(result, "Equals");
     // Teardown
 }
        public void CreateFromParameterRequestWillCorrectlyInvokeContainer()
        {
            // Fixture setup
            var sut = new PropertyRequestRelay();
            var propertyInfo = typeof(PropertyHolder<object>).GetProperty("Property");
            var expectedRequest = new SeededRequest(propertyInfo.PropertyType, propertyInfo.Name);

            var mockVerified = false;
            var containerMock = new DelegatingSpecimenContext();
            containerMock.OnResolve = r =>
            {
                Assert.Equal(expectedRequest, r);
                mockVerified = true;
                return null;
            };
            // Exercise system
            sut.Create(propertyInfo, containerMock);
            // Verify outcome
            Assert.True(mockVerified, "Mock verification");
            // Teardown
        }
 public void GetHashCodeWillReturnCorrectResultWhenSeedIsNull()
 {
     // Fixture setup
     var request = typeof(Version);
     var sut = new SeededRequest(request, null);
     var expectedHashCode = request.GetHashCode();
     // Exercise system
     var result = sut.GetHashCode();
     // Verify outcome
     Assert.Equal(expectedHashCode, result);
     // Teardown
 }