public void Unlocked_PermitsWriterLock() { AsyncContext.Run(async () => { var rwl = new AsyncReaderWriterLock(); await rwl.WriterLockAsync(); }); }
public void Unlocked_PermitsWriterLock() { Test.Async(async () => { var rwl = new AsyncReaderWriterLock(); await rwl.WriterLockAsync(); }); }
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 WriteLocked_PreventsReaderLock() { AsyncContext.Run(async () => { var rwl = new AsyncReaderWriterLock(); await rwl.WriterLockAsync(); var task = rwl.ReaderLockAsync(); await AssertEx.NeverCompletesAsync(task); }); }
public FakeStatusCyclocityRepository( ICyclocityRepository innerRepository, IFakeGenerator fakeStatusGenerator, ITaskulerScheduleHandle updateFakeDataScheduleHandle) { _InnerRepository = innerRepository; _FakeStatusGenerator = fakeStatusGenerator; _StationsListLock = new AsyncReaderWriterLock(); updateFakeDataScheduleHandle.AddTask(async () => await _UpdateFakeDataAsync()); }
public void WriteLocked_Unlocked_PermitsAnotherWriterLock() { AsyncContext.Run(async () => { var rwl = new AsyncReaderWriterLock(); var firstWriteLockTaken = new TaskCompletionSource(); var releaseFirstWriteLock = new TaskCompletionSource(); var task = Task.Run(async () => { using (await rwl.WriterLockAsync()) { firstWriteLockTaken.SetResult(); await releaseFirstWriteLock.Task; } }); await firstWriteLockTaken.Task; var lockTask = rwl.WriterLockAsync(); Assert.IsFalse(lockTask.IsCompleted); releaseFirstWriteLock.SetResult(); await lockTask; }); }
/// <summary> /// Creates the key for a lock. /// </summary> /// <param name="asyncReaderWriterLock">The lock to release. May not be <c>null</c>.</param> internal UpgradeableReaderKey(AsyncReaderWriterLock asyncReaderWriterLock) { _asyncReaderWriterLock = asyncReaderWriterLock; _cachedUpgradeKeyTask = TaskShim.FromResult <IDisposable>(new UpgradeKey(this)); }
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_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 Id_IsNotZero() { var rwl = new AsyncReaderWriterLock(); Assert.AreNotEqual(0, rwl.Id); }
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); }); }
/// <summary> /// Creates the key for a lock. /// </summary> /// <param name="asyncReaderWriterLock">The lock to release. May not be <c>null</c>.</param> public WriterKey(AsyncReaderWriterLock asyncReaderWriterLock) { _asyncReaderWriterLock = asyncReaderWriterLock; }
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_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 LockReleased_WriteTakesPriorityOverRead() { Test.Async(async () => { var rwl = new AsyncReaderWriterLock(); Task writeLock, readLock; using (await rwl.WriterLockAsync()) { readLock = rwl.ReaderLockAsync().AsTask(); writeLock = rwl.WriterLockAsync().AsTask(); } await writeLock; await AssertEx.NeverCompletesAsync(readLock); }); }
public void ReaderLocked_ReaderReleased_ReaderAndWriterWaiting_DoesNotReleaseReaderOrWriter() { Test.Async(async () => { var rwl = new AsyncReaderWriterLock(); Task readLock, writeLock; await rwl.ReaderLockAsync(); using (await rwl.ReaderLockAsync()) { writeLock = rwl.WriterLockAsync().AsTask(); readLock = rwl.ReaderLockAsync().AsTask(); } await TaskShim.WhenAll(AssertEx.NeverCompletesAsync(writeLock), AssertEx.NeverCompletesAsync(readLock)); }); }
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 WriterKey_MultiDispose_DoesNothing() { AsyncContext.Run(async () => { var rwl = new AsyncReaderWriterLock(); var key = await rwl.WriterLockAsync(); key.Dispose(); key.Dispose(); await rwl.WriterLockAsync(); }); }
public void ReaderLock_PreCancelled_LockNotAvailable_SynchronouslyCancels() { var rwl = new AsyncReaderWriterLock(); var token = new CancellationToken(true); rwl.WriterLockAsync(); var task = rwl.ReaderLockAsync(token); Assert.IsTrue(task.IsCompleted); Assert.IsTrue(task.IsCanceled); Assert.IsFalse(task.IsFaulted); }
public void LockReleased_WriteTakesPriorityOverUpgradeableRead() { AsyncContext.Run(async () => { var rwl = new AsyncReaderWriterLock(); Task writeLock, upgradeableReadLock; using (await rwl.WriterLockAsync()) { upgradeableReadLock = rwl.UpgradeableReaderLockAsync(); writeLock = rwl.WriterLockAsync(); } 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 ReadLocked_AllowsUpgradeableReaderLock() { Test.Async(async () => { var rwl = new AsyncReaderWriterLock(); await rwl.ReaderLockAsync(); await rwl.UpgradeableReaderLockAsync(); }); }
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 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 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 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 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_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 LoadTest() { Test.Async(async () => { var rwl = new AsyncReaderWriterLock(); var readKeys = new List<IDisposable>(); for (int i = 0; i != 1000; ++i) readKeys.Add(rwl.ReaderLock()); var writeTask = TaskShim.Run(() => { rwl.WriterLock().Dispose(); }); var readTasks = new List<Task>(); for (int i = 0; i != 100; ++i) readTasks.Add(TaskShim.Run(() => rwl.ReaderLock().Dispose())); await TaskShim.Delay(1000); foreach (var readKey in readKeys) readKey.Dispose(); await writeTask; foreach (var readTask in readTasks) await readTask; }); }
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 DebugView(AsyncReaderWriterLock rwl) { _rwl = rwl; }
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); }); }