Port unit tests for synchronization library from RecRoom codebase

Author: kroymann

src/ImageSharp.Web/Synchronization/RefCountedConcurrentDictionary.cs

@@ -2,6 +2,7 @@
 // Licensed under the Apache License, Version 2.0.
 
 using System;
+using System.Collections;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
 
@@ -160,6 +161,55 @@ public void Release(TKey key)
             }
         }
 
+        /// <summary>
+        /// Get an enumeration over the contents of the dictionary for testing/debugging purposes
+        /// </summary>
+        internal IEnumerable<(TKey Key, TValue Value, int RefCount)> DebugGetContents() => new RefCountedDictionaryEnumerable(this);
+
+        /// <summary>
+        /// Internal class used for testing/debugging purposes
+        /// </summary>
+        private class RefCountedDictionaryEnumerable : IEnumerable<(TKey Key, TValue Value, int RefCount)>
+        {
+            private readonly RefCountedConcurrentDictionary<TKey, TValue> dictionary;
+
+            internal RefCountedDictionaryEnumerable(RefCountedConcurrentDictionary<TKey, TValue> dictionary)
+                => this.dictionary = dictionary;
+
+            public IEnumerator<(TKey Key, TValue Value, int RefCount)> GetEnumerator()
+                => new RefCountedDictionaryEnumerator(this.dictionary);
+
+            IEnumerator IEnumerable.GetEnumerator() => this.GetEnumerator();
+        }
+
+        /// <summary>
+        /// Internal class used for testing/debugging purposes
+        /// </summary>
+        private class RefCountedDictionaryEnumerator : IEnumerator<(TKey Key, TValue Value, int RefCount)>
+        {
+            private readonly IEnumerator<KeyValuePair<TKey, RefCountedValue>> enumerator;
+
+            public RefCountedDictionaryEnumerator(RefCountedConcurrentDictionary<TKey, TValue> dictionary)
+                => this.enumerator = dictionary.dictionary.GetEnumerator();
+
+            public (TKey Key, TValue Value, int RefCount) Current
+            {
+                get
+                {
+                    KeyValuePair<TKey, RefCountedConcurrentDictionary<TKey, TValue>.RefCountedValue> keyValuePair = this.enumerator.Current;
+                    return (keyValuePair.Key, keyValuePair.Value.Value, keyValuePair.Value.RefCount);
+                }
+            }
+
+            object IEnumerator.Current => this.Current;
+
+            public void Dispose() => this.enumerator.Dispose();
+
+            public bool MoveNext() => this.enumerator.MoveNext();
+
+            public void Reset() => this.enumerator.Reset();
+        }
+
         /// <summary>
         /// Simple immutable tuple that combines a <typeparamref name="TValue"/> instance with a ref count integer.
         /// </summary>

tests/ImageSharp.Web.Tests/Synchronization/AsyncLockTests.cs

@@ -0,0 +1,30 @@
+// Copyright (c) Six Labors.
+// Licensed under the Apache License, Version 2.0.
+
+using System.Threading.Tasks;
+using SixLabors.ImageSharp.Web.Synchronization;
+using Xunit;
+
+namespace SixLabors.ImageSharp.Web.Tests.Synchronization
+{
+    public class AsyncLockTests
+    {
+        private readonly AsyncLock l = new();
+
+        [Fact]
+        public async Task OneAtATime()
+        {
+            Task<AsyncLock.Releaser> first = this.l.LockAsync();
+            Assert.True(first.IsCompletedSuccessfully);
+
+            Task<AsyncLock.Releaser> second = this.l.LockAsync();
+            Assert.False(second.IsCompleted);
+
+            // Release first hold on the lock and then await the second task to confirm it completes.
+            first.Result.Dispose();
+
+            // Await the second task to make sure we get the lock. The timeout specified in the [Fact] above will prevent this from running forever.
+            await second;
+        }
+    }
+}

tests/ImageSharp.Web.Tests/Synchronization/AsyncReaderWriterLockTests.cs

