AsyncReaderWriterLockTests.cs

namespace Microsoft.VisualStudio.Threading.Tests
{
    using System;
    using System.Collections.Generic;
    using System.Diagnostics;
    using System.Linq;
    using System.Reflection;
    using System.Threading;
    using System.Threading.Tasks;
    using Microsoft.VisualStudio.Threading;
    using Xunit;
    using Xunit.Abstractions;
    using Xunit.Sdk;

    /// <summary>
    /// Tests functionality of the <see cref="AsyncReaderWriterLock"/> class.
    /// </summary>
    public class AsyncReaderWriterLockTests : TestBase, IDisposable
    {
        private const char ReadChar = 'R';
        private const char UpgradeableReadChar = 'U';
        private const char StickyUpgradeableReadChar = 'S';
        private const char WriteChar = 'W';

        private const int GCAllocationAttempts = 3;
        private const int MaxGarbagePerLock = 500;
        private const int MaxGarbagePerYield = 1000;

        /// <summary>
        /// A flag that should be set to true by tests that verify some anti-pattern
        /// and as a result corrupts the lock or otherwise orphans outstanding locks,
        /// which would cause the test to hang if it waited for the lock to "complete".
        /// </summary>
        private static bool doNotWaitForLockCompletionAtTestCleanup;

        private AsyncReaderWriterLock asyncLock;

        public AsyncReaderWriterLockTests(ITestOutputHelper logger)
            : base(logger)
        {
#if DESKTOP || NETCOREAPP2_0
            this.asyncLock = new StaAverseLock();
#else
            this.asyncLock = new AsyncReaderWriterLock();
#endif
            doNotWaitForLockCompletionAtTestCleanup = false;
        }

        public void Dispose()
        {
            this.asyncLock.Complete();
            if (!doNotWaitForLockCompletionAtTestCleanup)
            {
                Assert.True(this.asyncLock.Completion.Wait(2000));
            }
        }

        [StaFact]
        public void NoLocksHeld()
        {
            Assert.False(this.asyncLock.IsReadLockHeld);
            Assert.False(this.asyncLock.IsUpgradeableReadLockHeld);
            Assert.False(this.asyncLock.IsWriteLockHeld);
            Assert.False(this.asyncLock.IsAnyLockHeld);
        }

        [StaFact]
        public async Task OnCompletedHasNoSideEffects()
        {
            await Task.Run(delegate
            {
                Assert.False(this.asyncLock.IsReadLockHeld);
                var awaitable = this.asyncLock.ReadLockAsync();
                Assert.False(this.asyncLock.IsReadLockHeld);
                var awaiter = awaitable.GetAwaiter();
                Assert.False(this.asyncLock.IsReadLockHeld);
                Assert.True(awaiter.IsCompleted);
                var releaser = awaiter.GetResult();
                Assert.True(this.asyncLock.IsReadLockHeld);
                releaser.Dispose();
                Assert.False(this.asyncLock.IsReadLockHeld);
            });
        }

        /// <summary>Verifies that folks who hold locks and do not wish to expose those locks when calling outside code may do so.</summary>
        [StaFact]
        public async Task HideLocks()
        {
            var writeLockHeld = new TaskCompletionSource<object>();
            using (await this.asyncLock.ReadLockAsync())
            {
                Assert.True(this.asyncLock.IsReadLockHeld);
                await Task.Run(async delegate
                {
                    Assert.True(this.asyncLock.IsReadLockHeld);
                    using (this.asyncLock.HideLocks())
                    {
                        Assert.False(this.asyncLock.IsReadLockHeld, "Lock should be hidden.");

                        // Ensure the lock is also hidden across call context propagation.
                        await Task.Run(delegate
                        {
                            Assert.False(this.asyncLock.IsReadLockHeld, "Lock should be hidden.");
                        });

                        // Also verify that although the lock is hidden, a new lock may need to wait for this lock to finish.
                        var writeAwaiter = this.asyncLock.WriteLockAsync().GetAwaiter();
                        Assert.False(writeAwaiter.IsCompleted, "The write lock should not be immediately available because a read lock is actually held.");
                        writeAwaiter.OnCompleted(delegate
                        {
                            using (writeAwaiter.GetResult())
                            {
                                writeLockHeld.SetAsync();
                            }
                        });
                    }

                    Assert.True(this.asyncLock.IsReadLockHeld, "Lock should be visible.");
                });

                Assert.True(this.asyncLock.IsReadLockHeld);
            }

            Assert.False(this.asyncLock.IsReadLockHeld);
            await writeLockHeld.Task;
        }

