using System;

using System.Linq;

using System.Reflection;

using System.Threading;

​

using FluentAssertions;

​

using NUnit.Framework;

using NUnitLite;

​

namespace Test

{

    public class Program

    {

        public static int Main(string[] args)

        {

            return new AutoRun(Assembly.GetExecutingAssembly())

                .Execute(new[] {"--nocolor"});

        }

    }

    /// <summary>

    /// Интерфейс сервиса получения отметок времени.

    /// </summary>

    public interface ITimeStampProvider

    {

        /// <summary>

        /// Возвращает текущую отметку времени.

        /// </summary>

        /// <remarks>

        /// Реализация должна:

        ///  - быть потокобезопасной

        ///  - возвращать отметки времени округлённые до 1 милисекунды

        ///  - допускается возвращение отметок времени из будущего, если в текущую миллисекунду отметка времени уже выдана.

        /// </remarks>

        /// <returns>Текущая отметка времени.</returns>

        DateTime TimeStamp();

    }

    /// <inheritdoc />

    public class TimeStampProvider : ITimeStampProvider

    {

        private long last = 0;

        /// <inheritdoc />

        public DateTime TimeStamp()

        {

            long initial;

            long computed;

​

            do

            {

                initial = last;

                computed = DateTime.Now.Ticks / TimeSpan.TicksPerMillisecond;

​

                if (computed <= initial)

                {

                    computed = initial + 1;

                }

            }

            while (Interlocked.CompareExchange(ref last, computed, initial) != initial);

​

            return new DateTime(computed * TimeSpan.TicksPerMillisecond);

        }

    }

​

    public class TimeStampProviderTest

    {

        /// <summary>

        /// Тестовый объект.

        /// </summary>

        private ITimeStampProvider _timeStampProvider;

​

        /// <summary>

        /// Настройка теста.

        /// </summary>

        [SetUp]

        public void Setup()

        {

            _timeStampProvider = new TimeStampProvider();

        }

​

        /// <summary>

        /// Тест на то, что провайдер возвращает только уникальные объекты.

        /// </summary>

        [Test]

        public void TimeStampProviderShouldReturnUniqueValuesTest()

        {

            // act

            var timeStamps = Enumerable

                .Range(0, 10000)

                .Select(_ => _timeStampProvider.TimeStamp()).ToArray();

​

            // assert

            timeStamps.Should().OnlyHaveUniqueItems();

        }

​

        /// <summary>

        /// Тест на то, что провайдер возвращает только уникальные объекты.

        /// </summary>

        [Test]

        public void ConcurrentTimeStampProviderShouldReturnUniqueValuesTest()

        {

            // act

            var timeStamps = Enumerable

                .Range(0, 10000)

                .AsParallel()

                .Select(_ => _timeStampProvider.TimeStamp()).ToArray();

​

            // assert

            timeStamps.Should().OnlyHaveUniqueItems();

        }

​

        /// <summary>

        /// Тест на то, что провайдер возвращает только уникальные объекты.

        /// </summary>

        [Test]

        public void TimeStampProviderShouldReturnRoundedValuesTest()

        {

            // act

            var timeStamps = Enumerable

                .Range(0, 1000)

                .AsParallel()

                .Select(_ => _timeStampProvider.TimeStamp()).ToArray();

​

            // assert

            foreach (var timeStamp in timeStamps)

            {

                (timeStamp.Ticks % TimeSpan.TicksPerMillisecond).Should().Be(0);

            }

        }

​

        /// <summary>

        /// Тест проверяет отсутствие залипания отметок времени в "прошлом".

        /// </summary>

        [Test]

        public void TimeStampIntervalTest()

        {

            // act

            var ts1 = _timeStampProvider.TimeStamp();

            Thread.Sleep(100);

            var ts2 = _timeStampProvider.TimeStamp();

​

            // assert

            (ts2 - ts1).TotalMilliseconds.Should().BeGreaterThan(90);

        }

    }

}