mfgames-locking-cil/src/MfGames.Locking.Tests/LockTests.cs

// <copyright file="LockTests.cs" company="Moonfire Games">
// Copyright (c) Moonfire Games. MIT License.
// </copyright>

namespace MfGames.Locking.Tests
{
    using System;
    using System.Collections.Generic;
    using System.Threading;
    using System.Threading.Tasks;
    using Xunit;
    using Xunit.Abstractions;

    public class LockTests
    {
        public static readonly TimeSpan ProcessTime = TimeSpan.FromMilliseconds(50);

        private readonly List<int> events;

        private readonly ReaderWriterLockSlim locker;

        private readonly ITestOutputHelper output;

        private readonly DateTime start;

        public LockTests(ITestOutputHelper output)
        {
            this.output = output;
            this.start = DateTime.UtcNow;
            this.locker = new ReaderWriterLockSlim();
            this.events = new List<int>();
        }

        private TimeSpan Elapsed => DateTime.UtcNow - this.start;

        [Fact]
        public void BasicDataGatheringWorks()
        {
            this.Report(ProcessTime, 1);
            this.Verify();
        }

        [Fact]
        public void ReadBlocksWrite()
        {
            Task.WaitAll(
                Task.Run(() => this.ReportInReadLock(ProcessTime * 0, ProcessTime * 3, 1)),
                Task.Run(() => this.ReportInWriteLock(ProcessTime * 1, ProcessTime * 1, 2)));

            this.Verify();
        }

        [Fact]
        public void ReadsDoNotBlockReads()
        {
            Task.WaitAll(
                Task.Run(() => this.ReportInReadLock(ProcessTime, ProcessTime * 5, 3)),
                Task.Run(() => this.ReportInReadLock(ProcessTime * 2, ProcessTime, 1)),
                Task.Run(() => this.ReportInReadLock(ProcessTime * 2, ProcessTime * 2, 2)));

            this.Verify();
        }

        [Fact]
        public void ThreadedDataGatheringWorks()
        {
            Task.WaitAll(
                Task.Run(() => this.ReportInReadLock(ProcessTime, ProcessTime, 1)));

            this.Verify();
        }

        [Fact]
        public void UpgradableBlocksUpgradable()
        {
            Task.WaitAll(
                Task.Run(() => this.ReportInUpgradableLock(ProcessTime, ProcessTime * 5, 1)),
                Task.Run(() => this.ReportInUpgradableLock(ProcessTime * 3, ProcessTime, 2)),
                Task.Run(() => this.ReportInUpgradableLock(ProcessTime * 2, ProcessTime * 2, 3)));

            this.Verify();
        }

        [Fact]
        public void UpgradableDoesNotBlockReads()
        {
            Task.WaitAll(
                Task.Run(() => this.ReportInUpgradableLock(ProcessTime, ProcessTime * 5, 3)),
                Task.Run(() => this.ReportInReadLock(ProcessTime * 2, ProcessTime, 1)),
                Task.Run(() => this.ReportInReadLock(ProcessTime * 2, ProcessTime * 2, 2)));

            this.Verify();
        }

        [Fact]
        public void WriteBlockRead()
        {
            Task.WaitAll(
                Task.Run(() => this.ReportInWriteLock(ProcessTime, ProcessTime * 3, 1)),
                Task.Run(() => this.ReportInReadLock(ProcessTime * 2, ProcessTime, 2)));

            this.Verify();
        }

        [Fact]
        public void WriteBlockReads()
        {
            Task.WaitAll(
                Task.Run(() => this.ReportInWriteLock(ProcessTime, ProcessTime * 5, 1)),
                Task.Run(() => this.ReportInReadLock(ProcessTime * 2, ProcessTime, 2)),
                Task.Run(() => this.ReportInReadLock(ProcessTime * 2, ProcessTime * 2, 3)));

            this.Verify();
        }

        private void AddEvent(int sequence)
        {
            // This is a monitor lock on the slim, just to give us a second lock.
            lock (this.locker)
            {
                this.output.WriteLine(this.Elapsed + ": " + sequence + " => adding sequence");
                this.events.Add(sequence);
            }
        }

        /// <summary>
        /// Waits a short period of time and then injects the sequence into the event list.
        /// </summary>
        private void Report(
            TimeSpan processTime,
            int sequence)
        {
            this.output.WriteLine(this.Elapsed + ": " + sequence + " => starting process");
            Thread.Sleep(processTime);
            this.output.WriteLine(this.Elapsed + ": " + sequence + " => finished process");
            this.AddEvent(sequence);
        }

        private void ReportInReadLock(
            TimeSpan settleTime,
            TimeSpan processTime,
            int sequence)
        {
            this.output.WriteLine(this.Elapsed + ": " + sequence + " => entering read lock: " + sequence);

            Thread.Sleep(settleTime);

            this.output.WriteLine(this.Elapsed + ": " + sequence + " => locking read lock: " + sequence);

            using (new ReadLock(this.locker))
            {
                this.output.WriteLine(this.Elapsed + ": " + sequence + " => starting read lock: " + sequence);

                this.Report(processTime, sequence);
            }
        }

        private void ReportInUpgradableLock(
            TimeSpan settleTime,
            TimeSpan processTime,
            int sequence)
        {
            this.output.WriteLine(this.Elapsed + ": " + sequence + " => entering upgradable lock: " + sequence);

            Thread.Sleep(settleTime);

            this.output.WriteLine(this.Elapsed + ": " + sequence + " => locking upgradable lock: " + sequence);

            using (new UpgradableLock(this.locker))
            {
                this.output.WriteLine(this.Elapsed + ": " + sequence + " => starting upgradable lock: " + sequence);

                this.Report(processTime, sequence);
            }
        }

        private void ReportInWriteLock(
            TimeSpan settleTime,
            TimeSpan processTime,
            int sequence)
        {
            this.output.WriteLine(this.Elapsed + ": " + sequence + " => entering write lock: " + sequence);

            Thread.Sleep(settleTime);

            this.output.WriteLine(this.Elapsed + ": " + sequence + " => locking write lock: " + sequence);

            using (new WriteLock(this.locker))
            {
                this.output.WriteLine(this.Elapsed + ": " + sequence + " => starting write lock: " + sequence);

                this.Report(processTime, sequence);
            }
        }

        /// <summary>
        /// Verifies the sequence of events.
        /// </summary>
        private void Verify()
        {
            this.output.WriteLine("Final Sequence: " + string.Join(", ", this.events));

            for (int i = 1; i <= this.events.Count; i++)
            {
                Assert.Equal(i, this.events[i - 1]);
            }
        }
    }
}