        [StaFact]
        public async Task HideLocksRevertedOutOfOrder()
        {
            AsyncReaderWriterLock.Suppression suppression;
            using (await this.asyncLock.ReadLockAsync())
            {
                Assert.True(this.asyncLock.IsReadLockHeld);
                suppression = this.asyncLock.HideLocks();
                Assert.False(this.asyncLock.IsReadLockHeld);
            }

            Assert.False(this.asyncLock.IsReadLockHeld);
            suppression.Dispose();
            Assert.False(this.asyncLock.IsReadLockHeld);
        }

        [StaFact]
        public void ReleaseDefaultCtorDispose()
        {
            default(AsyncReaderWriterLock.Releaser).Dispose();
        }

        [StaFact]
        public void SuppressionDefaultCtorDispose()
        {
            default(AsyncReaderWriterLock.Suppression).Dispose();
        }

        [StaFact]
        public void AwaitableDefaultCtorDispose()
        {
            Assert.Throws<InvalidOperationException>(() => default(AsyncReaderWriterLock.Awaitable).GetAwaiter());
        }

        /// <summary>Verifies that continuations of the Completion property's task do not execute in the context of the private lock.</summary>
        [StaFact]
        public async Task CompletionContinuationsDoNotDeadlockWithLockClass()
        {
            var continuationFired = new TaskCompletionSource<object>();
            var releaseContinuation = new TaskCompletionSource<object>();
            var continuation = this.asyncLock.Completion.ContinueWith(
                delegate
                {
                    continuationFired.SetAsync();
                    releaseContinuation.Task.Wait();
                },
                TaskContinuationOptions.ExecuteSynchronously); // this flag tries to tease out the sync-allowing behavior if it exists.

            var nowait = Task.Run(async delegate
            {
                await continuationFired.Task; // wait for the continuation to fire, and resume on an MTA thread.

                // Now on this separate thread, do something that should require the private lock of the lock class, to ensure it's not a blocking call.
                bool throwaway = this.asyncLock.IsReadLockHeld;

                releaseContinuation.SetResult(null);
            });

            using (await this.asyncLock.ReadLockAsync())
            {
                this.asyncLock.Complete();
            }

            await Task.WhenAll(releaseContinuation.Task, continuation);
        }

        /// <summary>Verifies that continuations of the Completion property's task do not execute synchronously with the last lock holder's Release.</summary>
        [StaFact]
        public async Task CompletionContinuationsExecuteAsynchronously()
        {
            var releaseContinuation = new TaskCompletionSource<object>();
            var continuation = this.asyncLock.Completion.ContinueWith(
                delegate
                {
                    releaseContinuation.Task.Wait();
                },
                TaskContinuationOptions.ExecuteSynchronously); // this flag tries to tease out the sync-allowing behavior if it exists.

            using (await this.asyncLock.ReadLockAsync())
            {
                this.asyncLock.Complete();
            }

            releaseContinuation.SetResult(null);
            await continuation;
        }

        [StaFact]
        public async Task CompleteMethodExecutesContinuationsAsynchronously()
        {
            var releaseContinuation = new TaskCompletionSource<object>();
            Task continuation = this.asyncLock.Completion.ContinueWith(
                delegate
                {
                    releaseContinuation.Task.Wait();
                },
                TaskContinuationOptions.ExecuteSynchronously);

            this.asyncLock.Complete();
            releaseContinuation.SetResult(null);
            await continuation;
        }

