public void Should_Be_Verified_When_Verfiable_Called()
        {
            var verifiableWrapper = new VerifiableWrapper();

            verifiableWrapper.Verifiable();
            Assert.That(verifiableWrapper.Verified, Is.True);
        }
        public void Should_Be_Verified_With_FailMessage_When_Verfiable_Called_With_Fail_Message()
        {
            var verifiableWrapper = new VerifiableWrapper();
            var failMessage       = "fail message";

            verifiableWrapper.Verifiable(failMessage);
            Assert.That(verifiableWrapper.Verified, Is.True);
            Assert.That(verifiableWrapper.VerifiableFailMessage, Is.EqualTo(failMessage));
        }
        public void WrapVerifiesForVerification_Should_Wrap_Passing_Self()
        {
            var verifiableWrapper = new VerifiableWrapper();
            var verifies          = new Mock <IVerifies>().Object;
            var wrapped           = verifiableWrapper.WrapVerifiesForVerification(verifies);

            Assert.That(wrapped, Is.TypeOf <VerifiableVerifies>());
            var wrappedResult = wrapped as VerifiableVerifies;

            Assert.That(wrappedResult.Wrapped, Is.EqualTo(verifies));
            Assert.That(wrappedResult.VerifiableWrapper, Is.EqualTo(verifiableWrapper));
        }
        public void WrapCallbackResultForVerification_Should_Wrap_Passing_Self()
        {
            var verifiableWrapper = new VerifiableWrapper();
            var callbackResult    = new Mock <ICallbackResult>().Object;
            var wrapped           = verifiableWrapper.WrapCallbackResultForVerification(callbackResult);

            Assert.That(wrapped, Is.TypeOf <VerifiableCallbackResult>());
            var wrappedResult = wrapped as VerifiableCallbackResult;

            Assert.That(wrappedResult.Wrapped, Is.EqualTo(callbackResult));
            Assert.That(wrappedResult.VerifiableWrapper, Is.EqualTo(verifiableWrapper));
        }
        public void WrapReturnsThrowsGetterForVerification_Should_Wrap_Passing_Self()
        {
            var verifiableWrapper   = new VerifiableWrapper();
            var returnsThrowsGetter = new Mock <IReturnsThrowsGetter <IToMock, int> >().Object;
            var wrapped             = verifiableWrapper.WrapReturnsThrowsGetterForVerification(returnsThrowsGetter);

            Assert.That(wrapped, Is.TypeOf <VerifiableReturnsThrowsGetter <IToMock, int> >());
            var wrappedResult = wrapped as VerifiableReturnsThrowsGetter <IToMock, int>;

            Assert.That(wrappedResult.Wrapped, Is.EqualTo(returnsThrowsGetter));
            Assert.That(wrappedResult.VerifiableWrapper, Is.EqualTo(verifiableWrapper));
        }
        public void Should_Not_Be_Verfied_If_Verifiable_Has_Not_Been_Called()
        {
            var verifiableWrapper = new VerifiableWrapper();

            Assert.That(verifiableWrapper.Verified, Is.False);
        }