public void Attempt_SucceedsOnLastAttempt()
        {
            int  counter = 0;
            bool success = Retry.Attempt(() => { counter++; return(counter == 5); }, 5, TimeSpan.FromMilliseconds(1));

            Assert.IsTrue(success);
        }
        public void Attempt_NumberOfAttemptsReached()
        {
            int counter = 0;

            Retry.Attempt(() => { counter++; return(false); }, 5, TimeSpan.FromMilliseconds(1));

            Assert.AreEqual(counter, 5);
        }
        public void Attempt_IntervalGreaterThanZero()
        {
            bool set = false;

            Retry.Attempt(() => { set = true; return(true); }, 1, TimeSpan.FromSeconds(1));

            Assert.IsTrue(set);
        }
        public void Attempt_ThrowException_HandleExceptions()
        {
            OperationResult result = Retry.Attempt(() => { throw new InvalidOperationException(); }, 5, TimeSpan.FromMilliseconds(1));

            Assert.IsFalse(result);
            Assert.IsFalse(string.IsNullOrEmpty(result.AllErrorMessages));
            Assert.IsFalse(result.ErrorMessages.Count == 0);
        }
        public void Attempt_IntervalRespected()
        {
            Stopwatch watch = new Stopwatch();

            watch.Start();
            Retry.Attempt(() => { return(false); }, 10, TimeSpan.FromMilliseconds(100));
            watch.Stop();

            //The elapsed time is a bit lower than the real time we're expecting.
            //Thread yielding is a request only and not exact.
            Assert.GreaterOrEqual(watch.ElapsedMilliseconds, 900);
        }
 public void Attempt_IntervalLessThanZero()
 {
     Retry.Attempt(() => { return(true); }, 1, (TimeSpan.FromSeconds(0) - TimeSpan.FromSeconds(1)));
 }
 public void Attempt_IntervalEqualsZero()
 {
     Retry.Attempt(() => { return(true); }, 1, TimeSpan.FromSeconds(0));
 }
 public void Attempt_AttemptsEqualsZero()
 {
     Retry.Attempt(() => { return(true); }, 0, TimeSpan.FromSeconds(1));
 }
 public void Attempt_AttemptsLessThanZero()
 {
     Retry.Attempt(() => { return(true); }, -1, TimeSpan.FromSeconds(1));
 }
 public void Attempt_FunctionNull()
 {
     Retry.Attempt(null);
 }
 public void Attempt_ThrowException_DontHandleExceptions()
 {
     OperationResult result = Retry.Attempt(() => { throw new InvalidOperationException(); }, 5, TimeSpan.FromMilliseconds(1), RetryExceptionBehaviour.DoNotHandle);
 }
        public void Attempt_Failed()
        {
            bool success = Retry.Attempt(() => { return(false); }, 5, TimeSpan.FromMilliseconds(1));

            Assert.IsFalse(success);
        }
        public void Attempt_Success()
        {
            bool success = Retry.Attempt(() => { return(true); }, 5, TimeSpan.FromMilliseconds(1));

            Assert.IsTrue(success);
        }