        [SkippableFact]
        public async Task NoMemoryLeakForManyLocks()
        {
            if (await this.ExecuteInIsolationAsync())
            {
                // First prime the pump to allocate some fixed cost memory.
                {
                    var lck = new AsyncReaderWriterLock();
                    using (await lck.ReadLockAsync())
                    {
                    }
                }

                bool passingAttemptObserved = false;
                for (int attempt = 0; !passingAttemptObserved && attempt < GCAllocationAttempts; attempt++)
                {
                    const int iterations = 1000;
                    long memory1 = GC.GetTotalMemory(true);
                    for (int i = 0; i < iterations; i++)
                    {
                        var lck = new AsyncReaderWriterLock();
                        using (await lck.ReadLockAsync())
                        {
                        }
                    }

                    long memory2 = GC.GetTotalMemory(true);
                    long allocated = (memory2 - memory1) / iterations;
                    this.Logger.WriteLine("Allocated bytes: {0} ({1} allowed)", allocated, MaxGarbagePerLock);
                    passingAttemptObserved = allocated <= MaxGarbagePerLock;
                }

                Assert.True(passingAttemptObserved);
            }
        }

#if DESKTOP
        [StaFact, Trait("TestCategory", "FailsInCloudTest")]
        public async Task CallAcrossAppDomainBoundariesWithLock()
        {
            var otherDomain = AppDomain.CreateDomain("test domain", AppDomain.CurrentDomain.Evidence, AppDomain.CurrentDomain.SetupInformation);
            try
            {
                var proxy = (OtherDomainProxy)otherDomain.CreateInstanceFromAndUnwrap(Assembly.GetExecutingAssembly().Location, typeof(OtherDomainProxy).FullName);
                proxy.SomeMethod(AppDomain.CurrentDomain.Id); // verify we can call it first.

                using (await this.asyncLock.ReadLockAsync())
                {
                    proxy.SomeMethod(AppDomain.CurrentDomain.Id); // verify we can call it while holding a project lock.
                }

                proxy.SomeMethod(AppDomain.CurrentDomain.Id); // verify we can call it after releasing a project lock.
            }
            finally
            {
                AppDomain.Unload(otherDomain);
            }
        }
#endif

        [StaFact]
        public async Task LockStackContainsFlags()
        {
            var asyncLock = new LockDerived();
            var customFlag = (AsyncReaderWriterLock.LockFlags)0x10000;
            var customFlag2 = (AsyncReaderWriterLock.LockFlags)0x20000;
            Assert.False(asyncLock.LockStackContains(customFlag));
            using (await asyncLock.UpgradeableReadLockAsync(customFlag))
            {
                Assert.True(asyncLock.LockStackContains(customFlag));
                Assert.False(asyncLock.LockStackContains(customFlag2));

                using (await asyncLock.WriteLockAsync(customFlag2))
                {
                    Assert.True(asyncLock.LockStackContains(customFlag));
                    Assert.True(asyncLock.LockStackContains(customFlag2));
                }

                Assert.True(asyncLock.LockStackContains(customFlag));
                Assert.False(asyncLock.LockStackContains(customFlag2));
            }

            Assert.False(asyncLock.LockStackContains(customFlag));
        }

        [StaFact]
        public async Task OnLockReleaseCallbacksWithOuterWriteLock()
        {
            var stub = new LockDerived();

            int onExclusiveLockReleasedAsyncInvocationCount = 0;
            stub.OnExclusiveLockReleasedAsyncDelegate = delegate
            {
                onExclusiveLockReleasedAsyncInvocationCount++;
                return Task.FromResult<object>(null);
            };

            int onUpgradeableReadLockReleasedInvocationCount = 0;
            stub.OnUpgradeableReadLockReleasedDelegate = delegate
            {
                onUpgradeableReadLockReleasedInvocationCount++;
            };

            this.asyncLock = stub;
            using (await this.asyncLock.WriteLockAsync())
            {
                using (await this.asyncLock.WriteLockAsync())
                {
                    using (await this.asyncLock.WriteLockAsync())
                    {
                        using (await this.asyncLock.UpgradeableReadLockAsync())
                        {
                            Assert.Equal(0, onUpgradeableReadLockReleasedInvocationCount);
                        }

                        Assert.Equal(0, onUpgradeableReadLockReleasedInvocationCount);
                    }

                    Assert.Equal(0, onExclusiveLockReleasedAsyncInvocationCount);
                }

                Assert.Equal(0, onExclusiveLockReleasedAsyncInvocationCount);
            }

            Assert.Equal(1, onExclusiveLockReleasedAsyncInvocationCount);
        }

