public void WriteLocked_PreventsUpgradeableReaderLock() { Test.Async(async () => { var rwl = new AsyncReaderWriterLock(); await rwl.WriterLockAsync(); var task = rwl.UpgradeableReaderLockAsync().AsTask(); await AssertEx.NeverCompletesAsync(task); }); }
public void ReaderLocked_ReaderReleased_ReaderAndUpgradingReaderWaiting_DoesNotReleaseReaderOrUpgradingReader() { Test.Async(async () => { var rwl = new AsyncReaderWriterLock(); Task readLock, upgradingReadLock; await rwl.ReaderLockAsync(); using (await rwl.ReaderLockAsync()) { var upgradeableReadLock = await rwl.UpgradeableReaderLockAsync(); upgradingReadLock = upgradeableReadLock.UpgradeAsync().AsTask(); readLock = rwl.ReaderLockAsync().AsTask(); } await TaskShim.WhenAll(AssertEx.NeverCompletesAsync(upgradingReadLock), AssertEx.NeverCompletesAsync(readLock)); }); }
public void LockReleased_AllowsUpgradeableReadAndMultipleReaders() { Test.Async(async () => { var rwl = new AsyncReaderWriterLock(); Task upgradeableReadLock, readLock1, readLock2; using (await rwl.WriterLockAsync()) { upgradeableReadLock = rwl.UpgradeableReaderLockAsync().AsTask(); readLock1 = rwl.ReaderLockAsync().AsTask(); readLock2 = rwl.ReaderLockAsync().AsTask(); } await TaskShim.WhenAll(upgradeableReadLock, readLock1, readLock2); }); }
public void LockReleased_WriteTakesPriorityOverUpgradeableRead() { Test.Async(async () => { var rwl = new AsyncReaderWriterLock(); Task writeLock, upgradeableReadLock; using (await rwl.WriterLockAsync()) { upgradeableReadLock = rwl.UpgradeableReaderLockAsync().AsTask(); writeLock = rwl.WriterLockAsync().AsTask(); } await writeLock; await AssertEx.NeverCompletesAsync(upgradeableReadLock); }); }
public void WriteLocked_UpgradeableReaderLockCancelled_DoesNotTakeLockWhenUnlocked() { Test.Async(async () => { var rwl = new AsyncReaderWriterLock(); using (await rwl.WriterLockAsync()) { var cts = new CancellationTokenSource(); var task = rwl.UpgradeableReaderLockAsync(cts.Token).AsTask(); cts.Cancel(); await AssertEx.ThrowsExceptionAsync<OperationCanceledException>(() => task); } await rwl.UpgradeableReaderLockAsync(); }); }
public void Upgrade_PreCancelled_LockNotAvailable_SynchronouslyCancels() { var rwl = new AsyncReaderWriterLock(); var token = new CancellationToken(true); var key = rwl.UpgradeableReaderLockAsync().AsTask().Result; rwl.ReaderLockAsync(); var task = key.UpgradeAsync(token).AsTask(); Assert.IsTrue(task.IsCompleted); Assert.IsTrue(task.IsCanceled); Assert.IsFalse(task.IsFaulted); }
public void UpgradeKey_MultiDispose_DoesNothing() { AsyncContext.Run(async () => { var rwl = new AsyncReaderWriterLock(); var upgradeable = await rwl.UpgradeableReaderLockAsync(); var key = await upgradeable.UpgradeAsync(); key.Dispose(); key.Dispose(); await upgradeable.UpgradeAsync(); }); }
public void UpgradeableKey_MultiUpgradeWhenFirstUpgradeIsIncomplete_ThrowsSynchronousException() { Test.Async(async () => { var rwl = new AsyncReaderWriterLock(); await rwl.ReaderLockAsync(); var key = await rwl.UpgradeableReaderLockAsync(); var _ = key.UpgradeAsync(); AssertEx.ThrowsException<InvalidOperationException>(() => key.UpgradeAsync()); }); }
public void UpgradeableReadAndReadLocked_UpgradeAborted_CompletesAsCanceled() { Test.Async(async () => { var rwl = new AsyncReaderWriterLock(); var readLockTaken = new TaskCompletionSource(); var task = TaskShim.Run(async () => { using (await rwl.ReaderLockAsync()) { readLockTaken.SetResult(); await TaskConstants.Never; } }); await readLockTaken.Task; Task upgradeTask; using (var key = await rwl.UpgradeableReaderLockAsync()) { upgradeTask = key.UpgradeAsync().AsTask(); Assert.IsFalse(key.Upgraded); } await AssertEx.ThrowsExceptionAsync<OperationCanceledException>(upgradeTask); }); }
public void UpgradeableReadAndReadLocked_Upgrade_WaitsForReaderLockToUnlock() { Test.Async(async () => { var rwl = new AsyncReaderWriterLock(); var readLockTaken = new TaskCompletionSource(); var releaseReadLock = new TaskCompletionSource(); var task = TaskShim.Run(async () => { using (await rwl.ReaderLockAsync()) { readLockTaken.SetResult(); await releaseReadLock.Task; } }); await readLockTaken.Task; using (var key = await rwl.UpgradeableReaderLockAsync()) { Assert.IsFalse(key.Upgraded); var lockTask = key.UpgradeAsync().AsTask(); Assert.IsFalse(lockTask.IsCompleted); releaseReadLock.SetResult(); await lockTask; Assert.IsTrue(key.Upgraded); } }); }
public void UpgradeableReadLocked_Upgraded_PreventsReaderLock() { Test.Async(async () => { var rwl = new AsyncReaderWriterLock(); var key = await rwl.UpgradeableReaderLockAsync(); await key.UpgradeAsync(); Assert.IsTrue(key.Upgraded); var task = rwl.WriterLockAsync().AsTask(); await AssertEx.NeverCompletesAsync(task); }); }
public void UpgradeableReadLocked_Unlocked_AllowsWriterLock() { Test.Async(async () => { var rwl = new AsyncReaderWriterLock(); using (var key = await rwl.UpgradeableReaderLockAsync()) { Assert.IsFalse(key.Upgraded); } await rwl.WriterLockAsync(); }); }
public void UpgradeableReadLocked_AllowsMultipleReaderLocks() { Test.Async(async () => { var rwl = new AsyncReaderWriterLock(); var key = await rwl.UpgradeableReaderLockAsync(); Assert.IsFalse(key.Upgraded); await rwl.ReaderLockAsync(); await rwl.ReaderLockAsync(); }); }
public void ReadLocked_AllowsUpgradeableReaderLock() { Test.Async(async () => { var rwl = new AsyncReaderWriterLock(); await rwl.ReaderLockAsync(); await rwl.UpgradeableReaderLockAsync(); }); }
public void ReaderLocked_UpgradableReaderReleased_UpgradableReaderWaiting_ReleasesUpgrableReader() { Test.Async(async () => { var rwl = new AsyncReaderWriterLock(); Task upgradableReadLock; using (await rwl.ReaderLockAsync()) using (await rwl.UpgradeableReaderLockAsync()) { upgradableReadLock = rwl.UpgradeableReaderLockAsync().AsTask(); Assert.IsFalse(upgradableReadLock.IsCompleted); } await upgradableReadLock; }); }
public void UpgradeableKey_MultiUpgrade_ThrowsException() { Test.Async(async () => { var rwl = new AsyncReaderWriterLock(); var key = await rwl.UpgradeableReaderLockAsync(); await key.UpgradeAsync(); await AssertEx.ThrowsExceptionAsync<InvalidOperationException>(async () => { await key.UpgradeAsync(); }); }); }
public void UpgradeableReadLocked_Downgrade_AllowsReaderLock() { Test.Async(async () => { var rwl = new AsyncReaderWriterLock(); var key = await rwl.UpgradeableReaderLockAsync(); var upgradeKey = await key.UpgradeAsync(); upgradeKey.Dispose(); await rwl.ReaderLockAsync(); }); }
public void UpgradeableReaderLock_PreCancelled_LockAvailable_SynchronouslyTakesLock() { var rwl = new AsyncReaderWriterLock(); var token = new CancellationToken(true); var task = rwl.UpgradeableReaderLockAsync(token).AsTask(); Assert.IsTrue(task.IsCompleted); Assert.IsFalse(task.IsCanceled); Assert.IsFalse(task.IsFaulted); }
public void UpgradeableReadLocked_PreventsWriterLock() { AsyncContext.Run(async () => { var rwl = new AsyncReaderWriterLock(); var key = await rwl.UpgradeableReaderLockAsync(); Assert.IsFalse(key.Upgraded); var task = rwl.WriterLockAsync(); await AssertEx.NeverCompletesAsync(task); }); }