@@ -0,0 +1,94 @@
+// Copyright (c) Six Labors.
+// Licensed under the Apache License, Version 2.0.
+
+using System.Threading.Tasks;
+using SixLabors.ImageSharp.Web.Synchronization;
+using Xunit;
+
+namespace SixLabors.ImageSharp.Web.Tests.Synchronization
+{
+    public class AsyncReaderWriterLockTests
+    {
+        private readonly AsyncReaderWriterLock l = new();
+
+        [Fact]
+        public void OneWriterAtATime()
+        {
+            Task<AsyncReaderWriterLock.Releaser> first = this.l.WriterLockAsync();
+            Assert.True(first.IsCompletedSuccessfully);
+
+            Task<AsyncReaderWriterLock.Releaser> second = this.l.WriterLockAsync();
+            Assert.False(second.IsCompleted);
+
+            first.Result.Dispose();
+            Assert.True(second.IsCompletedSuccessfully);
+        }
+
+        [Fact]
+        public void WriterBlocksReaders()
+        {
+            Task<AsyncReaderWriterLock.Releaser> first = this.l.WriterLockAsync();
+            Assert.True(first.IsCompletedSuccessfully);
+
+            Task<AsyncReaderWriterLock.Releaser> second = this.l.ReaderLockAsync();
+            Assert.False(second.IsCompleted);
+
+            first.Result.Dispose();
+            Assert.True(second.IsCompletedSuccessfully);
+        }
+
+        [Fact]
+        public void WaitingWriterBlocksReaders()
+        {
+            Task<AsyncReaderWriterLock.Releaser> first = this.l.ReaderLockAsync();
+            Assert.True(first.IsCompletedSuccessfully);
+
+            Task<AsyncReaderWriterLock.Releaser> second = this.l.WriterLockAsync();
+            Assert.False(second.IsCompleted);
+
+            Task<AsyncReaderWriterLock.Releaser> third = this.l.ReaderLockAsync();
+            Assert.False(third.IsCompleted);
+
+            first.Result.Dispose();
+            Assert.True(second.IsCompletedSuccessfully);
+            Assert.False(third.IsCompleted);
+
+            second.Result.Dispose();
+            Assert.True(third.IsCompletedSuccessfully);
+        }
+
+        [Fact]
+        public void MultipleReadersAtOnce()
+        {
+            Task<AsyncReaderWriterLock.Releaser> first = this.l.ReaderLockAsync();
+            Assert.True(first.IsCompletedSuccessfully);
+
+            Task<AsyncReaderWriterLock.Releaser> second = this.l.ReaderLockAsync();
+            Assert.True(second.IsCompletedSuccessfully);
+
+            Task<AsyncReaderWriterLock.Releaser> third = this.l.ReaderLockAsync();
+            Assert.True(third.IsCompletedSuccessfully);
+        }
+
+        [Fact]
+        public void AllWaitingReadersReleasedConcurrently()
+        {
+            Task<AsyncReaderWriterLock.Releaser> writer = this.l.WriterLockAsync();
+            Assert.True(writer.IsCompletedSuccessfully);
+
+            Task<AsyncReaderWriterLock.Releaser> reader1 = this.l.ReaderLockAsync();
+            Assert.False(reader1.IsCompleted);
+
+            Task<AsyncReaderWriterLock.Releaser> reader2 = this.l.ReaderLockAsync();
+            Assert.False(reader2.IsCompleted);
+
+            Task<AsyncReaderWriterLock.Releaser> reader3 = this.l.ReaderLockAsync();
+            Assert.False(reader3.IsCompleted);
+
+            writer.Result.Dispose();
+            Assert.True(reader1.IsCompletedSuccessfully);
+            Assert.True(reader2.IsCompletedSuccessfully);
+            Assert.True(reader3.IsCompletedSuccessfully);
+        }
+    }
+}

tests/ImageSharp.Web.Tests/Synchronization/RefCountedConcurrentDictionaryTests.cs