        [StaFact]
        public async Task OnLockReleaseCallbacksWithOuterUpgradeableReadLock()
        {
            var stub = new LockDerived();

            int onExclusiveLockReleasedAsyncInvocationCount = 0;
            stub.OnExclusiveLockReleasedAsyncDelegate = delegate
            {
                onExclusiveLockReleasedAsyncInvocationCount++;
                return Task.FromResult<object>(null);
            };

            int onUpgradeableReadLockReleasedInvocationCount = 0;
            stub.OnUpgradeableReadLockReleasedDelegate = delegate
            {
                onUpgradeableReadLockReleasedInvocationCount++;
            };

            this.asyncLock = stub;
            using (await this.asyncLock.UpgradeableReadLockAsync())
            {
                using (await this.asyncLock.UpgradeableReadLockAsync())
                {
                    using (await this.asyncLock.WriteLockAsync())
                    {
                        Assert.Equal(0, onUpgradeableReadLockReleasedInvocationCount);
                        Assert.Equal(0, onExclusiveLockReleasedAsyncInvocationCount);
                    }

                    Assert.Equal(0, onUpgradeableReadLockReleasedInvocationCount);
                    Assert.Equal(1, onExclusiveLockReleasedAsyncInvocationCount);
                }

                Assert.Equal(0, onUpgradeableReadLockReleasedInvocationCount);
                Assert.Equal(1, onExclusiveLockReleasedAsyncInvocationCount);
            }

            Assert.Equal(1, onUpgradeableReadLockReleasedInvocationCount);
            Assert.Equal(1, onExclusiveLockReleasedAsyncInvocationCount);
        }

        [StaFact]
        public async Task AwaiterInCallContextGetsRecycled()
        {
            await Task.Run(async delegate
            {
                Task remoteTask;
                var firstLockObserved = new TaskCompletionSource<object>();
                var secondLockAcquired = new TaskCompletionSource<object>();
                using (await this.asyncLock.ReadLockAsync())
                {
                    remoteTask = Task.Run(async delegate
                    {
                        Assert.True(this.asyncLock.IsReadLockHeld);
                        var nowait = firstLockObserved.SetAsync();
                        await secondLockAcquired.Task;
                        Assert.False(this.asyncLock.IsReadLockHeld, "Some remote call context saw a recycled lock issued to someone else.");
                    });
                    await firstLockObserved.Task;
                }

                using (await this.asyncLock.ReadLockAsync())
                {
                    await secondLockAcquired.SetAsync();
                    await remoteTask;
                }
            });
        }

        [StaFact]
        public async Task AwaiterInCallContextGetsRecycledTwoDeep()
        {
            await Task.Run(async delegate
            {
                Task remoteTask;
                var lockObservedOnce = new TaskCompletionSource<object>();
                var nestedLockReleased = new TaskCompletionSource<object>();
                var lockObservedTwice = new TaskCompletionSource<object>();
                var secondLockAcquired = new TaskCompletionSource<object>();
                var secondLockNotSeen = new TaskCompletionSource<object>();
                using (await this.asyncLock.ReadLockAsync())
                {
                    using (await this.asyncLock.ReadLockAsync())
                    {
                        remoteTask = Task.Run(async delegate
                        {
                            Assert.True(this.asyncLock.IsReadLockHeld);
                            var nowait = lockObservedOnce.SetAsync();
                            await nestedLockReleased.Task;
                            Assert.True(this.asyncLock.IsReadLockHeld);
                            nowait = lockObservedTwice.SetAsync();
                            await secondLockAcquired.Task;
                            Assert.False(this.asyncLock.IsReadLockHeld, "Some remote call context saw a recycled lock issued to someone else.");
                            Assert.False(this.asyncLock.IsWriteLockHeld, "Some remote call context saw a recycled lock issued to someone else.");
                            nowait = secondLockNotSeen.SetAsync();
                        });
                        await lockObservedOnce.Task;
                    }

                    var nowait2 = nestedLockReleased.SetAsync();
                    await lockObservedTwice.Task;
                }

                using (await this.asyncLock.WriteLockAsync())
                {
                    var nowait = secondLockAcquired.SetAsync();
                    await secondLockNotSeen.Task;
                }
            });
        }

        [StaFact, Trait("Stress", "true")]
        public async Task LockStress()
        {
            const int MaxLockAcquisitions = -1;
            const int MaxLockHeldDelay = 0; // 80;
            const int overallTimeout = 4000;
            const int iterationTimeout = overallTimeout;
            int maxWorkers = Environment.ProcessorCount * 4; // we do a lot of awaiting, but still want to flood all cores.
            bool testCancellation = false;
            await this.StressHelper(MaxLockAcquisitions, MaxLockHeldDelay, overallTimeout, iterationTimeout, maxWorkers, testCancellation);
        }

        [StaFact, Trait("Stress", "true"), Trait("TestCategory", "FailsInCloudTest")]
        public async Task CancellationStress()
        {
            const int MaxLockAcquisitions = -1;
            const int MaxLockHeldDelay = 0; // 80;
            const int overallTimeout = 4000;
            const int iterationTimeout = 100;
            int maxWorkers = Environment.ProcessorCount * 4; // we do a lot of awaiting, but still want to flood all cores.
            bool testCancellation = true;
            await this.StressHelper(MaxLockAcquisitions, MaxLockHeldDelay, overallTimeout, iterationTimeout, maxWorkers, testCancellation);
        }

