public void RecurringWorker_should_execute_tasks_periodically()
        {
            // Arrange
            var updater = new UpdaterDouble();

            var due           = TimeSpan.FromMilliseconds(600);
            var period        = TimeSpan.FromMilliseconds(150);
            var testTime      = TimeSpan.FromMilliseconds(1800);
            var expectedCount = 9;
            var tolerance     = 4;


            // Act
            updater.UpdatePeriodically(due, period);
            Assert.AreEqual(0, updater.UpdateCount);
            Delay(testTime);

            // Assert
#if (DNXCORE50)
            Assert.InRange(updater.UpdateCount, expectedCount - tolerance, expectedCount + tolerance);
#else
            Assert.GreaterOrEqual(updater.UpdateCount, expectedCount - tolerance);
            Assert.LessOrEqual(updater.UpdateCount, expectedCount + tolerance);
#endif
        }
Esempio n. 2
0
        public void RecurringWorker_should_execute_tasks_periodically()
        {
            // Arrange
            var counter       = 0;
            var due           = TimeSpan.FromMilliseconds(600);
            var period        = TimeSpan.FromMilliseconds(150);
            var testTime      = TimeSpan.FromMilliseconds(1800);
            var expectedCount = 9;
            var tolerance     = 4;

            Func <Task> testAction = () =>
            {
                counter++;
                return(TaskUtilities.CompletedTask);
            };

            using (var sut = new RecurringWorker(testAction, due, period))
            {
                Assert.AreEqual(0, counter);

                // Act
                Delay(testTime);
            }

            // Assert
#if (DNXCORE50)
            Assert.InRange(counter, expectedCount - tolerance, expectedCount + tolerance);
#else
            Assert.GreaterOrEqual(counter, expectedCount - tolerance);
            Assert.LessOrEqual(counter, expectedCount + tolerance);
#endif
        }
        public void RecurringWorker_should_execute_tasks_periodically()
        {
            // Arrange
            var counter          = 0;
            var delayBeforeStart = TimeSpan.FromMilliseconds(400);
            var delayAfterEnd    = TimeSpan.FromMilliseconds(400);
            var due           = TimeSpan.FromMilliseconds(1200);
            var period        = TimeSpan.FromMilliseconds(300);
            var workingTime   = TimeSpan.FromMilliseconds(3800);
            var expectedCount = 9;
            var tolerance     = 3;

            Task testAction()
            {
                counter++;
                return(TaskUtilities.CompletedTask);
            }

            using (var sut = new RecurringWorker(testAction, due, period))
            {
                sut.ExecutionOmitted += (o, e) => counter++;
                Delay(delayBeforeStart);
                sut.Start();
                Assert.AreEqual(0, counter);

                // Act
                Delay(workingTime);
            }
            Delay(delayAfterEnd);

            // Assert
#if (DNXCORE50)
            Assert.InRange(counter, expectedCount - tolerance, expectedCount + tolerance);
#else
            Assert.GreaterOrEqual(counter, expectedCount - tolerance);
            Assert.LessOrEqual(counter, expectedCount + tolerance);
#endif
        }