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);
});
}