        /// <summary>Tests that deadlocks don't occur when acquiring and releasing locks synchronously while async callbacks are defined.</summary>
        [StaFact]
        public async Task SynchronousLockReleaseWithCallbacks()
        {
            await Task.Run(async delegate
            {
#pragma warning disable SA1501 // Statement must not be on a single line: buggy analyzer misfires
                Func<Task> yieldingDelegate = async () => { await Task.Yield(); };
#pragma warning restore SA1501 // Statement must not be on a single line
                var asyncLock = new LockDerived
                {
                    OnBeforeExclusiveLockReleasedAsyncDelegate = yieldingDelegate,
                    OnBeforeLockReleasedAsyncDelegate = yieldingDelegate,
                    OnExclusiveLockReleasedAsyncDelegate = yieldingDelegate,
                };

                using (await asyncLock.WriteLockAsync())
                {
                }

                using (await asyncLock.UpgradeableReadLockAsync())
                {
                    using (await asyncLock.WriteLockAsync())
                    {
                    }
                }

                using (await asyncLock.WriteLockAsync())
                {
                    await Task.Yield();
                }

                using (await asyncLock.UpgradeableReadLockAsync())
                {
                    using (await asyncLock.WriteLockAsync())
                    {
                        await Task.Yield();
                    }
                }
            });
        }

        [StaFact]
        public async Task IsAnyLockHeldTest()
        {
            var asyncLock = new LockDerived();

            Assert.False(asyncLock.IsAnyLockHeld);
            await Task.Run(async delegate
            {
                Assert.False(asyncLock.IsAnyLockHeld);
                using (await asyncLock.ReadLockAsync())
                {
                    Assert.True(asyncLock.IsAnyLockHeld);
                }

                Assert.False(asyncLock.IsAnyLockHeld);
                using (await asyncLock.UpgradeableReadLockAsync())
                {
                    Assert.True(asyncLock.IsAnyLockHeld);
                }

                Assert.False(asyncLock.IsAnyLockHeld);
                using (await asyncLock.WriteLockAsync())
                {
                    Assert.True(asyncLock.IsAnyLockHeld);
                }

                Assert.False(asyncLock.IsAnyLockHeld);
            });
        }

        [StaFact]
        public async Task IsAnyLockHeldReturnsFalseForIncompatibleSyncContexts()
        {
            var dispatcher = SingleThreadedSynchronizationContext.New();
            var asyncLock = new LockDerived();
            using (await asyncLock.ReadLockAsync())
            {
                Assert.True(asyncLock.IsAnyLockHeld);
                SynchronizationContext.SetSynchronizationContext(dispatcher);
                Assert.False(asyncLock.IsAnyLockHeld);
            }
        }

        [StaFact]
        public async Task IsAnyPassiveLockHeldReturnsTrueForIncompatibleSyncContexts()
        {
            var dispatcher = SingleThreadedSynchronizationContext.New();
            var asyncLock = new LockDerived();
            using (await asyncLock.ReadLockAsync())
            {
                Assert.True(asyncLock.IsAnyPassiveLockHeld);
                SynchronizationContext.SetSynchronizationContext(dispatcher);
                Assert.True(asyncLock.IsAnyPassiveLockHeld);
            }
        }

        [StaFact]
        public async Task IsPassiveReadLockHeldReturnsTrueForIncompatibleSyncContexts()
        {
            var dispatcher = SingleThreadedSynchronizationContext.New();
            using (await this.asyncLock.ReadLockAsync())
            {
                Assert.True(this.asyncLock.IsPassiveReadLockHeld);
                SynchronizationContext.SetSynchronizationContext(dispatcher);
                Assert.True(this.asyncLock.IsPassiveReadLockHeld);
            }
        }

        [StaFact]
        public async Task IsPassiveUpgradeableReadLockHeldReturnsTrueForIncompatibleSyncContexts()
        {
            var dispatcher = SingleThreadedSynchronizationContext.New();
            using (await this.asyncLock.UpgradeableReadLockAsync())
            {
                Assert.True(this.asyncLock.IsPassiveUpgradeableReadLockHeld);
                SynchronizationContext.SetSynchronizationContext(dispatcher);
                Assert.True(this.asyncLock.IsPassiveUpgradeableReadLockHeld);
            }
        }