@@ -0,0 +1,151 @@
+// Copyright (c) Six Labors.
+// Licensed under the Apache License, Version 2.0.
+
+using System;
+using System.Collections.Concurrent;
+using System.Linq;
+using System.Threading.Tasks;
+using SixLabors.ImageSharp.Web.Synchronization;
+using Xunit;
+
+namespace SixLabors.ImageSharp.Web.Tests.Synchronization
+{
+    public class RefCountedConcurrentDictionaryTests
+    {
+        private readonly ConcurrentBag<string> released;
+        private readonly RefCountedConcurrentDictionary<string, string> dictionary;
+
+        public RefCountedConcurrentDictionaryTests()
+        {
+            this.released = new ConcurrentBag<string>();
+            this.dictionary = new RefCountedConcurrentDictionary<string, string>(
+                valueFactory: this.ValueForKey,
+                valueReleaser: value => this.released.Add(value));
+        }
+
+        [Fact]
+        public void AddThenRelease()
+        {
+            this.dictionary.Get("test");
+            this.ValidateDictionary(("test", 1));
+            this.ValidateReleased();
+
+            this.dictionary.Release("test");
+            this.ValidateDictionary();
+            this.ValidateReleased("test");
+        }
+
+        [Fact]
+        public void AddTwiceThenReleaseTwice()
+        {
+            this.dictionary.Get("test");
+            this.ValidateDictionary(("test", 1));
+            this.ValidateReleased();
+
+            this.dictionary.Get("test");
+            this.ValidateDictionary(("test", 2));
+            this.ValidateReleased();
+
+            this.dictionary.Release("test");
+            this.ValidateDictionary(("test", 1));
+            this.ValidateReleased();
+
+            this.dictionary.Release("test");
+            this.ValidateDictionary();
+            this.ValidateReleased("test");
+        }
+
+        [Fact]
+        public void AddAndReleaseABunchOfKeys()
+        {
+            this.dictionary.Get("a");
+            this.dictionary.Get("b");
+            this.dictionary.Get("c");
+            this.dictionary.Get("a");
+            this.dictionary.Release("b");
+            this.dictionary.Get("b");
+            this.ValidateDictionary(("a", 2), ("b", 1), ("c", 1));
+            this.ValidateReleased("b");
+
+            this.dictionary.Release("a");
+            this.dictionary.Release("b");
+            this.dictionary.Release("c");
+            this.ValidateDictionary(("a", 1));
+            this.ValidateReleased("b", "b", "c");
+
+            this.dictionary.Release("a");
+            this.ValidateDictionary();
+            this.ValidateReleased("a", "b", "b", "c");
+        }
+
+        [Fact]
+        public async Task StressTest()
+        {
+            string[] keys = new string[] { "a", "b", "c", "d", "e", "f", "g", "h" };
+
+            async Task Worker(int workerIndex)
+            {
+                var random = new Random(workerIndex);
+                for (int i = 0; i < 1000; i++)
+                {
+                    string key = keys[random.Next(0, keys.Length)];
+                    this.dictionary.Get(key);
+                    await Task.Delay(random.Next(0, 2));
+                    this.dictionary.Release(key);
+                }
+            }
+
+            await Task.WhenAll(Enumerable.Range(0, 1000).Select(Worker));
+
+            Assert.Empty(this.dictionary.DebugGetContents());
+        }
+
+        [Fact]
+        public void ReleaseNonExistentThrows()
+            => Assert.Throws<InvalidOperationException>(() => this.dictionary.Release("test"));
+
+        [Fact]
+        public void DoubleReleaseThrows()
+        {
+            this.dictionary.Get("test");
+            this.dictionary.Release("test");
+            Assert.Throws<InvalidOperationException>(() => this.dictionary.Release("test"));
+        }
+
+        [Fact]
+        public void ValueFactoryIsRequired()
+            => Assert.Throws<ArgumentNullException>("valueFactory", () => new RefCountedConcurrentDictionary<string, string>(null!, null));
+
+        private string ValueForKey(string key) => $"{key}.value";
+
+        /// <summary>
+        /// Validate that the dictionary contains precisely the specified key/value/refcount tuples.
+        /// </summary>
+        private void ValidateDictionary(params (string Key, int RefCount)[] expectedValues)
+        {
+            Action<(string, string, int)> CreateElementInspector((string Key, int RefCount) expected)
+                => ((string Key, string Value, int RefCount) actual) =>
+                {
+                    Assert.Equal(expected.Key, actual.Key);
+                    Assert.Equal(this.ValueForKey(expected.Key), actual.Value);
+                    Assert.Equal(expected.RefCount, actual.RefCount);
+                };
+
+            Assert.Collection(
+                collection: this.dictionary.DebugGetContents().OrderBy(v => v.Key),
+                elementInspectors: expectedValues.OrderBy(v => v.Key).Select(CreateElementInspector).ToArray());
+        }
+
+        /// <summary>
+        /// Validate that the specific values were released.
+        /// </summary>
+        private void ValidateReleased(params string[] expectedValues)
+        {
+            Action<string> CreateElementInspector(string expected) => (string actual) => Assert.Equal(this.ValueForKey(expected), actual);
+
+            Assert.Collection(
+                collection: this.released.OrderBy(v => v),
+                elementInspectors: expectedValues.OrderBy(v => v).Select(CreateElementInspector).ToArray());
+        }
+    }
+}