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 _checkValue;

        public TimeStampProvider()

        {

            _checkValue = 0;

        }

​

        /// <inheritdoc />

        /// <remarks> https://docs.microsoft.com/ru-ru/dotnet/api/system.threading.interlocked.compareexchange?view=net-5.0</remarks> 

        public DateTime TimeStamp()

        {

            long initialValue;

            long computedValue;

            do

            {

                initialValue = _checkValue;

                var nowDateTime = DateTime.Now;

                var ticks = nowDateTime.Ticks - (nowDateTime.Ticks % TimeSpan.TicksPerMillisecond);

                computedValue = Math.Max(ticks, initialValue) + TimeSpan.TicksPerMillisecond;

            }while (initialValue != Interlocked.CompareExchange(ref _checkValue, computedValue, initialValue));

            return new DateTime(computedValue);

        }

    }

​

    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);

        }

    }

}