        [StaFact]
        public async Task IsPassiveWriteLockHeldReturnsTrueForIncompatibleSyncContexts()
        {
            var dispatcher = SingleThreadedSynchronizationContext.New();
            using (var releaser = await this.asyncLock.WriteLockAsync())
            {
                Assert.True(this.asyncLock.IsPassiveWriteLockHeld);
                SynchronizationContext.SetSynchronizationContext(dispatcher);
                Assert.True(this.asyncLock.IsPassiveWriteLockHeld);
                await releaser.ReleaseAsync();
            }
        }

#region ReadLockAsync tests

        [StaFact]
        public async Task ReadLockAsyncSimple()
        {
            Assert.False(this.asyncLock.IsReadLockHeld);
            using (await this.asyncLock.ReadLockAsync())
            {
                Assert.True(this.asyncLock.IsAnyLockHeld);
                Assert.True(this.asyncLock.IsReadLockHeld);
                Assert.False(this.asyncLock.IsUpgradeableReadLockHeld);
                Assert.False(this.asyncLock.IsWriteLockHeld);
                await Task.Yield();
                Assert.True(this.asyncLock.IsAnyLockHeld);
                Assert.True(this.asyncLock.IsReadLockHeld);
                Assert.False(this.asyncLock.IsUpgradeableReadLockHeld);
                Assert.False(this.asyncLock.IsWriteLockHeld);
            }

            Assert.False(this.asyncLock.IsReadLockHeld);
            Assert.False(this.asyncLock.IsUpgradeableReadLockHeld);
            Assert.False(this.asyncLock.IsWriteLockHeld);
        }

        [StaFact]
        public async Task ReadLockNotIssuedToAllThreads()
        {
            var evt = new ManualResetEventSlim(false);
            var otherThread = Task.Run(delegate
            {
                evt.Wait();
                Assert.False(this.asyncLock.IsReadLockHeld);
            });

            using (await this.asyncLock.ReadLockAsync())
            {
                Assert.True(this.asyncLock.IsReadLockHeld);
                evt.Set();
                await otherThread;
            }
        }

        [StaFact]
        public async Task ReadLockImplicitSharing()
        {
            using (await this.asyncLock.ReadLockAsync())
            {
                Assert.True(this.asyncLock.IsReadLockHeld);

                await Task.Run(delegate
                {
                    Assert.True(this.asyncLock.IsReadLockHeld);
                });

                Assert.True(this.asyncLock.IsReadLockHeld);
            }
        }

        [StaFact]
        public async Task ReadLockImplicitSharingCutOffByParent()
        {
            Task subTask;
            var outerLockReleased = new TaskCompletionSource<object>();
            using (await this.asyncLock.ReadLockAsync())
            {
                Assert.True(this.asyncLock.IsReadLockHeld);

                var subTaskObservedLock = new TaskCompletionSource<object>();
                subTask = Task.Run(async delegate
                {
                    Assert.True(this.asyncLock.IsReadLockHeld);
                    await subTaskObservedLock.SetAsync();
                    await outerLockReleased.Task;
                    Assert.False(this.asyncLock.IsReadLockHeld);
                });

                await subTaskObservedLock.Task;
            }

            Assert.False(this.asyncLock.IsReadLockHeld);
            await outerLockReleased.SetAsync();
            await subTask;
        }

        /// <summary>Verifies that when a thread that already has inherited an implicit lock explicitly requests a lock, that that lock can outlast the parents lock.</summary>
        [StaFact]
        public async Task ReadLockImplicitSharingNotCutOffByParentWhenExplicitlyRetained()
        {
            Task subTask;
            var outerLockReleased = new TaskCompletionSource<object>();
            using (await this.asyncLock.ReadLockAsync())
            {
                Assert.True(this.asyncLock.IsReadLockHeld);

                var subTaskObservedLock = new TaskCompletionSource<object>();
                subTask = Task.Run(async delegate
                {
                    Assert.True(this.asyncLock.IsReadLockHeld);
                    using (await this.asyncLock.ReadLockAsync())
                    {
                        await subTaskObservedLock.SetAsync();
                        await outerLockReleased.Task;
                        Assert.True(this.asyncLock.IsReadLockHeld);
                    }

                    Assert.False(this.asyncLock.IsReadLockHeld);
                });

                await subTaskObservedLock.Task;
            }

            Assert.False(this.asyncLock.IsReadLockHeld);
            await outerLockReleased.SetAsync();
            await subTask;
        }

