using System;

using System.Linq;

using System.Reflection;

using System.Threading;

using System.Collections.Generic;

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 DateTime _lastReturnedValue;

        private readonly object lockObject = new object();

​

        public TimeStampProvider()

        {

            _lastReturnedValue = RoundToMilliseconds(DateTime.Now);

        }

​

        /// <inheritdoc />

        public DateTime TimeStamp()

        {

           var roundedToMilliseconds = RoundToMilliseconds(DateTime.Now);

​

            lock (lockObject)

            {

                return _lastReturnedValue < roundedToMilliseconds

                    ? _lastReturnedValue = roundedToMilliseconds

                    : _lastReturnedValue = _lastReturnedValue.AddMilliseconds(1);

            }

        }

​

        private DateTime RoundToMilliseconds(DateTime now)

        {

            return new DateTime(now.Year, now.Month, now.Day, now.Hour, now.Minute, now.Second, now.Millisecond, now.Kind);

        }

    }

​

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

        }

    }

}