public void Should_stop_when_wait_first_delay()
        {
            var canStop = false;
            var calls   = 0;

            TimeSpan Provider()
            {
                canStop = true;
                return(TimeSpan.FromSeconds(100500));
            }

            var periodicalAction = new AsyncPeriodicalAction(
                () =>
            {
                ++calls;
                throw new Exception();
            },
                errorHandler,
                Provider,
                true);

            periodicalAction.Start();

            var spinWait = new SpinWait();

            while (!canStop)
            {
                spinWait.SpinOnce();
            }

            periodicalAction.Stop();
            calls.Should().Be(0);
            errors.Should().Be(0);
        }
        public void Should_not_stop_when_action_throws_OperationCanceledException_with_unknown_token()
        {
            var counter = 0;

            Task Action()
            {
                counter++;
                throw new OperationCanceledException(new CancellationToken(true));
            }

            var periodicalAction = new AsyncPeriodicalAction(
                Action,
                errorHandler,
                () => TimeSpan.Zero);

            periodicalAction.Start();

            var spinWait = new SpinWait();

            while (counter < 2)
            {
                spinWait.SpinOnce();
            }

            periodicalAction.Stop();
            errors.Should().BeGreaterThan(1);
        }
        public void Should_not_stop_when_action_throws_exception()
        {
            var counter = 0;

            Task Action()
            {
                counter++;
                return(Task.FromException(new Exception()));
            }

            var periodicalAction = new AsyncPeriodicalAction(
                Action,
                errorHandler,
                () => TimeSpan.Zero);

            periodicalAction.Start();

            var spinWait = new SpinWait();

            while (counter < 2)
            {
                spinWait.SpinOnce();
            }

            periodicalAction.Stop();
            errors.Should().BeGreaterThan(1);
        }
        public void Should_stop_when_action_throws_OperationCanceledException_with_proper_token()
        {
            var canStop = false;

            Task Action(CancellationToken token, TimeSpan remaining)
            {
                canStop = true;

                var actionSpinWait = new SpinWait();

                while (!token.IsCancellationRequested)
                {
                    actionSpinWait.SpinOnce();
                }

                token.ThrowIfCancellationRequested();
                return(Task.CompletedTask);
            }

            var periodicalAction = new AsyncPeriodicalAction(
                Action,
                errorHandler,
                () => TimeSpan.Zero);

            periodicalAction.Start();

            var spinWait = new SpinWait();

            while (!canStop)
            {
                spinWait.SpinOnce();
            }

            periodicalAction.Stop();
            errors.Should().Be(0);
        }
 public void Dispose()
 {
     periodicalChecker.Stop();
     currentWatcher?.Dispose();
     currentWatcher = null;
 }