        [StaFact]
        public async Task ConcurrentReaders()
        {
            var reader1HasLock = new ManualResetEventSlim();
            var reader2HasLock = new ManualResetEventSlim();
            await Task.WhenAll(
                Task.Run(async delegate
                {
                    using (await this.asyncLock.ReadLockAsync())
                    {
                        reader1HasLock.Set();
                        reader2HasLock.Wait(); // synchronous block to ensure multiple *threads* hold lock.
                    }
                }),
                Task.Run(async delegate
                {
                    using (await this.asyncLock.ReadLockAsync())
                    {
                        reader2HasLock.Set();
                        reader1HasLock.Wait(); // synchronous block to ensure multiple *threads* hold lock.
                    }
                }));
        }

        [StaFact]
        public async Task NestedReaders()
        {
            using (await this.asyncLock.ReadLockAsync())
            {
                Assert.True(this.asyncLock.IsReadLockHeld);
                Assert.False(this.asyncLock.IsUpgradeableReadLockHeld);
                Assert.False(this.asyncLock.IsWriteLockHeld);
                using (await this.asyncLock.ReadLockAsync())
                {
                    Assert.True(this.asyncLock.IsReadLockHeld);
                    Assert.False(this.asyncLock.IsUpgradeableReadLockHeld);
                    Assert.False(this.asyncLock.IsWriteLockHeld);
                    using (await this.asyncLock.ReadLockAsync())
                    {
                        Assert.True(this.asyncLock.IsReadLockHeld);
                        Assert.False(this.asyncLock.IsUpgradeableReadLockHeld);
                        Assert.False(this.asyncLock.IsWriteLockHeld);
                    }

                    Assert.True(this.asyncLock.IsReadLockHeld);
                    Assert.False(this.asyncLock.IsUpgradeableReadLockHeld);
                    Assert.False(this.asyncLock.IsWriteLockHeld);
                }

                Assert.True(this.asyncLock.IsReadLockHeld);
                Assert.False(this.asyncLock.IsUpgradeableReadLockHeld);
                Assert.False(this.asyncLock.IsWriteLockHeld);
            }

            Assert.False(this.asyncLock.IsReadLockHeld);
            Assert.False(this.asyncLock.IsUpgradeableReadLockHeld);
            Assert.False(this.asyncLock.IsWriteLockHeld);
        }

        [StaFact]
        public async Task DoubleLockReleaseDoesNotReleaseOtherLocks()
        {
            var readLockHeld = new TaskCompletionSource<object>();
            var writerQueued = new TaskCompletionSource<object>();
            var writeLockHeld = new TaskCompletionSource<object>();
            await Task.WhenAll(
                Task.Run(async delegate
                {
                    using (var outerReleaser = await this.asyncLock.ReadLockAsync())
                    {
                        await readLockHeld.SetAsync();
                        await writerQueued.Task;
                        using (var innerReleaser = await this.asyncLock.ReadLockAsync())
                        {
                            innerReleaser.Dispose(); // doing this here will lead to double-disposal at the close of the using block.
                        }

                        await Task.Delay(AsyncDelay);
                        Assert.False(writeLockHeld.Task.IsCompleted);
                    }
                }),
                Task.Run(async delegate
                {
                    await readLockHeld.Task;
                    var writeAwaiter = this.asyncLock.WriteLockAsync().GetAwaiter();
                    Assert.False(writeAwaiter.IsCompleted);
                    writeAwaiter.OnCompleted(delegate
                    {
                        using (writeAwaiter.GetResult())
                        {
                            writeLockHeld.SetAsync();
                        }
                    });
                    await writerQueued.SetAsync();
                }),
                writeLockHeld.Task);
        }

        [StaFact]
        public void ReadLockReleaseOnSta()
        {
            this.LockReleaseTestHelper(this.asyncLock.ReadLockAsync());
        }

#if ISOLATED_TEST_SUPPORT
        [StaFact, Trait("GC", "true")]
        public async Task UncontestedTopLevelReadLockAsyncGarbageCheck()
        {
            if (await this.ExecuteInIsolationAsync())
            {
                var cts = new CancellationTokenSource();
                await this.UncontestedTopLevelLocksAllocFreeHelperAsync(() => this.asyncLock.ReadLockAsync(cts.Token), false);
            }
        }

