public async Task GetNextDateTimeMustReturnIncrementalTicks()
        {
            long            startTick        = 0;
            long            expectedTick     = 0;
            var             incrementalClock = new IncrementalClock(startTick);
            Func <DateTime> clock            = incrementalClock.GetNextDateTime;

            while (expectedTick <= 5)
            {
                await RandomDelay(); // Make sure it's not real time dependent

                Assert.Equal(++expectedTick, clock().Ticks);
                Assert.Equal(expectedTick, incrementalClock.CurrentTick);
            }
        }
        public async Task GetNextDateTimeMustReturnIncrementTicksInMultiThreadContext()
        {
            long startTick           = 56749874;
            var  incrementalClock    = new IncrementalClock(startTick);
            IEnumerable <long> range = Enumerable.Range(1, 5000).Select(x => (long)x);

            long[] ticksFromincrementalClock = await Task.WhenAll(range
                                                                  .Select(async _ =>
            {
                await RandomDelay();
                return(incrementalClock.GetNextDateTime().Ticks);
            }));

            List <long> expectedTicks = range.Select(x => x + startTick).ToList();

            Assert.Equal(ticksFromincrementalClock.OrderBy(x => x).ToList(), expectedTicks);
        }
        public void Returns_new_value_after_buffering_period_passes()
        {
            DateTime dateTime         = DateTime.MinValue;
            var      bufferingPeriod  = TimeSpan.FromTicks(1);
            var      incrementalClock = new IncrementalClock();
            int      executions       = 0;
            var      genericBuffer    = new GenericBuffer <int>(factory: () => executions++, bufferingPeriod: bufferingPeriod, clock: () => dateTime);


            Assert.Equal(0, genericBuffer.GetValue()); // Before buffering period is past

            dateTime += bufferingPeriod;
            Assert.Equal(1, genericBuffer.GetValue()); // After first buffering period is past

            dateTime += bufferingPeriod;
            Assert.Equal(2, genericBuffer.GetValue()); // After second buffering period is past
        }
        public async Task Returns_new_value_after_buffering_period_passes()
        {
            CancellationToken ct       = CancellationToken.None;
            DateTime          dateTime = DateTime.MinValue;
            var bufferingPeriod        = TimeSpan.FromTicks(1);
            var incrementalClock       = new IncrementalClock();
            int executions             = 0;
            var asyncGenericBuffer     = new AsyncGenericBuffer <int>(factory: _ => Task.FromResult(executions++), bufferingPeriod: bufferingPeriod, clock: () => dateTime);


            Assert.Equal(0, await asyncGenericBuffer.GetValueAsync(ct)); // Before buffering period is past

            dateTime += bufferingPeriod;
            Assert.Equal(1, await asyncGenericBuffer.GetValueAsync(ct)); // After first buffering period is past

            dateTime += bufferingPeriod;
            Assert.Equal(2, await asyncGenericBuffer.GetValueAsync(ct)); // After second buffering period is past
        }