        [StaFact, Trait("GC", "true")]
        public async Task NestedReadLockAsyncGarbageCheck()
        {
            if (await this.ExecuteInIsolationAsync())
            {
                await this.NestedLocksAllocFreeHelperAsync(() => this.asyncLock.ReadLockAsync(), false);
            }
        }
#endif

#if DESKTOP || NETCOREAPP2_0
        [StaFact]
        public void LockAsyncThrowsOnGetResultBySta()
        {
            Assert.Equal(ApartmentState.STA, Thread.CurrentThread.GetApartmentState()); // STA required.

            var awaiter = this.asyncLock.ReadLockAsync().GetAwaiter();
            Assert.Throws<InvalidOperationException>(() => awaiter.GetResult()); // throws on an STA thread
        }
#endif

        [StaFact]
        public void LockAsyncNotIssuedTillGetResultOnSta()
        {
            var awaiter = this.asyncLock.ReadLockAsync().GetAwaiter();
            Assert.False(this.asyncLock.IsReadLockHeld);
            try
            {
                awaiter.GetResult();
            }
            catch (InvalidOperationException)
            {
                // This exception happens because we invoke it on the STA.
                // But we have to invoke it so that the lock is effectively canceled
                // so the test doesn't hang in Cleanup.
            }
        }

        [StaFact]
        public async Task LockAsyncNotIssuedTillGetResultOnMta()
        {
            await Task.Run(delegate
            {
                var awaiter = this.asyncLock.ReadLockAsync().GetAwaiter();
                try
                {
                    Assert.False(this.asyncLock.IsReadLockHeld);
                }
                finally
                {
                    awaiter.GetResult().Dispose();
                }
            });
        }

        [StaFact]
        public async Task AllowImplicitReadLockConcurrency()
        {
            using (await this.asyncLock.ReadLockAsync())
            {
                await this.CheckContinuationsConcurrencyHelper();
            }
        }

        [StaFact]
        public async Task ReadLockAsyncYieldsIfSyncContextSet()
        {
            await Task.Run(async delegate
            {
                SynchronizationContext.SetSynchronizationContext(new SynchronizationContext());

                var awaiter = this.asyncLock.ReadLockAsync().GetAwaiter();
                try
                {
                    Assert.False(awaiter.IsCompleted);
                }
                catch
                {
                    awaiter.GetResult().Dispose(); // avoid test hangs on test failure
                    throw;
                }

                var lockAcquired = new TaskCompletionSource<object>();
                awaiter.OnCompleted(delegate
                {
                    using (awaiter.GetResult())
                    {
                        Assert.Null(SynchronizationContext.Current);
                    }

                    lockAcquired.SetAsync();
                });
                await lockAcquired.Task;
            });
        }

        [StaFact]
        public async Task ReadLockAsyncConcurrent()
        {
            var firstReadLockObtained = new TaskCompletionSource<object>();
            var secondReadLockObtained = new TaskCompletionSource<object>();
            await Task.WhenAll(
                Task.Run(async delegate
                {
                    using (await this.asyncLock.ReadLockAsync())
                    {
                        Assert.True(this.asyncLock.IsReadLockHeld);
                        await firstReadLockObtained.SetAsync();
                        Assert.True(this.asyncLock.IsReadLockHeld);
                        await secondReadLockObtained.Task;
                    }

                    Assert.False(this.asyncLock.IsReadLockHeld);
                }),
                Task.Run(async delegate
                {
                    await firstReadLockObtained.Task;
                    using (await this.asyncLock.ReadLockAsync())
                    {
                        Assert.True(this.asyncLock.IsReadLockHeld);
                        await secondReadLockObtained.SetAsync();
                        Assert.True(this.asyncLock.IsReadLockHeld);
                        await firstReadLockObtained.Task;
                    }

                    Assert.False(this.asyncLock.IsReadLockHeld);
                }));
        }

        [StaFact]
        public async Task ReadLockAsyncContention()
        {
            var firstLockObtained = new TaskCompletionSource<object>();
            await Task.WhenAll(
                Task.Run(async delegate
                {
                    using (await this.asyncLock.WriteLockAsync())
                    {
                        Assert.True(this.asyncLock.IsWriteLockHeld);
                        var nowait = firstLockObtained.SetAsync();
                        await Task.Delay(AsyncDelay); // hold it long enough to ensure our other thread blocks waiting for the read lock.
                        Assert.True(this.asyncLock.IsWriteLockHeld);